@thisisagile/easy 13.6.10 → 13.6.12

package/src/sql/TableGateway.ts

@@ -1,4 +1,4 @@
-import { Gateway, Id, isDefined, Json, List, Optional, PageOptions } from '../types';
+import { Gateway, Id, isDefined, Json, Optional, PageList, PageOptions, toPageList } from '../types';
 import { QueryProvider } from '../data';
 import { when } from '../validation';
 import { ifDefined } from '../utils';
@@ -13,10 +13,15 @@ export class TableGateway<T extends Table> extends Gateway<PageOptions> {
 
   protected provide = ({ provider }: TableOptions = {}): QueryProvider => provider ?? this.provider;
 
-  all(options?: TableOptions): Promise<List<Json>> {
+  all(options?: TableOptions): Promise<PageList<Json>> {
     return this.provide(options)
       .query(this.table.select())
-      .then(js => js.map(j => this.table.in(j)));
+      .then(js =>
+        toPageList(
+          js.map(j => this.table.in(j)),
+          options
+        )
+      );
   }
 
   byId(id: Id, options?: TableOptions): Promise<Optional<Json>> {

package/src/types/List.ts

@@ -11,9 +11,13 @@ import { meta } from './Meta';
 import { Optional } from './Types';
 
 export class List<T = unknown> extends Array<T> {
-  asc = (p: GetProperty<T, any>): List<T> => this.sort((e1, e2) => (ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1));
+  asc(p: GetProperty<T, any>): List<T> {
+    return this.sort((e1, e2) => (ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1));
+  }
 
-  desc = (p: GetProperty<T, any>): List<T> => this.sort((e1, e2) => (ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1));
+  desc(p: GetProperty<T, any>): List<T> {
+    return this.sort((e1, e2) => (ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1));
+  }
 
   first = (p?: (value: T, index: number, array: T[]) => unknown, params?: unknown): T => (p ? this.find(p, params) : this[0]) as T;
 
@@ -31,13 +35,21 @@ export class List<T = unknown> extends Array<T> {
 
   overlaps = (...items: ArrayLike<T>): boolean => toList<T>(...items).some(i => this.some(t => i === t));
 
-  diff = (others: ArrayLike<T>): List<T> => this.filter(i => !others.includes(i));
+  diff(others: ArrayLike<T>): List<T> {
+    return this.filter(i => !others.includes(i));
+  }
 
-  diffByKey = (others: ArrayLike<T>, key: keyof T): List<T> => this.filter((i: any) => !others.some((o: any) => o[key] === i[key]));
+  diffByKey(others: ArrayLike<T>, key: keyof T): List<T> {
+    return this.filter((i: any) => !others.some((o: any) => o[key] === i[key]));
+  }
 
-  intersect = (others: ArrayLike<T>): List<T> => this.filter(i => others.includes(i));
+  intersect(others: ArrayLike<T>): List<T> {
+    return this.filter(i => others.includes(i));
+  }
 
-  intersectByKey = (others: ArrayLike<T>, key: keyof T): List<T> => this.filter((i: any) => others.some((o: any) => o[key] === i[key]));
+  intersectByKey(others: ArrayLike<T>, key: keyof T): List<T> {
+    return this.filter((i: any) => others.some((o: any) => o[key] === i[key]));
+  }
 
   toJSON = (): Json[] =>
     this.reduce((a, i) => {
@@ -45,49 +57,82 @@ export class List<T = unknown> extends Array<T> {
       return a;
     }, new Array<Json>());
 
-  map = <U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<U> => toList<U>(super.map(f, params));
+  map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<U> {
+    return toList<U>(super.map(f, params));
+  }
 
-  flatMap = <U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): List<U> =>
-    toList<U>(super.flatMap(f, params));
+  flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): List<U> {
+    return toList<U>(super.flatMap(f, params));
+  }
 
-  mapDefined = <U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<NonNullable<U>> => this.map(f, params).defined();
+  mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<NonNullable<U>> {
+    return this.map(f, params).defined();
+  }
 
-  mapAsync = (f: (i: T) => Promise<T>): Promise<List<T>> => Promise.all(super.map(e => f(e))).then(a => toList<T>(a));
+  mapAsync(f: (i: T) => Promise<T>): Promise<List<T>> {
+    return Promise.all(super.map(e => f(e))).then(a => toList<T>(a));
+  }
 
-  distinct = (): List<T> => this.filter((i, index) => this.indexOf(i) === index);
+  distinct(): List<T> {
+    return this.filter((i, index) => this.indexOf(i) === index);
+  }
 
-  distinctByKey = (key: keyof T): List<T> => meta(this.toObject(key)).values();
+  distinctByKey(key: keyof T): List<T> {
+    return meta(this.toObject(key)).values();
+  }
 
-  filter = (p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T> => toList<T>(super.filter(p, params));
+  filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T> {
+    return toList<T>(super.filter(p, params));
+  }
 
   sum = (p: (t: T) => number): number => this.reduce((sum: number, i) => sum + p(i), 0);
 
   byId = (id: Id): T => this.first(i => asString((i as any).id) === asString(id));
 
-  add = (...items: (T | T[])[]): this => {
+  add = (...items: ArrayLike<T>): this => {
     super.push(...toArray(...items));
     return this;
   };
 
-  remove = (item: T): List<T> => {
+  concat(...items: ConcatArray<T>[]): List<T>;
+  concat(...items: (T | ConcatArray<T>)[]): List<T>;
+  concat(...items: (T | ConcatArray<T>)[]): List<T> {
+    return toList<T>(super.concat(...items));
+  }
+
+  reverse(): List<T> {
+    return toList<T>(super.reverse());
+  }
+
+  splice(start: number, deleteCount?: number): List<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): List<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): List<T> {
+    return toList<T>(super.splice(start, deleteCount, ...items));
+  }
+
+  remove(item: T): List<T> {
     const index = this.indexOf(item);
     if (index > -1) {
       this.splice(index, 1);
     }
     return this;
-  };
+  }
 
-  replace = (key: keyof T, item: T): List<T> => {
+  replace(key: keyof T, item: T): List<T> {
     tryTo(() => item[key])
       .map(k => this.findIndex(i => i[key] === k))
       .filter(i => i > -1)
       .map(i => (this[i] = item));
     return this;
-  };
+  }
 
-  switch = (item: T): List<T> => (this.includes(item) ? this.remove(item) : this.add(item));
+  switch(item: T): List<T> {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
 
-  defined = (): List<NonNullable<T>> => this.reduce((l, v) => (isDefined(v) ? l.add(v) : l), toList<NonNullable<T>>());
+  defined(): List<NonNullable<T>> {
+    return this.reduce((l, v) => (isDefined(v) ? l.add(v) : l), toList<NonNullable<T>>());
+  }
 
   toObject = (key: keyof T, options: { deleteKey?: boolean } = {}): Record<string | number | symbol, T> =>
     this.reduce((o: any, i) => {
@@ -104,7 +149,9 @@ export class List<T = unknown> extends Array<T> {
       return a;
     }, {} as Record<string | number | symbol, List<T>>);
 
-  orElse = (...alt: ArrayLike<T>): Optional<List<T>> => (!isEmpty(this) ? this : !isEmpty(...alt) ? toList<T>(...alt) : undefined);
+  orElse(...alt: ArrayLike<T>): Optional<List<T>> {
+    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList<T>(...alt) : undefined;
+  }
 
   weave = (insertFrom: T[], interval: number): this => {
     for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {

package/src/types/PageList.ts

@@ -1,7 +1,12 @@
-import { isList, List, toList } from './List';
-import { Construct, ofConstruct, on } from './Constructor';
+import { isList, List } from './List';
+import { Construct, ofConstruct } from './Constructor';
 import { isA } from './IsA';
 import { PlainSort, Sort } from './Sort';
+import { GetProperty } from './Get';
+import { ArrayLike } from './Array';
+import { Optional } from './Types';
+import { isNumber } from './Is';
+import { choose } from './Case';
 
 export type FilterValue = { label?: string; value: any };
 export type Filter = { label?: string; field: string; shortField?: string; values: FilterValue[] };
@@ -14,21 +19,147 @@ export const toShortFilter = (field: string, shortField: string, value: any): Fi
 });
 
 export type PageOptions = { take?: number; skip?: number; sort?: Sort[]; sorts?: PlainSort; filters?: Filter[] };
-export type PageList<T> = List<T> & Omit<PageOptions, 'sort'> & { total?: number };
-
-export const isPageList = <T>(l?: T[]): l is PageList<T> => isList<T>(l) && isA(l, 'total');
-
-export const toPageList = <T>(items?: T[], options?: Omit<PageOptions, 'sort'> & { total?: number }): PageList<T> =>
-  on(toList<T>(...(items ?? [])) as PageList<T>, l => {
-    l.take = options?.take ?? 250;
-    l.skip = options?.skip ?? 0;
-    l.total = options?.total;
-    l.sorts = options?.sorts;
-    l.filters = options?.filters;
-  });
-
-export const asPageList = <T, U>(c: Construct<T>, items = toPageList<U>()): PageList<T> =>
-  toPageList<T>(
-    items.map(i => ofConstruct(c, i)),
-    items
-  );
+
+export class PageList<T> extends List<T> {
+  private _take = 250;
+  private _skip = 0;
+  private _total?: number;
+  private _sorts?: PlainSort;
+  private _filters?: Filter[];
+
+  setPageOptions(options?: PageOptions & { total?: number }): this {
+    this._take = options?.take ?? 250;
+    this._skip = options?.skip ?? 0;
+    this._total = options?.total;
+    this._sorts = options?.sorts;
+    this._filters = options?.filters;
+    return this;
+  }
+
+  get take(): number {
+    return this._take;
+  }
+
+  get skip(): number {
+    return this._skip;
+  }
+
+  get total(): Optional<number> {
+    return this._total;
+  }
+
+  get sorts(): Optional<PlainSort> {
+    return this._sorts;
+  }
+
+  get filters(): Optional<Filter[]> {
+    return this._filters;
+  }
+
+  asc(p: GetProperty<T, any>): PageList<T> {
+    return toPageList(super.asc(p), this);
+  }
+
+  desc(p: GetProperty<T, any>): PageList<T> {
+    return toPageList(super.desc(p), this);
+  }
+
+  diff(others: ArrayLike<T>): PageList<T> {
+    return toPageList(super.diff(others), this);
+  }
+
+  diffByKey(others: ArrayLike<T>, key: keyof T): PageList<T> {
+    return toPageList(super.diffByKey(others, key), this);
+  }
+
+  intersect(others: ArrayLike<T>): PageList<T> {
+    return toPageList(super.intersect(others), this);
+  }
+
+  intersectByKey(others: ArrayLike<T>, key: keyof T): PageList<T> {
+    return toPageList(super.intersectByKey(others, key), this);
+  }
+
+  map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<U> {
+    const items = super.map(f, params);
+    return toPageList(items, this);
+  }
+
+  flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): PageList<U> {
+    return toPageList(super.flatMap(f, params), this);
+  }
+
+  mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<NonNullable<U>> {
+    return toPageList(super.mapDefined(f, params), this);
+  }
+
+  mapAsync(f: (i: T) => Promise<T>): Promise<PageList<T>> {
+    return super.mapAsync(f).then(r => toPageList(r, this));
+  }
+
+  distinct(): PageList<T> {
+    return toPageList(super.distinct(), this);
+  }
+
+  distinctByKey(key: keyof T): PageList<T> {
+    return toPageList(super.distinctByKey(key), this);
+  }
+
+  filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): PageList<T> {
+    return toPageList(super.filter(p, params), this);
+  }
+
+  concat(...items: ConcatArray<T>[]): PageList<T>;
+  concat(...items: (T | ConcatArray<T>)[]): PageList<T>;
+  concat(...items: (T | ConcatArray<T>)[]): PageList<T> {
+    return toPageList(super.concat(...items), this);
+  }
+
+  reverse(): PageList<T> {
+    return toPageList(super.reverse(), this);
+  }
+
+  splice(start: number, deleteCount?: number): PageList<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): PageList<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): PageList<T> {
+    return toPageList(super.splice(start, deleteCount, ...items), this);
+  }
+
+  remove(item: T): PageList<T> {
+    return toPageList(super.remove(item), this);
+  }
+
+  replace(key: keyof T, item: T): PageList<T> {
+    return toPageList(super.replace(key, item), this);
+  }
+
+  switch(item: T): PageList<T> {
+    return toPageList(super.switch(item), this);
+  }
+
+  defined(): PageList<NonNullable<T>> {
+    return toPageList(super.defined(), this);
+  }
+
+  orElse(...alt: ArrayLike<T>): Optional<PageList<T>> {
+    return toPageList(super.orElse(...alt), this);
+  }
+
+  slice(start?: number, end?: number): PageList<T> {
+    return toPageList(super.slice(start, end), this);
+  }
+}
+
+export const isPageList = <T>(l?: unknown): l is PageList<T> => isList<T>(l) && isA(l, 'total');
+
+export const toPageList = <T>(items: T[] = [], options?: Omit<PageOptions, 'sort'> & { total?: number }): PageList<T> =>
+  choose(items)
+    .case(
+      i => i.length === 1 && isNumber(i[0]),
+      i => new PageList<T>().add(...i)
+    )
+    .else(i => new PageList<T>(...i))
+    .setPageOptions(options);
+
+/* @deprecated No longer needed as the PageList is now a class that extends from List, use the map function */
+export const asPageList = <T, U>(c: Construct<T>, items = toPageList<U>()): PageList<T> => items.map(i => ofConstruct(c, i));

package/src/utils/If.ts

@@ -1,6 +1,8 @@
-import {Construct, isDefined, isNotEmpty, isTrue, ofConstruct, Optional} from '../types';
+import { Construct, isDefined, isNotEmpty, isTrue, ofConstruct, Optional } from '../types';
 
 export const ifTrue = <T>(o: unknown, f: Construct<T>, alt?: Construct<T>): Optional<T> => (isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o));
 export const ifFalse = <T>(o: unknown, f: Construct<T>, alt?: Construct<T>): Optional<T> => (!isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o));
-export const ifDefined = <Out, In = unknown>(o: Optional<In>, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out> => (isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt));
-export const ifNotEmpty = <T>(o: unknown, f: Construct<T> = o => o, alt?: Construct<T>): Optional<T> => isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+export const ifDefined = <Out, In = unknown>(o: Optional<In>, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out> =>
+  isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt);
+export const ifNotEmpty = <T>(o: unknown, f: Construct<T> = o => o, alt?: Construct<T>): Optional<T> =>
+  isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);

package/src/utils/View.ts

@@ -29,13 +29,13 @@ export type InOut = { in?: Func | View; col?: string };
 const isColOnly = (v: unknown): v is InOut => isObject(v) && isDefined(v.col) && !isDefined(v.in);
 const isInOnly = (v: unknown): v is InOut => isObject(v) && !isDefined(v.col) && isFunction(v.in);
 const isColAndFunction = (
-  v: unknown,
+  v: unknown
 ): v is {
   col: string;
   in: Func;
 } => isObject(v) && isDefined(v.col) && isFunction(v.in);
 const isColAndView = (
-  v: unknown,
+  v: unknown
 ): v is {
   col: string;
   in: View;
@@ -50,9 +50,9 @@ const toFunc = (a: any, col: string, f: Func = a => a): Func =>
 const toViewer = (key: string, value: unknown): Viewer =>
   choose(value)
     .is.not.defined(
-    v => v,
-    () => toViewer(key, () => undefined),
-  )
+      v => v,
+      () => toViewer(key, () => undefined)
+    )
     .type(isBoolean, b => toViewer(key, () => b))
     .type(isNumber, n => toViewer(key, () => n))
     .type(isString, s => toViewer(key, (a: any) => toFunc(a, s)(a)))
@@ -60,7 +60,7 @@ const toViewer = (key: string, value: unknown): Viewer =>
     .type(isFunction, f => toViewer(key, { in: { key, f } }))
     .type(isInOnly, io => toViewer(key, { in: { key, f: io.in } }))
     .type(isColAndFunction, io => toViewer(key, { in: { key, f: (a: any) => toFunc(a, io.col, io.in)(a) } }))
-    .type(isColAndView, io => toViewer(key, { in: { key, f: (a: any) => toFunc(a, io.col, io.in.from)(a) } }))
+    .type(isColAndView, io => toViewer(key, { in: { key, f: (a: any) => io.in.from(traverse(a, io.col)) } }))
     .else(v => v as Viewer);
 
 const toViewers = (views: Views): Viewer[] =>
@@ -69,22 +69,25 @@ const toViewers = (views: Views): Viewer[] =>
     .map(([k, v]) => toViewer(k, v));
 
 export class View<V = Json> {
-  constructor(private views: Views<V> = {} as Views<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {
-  }
+  constructor(private views: Views<V> = {} as Views<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {}
 
   get fromSource(): View<V> {
     return new View(this.views, 'source', this.viewers);
   }
 
-  from = <T = unknown>(source: T): T extends PageList<infer V> ? PageList<V> : T extends List<infer V> ? List<V> : T extends Array<infer V> ? V[] : V =>
-    isArray(source)
-      ? isPageList(source)
-        ? toPageList(
-          source.map(s => this.reduce(asJson(s))),
-          source,
-        )
-        : source.map(s => this.reduce(asJson(s)))
-      : this.reduce(asJson(source));
+  from<T = unknown>(source: PageList<T>): PageList<V>;
+  from<T = unknown>(source: List<T>): List<V>;
+  from<T = unknown>(source: T[]): V[];
+  from<T = unknown>(source: T): V;
+  from<T = unknown>(source: PageList<T> | List<T> | T[] | T): PageList<V> | List<V> | V[] | V {
+    if (isPageList(source))
+      return toPageList(
+        source.map(s => this.reduce(asJson(s))),
+        source
+      );
+    if (isArray(source)) return source.map(s => this.reduce(asJson(s)));
+    return this.reduce(asJson(source));
+  }
 
   same = (one?: unknown, another?: unknown): boolean => isEqual(this.from(one), this.from(another));
 
@@ -101,11 +104,11 @@ export const views = {
   keepOr: (alt?: unknown) => (a: unknown, key?: string) => traverse(a, key) ?? alt,
   or:
     (key: string, alt = '') =>
-      (a: unknown) =>
-        traverse(a, key) ?? alt,
+    (a: unknown) =>
+      traverse(a, key) ?? alt,
   value: (value: unknown) => () => value,
   to:
     <T>(ctor: Constructor<T>) =>
-      (a: unknown, key?: string) =>
-        new ctor(traverse(a, key)),
+    (a: unknown, key?: string) =>
+      new ctor(traverse(a, key)),
 };