@thisisagile/easy 15.29.2 → 15.29.3

package/src/http/CacheControl.ts

@@ -1,10 +1,16 @@
-import { cacheAge, CacheAge, entries, isNumber, on } from '../types';
-import { ifDefined } from '../utils';
+import { cacheAge, CacheAge } from '../types/CacheAge';
+import { on } from '../types/Constructor';
+import { entries } from '../types/Object';
+import { ifDefined } from '../utils/If';
+import { isNumber } from '../types/Is';
 
 export class CacheControl {
   name = 'Cache-Control';
 
-  protected constructor(readonly enabled = true, private directives: Record<string, boolean | CacheAge | undefined> = {}) {}
+  protected constructor(
+    readonly enabled = true,
+    private directives: Record<string, boolean | CacheAge | undefined> = {}
+  ) {}
 
   static disabled = () => new CacheControl(false);
 

package/src/http/ContentType.ts

@@ -1,5 +1,7 @@
-import { asString, Enum, Get, ofGet } from '../types';
 import formUrlEncoded from 'form-urlencoded';
+import { Enum } from '../types/Enum';
+import { Get, ofGet } from '../types/Get';
+import { asString } from '../types/Text';
 
 export class ContentType extends Enum {
   static Form = new ContentType('form', 'application/x-www-form-urlencoded', b => formUrlEncoded(b));
@@ -8,7 +10,11 @@ export class ContentType extends Enum {
   static Text = new ContentType('text', 'text/plain');
   static Xml = new ContentType('xml', 'application/xml');
 
-  private constructor(name: string, readonly type: string, protected readonly encoder: Get<string> = b => asString(b)) {
+  private constructor(
+    name: string,
+    readonly type: string,
+    protected readonly encoder: Get<string> = b => asString(b)
+  ) {
     super(name, type);
   }
 

package/src/http/HttpStatus.ts

@@ -1,4 +1,7 @@
-import { Code, Enum, isAn, TypeGuard } from '../types';
+import { Enum } from '../types/Enum';
+import { TypeGuard } from '../types/TypeGuard';
+import { isAn } from '../types/IsA';
+import { Code } from '../types/Id';
 
 export class HttpStatus extends Enum {
   static Continue = new HttpStatus('Continue', 100);

package/src/http/HttpVerb.ts

@@ -1,4 +1,4 @@
-import { Enum } from '../types';
+import { Enum } from '../types/Enum';
 
 export class HttpVerb extends Enum {
   static Get = new HttpVerb('Get');

package/src/http/LocalRequestStore.ts

@@ -1,6 +1,8 @@
-import { ctx, Func, Store } from '../types';
 import { Response } from './Response';
 import { Request } from './Request';
+import { Store } from '../types/Cache';
+import { Func } from '../types/Func';
+import { ctx } from '../types/Context';
 
 export class LocalRequestStore implements Store<Response, Request> {
   key = (_req: Request): string => '';

package/src/http/OriginatedError.ts

@@ -1,8 +1,12 @@
-import { ErrorOrigin, isError } from '../types';
 import { VerbOptions } from './Verb';
+import { ErrorOrigin } from '../types/ErrorOrigin';
+import { isError } from '../types/Is';
 
 export class OriginatedError extends Error {
-  constructor(readonly origin: ErrorOrigin, readonly options?: VerbOptions) {
+  constructor(
+    readonly origin: ErrorOrigin,
+    readonly options?: VerbOptions
+  ) {
     super();
     if (isError(origin)) this.stack = origin.stack;
   }

package/src/http/Request.ts

@@ -1,6 +1,6 @@
-import { Uri } from '../types';
 import { HttpVerb } from './HttpVerb';
 import { RequestOptions } from './RequestOptions';
+import type { Uri } from '../types/Uri';
 
 export type Request = {
   uri: Uri;

package/src/http/RequestOptions.ts

@@ -1,6 +1,16 @@
-import { asString, CacheAge, ctx, Enum, Id, isDefined, isNotEmpty, on, Optional, PageOptions, Text, toUuid } from '../types';
 import { HttpHeader } from './HttpHeader';
 import { ContentType } from './ContentType';
+import { PageOptions } from '../types/PageList';
+import { Optional } from '../types/Types';
+import { Text } from '../types/Text';
+import { Enum } from '../types/Enum';
+import { CacheAge } from '../types/CacheAge';
+import { ctx } from '../types/Context';
+import { toUuid } from '../types/Uuid';
+import { Id } from '../types/Id';
+import { on } from '../types/Constructor';
+import { asString } from '../types/Text';
+import { isDefined, isNotEmpty } from '../types/Is';
 
 export const toPageOptions = (options?: RequestOptions | PageOptions): Optional<PageOptions> =>
   options instanceof RequestOptions ? options.pageOptions : options;
@@ -8,7 +18,11 @@ export const toPageOptions = (options?: RequestOptions | PageOptions): Optional<
 export class RequestOptions extends Enum {
   public requestOptions: { maxRedirects?: number; validateStatus?: (status: number) => boolean; timeout?: CacheAge } = {};
 
-  constructor(readonly type: ContentType = ContentType.Json, readonly headers: { [key: string]: any } = {}, public pageOptions?: PageOptions) {
+  constructor(
+    readonly type: ContentType = ContentType.Json,
+    readonly headers: { [key: string]: any } = {},
+    public pageOptions?: PageOptions
+  ) {
     super(type.name);
     this.headers['Content-Type'] = type.id;
     this.headers[HttpHeader.Correlation] = ctx.request.correlationId ?? toUuid();

package/src/http/Response.ts

@@ -1,6 +1,7 @@
-import { HttpStatus, toHttpStatus } from './HttpStatus';
-import { rest, RestResult } from './RestResult';
-import { Code, isA, TypeGuard } from '../types';
+import { HttpStatus } from './HttpStatus';
+import type { RestResult } from './RestResult';
+import { isA } from '../types/IsA';
+import { TypeGuard } from '../types/TypeGuard';
 
 export type Response = {
   status: HttpStatus;
@@ -9,9 +10,3 @@ export type Response = {
 };
 
 export const isResponse: TypeGuard<Response> = (r?: unknown): r is Response => isA<Response>(r, 'status', 'body');
-
-export const toResponse = (status: HttpStatus | Code, body?: unknown, headers?: { [key: string]: any }): Response => ({
-  status: toHttpStatus(status),
-  headers,
-  body: rest.to(body),
-});

package/src/http/RestResult.ts

@@ -1,6 +1,12 @@
-import { choose, Id, isDefined, isError, isResult, isResults, Json, List, Result, toList, toResult } from '../types';
 import { HttpStatus, isHttpStatus } from './HttpStatus';
 import { isResponse } from './Response';
+import { List, toList } from '../types/List';
+import { Json } from '../types/Json';
+import { isResult, Result, toResult } from '../types/Result';
+import { isDefined, isError } from '../types/Is';
+import { choose } from '../types/Case';
+import { isResults } from '../types/Results';
+import { Id } from '../types/Id';
 
 export type RestResult = {
   data?: { code: number; items: List<Json>; itemCount: number; totalItems?: number; meta?: Json };

package/src/http/Verb.ts

@@ -1,5 +1,8 @@
-import { meta } from '../types';
-import { CacheControl, ContentType, HttpStatus, HttpVerb } from './index';
+import { meta } from '../types/Meta';
+import { HttpStatus } from './HttpStatus';
+import { ContentType } from './ContentType';
+import { CacheControl } from './CacheControl';
+import { HttpVerb } from './HttpVerb';
 
 export type VerbOptions = { onOk?: HttpStatus; onNotFound?: HttpStatus; onError?: HttpStatus; type?: ContentType; cache?: CacheControl };
 export type Verb = { verb: HttpVerb; options: VerbOptions };

package/src/http/toResponse.ts

@@ -0,0 +1,12 @@
+import { HttpStatus, toHttpStatus } from './HttpStatus';
+import { rest } from './RestResult';
+import { Response } from './Response';
+import { Code } from '../types/Id';
+
+export function toResponse(status: HttpStatus | Code, body?: unknown, headers?: { [key: string]: any }): Response {
+  return {
+    status: toHttpStatus(status),
+    headers,
+    body: rest.to(body),
+  };
+}

package/src/index.ts

@@ -1,12 +1,129 @@
-export * from './data';
-export * from './domain';
-export * from './http';
-export * from './health';
-export * from './process';
-export * from './resources';
-export * from './services';
-export * from './security';
-export * from './sql';
-export * from './types';
-export * from './utils';
-export * from './validation';
+export * from './data/Condition';
+export * from './data/InMemoryGateway';
+export * from './data/Database';
+export * from './data/DataProvider';
+export * from './data/Field';
+export * from './data/Query';
+export * from './data/QueryProvider';
+
+export * from './domain/Audit';
+export * from './domain/Child';
+export * from './domain/DateTime';
+export * from './domain/Entity';
+export * from './domain/Struct';
+export * from './domain/Repo';
+export * from './domain/Typo';
+
+export * from './health/HealthResource';
+export * from './health/HealthUri';
+
+export * from './http/CacheControl';
+export * from './http/ContentType';
+export * from './http/HttpHeader';
+export * from './http/HttpStatus';
+export * from './http/HttpVerb';
+export * from './http/OriginatedError';
+export * from './http/Request';
+export * from './http/RequestOptions';
+export * from './http/RequestProvider';
+export * from './http/Response';
+export * from './http/RestResult';
+export * from './http/toResponse';
+export * from './http/Verb';
+
+export * from './process/App';
+export * from './process/Manage';
+export * from './process/Scope';
+export * from './process/Search';
+export * from './process/UseCase';
+
+export * from './resources/AppProvider';
+export * from './resources/Req';
+export * from './resources/Requires';
+export * from './resources/Resource';
+export * from './resources/Route';
+export * from './resources/Service';
+
+export * from './security/Jwt';
+
+export * from './services/Api';
+export * from './services/ApiGateway';
+export * from './services/AxiosProvider';
+export * from './services/MappedRouteGateway';
+export * from './services/RouteGateway';
+export * from './services/ViewRouteGateway';
+
+export * from './sql/Clause';
+export * from './sql/Column';
+export * from './sql/Delete';
+export * from './sql/Insert';
+export * from './sql/Join';
+export * from './sql/SqlQuery';
+export * from './sql/Select';
+export * from './sql/Table';
+export * from './sql/TableGateway';
+export * from './sql/Update';
+
+export * from './types/Array';
+export * from './types/Builder';
+export * from './types/Cache';
+export * from './types/CacheAge';
+export * from './types/Case';
+export * from './types/Constructor';
+export * from './types/Context';
+export * from './types/Enum';
+export * from './types/Environment';
+export * from './types/ErrorOrigin';
+export * from './types/Exception';
+export * from './types/Falsy';
+export * from './types/Func';
+export * from './types/Gateway';
+export * from './types/Get';
+export * from './types/Id';
+export * from './types/Identity';
+export * from './types/Is';
+export * from './types/IsA';
+export * from './types/IsDate';
+export * from './types/IsEqual';
+export * from './types/Json';
+export * from './types/List';
+export * from './types/Message';
+export * from './types/Meta';
+export * from './types/Nullish';
+export * from './types/Number';
+export * from './types/Object';
+export * from './types/PageList';
+export * from './types/Parser';
+export * from './types/Primitive';
+export * from './types/Repository';
+export * from './types/Result';
+export * from './types/Results';
+export * from './types/Sort';
+export * from './types/Tag';
+export * from './types/Template';
+export * from './types/Text';
+export * from './types/Try';
+export * from './types/TypeGuard';
+export * from './types/Types';
+export * from './types/Uri';
+export * from './types/Uuid';
+export * from './types/Validatable';
+export * from './types/Value';
+
+export * from './utils/Base64';
+export * from './utils/Convert';
+export * from './utils/If';
+export * from './utils/Loading';
+export * from './utils/Log';
+export * from './utils/Mapper';
+export * from './utils/Promise';
+export * from './utils/Property';
+export * from './utils/State';
+export * from './utils/Sentence';
+export * from './utils/Traverse';
+export * from './utils/View';
+export * from './utils/Wait';
+
+export * from './validation/Contraints';
+export * from './validation/Validate';
+export * from './validation/When';

package/src/process/Manage.ts

@@ -1,5 +1,7 @@
 import { Search } from './Search';
-import { FetchOptions, Id, Json } from '../types';
+import { FetchOptions } from '../types/Gateway';
+import { Json } from '../types/Json';
+import { Id } from '../types/Id';
 
 export class Manage<T, Options = FetchOptions> extends Search<T, Options> {
   add(json: Json): Promise<T> {

package/src/process/Scope.ts

@@ -1,7 +1,17 @@
-import { Enum, IdName, isString, kebab, List, Text, text, toList } from '../types';
+import { Enum } from '../types/Enum';
+import { text } from '../types/Template';
+import type { Text } from '../types/Text';
+import { List, toList } from '../types/List';
+import { IdName } from '../types/Identity';
+import { isString } from '../types/Is';
+import { kebab } from '../types/Text';
 
 export class Scope extends Enum {
-  protected constructor(readonly name: string, id: Text = text(name).kebab, readonly subs: List<Scope> = toList()) {
+  protected constructor(
+    readonly name: string,
+    id: Text = text(name).kebab,
+    readonly subs: List<Scope> = toList()
+  ) {
     super(name, id.toString());
   }
 

package/src/process/Search.ts

@@ -1,6 +1,12 @@
-import { choose, FetchOptions, Id, JsonValue, Key, List, PageList, Repository, toPageList } from '../types';
-import { resolve } from '../utils';
-import { Req } from '../resources';
+import { FetchOptions } from '../types/Gateway';
+import { Repository } from '../types/Repository';
+import { PageList, toPageList } from '../types/PageList';
+import { Id, Key } from '../types/Id';
+import { List } from '../types/List';
+import { Req } from '../resources/Req';
+import { JsonValue } from '../types/Json';
+import { choose } from '../types/Case';
+import { resolve } from '../utils/Promise';
 
 export class Search<T, Options = FetchOptions> {
   constructor(protected repo: Repository<T, Options>) {}

package/src/process/UseCase.ts

@@ -1,9 +1,19 @@
-import { Enum, IdName, isIn, isString, kebab, List, Text, text, toList } from '../types';
 import { Scope } from './Scope';
 import { App } from './App';
+import { Enum } from '../types/Enum';
+import { text } from '../types/Template';
+import { kebab, Text } from '../types/Text';
+import { List, toList } from '../types/List';
+import { IdName } from '../types/Identity';
+import { isIn, isString } from '../types/Is';
 
 export class UseCase extends Enum {
-  constructor(readonly app: App, name: string, id: Text = text(name).kebab, readonly scopes: List<Scope> = toList<Scope>()) {
+  constructor(
+    readonly app: App,
+    name: string,
+    id: Text = text(name).kebab,
+    readonly scopes: List<Scope> = toList<Scope>()
+  ) {
     super(name, id.toString());
   }
 

package/src/resources/AppProvider.ts

@@ -1,6 +1,6 @@
 import { Resource } from './Resource';
 import { Service } from './Service';
-import { Func } from '../types';
+import { Func } from '../types/Func';
 
 export type Handler = Func<void, any>;
 

package/src/resources/Req.ts

@@ -1,10 +1,21 @@
-import { asNumber, Id, Json, JsonValue, OneOrMore, Optional, PageOptions, Text } from '../types';
-import { ifDefined } from '../utils';
+import { PageOptions } from '../types/PageList';
+import { Optional } from '../types/Types';
+import { Json, JsonValue } from '../types/Json';
+import { OneOrMore } from '../types/Array';
+import { ifDefined } from '../utils/If';
+import { asNumber } from '../types/Number';
+import { Id } from '../types/Id';
+import type { Text } from '../types/Text';
 
 export class Req<T = unknown> implements Omit<PageOptions, 'sort'> {
   readonly skip: Optional<number>;
   readonly take: Optional<number>;
-  constructor(readonly path: Json = {}, readonly query: Json = {}, readonly body: T, readonly headers: Record<string, OneOrMore<string>>) {
+  constructor(
+    readonly path: Json = {},
+    readonly query: Json = {},
+    readonly body: T,
+    readonly headers: Record<string, OneOrMore<string>>
+  ) {
     this.skip = ifDefined(query.skip, s => asNumber(s));
     this.take = ifDefined(query.take, t => asNumber(t));
   }

package/src/resources/Requires.ts

@@ -1,5 +1,6 @@
-import { meta } from '../types';
-import { Scope, UseCase } from '../process';
+import { meta } from '../types/Meta';
+import { Scope } from '../process/Scope';
+import { UseCase } from '../process/UseCase';
 
 export class Requires {
   readonly labCoat =

package/src/resources/Route.ts

@@ -1,9 +1,14 @@
-import { List, meta, Optional, tryTo, Uri } from '../types';
-import { Verb } from '../http';
 import { Req } from './Req';
 import { Resource } from './Resource';
-import { Scope, UseCase } from '../process';
 import { RequestHandler } from 'express';
+import { Uri } from '../types/Uri';
+import { meta } from '../types/Meta';
+import { List } from '../types/List';
+import { Scope } from '../process/Scope';
+import { UseCase } from '../process/UseCase';
+import { Verb } from '../http/Verb';
+import { Optional } from '../types/Types';
+import { tryTo } from '../types/Try';
 
 export const route =
   (uri: Uri): ClassDecorator =>

package/src/resources/Service.ts

@@ -1,11 +1,18 @@
 import { AppProvider, Handler } from './AppProvider';
-import { Constructor, Enum, List, toList, tryTo } from '../types';
 import { Resource } from './Resource';
+import { Enum } from '../types/Enum';
+import { List, toList } from '../types/List';
+import { Constructor } from '../types/Constructor';
+import { tryTo } from '../types/Try';
 
 export class Service extends Enum {
   protected port = 8080;
 
-  constructor(readonly name: string, protected app: AppProvider, protected resources: List<Resource> = toList()) {
+  constructor(
+    readonly name: string,
+    protected app: AppProvider,
+    protected resources: List<Resource> = toList()
+  ) {
     super(name);
   }
 

package/src/security/Jwt.ts

@@ -1,5 +1,11 @@
 import { Algorithm, decode, sign, verify } from 'jsonwebtoken';
-import { ctx, Json, OneOrMore, Optional, tryTo, Validatable, Value } from '../types';
+import { Optional } from '../types/Types';
+import { OneOrMore } from '../types/Array';
+import { Value } from '../types/Value';
+import { Validatable } from '../types/Validatable';
+import { tryTo } from '../types/Try';
+import { ctx } from '../types/Context';
+import { Json } from '../types/Json';
 
 interface SignOptions {
   audience?: Optional<OneOrMore<string>>;

package/src/services/Api.ts

@@ -1,11 +1,20 @@
-import { FetchOptions, Store, Uri } from '../types';
-import { HttpVerb, Request, RequestOptions, RequestProvider, Response, toPageOptions } from '../http';
 import { AxiosProvider } from './AxiosProvider';
+import { RequestOptions, toPageOptions } from '../http/RequestOptions';
+import { FetchOptions } from '../types/Gateway';
+import { RequestProvider } from '../http/RequestProvider';
+import { Store } from '../types/Cache';
+import { Uri } from '../types/Uri';
+import { HttpVerb } from '../http/HttpVerb';
+import { Request } from '../http/Request';
+import { Response } from '../http/Response';
 
 export type RouteOptions = RequestOptions | FetchOptions;
 
 export class Api {
-  constructor(readonly provider: RequestProvider = new AxiosProvider(), protected store?: Store<Response, Request>) {}
+  constructor(
+    readonly provider: RequestProvider = new AxiosProvider(),
+    protected store?: Store<Response, Request>
+  ) {}
 
   get(uri: Uri, options?: RouteOptions, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
     return this.execute({

package/src/services/ApiGateway.ts

@@ -1,6 +1,11 @@
 import { Api, RouteOptions } from './Api';
-import { FetchOptions, Gateway, Json, Optional, PageList, toPageList, Uri, use } from '../types';
-import { RequestOptions } from '../http';
+import { FetchOptions, Gateway } from '../types/Gateway';
+import { Uri } from '../types/Uri';
+import { PageList, toPageList } from '../types/PageList';
+import { Json } from '../types/Json';
+import { use } from '../types/Constructor';
+import { Optional } from '../types/Types';
+import { RequestOptions } from '../http/RequestOptions';
 
 export class ApiGateway extends Gateway<RouteOptions> {
   constructor(readonly api: Api = new Api()) {

package/src/services/AxiosProvider.ts

@@ -1,6 +1,18 @@
 import axios, { AxiosError, AxiosInstance, AxiosResponse, Method } from 'axios';
-import { HttpStatus, HttpVerb, isRestResult, Request, RequestOptions, RequestProvider, Response, toResponse } from '../http';
-import { cacheAge, choose, ctx, isDefined, isEmpty, toResult, Uri } from '../types';
+import { toResponse } from '../http/toResponse';
+import { isDefined, isEmpty } from '../types/Is';
+import { Uri } from '../types/Uri';
+import { HttpVerb } from '../http/HttpVerb';
+import { choose } from '../types/Case';
+import { isRestResult } from '../http/RestResult';
+import { toResult } from '../types/Result';
+import { HttpStatus } from '../http/HttpStatus';
+import { RequestProvider } from '../http/RequestProvider';
+import { RequestOptions } from '../http/RequestOptions';
+import { ctx } from '../types/Context';
+import { cacheAge } from '../types/CacheAge';
+import { Response } from '../http/Response';
+import { Request } from '../http/Request';
 
 const isResponse = (a: unknown): a is { response: AxiosResponse } => isDefined((a as any)?.response);
 const isRequest = (a: unknown): a is { request: any } => isDefined((a as any)?.request);

package/src/services/MappedRouteGateway.ts

@@ -1,11 +1,20 @@
 import { Api } from './Api';
-import { Func, Json, Optional, PageList, Uri } from '../types';
-import { Mapper } from '../utils';
 import { RouteGateway } from './RouteGateway';
-import { RequestOptions } from '../http';
+import { Func } from '../types/Func';
+import { Uri } from '../types/Uri';
+import { Mapper } from '../utils/Mapper';
+import { RequestOptions } from '../http/RequestOptions';
+import { PageList } from '../types/PageList';
+import { Json } from '../types/Json';
+import { Optional } from '../types/Types';
 
 export class MappedRouteGateway extends RouteGateway {
-  constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly map = new Mapper(), readonly api: Api = new Api()) {
+  constructor(
+    readonly route: Func<Uri>,
+    readonly routeId: Func<Uri>,
+    readonly map = new Mapper(),
+    readonly api: Api = new Api()
+  ) {
     super(route, routeId, api);
   }
 

package/src/services/RouteGateway.ts

@@ -1,10 +1,21 @@
 import { Api, RouteOptions } from './Api';
-import { Func, Id, Json, JsonValue, List, Optional, PageList, toArray, Uri } from '../types';
-import { HttpStatus } from '../http';
 import { ApiGateway } from './ApiGateway';
+import { Func } from '../types/Func';
+import { Uri } from '../types/Uri';
+import { PageList } from '../types/PageList';
+import { Json, JsonValue } from '../types/Json';
+import { Id } from '../types/Id';
+import { Optional } from '../types/Types';
+import { List } from '../types/List';
+import { toArray } from '../types/Array';
+import { HttpStatus } from '../http/HttpStatus';
 
 export class RouteGateway extends ApiGateway {
-  constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
+  constructor(
+    readonly route: Func<Uri>,
+    readonly routeId: Func<Uri>,
+    readonly api: Api = new Api()
+  ) {
     super(api);
   }
 

package/src/services/ViewRouteGateway.ts

@@ -1,8 +1,12 @@
 import { Api } from './Api';
-import { Func, Json, Optional, PageList, Uri } from '../types';
-import { view } from '../utils';
 import { RouteGateway } from './RouteGateway';
-import { RequestOptions } from '../http';
+import { Func } from '../types/Func';
+import { Uri } from '../types/Uri';
+import { view } from '../utils/View';
+import { RequestOptions } from '../http/RequestOptions';
+import { PageList } from '../types/PageList';
+import { Json } from '../types/Json';
+import { Optional } from '../types/Types';
 
 export class ViewRouteGateway extends RouteGateway {
   constructor(