@thisisagile/easy 15.29.2 → 15.29.3

package/src/sql/Clause.ts

@@ -1,10 +1,17 @@
-import { isA, isBoolean, isNumber, Text, TypeGuard } from '../types';
-import { convert, Convert } from '../utils';
+import { isBoolean, isNumber } from '../types/Is';
+import { convert, Convert } from '../utils/Convert';
+import { TypeGuard } from '../types/TypeGuard';
+import { isA } from '../types/IsA';
+import type { Text } from '../types/Text';
 
 export const quote = (a: unknown): string => (isNumber(a) || isBoolean(a) || isClause(a) ? a.toString() : `'${a as string}'`);
 
 export class Clause implements Text {
-  constructor(readonly first: unknown, readonly operator: string, readonly second: unknown) {}
+  constructor(
+    readonly first: unknown,
+    readonly operator: string,
+    readonly second: unknown
+  ) {}
 
   and = (other: Clause): Clause => new ParathesizedClause(this, 'AND', other);
   or = (other: Clause): Clause => new ParathesizedClause(this, 'OR', other);

package/src/sql/Column.ts

@@ -1,10 +1,17 @@
-import { Property, PropertyOptions } from '../utils';
 import { Clause, toClause } from './Clause';
-import { Json, JsonValue, ofGet, Text, tryTo } from '../types';
 import { Table } from './Table';
+import { Property, PropertyOptions } from '../utils/Property';
+import { Json, JsonValue } from '../types/Json';
+import { tryTo } from '../types/Try';
+import { ofGet } from '../types/Get';
+import type { Text } from '../types/Text';
 
 export class Column extends Property implements Text {
-  constructor(readonly owner: Table, property: string, options?: PropertyOptions) {
+  constructor(
+    readonly owner: Table,
+    property: string,
+    options?: PropertyOptions
+  ) {
     super(property, options);
   }
 
@@ -85,7 +92,10 @@ export class Column extends Property implements Text {
 }
 
 export class PatternColumn extends Column {
-  constructor(protected col: Column, protected pattern: string) {
+  constructor(
+    protected col: Column,
+    protected pattern: string
+  ) {
     super(col.owner, col.property);
   }
 

package/src/sql/Count.ts

@@ -1,5 +1,5 @@
-import { ifGet } from '../types';
 import { Select } from './Select';
+import { ifGet } from '../types/Get';
 
 export class Count extends Select {
   toString(): string {

package/src/sql/Delete.ts

@@ -1,5 +1,5 @@
 import { SqlQuery } from './SqlQuery';
-import { ifGet } from '../types';
+import { ifGet } from '../types/Get';
 
 export class Delete extends SqlQuery {
   toString(): string {

package/src/sql/Insert.ts

@@ -1,10 +1,13 @@
 import { SqlQuery } from './SqlQuery';
-import { Json } from '../types';
 import { quote } from './Clause';
 import { Table } from './Table';
+import { Json } from '../types/Json';
 
 export class Insert extends SqlQuery {
-  constructor(protected table: Table, protected fields: Json) {
+  constructor(
+    protected table: Table,
+    protected fields: Json
+  ) {
     super(table);
   }
 

package/src/sql/Select.ts

@@ -1,8 +1,9 @@
-import { ifGet, List, toList } from '../types';
 import { Column, OrderColumn } from './Column';
 import { Join } from './Join';
 import { SqlQuery } from './SqlQuery';
 import { Table } from './Table';
+import { List, toList } from '../types/List';
+import { ifGet } from '../types/Get';
 
 export class Select extends SqlQuery {
   protected ordered: List<OrderColumn> = toList();
@@ -11,7 +12,10 @@ export class Select extends SqlQuery {
   protected _limit = 0;
   protected _offset = 0;
 
-  constructor(table: Table | Join, readonly columns: List<Column> = toList()) {
+  constructor(
+    table: Table | Join,
+    readonly columns: List<Column> = toList()
+  ) {
     super(table);
   }
 

package/src/sql/SqlQuery.ts

@@ -1,8 +1,14 @@
-import { Clause, Join, List, Table, toList } from '../index';
-import { Query } from '../data';
+import { Query } from '../data/Query';
+import { Table } from './Table';
+import { Join } from './Join';
+import { List, toList } from '../types/List';
+import { Clause } from './Clause';
 
 export class SqlQuery implements Query {
-  constructor(protected table: Table | Join, readonly clauses: List<Clause> = toList()) {}
+  constructor(
+    protected table: Table | Join,
+    readonly clauses: List<Clause> = toList()
+  ) {}
 
   where = (...clauses: Clause[]): this => {
     this.clauses.add(clauses);

package/src/sql/Table.ts

@@ -1,13 +1,16 @@
 import { Column } from './Column';
-import { MapOptions, Mapper, mappings, PropertyOptions } from '../utils';
-import { Database } from '../data';
-import { Json, toList, toUuid } from '../types';
 import { Select } from './Select';
 import { Insert } from './Insert';
 import { Update } from './Update';
 import { Delete } from './Delete';
 import { Join } from './Join';
 import { Count } from './Count';
+import { MapOptions, Mapper, mappings } from '../utils/Mapper';
+import { PropertyOptions } from '../utils/Property';
+import { toUuid } from '../types/Uuid';
+import { Database } from '../data/Database';
+import { toList } from '../types/List';
+import { Json } from '../types/Json';
 
 export class Table extends Mapper {
   protected readonly map = {

package/src/sql/TableGateway.ts

@@ -1,13 +1,21 @@
-import { Gateway, Id, isDefined, Json, Optional, PageList, PageOptions, toPageList } from '../types';
-import { QueryProvider } from '../data';
-import { when } from '../validation';
-import { ifDefined } from '../utils';
 import { Table } from './Table';
+import { PageList, PageOptions, toPageList } from '../types/PageList';
+import { QueryProvider } from '../data/QueryProvider';
+import { Gateway } from '../types/Gateway';
+import { Json } from '../types/Json';
+import { Id } from '../types/Id';
+import { Optional } from '../types/Types';
+import { ifDefined } from '../utils/If';
+import { isDefined } from '../types/Is';
+import { when } from '../validation/When';
 
 export type TableOptions = PageOptions & { provider?: QueryProvider };
 
 export class TableGateway<T extends Table> extends Gateway<PageOptions> {
-  constructor(readonly table: T, readonly provider = table.db.provide<QueryProvider>()) {
+  constructor(
+    readonly table: T,
+    readonly provider = table.db.provide<QueryProvider>()
+  ) {
     super();
   }
 

package/src/sql/Update.ts

@@ -1,10 +1,14 @@
 import { SqlQuery } from './SqlQuery';
-import { ifGet, Json } from '../types';
 import { toClause } from './Clause';
 import { Table } from './Table';
+import { Json } from '../types/Json';
+import { ifGet } from '../types/Get';
 
 export class Update extends SqlQuery {
-  constructor(protected table: Table, protected fields: Json) {
+  constructor(
+    protected table: Table,
+    protected fields: Json
+  ) {
     super(table);
   }
 

package/src/types/CacheAge.ts

@@ -1,4 +1,6 @@
-import { asNumber, asString, choose } from './index';
+import { asNumber } from './Number';
+import { choose } from './Case';
+import { asString } from './Text';
 
 export type CacheAge = `${number}${'ms' | 's' | 'm' | 'h' | 'd'}` | number;
 

package/src/types/Case.ts

@@ -1,5 +1,9 @@
-import { Func, Get, isDefined, isEmpty, ofGet, Predicate, tryTo, TypeGuard } from './index';
-import { validate } from '../validation';
+import { Get, ofGet, Predicate } from './Get';
+import { TypeGuard } from './TypeGuard';
+import { Func } from './Func';
+import { isDefined, isEmpty } from './Is';
+import { validate } from '../validation/Validate';
+import { tryTo } from './Try';
 
 class CaseBuilder<V> {
   constructor(readonly v: V) {}
@@ -31,7 +35,10 @@ class CaseBuilder<V> {
 }
 
 class Case<T, V = unknown> {
-  constructor(protected value: V, protected outcome?: T) {}
+  constructor(
+    protected value: V,
+    protected outcome?: T
+  ) {}
 
   case(pred: Predicate<V>, out: Get<T, V>): Case<T, V> {
     return tryTo(pred, this.value)
@@ -72,7 +79,10 @@ class Case<T, V = unknown> {
 }
 
 class Found<T, V> extends Case<T, V> {
-  constructor(protected value: V, protected outcome: T) {
+  constructor(
+    protected value: V,
+    protected outcome: T
+  ) {
     super(value, outcome);
   }
 

package/src/types/Constructor.ts

@@ -1,6 +1,6 @@
 import { Get } from './Get';
 import { isFunc } from './Func';
-import { isDefined } from './Is';
+import { isDefined, isFunction } from './Is';
 import { isPrimitive } from './Primitive';
 import { Optional } from './Types';
 
@@ -10,6 +10,8 @@ export type Construct<Out, In = any> = Get<Out, In> | Constructor<Out>;
 
 export const isConstructor = <T>(c?: unknown): c is Constructor<T> => (isDefined(c) && isFunc<T, unknown>(c) && c.prototype && c.prototype.constructor) === c;
 
+export const isInstance = <T>(ctor: Constructor<T>, o?: unknown): o is T => isFunction(ctor) && o instanceof ctor;
+
 export const ofConstruct = <T>(c: Construct<T>, ...args: unknown[]): T => (isConstructor<T>(c) ? new c(...args) : isFunc<T, unknown>(c) ? c(...args) : c);
 
 export const toName = (subject?: unknown, postfix = ''): string => (subject as any)?.constructor?.name?.replace(postfix, '').toLowerCase() ?? '';

package/src/types/Context.ts

@@ -1,8 +1,7 @@
 import { Uuid } from './Uuid';
-import { text } from './Text';
 import { Identity } from './Identity';
-import { tryTo } from './Try';
 import { Optional } from './Types';
+import { text } from './Template';
 
 export interface EnvContext {
   readonly domain: string;
@@ -21,12 +20,12 @@ export class DotEnvContext implements EnvContext {
   readonly port = Number.parseInt(process.env.PORT ?? '8080');
   readonly app = process.env.APP ?? '';
 
-  readonly get = (key: string, alt?: string): Optional<string> =>
-    tryTo(() =>
-      text(key)
-        .map(k => k.replace(/([a-z])([A-Z])/g, '$1 $2'))
-        .snake.toString()
-    ).map(k => process.env[k] ?? alt).value;
+  readonly get = (key: string, alt?: string): Optional<string> => {
+    const k = text(key)
+      .map(k => k.replace(/([a-z])([A-Z])/g, '$1 $2'))
+      .snake.toString();
+    return process.env[k] ?? alt;
+  };
 }
 
 export interface RequestContext {

package/src/{domain/enums → types}/Environment.ts

@@ -1,4 +1,4 @@
-import { Enum } from '../../types';
+import { Enum } from './Enum';
 
 export class Environment extends Enum {
   static readonly Dev = new Environment('Development', 'dev');

package/src/types/ErrorOrigin.ts

@@ -1,6 +1,6 @@
 import { Text } from './Text';
 import { Exception } from './Exception';
-import { Response } from '../http';
+import { Response } from '../http/Response';
 import { Results } from './Results';
 import { Result } from './Result';
 

package/src/types/Exception.ts

@@ -1,7 +1,8 @@
-import { asString, Text, text } from './Text';
+import { asString, Text } from './Text';
 import { Enum } from './Enum';
 import { isDefined } from './Is';
 import { Id } from './Id';
+import { text } from './Template';
 
 export class Exception extends Enum {
   static readonly AlreadyExists = new Exception('Subject already exists');
@@ -11,7 +12,11 @@ export class Exception extends Enum {
   static readonly IsNotValid = new Exception('Is not valid');
   static readonly Unknown = new Exception('Unknown error');
 
-  constructor(readonly message: string, id?: Id, readonly reason?: Text) {
+  constructor(
+    readonly message: string,
+    id?: Id,
+    readonly reason?: Text
+  ) {
     super(message, id ?? text(message).pascal.toString());
   }
 

package/src/types/Gateway.ts

@@ -1,10 +1,10 @@
 import { Json, JsonValue } from './Json';
 import { Id } from './Id';
 import { Exception } from './Exception';
-import { reject } from '../utils';
 import { PageList, PageOptions } from './PageList';
 import { List } from './List';
 import { Optional } from './Types';
+import { reject } from '../utils/Promise';
 
 export type FetchOptions = PageOptions;
 

package/src/types/Is.ts

@@ -1,6 +1,3 @@
-import { Constructor, use } from './Constructor';
-import { Identity } from './Identity';
-
 export const isDefined = <T = unknown>(o?: T): o is NonNullable<T> => o !== undefined && o !== null;
 
 export const isUndefined = (v?: unknown): v is never => v === undefined || v === null;
@@ -28,16 +25,12 @@ export const isFunction = (o?: unknown): o is (...params: unknown[]) => unknown
 
 export const isArray = <T = any>(o?: unknown): o is Array<T> => isDefined(o) && o instanceof Array;
 
-export const isInstance = <T>(ctor: Constructor<T>, o?: unknown): o is T => isFunction(ctor) && o instanceof ctor;
-
 export const isIn = (o: unknown, values: unknown[]): boolean => isArray(values) && values.some(v => v === o);
 
 export const isIntersecting = (o?: unknown[], values?: unknown[]): boolean => isArray(o) && isArray(values) && o.some(ov => isIn(ov, values));
 
 export const isError = (e: unknown): e is Error => isDefined(e) && e instanceof Error;
 
-export const isIdentity = (by: unknown): by is Identity => use(by as Identity, b => isObject(b) && isDefined(b.id));
-
 export const isNotPresent = (...os: unknown[]): boolean =>
   os.some(
     o =>

package/src/types/IsA.ts

@@ -1,4 +1,8 @@
 import { isPrimitive } from './Primitive';
+import { Identity } from './Identity';
+import { use } from './Constructor';
+import { isDefined, isObject } from './Is';
 
 export const isA = <T>(t?: unknown, ...properties: (keyof T)[]): t is T => !isPrimitive(t) && properties.every(p => p.toString() in (t as any));
 export const isAn = isA;
+export const isIdentity = (by: unknown): by is Identity => use(by as Identity, b => isObject(b) && isDefined(b.id));

package/src/types/Json.ts

@@ -1,9 +1,9 @@
 import { isA } from './IsA';
 import { isEmpty, isObject } from './Is';
 import { Get, ofGet } from './Get';
-import { ifDefined } from '../utils';
+import { ifDefined } from '../utils/If';
 import { TypeGuard } from './TypeGuard';
-import { entries } from './Meta';
+import { entries } from './Object';
 
 export type JsonValue = string | number | boolean | null | Json | JsonValue[];
 export type Json = { [key: string]: JsonValue };

package/src/types/List.ts

@@ -1,14 +1,13 @@
 import { ArrayLike, toArray } from './Array';
 import { Constructor, on } from './Constructor';
-import { json, Json } from './Json';
+import type { Json } from './Json';
 import { isArray, isDefined, isEmpty } from './Is';
 import { isA } from './IsA';
 import { Get, GetProperty, ofGet, ofProperty } from './Get';
-import { Id } from './Id';
+import type { Id } from './Id';
 import { asString } from './Text';
-import { tryTo } from './Try';
-import { meta } from './Meta';
 import { Optional } from './Types';
+import { ifDefined, ifTrue } from '../utils/If';
 
 export class List<T = unknown> extends Array<T> {
   asc(p: GetProperty<T, any>): List<T> {
@@ -24,7 +23,11 @@ export class List<T = unknown> extends Array<T> {
   }
 
   firstValue<V>(f: (t: T) => V, alt?: Get<V, T>): Optional<V> {
-    return tryTo(() => this.first(t => !!f(t))).map(i => (i ? f(i) : ofGet(alt, i))).value;
+    return ifDefined(
+      this.first(t => !!f(t)),
+      f,
+      v => ofGet(alt, v)
+    );
   }
 
   isFirst(value: T): boolean {
@@ -76,7 +79,7 @@ export class List<T = unknown> extends Array<T> {
 
   toJSON(): Json[] {
     return this.reduce((a, i) => {
-      a.push(json.parse(i));
+      a.push(JSON.parse(JSON.stringify(i ?? {})));
       return a;
     }, new Array<Json>());
   }
@@ -102,7 +105,7 @@ export class List<T = unknown> extends Array<T> {
   }
 
   distinctByKey(key: keyof T): List<T> {
-    return meta(this.toObject(key)).values();
+    return toList([...Object.values<T>(this.toObject(key)), ...Object.values<T>(Object.getPrototypeOf(this.toObject(key)))]);
   }
 
   filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T> {
@@ -155,10 +158,8 @@ export class List<T = unknown> extends Array<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));
+    const index = this.findIndex(i => i[key] === item?.[key]);
+    ifTrue(index != -1, () => this.splice(index, 1, item));
     return this;
   }
 
@@ -218,7 +219,7 @@ export const toList = <T = unknown>(...items: ArrayLike<T>): List<T> => new List
 
 export const isList = <T>(l?: unknown): l is List<T> => isDefined(l) && isArray(l) && isA<List<T>>(l, 'first', 'last', 'asc', 'desc');
 
-export const asList = <T>(c: Constructor<T>, items: unknown | unknown[] = []): List<T> => toList<T>(toArray(items).map(i => new c(i)));
+export const asList = <T>(c: Constructor<T>, items: unknown = []): List<T> => toList<T>(toArray(items).map(i => new c(i)));
 
 export const maxValue = <T>(l: List<T>, key: keyof T): T[keyof T] | undefined => l.desc(key).first()?.[key];
 

package/src/types/Meta.ts

@@ -3,13 +3,15 @@ import { List, toList } from './List';
 import { isDefined } from './Is';
 import { on, use } from './Constructor';
 import { Optional } from './Types';
+import { Entry, entries, values } from './Object';
 
 type MetaParseOptions = { initial?: any; skipUndefined?: boolean };
 
-type Entry<T = unknown> = [key: string, value: T];
-
 class ClassMeta {
-  constructor(readonly subject: any, private readonly data: any = (subject.prototype ?? subject).constructor) {}
+  constructor(
+    readonly subject: any,
+    private readonly data: any = (subject.prototype ?? subject).constructor
+  ) {}
 
   get = <T>(key: string): T => Reflect.getMetadata(key, this.data) as T;
 
@@ -18,8 +20,7 @@ class ClassMeta {
     return value;
   };
 
-  entries = <T = unknown>(): List<Entry<T>> =>
-    toList([...Object.entries(this.subject), ...Object.entries(Object.getPrototypeOf(this.subject))]) as List<Entry<T>>;
+  entries = <T = unknown>(): List<Entry<T>> => entries<T>(this.subject);
 
   parse = <Out, Value>(f: (v: Value) => Out, options: MetaParseOptions = {}): Record<string, Out> => {
     const { initial = {}, skipUndefined = false } = options;
@@ -36,13 +37,17 @@ class ClassMeta {
       .map(p => p.get<T>(key))
       .reduce((list, u) => (u ? list.add(u) : list), toList<T>());
 
-  values = <T = unknown>(): List<T> => toList([...Object.values<T>(this.subject), ...Object.values<T>(Object.getPrototypeOf(this.subject))]);
+  values = <T = unknown>(): List<T> => values<T>(this.subject);
 
   property = (property: string | symbol): PropertyMeta => new PropertyMeta(this.subject, property);
 }
 
 class PropertyMeta {
-  constructor(readonly subject: any, readonly property: string | symbol, private readonly data = Reflect.getMetadata(property, subject)) {}
+  constructor(
+    readonly subject: any,
+    readonly property: string | symbol,
+    private readonly data = Reflect.getMetadata(property, subject)
+  ) {}
 
   get value(): any {
     return this.subject[this.property];
@@ -57,5 +62,3 @@ class PropertyMeta {
 }
 
 export const meta = (subject: unknown): ClassMeta => new ClassMeta(subject ?? {});
-
-export const entries = <T = unknown>(subject: Record<string, T>): List<Entry<T>> => meta(subject).entries<T>();

package/src/types/Object.ts

@@ -0,0 +1,16 @@
+import { List, toList } from './List';
+import { ifDefined } from '../utils/If';
+
+export type Entry<T = unknown> = [key: string, value: T];
+
+export function entries<T = unknown>(subject: { [p: string]: T } | ArrayLike<T>): List<Entry<T>> {
+  return ifDefined(
+    subject,
+    () => toList<Entry<T>>([...Object.entries(subject), ...Object.entries(Object.getPrototypeOf(subject))] as Entry<T>[]),
+    () => toList<Entry<T>>()
+  );
+}
+
+export function values<T = unknown>(subject: { [p: string]: T } | ArrayLike<T>): List<T> {
+  return toList([...Object.values<T>(subject), ...Object.values<T>(Object.getPrototypeOf(subject))]);
+}

package/src/types/Parser.ts

@@ -1,6 +1,6 @@
 import { Get, ofGet, Predicate } from './Get';
 import { isDefined, isEmpty, isIn, isObject, isString, isTrue } from './Is';
-import { isValid } from '../validation';
+import { isValid } from '../validation/Validate';
 import { Constructor, on } from './Constructor';
 import { toArray } from './Array';
 

package/src/types/Repository.ts

@@ -1,5 +1,10 @@
-import { Exception, FetchOptions, Id, Json, JsonValue, Key, List, PageList } from './index';
-import { reject } from '../utils';
+import { FetchOptions } from './Gateway';
+import { PageList } from './PageList';
+import { Exception } from './Exception';
+import { reject } from '../utils/Promise';
+import { Id, Key } from './Id';
+import { List } from './List';
+import { Json, JsonValue } from './Json';
 
 export class Repository<T, Options = FetchOptions> {
   all(options?: Options): Promise<PageList<T>> {