select operator by string

.gitignore

@@ -34,6 +34,8 @@ jspm_packages
 # Optional npm cache directory
 .npm
 
+.package-lock.json
+
 # Optional REPL history
 .node_repl_history
 

src/linq/enumerable.ts

@@ -243,11 +243,13 @@ export class Enumerable<TEntity> implements IEnumerable<TEntity>
     * returns a new IEnumerable of TResult
     * @param selector
     */
-    public select<TResult>(selector: (it: TEntity) => TResult): IEnumerable<TResult> {
+    public select<TResult>(selector: (it: TEntity) => TResult): IEnumerable<TResult>
+    public select<TResult extends Partial<TEntity>>(selector: string): IEnumerable<TResult>
+    public select(selector: string | ((it: TEntity) => Record<string, any>)): IEnumerable<Record<string, any>> {
         if (typeof this.items == 'object' && typeof this.items[Symbol.asyncIterator] == 'function') {
-            return new Enumerable<TResult>(new SelectOperator<TEntity>(selector).evaluateAsync(this));
+            return new Enumerable(new SelectOperator(selector).evaluateAsync(this));
         } else {
-            return new Enumerable<TResult>(new SelectOperator<TEntity>(selector).evaluate(this));
+            return new Enumerable(new SelectOperator(selector).evaluate(this));
         }
     }
 

src/linq/operators/selectoperator.ts

@@ -1,8 +1,19 @@
 import { Operator, OperatorType } from './operator';
 
 export class SelectOperator<TEntity> extends Operator<TEntity> {
-    constructor(public selector: (it: TEntity) => {}) {
+    private selector: (it: TEntity) => {}
+
+    constructor(selector:  string | ((it: TEntity) => {})) {
         super(OperatorType.Select);
+
+        if(typeof selector == 'string') {
+            let keys = selector ? selector.split(',').map(sel => sel.trim()) : []
+
+            this.selector = (it) => remapper(keys, it)
+        }
+        else {
+            this.selector = selector
+        }
     }
 
     public* evaluate(items: Iterable<TEntity>): IterableIterator<any> {
@@ -20,4 +31,32 @@ export class SelectOperator<TEntity> extends Operator<TEntity> {
             yield this.selector(item)
         }
     }
+}
+
+function remapper(keys: string[], object: Record<string, any>): Record<string, any> {
+    if(!keys || keys.length == 0)
+        return object
+
+    let remapped = {},
+        groups: { [key: string]: string[] } = {}
+
+    for(let key of keys) {
+        let match = /([^/]+)\/(.*)/i.exec(key)
+
+        if(match) {
+            if(!groups[match[1]]) 
+                groups[match[1]] = []
+
+            groups[match[1]].push(match[2])
+        }
+        else {
+            remapped[key] = object[key]
+        }
+    }
+
+    for(let [prop, keys] of Object.entries(groups)) {
+        remapped[prop] = remapper(keys, object[prop])
+    }
+
+    return remapped
 }

src/test/enumerable.ts

@@ -461,6 +461,16 @@ describe("When using Enumerable", () => {
         assert.equal(car.model, 'QASHQAI');
     })
 
+    it("should be able to convert list by using select by string", () => {
+        let car = new Enumerable(cars)
+            .where(it => it.id == 2)
+            .select('id, type/make')
+            .first();
+
+        assert.equal(car.id, 2);
+        assert.equal(car.type.make, 'NISSAN')
+    })
+
     it("should be able to get first Operator by class", () => {
         let query: Enumerable<ICar> = new Enumerable<ICar>();