@thisisagile/easy 12.7.21 → 12.7.22

package/src/http/CacheControl.ts

@@ -1,45 +1,47 @@
-import {cacheAge, CacheAge, isNumber, meta, on} from '../types';
-import {ifDefined} from "../utils";
+import { cacheAge, CacheAge, isNumber, meta, on } from '../types';
+import { ifDefined } from '../utils';
 
 export class CacheControl {
-    name = 'Cache-Control';
+  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);
+  static disabled = () => new CacheControl(false);
 
-    static OneSecond = () => new CacheControl().maxAge(1).staleWhileRevalidate(1);
+  static OneSecond = () => new CacheControl().maxAge(1).staleWhileRevalidate(1);
 
-    static fiveSeconds = () => new CacheControl().maxAge(5).staleWhileRevalidate(5);
+  static fiveSeconds = () => new CacheControl().maxAge(5).staleWhileRevalidate(5);
 
-    static tenSeconds = () => new CacheControl().maxAge(10).staleWhileRevalidate(10);
+  static tenSeconds = () => new CacheControl().maxAge(10).staleWhileRevalidate(10);
 
-    static thirtySeconds = () => new CacheControl().maxAge(30).staleWhileRevalidate(30);
+  static thirtySeconds = () => new CacheControl().maxAge(30).staleWhileRevalidate(30);
 
-    static sixtySeconds = () => new CacheControl().maxAge(60).staleWhileRevalidate(60);
+  static sixtySeconds = () => new CacheControl().maxAge(60).staleWhileRevalidate(60);
 
-    static custom = (maxAge?: CacheAge, staleWhileRevalidate?: CacheAge) => new CacheControl().maxAge(maxAge).staleWhileRevalidate(staleWhileRevalidate);
+  static custom = (maxAge?: CacheAge, staleWhileRevalidate?: CacheAge) => new CacheControl().maxAge(maxAge).staleWhileRevalidate(staleWhileRevalidate);
 
-    readonly maxAge = (ca?: CacheAge): this => on(this, t => t.directives['max-age'] = ca);
+  readonly maxAge = (ca?: CacheAge): this => on(this, t => (t.directives['max-age'] = ca));
 
-    readonly sharedMaxAge = (ca?: CacheAge): this => on(this, t => t.directives['s-maxage'] = ca);
+  readonly sharedMaxAge = (ca?: CacheAge): this => on(this, t => (t.directives['s-maxage'] = ca));
 
-    readonly noCache = (a?: boolean): this => on(this, t => t.directives['no-cache'] = a);
+  readonly noCache = (a?: boolean): this => on(this, t => (t.directives['no-cache'] = a));
 
-    readonly mustRevalidate = (a?: boolean): this => on(this, t => t.directives['must-revalidate'] = a);
+  readonly mustRevalidate = (a?: boolean): this => on(this, t => (t.directives['must-revalidate'] = a));
 
-    readonly private = (a?: boolean): this => on(this, t => t.directives['private'] = a);
+  readonly private = (a?: boolean): this => on(this, t => (t.directives['private'] = a));
 
-    readonly public = (a?: boolean): this => on(this, t => t.directives['public'] = a);
+  readonly public = (a?: boolean): this => on(this, t => (t.directives['public'] = a));
 
-    readonly immutable = (a?: boolean): this => on(this, t => t.directives['immutable'] = a);
+  readonly immutable = (a?: boolean): this => on(this, t => (t.directives['immutable'] = a));
 
-    readonly staleWhileRevalidate = (ca?: CacheAge): this => on(this, t => t.directives['stale-while-revalidate'] = ca);
+  readonly staleWhileRevalidate = (ca?: CacheAge): this => on(this, t => (t.directives['stale-while-revalidate'] = ca));
 
-    value = (): string => this.toString();
+  value = (): string => this.toString();
 
-    toString(): string {
-        return meta(this.directives).entries().mapDefined(([k, v]) => ifDefined(v, isNumber(v) ? `${k}=${cacheAge.toSeconds(v)}` : k)).join(',');
-    }
+  toString(): string {
+    return meta(this.directives)
+      .entries()
+      .mapDefined(([k, v]) => ifDefined(v, isNumber(v) ? `${k}=${cacheAge.toSeconds(v)}` : k))
+      .join(',');
+  }
 }

package/src/http/LocalRequestStore.ts

@@ -0,0 +1,12 @@
+import { ctx, Func, Store } from '../types';
+import { Response } from './Response';
+import { Request } from './Request';
+
+export class LocalRequestStore implements Store<Response, Request> {
+  key = (req: Request): string => '';
+
+  execute(req: Request, f: Func<Promise<Response>, Request>): Promise<Response> {
+    const key = this.key(req);
+    return ctx.request.get(key) ?? ctx.request.set(key, f(req));
+  }
+}

package/src/http/NoRequestStore.ts

@@ -1,9 +1,9 @@
-import {Func, Store} from "../types";
-import {Request} from "./Request";
-import {Response} from "./Response";
+import { Func, Store } from '../types';
+import { Request } from './Request';
+import { Response } from './Response';
 
 export class NoRequestStore implements Store<Response, Request> {
-    execute(req: Request, f: Func<Promise<Response>, Request>): Promise<Response> {
-        return f(req);
-    }
+  execute(req: Request, f: Func<Promise<Response>, Request>): Promise<Response> {
+    return f(req);
+  }
 }

package/src/http/RestResult.ts

@@ -8,7 +8,7 @@ export type RestResult = {
 };
 
 const hasErrors = (a: any): a is { error: { code: number; errors: List<Result> } } => isDefined(a?.error?.errors);
-const hasItems = (a: any): a is { data: { code: number; items: List<Json>; totalItems?: number; meta?: Json; } } => isDefined(a?.data.items);
+const hasItems = (a: any): a is { data: { code: number; items: List<Json>; totalItems?: number; meta?: Json } } => isDefined(a?.data.items);
 
 export const rest = {
   toData: (status: HttpStatus, items: Json[] = [], totalItems?: number, meta?: Json): RestResult => ({

package/src/services/Api.ts

@@ -1,81 +1,70 @@
-import {FetchOptions, Uri} from '../types';
-import {HttpVerb, RequestOptions, RequestProvider, Response, toPageOptions} from '../http';
-import {AxiosProvider} from './AxiosProvider';
+import { FetchOptions, Store, Uri } from '../types';
+import { HttpVerb, Request, RequestOptions, RequestProvider, Response, toPageOptions } from '../http';
+import { AxiosProvider } from './AxiosProvider';
 
 export type RouteOptions = RequestOptions | FetchOptions;
 
 export class Api {
-    constructor(readonly provider: RequestProvider = new AxiosProvider()) {
-    }
+  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.provider.execute({
-            uri: uri.skip(toPageOptions(options)?.skip).take(toPageOptions(options)?.take),
-            verb: HttpVerb.Get,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Get, options),
-        });
-    }
+  get(uri: Uri, options?: RouteOptions, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri: uri.skip(toPageOptions(options)?.skip).take(toPageOptions(options)?.take),
+      verb: HttpVerb.Get,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Get, options),
+    });
+  }
 
-    post(
-        uri: Uri,
-        body?: unknown,
-        options: RouteOptions = RequestOptions.Json,
-        transform?: (r: any) => any,
-        transformError = (r: any) => r
-    ): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Post,
-            body,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Post, options)
-        });
-    }
+  post(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Post,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Post, options),
+    });
+  }
 
-    put(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Put,
-            body,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Put, options)
-        });
-    }
+  put(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Put,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Put, options),
+    });
+  }
 
-    patch(
-        uri: Uri,
-        body?: unknown,
-        options: RouteOptions = RequestOptions.Json,
-        transform?: (r: any) => any,
-        transformError = (r: any) => r
-    ): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Patch,
-            body,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Patch, options)
-        });
-    }
+  patch(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Patch,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Patch, options),
+    });
+  }
 
-    delete(uri: Uri, options: RouteOptions = RequestOptions.Json, transform?: (b: any) => any, transformError = (r: any) => r): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Delete,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Delete, options)
-        });
-    }
+  delete(uri: Uri, options: RouteOptions = RequestOptions.Json, transform?: (b: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Delete,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Delete, options),
+    });
+  }
 
-    options(verb: HttpVerb, options?: RouteOptions): RequestOptions {
-        return options instanceof RequestOptions ? options : RequestOptions.Json;
-    }
+  options(verb: HttpVerb, options?: RouteOptions): RequestOptions {
+    return options instanceof RequestOptions ? options : RequestOptions.Json;
+  }
+
+  execute = (req: Request): Promise<Response> => (this.store ? this.store.execute(req, () => this.provider.execute(req)) : this.provider.execute(req));
 }
 
 export const api: Api = new Api();

package/src/services/RouteGateway.ts

@@ -1,81 +1,91 @@
-import {Api, RouteOptions} from './Api';
-import {FetchOptions, Filter, Func, Gateway, Id, Json, JsonValue, PageList, toPageList, Uri} from '../types';
-import {HttpStatus, RequestOptions, toPageOptions} from '../http';
+import { Api, RouteOptions } from './Api';
+import { FetchOptions, Filter, Func, Gateway, Id, Json, JsonValue, PageList, toPageList, Uri } from '../types';
+import { HttpStatus, RequestOptions, toPageOptions } from '../http';
 
 export class RouteGateway extends Gateway<RouteOptions> {
-    constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
-        super();
-    }
-
-    get(uri: Uri, options?: RouteOptions): Promise<PageList<Json>> {
-        return this.api.get(uri, options).then(r => toPageList<Json>(r.body.data?.items, toPageOptions(options) && {
-            total: r.body.data?.totalItems,
-            filters: r.body.data?.meta?.filters as Filter[],
-        }));
-    }
-
-    getOne(uri: Uri, options?: RouteOptions): Promise<Json | undefined> {
-        return this.get(uri, options).then(r => r.first());
-    }
-
-    all(options?: RouteOptions): Promise<PageList<Json>> {
-        return this.get(this.route(), options);
-    }
-
-    byId(id: Id, options?: RouteOptions): Promise<Json | undefined> {
-        return this.getOne(this.routeId().id(id));
-    }
-
-    search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>> {
-        return this.get(this.route().query(q), options);
-    }
-
-    exists(id: Id, options?: RouteOptions): Promise<boolean> {
-        return this.get(this.routeId().id(id))
-            .then(r => r.length === 1)
-            .catch(r => (HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r)));
-    }
-
-    add(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.post(this.route(), item);
-    }
-
-    filter(options?: RouteOptions): Promise<PageList<Json>> {
-        return this.postSearch(this.route(), options);
-    }
-
-    update(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.patch(this.routeId().id(item.id), item);
-    }
-
-    upsert(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.put(this.routeId().id(item.id), item);
-    }
-
-    remove(id: Id, options?: RouteOptions): Promise<boolean> {
-        return this.delete(this.routeId().id(id));
-    }
-
-    post(uri: Uri, item?: Json): Promise<Json> {
-        return this.api.post(uri, item).then(r => r.body.data?.items.first() ?? {});
-    }
-
-    postSearch(uri: Uri, options?: RequestOptions | FetchOptions): Promise<PageList<Json>> {
-        return this.api.post(uri, options).then(r => toPageList<Json>(r.body.data?.items, toPageOptions(options) && {
-            total: r.body.data?.totalItems,
-            filters: r.body.data?.meta?.filters as Filter[],
-        }));
-    }
-
-    patch(uri: Uri, item: Json): Promise<Json> {
-        return this.api.patch(uri, item).then(r => r.body.data?.items.first() ?? {});
-    }
-
-    put(uri: Uri, item: Json): Promise<Json> {
-        return this.api.put(uri, item).then(r => r.body.data?.items.first() ?? {});
-    }
-
-    delete(uri: Uri, options?: RouteOptions): Promise<boolean> {
-        return this.api.delete(uri).then(() => true);
-    }
+  constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
+    super();
+  }
+
+  get(uri: Uri, options?: RouteOptions): Promise<PageList<Json>> {
+    return this.api.get(uri, options).then(r =>
+      toPageList<Json>(
+        r.body.data?.items,
+        toPageOptions(options) && {
+          total: r.body.data?.totalItems,
+          filters: r.body.data?.meta?.filters as Filter[],
+        }
+      )
+    );
+  }
+
+  getOne(uri: Uri, options?: RouteOptions): Promise<Json | undefined> {
+    return this.get(uri, options).then(r => r.first());
+  }
+
+  all(options?: RouteOptions): Promise<PageList<Json>> {
+    return this.get(this.route(), options);
+  }
+
+  byId(id: Id, options?: RouteOptions): Promise<Json | undefined> {
+    return this.getOne(this.routeId().id(id));
+  }
+
+  search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>> {
+    return this.get(this.route().query(q), options);
+  }
+
+  exists(id: Id, options?: RouteOptions): Promise<boolean> {
+    return this.get(this.routeId().id(id))
+      .then(r => r.length === 1)
+      .catch(r => (HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r)));
+  }
+
+  add(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.post(this.route(), item);
+  }
+
+  filter(options?: RouteOptions): Promise<PageList<Json>> {
+    return this.postSearch(this.route(), options);
+  }
+
+  update(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.patch(this.routeId().id(item.id), item);
+  }
+
+  upsert(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.put(this.routeId().id(item.id), item);
+  }
+
+  remove(id: Id, options?: RouteOptions): Promise<boolean> {
+    return this.delete(this.routeId().id(id));
+  }
+
+  post(uri: Uri, item?: Json): Promise<Json> {
+    return this.api.post(uri, item).then(r => r.body.data?.items.first() ?? {});
+  }
+
+  postSearch(uri: Uri, options?: RequestOptions | FetchOptions): Promise<PageList<Json>> {
+    return this.api.post(uri, options).then(r =>
+      toPageList<Json>(
+        r.body.data?.items,
+        toPageOptions(options) && {
+          total: r.body.data?.totalItems,
+          filters: r.body.data?.meta?.filters as Filter[],
+        }
+      )
+    );
+  }
+
+  patch(uri: Uri, item: Json): Promise<Json> {
+    return this.api.patch(uri, item).then(r => r.body.data?.items.first() ?? {});
+  }
+
+  put(uri: Uri, item: Json): Promise<Json> {
+    return this.api.put(uri, item).then(r => r.body.data?.items.first() ?? {});
+  }
+
+  delete(uri: Uri, options?: RouteOptions): Promise<boolean> {
+    return this.api.delete(uri).then(() => true);
+  }
 }

package/src/types/Cache.ts

@@ -1,12 +1,12 @@
-import {Func} from "./Func";
-import {CacheAge} from "./CacheAge";
-import {Construct} from "./Constructor";
+import { Func } from './Func';
+import { CacheAge } from './CacheAge';
+import { Construct } from './Constructor';
 
 export interface Store<To = any, From = any> {
-    execute: (fetch: From, f: Func<Promise<To>, From>) => Promise<To>;
+  execute: (fetch: From, f: Func<Promise<To>, From>) => Promise<To>;
 }
 
 export type CacheOptions = {
-    expiresIn?: CacheAge;
-    store?: Construct<Store>;
+  expiresIn?: CacheAge;
+  store?: Construct<Store>;
 };

package/src/types/CacheAge.ts

@@ -1,55 +1,55 @@
-import {asNumber, asString, choose} from "./index";
+import { asNumber, asString, choose } from './index';
 
 export type CacheAge = `${number}${'ms' | 's' | 'm' | 'h' | 'd'}` | number;
 
 const ageNumber = (s: string): number => asNumber(s.replace(/[a-z]/g, ''));
 
 export const cacheAge = {
-    toMilliseconds: (ca: CacheAge): number =>
-        choose(asString(ca))
-            .case(
-                c => c.endsWith('ms'),
-                c => ageNumber(c)
-            )
-            .case(
-                c => c.endsWith('s'),
-                c => ageNumber(c) * 1000
-            )
-            .case(
-                c => c.endsWith('m'),
-                c => ageNumber(c) * 60 * 1000
-            )
-            .case(
-                c => c.endsWith('h'),
-                c => ageNumber(c) * 3600 * 1000
-            )
-            .case(
-                c => c.endsWith('d'),
-                c => ageNumber(c) * 24 * 3600 * 1000
-            )
-            .else(ca as number),
+  toMilliseconds: (ca: CacheAge): number =>
+    choose(asString(ca))
+      .case(
+        c => c.endsWith('ms'),
+        c => ageNumber(c)
+      )
+      .case(
+        c => c.endsWith('s'),
+        c => ageNumber(c) * 1000
+      )
+      .case(
+        c => c.endsWith('m'),
+        c => ageNumber(c) * 60 * 1000
+      )
+      .case(
+        c => c.endsWith('h'),
+        c => ageNumber(c) * 3600 * 1000
+      )
+      .case(
+        c => c.endsWith('d'),
+        c => ageNumber(c) * 24 * 3600 * 1000
+      )
+      .else(ca as number),
 
-    toSeconds: (ca: CacheAge): number =>
-        choose(asString(ca))
-            .case(
-                c => c.endsWith('ms'),
-                c => ageNumber(c) / 1000
-            )
-            .case(
-                c => c.endsWith('s'),
-                c => ageNumber(c)
-            )
-            .case(
-                c => c.endsWith('m'),
-                c => ageNumber(c) * 60
-            )
-            .case(
-                c => c.endsWith('h'),
-                c => ageNumber(c) * 3600
-            )
-            .case(
-                c => c.endsWith('d'),
-                c => ageNumber(c) * 24 * 3600
-            )
-            .else(ca as number)
-}
+  toSeconds: (ca: CacheAge): number =>
+    choose(asString(ca))
+      .case(
+        c => c.endsWith('ms'),
+        c => ageNumber(c) / 1000
+      )
+      .case(
+        c => c.endsWith('s'),
+        c => ageNumber(c)
+      )
+      .case(
+        c => c.endsWith('m'),
+        c => ageNumber(c) * 60
+      )
+      .case(
+        c => c.endsWith('h'),
+        c => ageNumber(c) * 3600
+      )
+      .case(
+        c => c.endsWith('d'),
+        c => ageNumber(c) * 24 * 3600
+      )
+      .else(ca as number),
+};

package/src/types/Constructor.ts

@@ -13,6 +13,6 @@ export const ofConstruct = <T>(c: Construct<T>, ...args: unknown[]): T => (isCon
 export const toName = (subject?: unknown, postfix = ''): string => (subject as any)?.constructor?.name?.replace(postfix, '').toLowerCase() ?? '';
 
 export const on = <T>(t: T, f: (t: T) => unknown): T => {
-    f(t);
-    return t;
-};
+  f(t);
+  return t;
+};

package/src/types/Gateway.ts

@@ -4,8 +4,7 @@ import { Exception } from './Exception';
 import { reject } from '../utils';
 import { PageList, PageOptions } from './PageList';
 import { List } from './List';
-import {CacheOptions} from "./Cache";
-
+import { CacheOptions } from './Cache';
 
 export type FetchOptions = PageOptions & CacheOptions;
 

package/src/types/List.ts

@@ -77,7 +77,7 @@ export class List<T = unknown> extends Array<T> {
     tryTo(() => item[key])
       .map(k => this.findIndex(i => i[key] === k))
       .filter(i => i > -1)
-      .map(i => this[i] = item);
+      .map(i => (this[i] = item));
     return this;
   };
 

package/src/types/PageList.ts

@@ -2,7 +2,7 @@ import { isList, List, toList } from './List';
 import { Construct, ofConstruct } from './Constructor';
 import { isA } from './IsA';
 
-export type Sort =  { key: string; value: -1 | 1 };
+export type Sort = { key: string; value: -1 | 1 };
 
 export type FilterValue = { label?: string; value: any };
 export type Filter = { label?: string; field: string; values: FilterValue[] };
@@ -26,5 +26,5 @@ export const toPageList = <T>(items?: T[], options?: Omit<PageOptions, 'sort'> &
 export const asPageList = <T, U>(c: Construct<T>, items = toPageList<U>()): PageList<T> =>
   toPageList<T>(
     items.map(i => ofConstruct(c, i)),
-    items,
+    items
   );

package/src/types/Types.ts

@@ -1,2 +1 @@
-
 export type DontInfer<T> = [T][T extends any ? 0 : never];