Groupby

src/implements/methods.ts

@@ -23,7 +23,8 @@ import { OrderByClause } from "../methods/orderBy";
 import { OrderByDescendingClause } from "../methods/orderByDescending";
 
 export class IteratorMethods<T> implements Methods<T> {
-
+
+
  // Contains all iterators
  _iteratorCollection: Array<IIterator<T>> = [];
 
@@ -72,6 +73,10 @@ export class IteratorMethods<T> implements Methods<T> {
  return this;
  }
 
+ groupBy(iterator: (entity: T) => any): Methods<{ key: any; items: T[]; }> {
+ throw new Error("Method not implemented.");
+ }
+
  toList<S>(): Promise<S[]> {
 
  // From cache

src/intefaces/methods.interface.ts

@@ -11,6 +11,7 @@ export interface Methods<T> {
  orderByDescending(iterator: (entity: T) => T): Methods<T>;
  join<S>(source: S[] | Promise<S[]>, iterator: (aEntity: T, bEntity: S) => boolean): Methods<{ x: T, y: S }>;
  leftJoin<S, U extends T & S>(source: S[] | Promise<S[]>, iterator: (aEntity: T, bEntity: S) => boolean): Methods<U>;
+ groupBy(iterator: (entity: T) => any): Methods<{ key: any, items: T[] }>;
 
  // Execute methods
  toList<S extends T>(): Promise<S[]>;

src/methods/any.ts

@@ -5,7 +5,7 @@ export class AnyClause<T> implements IIterator<T> {
  _iterator: (item: T) => boolean;
 
  execute(source: T[] | any[]): T[] | T | any {
- if (!source) return source.length;
+ if (!source) return false;
  else {
  return (source as T[]).every((x) => {
  return this._iterator(x);

src/methods/groupBy.ts

@@ -0,0 +1,52 @@
+import { IIterator } from "../intefaces/iterator.interface";
+import { SelectClause } from "./select";
+
+export class GroupByClause<T> implements IIterator<T> {
+
+ _iterator: (item: T) => any;
+
+ execute(source: T[]): T[] | any[] {
+
+ if (!source) return null;
+
+ // Object contains all data in array follow by [index] : {object}
+ let _tmp = {};
+
+ source.forEach((x: T, i: number) => {
+ _tmp[i] = x;
+ });
+
+ // Make lookup list base on input iterator function
+ let _result = (source as T[]).map((x: T, index: number) => {
+ return {
+ value: (this._iterator(x)),
+ index: index
+ }
+ });
+
+ let _distinctGroupByValues =
+ this.distinct(new SelectClause(this._iterator).execute(source));
+
+ // Prepare
+ let _keyLookup = {};
+ _distinctGroupByValues.forEach(key => {
+ _keyLookup[key] = [];
+ });
+
+ if (!_result) return null;
+
+ _result.forEach(lk => {
+ _keyLookup[lk.value] = _tmp[lk.index];
+ });
+ }
+
+ constructor(func: (item: T) => any) {
+ this._iterator = func;
+ }
+
+ private distinct(array: any[]) {
+ return array.filter((val, index, self) => {
+ return self.indexOf(val) === index;
+ });
+ }
+}