Merge pull request #26 from tfso/bugfix/iteration-of-several-operators

bugfix/Iteration of several operators
tfso · Oct 25, 2024 · 7a5d5b9 · 7a5d5b9
2 parents 5c9e352 + aa26000
commit 7a5d5b9
Show file tree

Hide file tree

Showing 2 changed files with 27 additions and 23 deletions.
diff --git a/src/linq/base.ts b/src/linq/base.ts
@@ -107,15 +107,11 @@ export default abstract class Base<TEntity extends Entity> implements IEnumerabl
 
             if(operator) {
                 if('evaluate' in operator) {
-                    switch(idx) {
-                        case 0: generator = items; break
-                        default: generator = iterate(items, operators, idx - 1)
-                    }
-
+                    generator = iterate(items, operators, idx - 1)
                     evaluate = operator.evaluate()
                 }
                 else {
-                    generator = operator.asyncIterator(items)
+                    generator = iterate(operator.asyncIterator(items), operators, idx - 1)
                 }
             }
             else {
@@ -139,12 +135,9 @@ export default abstract class Base<TEntity extends Entity> implements IEnumerabl
             }
         }
 
-        let iterator = iterate(this.items instanceof Repository ? this.items[Symbol.asyncIterator](this) : this.items[Symbol.asyncIterator](), this.operators),
-            result: IteratorResult<TEntity>
+        let iterator = iterate(this.items instanceof Repository ? this.items[Symbol.asyncIterator](this) : this.items[Symbol.asyncIterator](), this.operators)
 
-        while (!(result = await Promise.resolve(iterator.next())).done) {
-            yield result.value
-        }
+        yield * iterator
     }
 
     protected * getIterator(): IterableIterator<TEntity> {
@@ -161,15 +154,11 @@ export default abstract class Base<TEntity extends Entity> implements IEnumerabl
 
             if(operator) {
                 if('evaluate' in operator) {
-                    switch(idx) {
-                        case 0: generator = items; break
-                        default: generator = iterate(items, operators, idx - 1)
-                    }
-
+                    generator = iterate(items, operators, idx - 1)
                     evaluate = operator.evaluate()
                 }
                 else {
-                    generator = operator.iterator(items)
+                    generator = iterate(operator.iterator(items), operators, idx - 1)
                 }
             }
             else {
@@ -193,12 +182,9 @@ export default abstract class Base<TEntity extends Entity> implements IEnumerabl
             }
         }
 
-        let iterator = iterate(this.items[Symbol.iterator](), this.operators),
-            result: IteratorResult<TEntity>
-
-        while (!(result = iterator.next()).done) {
-            yield result.value
-        }
+        let iterator = iterate(this.items[Symbol.iterator](), this.operators)
+
+        yield * iterator
     }
 
     [Symbol.iterator](): IterableIterator<TEntity> {

diff --git a/src/test/enumerable/record.ts b/src/test/enumerable/record.ts
@@ -110,6 +110,15 @@ describe('When using enumerable for record type', () => {
             chai.expect(ar).to.deep.equal([1990, 1999, 2004, 2009, 2019])
         })
 
+        it('should async iterate using where and orderBy', async () => {
+            let ar = []
+
+            for await(let car of new jsEnumerable.Enumerable(asyncIterator()).where(it => it.year >= 2004).orderBy('year'))
+                ar.push(car.year)
+
+            chai.expect(ar).to.deep.equal([2004, 2009, 2019])
+        })
+
         it('should async iterate using select with property keys', async () => {
             let car = await new jsEnumerable.Enumerable(asyncIterator()).select('make', 'year').firstAsync()
 
@@ -395,6 +404,15 @@ describe('When using enumerable for record type', () => {
             chai.expect(ar).to.deep.equal([1990, 1999, 2004, 2009, 2019])
         })
 
+        it('should iterate using where and orderBy', async () => {
+            let ar = []
+
+            for(let car of new jsEnumerable.Enumerable(iterator()).where(it => it.year >= 2004).orderBy('year'))
+                ar.push(car.year)
+
+            chai.expect(ar).to.deep.equal([2004, 2009, 2019])
+        })
+
         it('should iterate using select with property keys', () => {
             let car = new jsEnumerable.Enumerable(iterator()).select('make', 'year').first()