@art-ws/common 1.0.4 → 2.0.2

package/dist/es/managed-promise.js

@@ -0,0 +1,24 @@
+import BlueBirdPromise from "bluebird";
+// http://bluebirdjs.com/docs/api/cancellation.html
+export function ManagedPromise(args) {
+    let fulfill;
+    let rejected = () => { };
+    const promise = new BlueBirdPromise((resolve, reject, onCancel) => {
+        fulfill = resolve;
+        rejected = reject;
+        if (typeof onCancel === "function") {
+            onCancel(() => {
+                if (typeof args?.onCancel === "function") {
+                    args.onCancel();
+                }
+            });
+        }
+    });
+    promise.resolvedValue = undefined;
+    promise.resolve = (value) => {
+        promise.resolvedValue = value;
+        return fulfill(value);
+    };
+    promise.reject = rejected;
+    return promise;
+}

package/dist/{mem-cache → es/mem-cache}/cache-stat.d.ts

@@ -12,4 +12,3 @@ export declare class CacheStat {
     incMiss(): void;
     getStatistics(): CacheStatistics;
 }
-//# sourceMappingURL=cache-stat.d.ts.map

package/dist/{mem-cache → es/mem-cache}/cache-stat.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheStat = void 0;
-class CacheStat {
-    constructor() {
-        this.total = 0;
-        this.hit = 0;
-    }
+export class CacheStat {
+    total = 0;
+    hit = 0;
     incHit() {
         this.hit++;
         this.total++;
@@ -19,10 +14,8 @@ class CacheStat {
             total: this.total,
             hit: this.hit,
             miss,
-            hit_percent: this.total ? (this.hit * 100) / this.total : null,
-            miss_percent: this.total ? (miss * 100) / this.total : null,
+            hit_percent: this.total ? (this.hit * 100) / this.total : 0,
+            miss_percent: this.total ? (miss * 100) / this.total : 0,
         };
     }
 }
-exports.CacheStat = CacheStat;
-//# sourceMappingURL=cache-stat.js.map

package/dist/{mem-cache → es/mem-cache}/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./cache-stat";
 export * from "./memory-cache";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/mem-cache/index.js

@@ -0,0 +1,3 @@
+// created from 'create-ts-index'
+export * from "./cache-stat";
+export * from "./memory-cache";

package/dist/{mem-cache → es/mem-cache}/memory-cache.d.ts

@@ -1,7 +1,7 @@
-import { HeartBeat } from "../heart-beat";
+import type { HeartBeat } from "../heart-beat";
 import { CacheStat } from "./cache-stat";
-export declare type CacheCanRemoveCallback = (value?: unknown, key?: string) => boolean;
-export declare type CacheOnRemoveCallback = (value?: unknown, key?: string) => void;
+export type CacheCanRemoveCallback = (value?: unknown, key?: string) => boolean;
+export type CacheOnRemoveCallback = (value?: unknown, key?: string) => void;
 export interface CacheItemOptions {
     timeToIdle?: number;
     timeToLive?: number;
@@ -56,4 +56,3 @@ export declare class MemoryCacheBase {
     vacuum(): void;
     destroy(): void;
 }
-//# sourceMappingURL=memory-cache.d.ts.map

package/dist/{mem-cache → es/mem-cache}/memory-cache.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryCacheBase = exports.CacheItem = void 0;
-const slf_1 = require("@art-ws/slf");
-const promise_race_1 = require("../shared/promise-race");
-const cache_stat_1 = require("./cache-stat");
+import { getLogger } from "@art-ws/slf";
+import { synchronized } from "../shared/promise-race";
+import { CacheStat } from "./cache-stat";
 function now() {
     return new Date().valueOf();
 }
@@ -11,12 +8,13 @@ const DEFAULT_TTL = 15 * 1000; // Milliseconds
 const defaultCacheItemOptions = {
     timeToLive: DEFAULT_TTL,
 };
-class CacheItem {
+export class CacheItem {
+    createdAt = now();
+    lastHitAt = null;
+    cacheValue = null;
+    cacheHitCount = 0;
+    options;
     constructor(value, options) {
-        this.createdAt = now();
-        this.lastHitAt = null;
-        this.cacheValue = null;
-        this.cacheHitCount = 0;
         this.cacheValue = value;
         this.options = options || {};
         if (this.options.timeToIdle) {
@@ -61,16 +59,17 @@ class CacheItem {
         }
     }
 }
-exports.CacheItem = CacheItem;
 function isEmpty(v) {
     return v === undefined || v === null;
 }
-class MemoryCacheBase {
+export class MemoryCacheBase {
+    logger = getLogger("MemoryCacheBase");
+    heartBeat;
+    cache = new Map();
+    expirationStrategy = null;
+    subscription = null;
+    stat = new CacheStat();
     constructor(options) {
-        this.logger = slf_1.getLogger(MemoryCacheBase);
-        this.cache = new Map();
-        this.expirationStrategy = null;
-        this.stat = new cache_stat_1.CacheStat();
         if (options) {
             this.expirationStrategy = options.expirationStrategy ?? null;
         }
@@ -117,6 +116,8 @@ class MemoryCacheBase {
     checkItemExpired(key, item) {
         this.logger.trace(() => [`checkItemExpired(${key})`]);
         const targetItem = item || this.cache.get(key);
+        if (!targetItem)
+            return;
         if (this.isItemExpired(targetItem)) {
             this.removeItem(key, targetItem);
         }
@@ -125,7 +126,7 @@ class MemoryCacheBase {
         const targetItem = item ?? this.cache.get(key);
         let canRemove = true;
         if (targetItem) {
-            canRemove = targetItem.canRemove(key) ?? Boolean(force);
+            canRemove = targetItem.canRemove(key) || Boolean(force);
             if (canRemove) {
                 targetItem.onRemove(key);
             }
@@ -154,7 +155,7 @@ class MemoryCacheBase {
     async getOrUpdateAsync(key, fn, options) {
         let value = this.get(key);
         if (isEmpty(value)) {
-            value = await promise_race_1.racePromise(key, () => Promise.resolve(fn()), this);
+            value = await synchronized(key, () => Promise.resolve(fn()), this);
             this.set(key, value, options);
         }
         return value;
@@ -211,5 +212,3 @@ class MemoryCacheBase {
         }
     }
 }
-exports.MemoryCacheBase = MemoryCacheBase;
-//# sourceMappingURL=memory-cache.js.map

package/dist/{node-zone.d.ts → es/node-zone.d.ts}

@@ -1,18 +1,18 @@
 export interface ZoneSpec {
     name: string;
-    properties?: object;
+    properties?: Record<string, any>;
 }
 export declare class Zone {
     private readonly zoneData;
     private readonly zoneName;
     private readonly zoneParent;
+    uid: number;
     constructor(parent: Zone | null, spec: string | ZoneSpec | null);
-    get data(): object;
+    get data(): Record<string, any>;
     get name(): string;
     get parent(): Zone | null;
     fork(spec: ZoneSpec): Zone;
     run<T>(callback: () => T, thisArg?: any, args?: any[]): T;
-    wrap(callback: () => unknown): () => unknown;
     static isEnabled(): boolean;
     static enable(): void;
     static disable(): void;
@@ -20,4 +20,3 @@ export declare class Zone {
     getZoneWith(key: string): Zone | null;
     static get current(): Zone;
 }
-//# sourceMappingURL=node-zone.d.ts.map

package/dist/{node-zone.js → es/node-zone.js}

@@ -1,17 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zone = void 0;
-const tslib_1 = require("tslib");
-const async_hooks_1 = tslib_1.__importDefault(require("async_hooks"));
+import asyncHooks from "async_hooks";
 // inspired by https://raw.githubusercontent.com/JsCommunity/node-zone/master/index.js
 // https://nodejs.org/api/async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource
 // https://dzone.com/articles/beware-the-performance-cost-of-async-hooks-node-8
 // https://github.com/bmeurer/async-hooks-performance-impact
 const zones = Object.create(null);
 let current;
-const asyncHook = async_hooks_1.default.createHook({
+const asyncHook = asyncHooks.createHook({
     init(uid) {
         zones[uid] = current;
+        if (current) {
+            current.uid = uid;
+        }
     },
     before(uid) {
         current = zones[uid];
@@ -43,11 +42,12 @@ const toggleAsyncHooks = (value) => {
         asyncHook.disable();
     }
 };
-class Zone {
+export class Zone {
+    zoneData = Object.create(null);
+    zoneName = "root";
+    zoneParent = null;
+    uid = 0;
     constructor(parent, spec) {
-        this.zoneData = Object.create(null);
-        this.zoneName = "root";
-        this.zoneParent = null;
         toggleAsyncHooks(true);
         if (parent !== null) {
             const data = (this.zoneData = Object.create(parent.data));
@@ -62,6 +62,7 @@ class Zone {
                 if (properties) {
                     for (const key in properties) {
                         if (properties.hasOwnProperty(key)) {
+                            ;
                             data[key] = properties[key];
                         }
                     }
@@ -86,21 +87,14 @@ class Zone {
         const previous = current;
         try {
             current = this;
-            return callback.apply(thisArg ?? null, args ?? []);
+            return callback.apply(thisArg ?? null, (args ?? []));
         }
         finally {
             current = previous;
         }
     }
-    wrap(callback) {
-        const { run: wrapper } = this;
-        // https://stackoverflow.com/questions/41944650/this-implicitly-has-type-any-because-it-does-not-have-a-type-annotation
-        return function (...args) {
-            return wrapper(callback, this, args);
-        };
-    }
     static isEnabled() {
-        return Boolean(asyncHooksEnabled);
+        return !!asyncHooksEnabled;
     }
     static enable() {
         toggleAsyncHooks(true);
@@ -110,7 +104,7 @@ class Zone {
     }
     // minimal zone.js compatibility
     get(key) {
-        return this.zoneData[key] || null;
+        return this.zoneData[key] ?? null;
     }
     getZoneWith(key) {
         if (Object.prototype.hasOwnProperty.call(this.zoneData, key)) {
@@ -123,6 +117,4 @@ class Zone {
         return current;
     }
 }
-exports.Zone = Zone;
 const root = (current = new Zone(null, null));
-//# sourceMappingURL=node-zone.js.map

package/dist/es/object-hash/index.d.ts

@@ -0,0 +1 @@
+export * from "./object-hash";

package/dist/es/object-hash/index.js

@@ -0,0 +1,2 @@
+// created from 'create-ts-index'
+export * from "./object-hash";

package/dist/es/object-hash/object-hash.d.ts

@@ -0,0 +1 @@
+export declare const getObjectHash: (o: Record<string, any>) => string;

package/dist/es/object-hash/object-hash.js

@@ -0,0 +1,3 @@
+import { hasher } from "node-object-hash";
+const hashSortCoerce = hasher({ sort: true, coerce: true });
+export const getObjectHash = (o) => hashSortCoerce.hash(o);

package/dist/es/shared/api-client/api-client.interface.d.ts

@@ -0,0 +1,63 @@
+import { Observable } from "rxjs";
+export type ApiClientHttpMethods = "get" | "post" | "put" | "delete" | "patch";
+export interface IApiClientRequestOptions {
+    cached: boolean;
+    urlEncoded: boolean;
+    headers: Record<string, any>;
+}
+export interface IApiClientConfig {
+    production: boolean;
+    apiBaseUrl: string;
+}
+export interface IApiClientMethodOptions {
+    baseUrl: string;
+    parentUrl: string;
+    headers: Record<string, any>;
+    reqId: string;
+}
+export interface IApiClientRequestArgs<O = IApiClientRequestOptions> extends Partial<IApiClientMethodOptions> {
+    url: string;
+    method: ApiClientHttpMethods;
+    query?: Record<string, any>;
+    data?: Record<string, any>;
+    options?: Partial<O>;
+}
+export interface IApiClientAware {
+    apiClient: IApiClient;
+    options?: Partial<IApiClientMethodOptions>;
+}
+export interface IApiClientReverseRouteDef {
+    url: string;
+    method: ApiClientHttpMethods;
+}
+export interface IApiClientReverseRoute {
+    getReverseRoute(ref: IApiClientAware, key: string): IApiClientReverseRouteDef;
+}
+export interface IApiClientUrlMaker {
+    getUrl(options?: {
+        url?: string;
+        baseUrl?: string;
+        query?: any;
+    }): string;
+}
+export interface IApiClient extends Partial<IApiClientUrlMaker> {
+    request<T>(args: IApiClientRequestArgs): Observable<T>;
+}
+export interface IApiClientTokenProvider {
+    getToken(): string;
+}
+export declare class ApiClientConfig implements IApiClientConfig {
+    production: boolean;
+    apiBaseUrl: string;
+}
+export declare abstract class ApiClientTokenProvider implements IApiClientTokenProvider {
+    abstract getToken(): string;
+}
+export interface TApiClientConstructor<T extends ApiClientBase = ApiClientBase> {
+    new (apiClient: IApiClient, options?: Partial<IApiClientMethodOptions>): T;
+}
+export declare class ApiClientBase implements IApiClientAware {
+    apiClient: IApiClient;
+    options?: Partial<IApiClientMethodOptions> | undefined;
+    constructor(apiClient: IApiClient, options?: Partial<IApiClientMethodOptions> | undefined);
+}

package/dist/es/shared/api-client/api-client.interface.js

@@ -0,0 +1,15 @@
+import { Observable } from "rxjs";
+export class ApiClientConfig {
+    production = false;
+    apiBaseUrl = "";
+}
+export class ApiClientTokenProvider {
+}
+export class ApiClientBase {
+    apiClient;
+    options;
+    constructor(apiClient, options) {
+        this.apiClient = apiClient;
+        this.options = options;
+    }
+}

package/dist/es/shared/api-client/decorators.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import type { IApiClientRequestOptions as RequestOptions, TApiClientConstructor } from "./api-client.interface";
+export declare function ApiGet(url?: string, options?: Partial<RequestOptions>): (target: any, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ApiPost(url?: string, options?: Partial<RequestOptions>): (target: any, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ApiPut(url?: string, options?: Partial<RequestOptions>): (target: any, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ApiDelete(url?: string, options?: Partial<RequestOptions>): (target: any, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ApiPatch(url?: string, options?: Partial<RequestOptions>): (target: any, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ApiGroup(url: string, clz?: TApiClientConstructor): (target: Object, key: string) => void;

package/dist/es/shared/api-client/decorators.js

@@ -0,0 +1,73 @@
+import "reflect-metadata";
+import { makeUrl } from "./make-url";
+function getDecorator(method, url, options) {
+    return function (target, property, descriptor) {
+        if (descriptor === undefined) {
+            descriptor = Object.getOwnPropertyDescriptor(target, property);
+        }
+        descriptor.value = function (...args) {
+            const { apiClient, options: o2 } = this;
+            const [allArgs = {}, a2 = {}] = args || [];
+            const o1 = a2;
+            const r = makeUrl({ url: (o2?.parentUrl ?? "") + url, query: allArgs });
+            const effectiveURL = r.url;
+            const effectiveQuery = r.query;
+            const reqArgs = {
+                method,
+                url: effectiveURL,
+                query: effectiveQuery,
+                options,
+                baseUrl: o1?.baseUrl ?? o2?.baseUrl,
+                headers: o1?.headers ?? o2?.headers,
+                reqId: o1?.reqId ?? o2?.reqId,
+            };
+            return apiClient.request(reqArgs);
+        };
+        return descriptor;
+    };
+}
+export function ApiGet(url, options) {
+    return getDecorator("get", url ?? "", options ?? {});
+}
+export function ApiPost(url, options) {
+    return getDecorator("post", url ?? "", options ?? {});
+}
+export function ApiPut(url, options) {
+    return getDecorator("put", url ?? "", options ?? {});
+}
+export function ApiDelete(url, options) {
+    return getDecorator("delete", url ?? "", options ?? {});
+}
+export function ApiPatch(url, options) {
+    return getDecorator("patch", url ?? "", options ?? {});
+}
+// https://gist.github.com/remojansen/16c661a7afd68e22ac6e
+export function ApiGroup(url, clz) {
+    return function (target, key) {
+        // https://www.typescriptlang.org/tsconfig#emitDecoratorMetadata
+        const propType = Reflect.getMetadata("design:type", target, key);
+        const Clz = clz ?? propType;
+        const propKey = `__${key}__`;
+        const getter = function () {
+            const self = this;
+            let ref = self[propKey];
+            if (!ref) {
+                ref = new Clz(self.apiClient, {
+                    ...self.options,
+                    parentUrl: (self.options?.parentUrl ?? "") + url,
+                });
+                self[propKey] = ref;
+            }
+            return ref;
+        };
+        const setter = () => {
+            throw new Error(`Property '${key}' is readonly`);
+        };
+        Object.defineProperty(target, key, {
+            get: getter,
+            set: setter,
+            enumerable: true,
+            configurable: true,
+        });
+    };
+}

package/dist/es/shared/api-client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api-client.interface";
+export * from "./decorators";

package/dist/es/shared/api-client/index.js

@@ -0,0 +1,3 @@
+// created from 'create-ts-index'
+export * from "./api-client.interface";
+export * from "./decorators";

package/dist/es/shared/api-client/make-url.d.ts

@@ -0,0 +1,6 @@
+export interface TMakeUrlOptions {
+    url: string;
+    query: any;
+    addQueryParams?: boolean;
+}
+export declare function makeUrl(options: TMakeUrlOptions): TMakeUrlOptions;

package/dist/es/shared/api-client/make-url.js

@@ -0,0 +1,32 @@
+const isDefined = (x) => !(x === undefined || x === null || Number.isNaN(x));
+const replaceAll = (s, search, replacement) => {
+    return s.replace(new RegExp(search, "g"), replacement);
+};
+export function makeUrl(options) {
+    const { query: args, addQueryParams } = options;
+    let { url } = options;
+    const query = {};
+    Object.keys(args).forEach((k) => {
+        const v = args[k];
+        if (isDefined(v)) {
+            if (url.includes(`:${k}`)) {
+                url = replaceAll(url, `:${k}`, v + "");
+            }
+            else {
+                query[k] = v;
+            }
+        }
+    });
+    let qp = "";
+    if (addQueryParams) {
+        const q = [];
+        Object.keys(query).forEach((k) => {
+            q.push(`${k}=${encodeURIComponent(query[k] + "")}`);
+        });
+        qp = q.join("&");
+    }
+    if (qp) {
+        url = `${url}?${qp}`;
+    }
+    return { url, query };
+}

package/dist/{shared → es/shared}/assert-dsl.d.ts

@@ -3,13 +3,16 @@ export declare class AssertDSL {
     value: any;
     constructor(args: any);
     defined(message?: string): this;
-    truthly(message?: string): this;
+    truthy(message?: string): this;
     range(a: number, b: number): this;
     intLike(): this;
+    intList(): this;
     int(compatible?: boolean): this;
     typeOf(typeName: string): this;
+    bool(): this;
     func(): this;
     object(): this;
+    number(): this;
     str(): this;
     anyOf<T>(values: T[]): this;
     string(): this;
@@ -24,4 +27,3 @@ export declare class AssertDSL {
     eq(value: any): this;
 }
 export declare function assert(arg: any): AssertDSL;
-//# sourceMappingURL=assert-dsl.d.ts.map

package/dist/{shared → es/shared}/assert-dsl.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = exports.AssertDSL = void 0;
-class AssertDSL {
+export class AssertDSL {
+    name = "";
+    value;
     constructor(args) {
-        this.name = "";
         if (typeof args === "object") {
             const keys = Object.keys(args);
             if (keys.length === 1) {
@@ -24,9 +22,9 @@ class AssertDSL {
             throw new Error(message || `${this.name} not defined`);
         return this;
     }
-    truthly(message) {
+    truthy(message) {
         if (!this.value)
-            throw new Error(message || `${this.name} not truthly`);
+            throw new Error(message || `${this.name} not truthy`);
         return this;
     }
     range(a, b) {
@@ -37,13 +35,26 @@ class AssertDSL {
     intLike() {
         return this.int(true);
     }
+    intList() {
+        this.string();
+        this.value
+            .split(",")
+            .filter(Boolean)
+            .map((x) => Number(x))
+            .forEach((x) => {
+            if (!Number.isInteger(x)) {
+                throw new Error(`${this.name} is not an integers comma delimited list`);
+            }
+        });
+        return this;
+    }
     int(compatible) {
-        let candidate = this.value;
+        let mayBe = this.value;
         if (compatible) {
-            candidate = parseInt(candidate) || candidate;
+            mayBe = parseInt(mayBe) ?? mayBe;
         }
-        if (!Number.isInteger(candidate))
-            throw new Error(`${this.name} is '${`${candidate}`}', but not an integer number`);
+        if (!Number.isInteger(mayBe))
+            throw new Error(`${this.name} is '${`${mayBe}`}', but not an integer number`);
         return this;
     }
     typeOf(typeName) {
@@ -52,12 +63,18 @@ class AssertDSL {
             throw new Error(`${this.name} is not an ${typeName}, but '${t}'`);
         return this;
     }
+    bool() {
+        return this.typeOf("boolean");
+    }
     func() {
         return this.typeOf("function");
     }
     object() {
         return this.typeOf("object");
     }
+    number() {
+        return this.typeOf("number");
+    }
     str() {
         return this.string();
     }
@@ -74,7 +91,7 @@ class AssertDSL {
         ;
         (props || []).forEach((prop) => {
             if (!this.value.hasOwnProperty(prop))
-                throw new Error(`Property ${this.name}.${prop} not defined`);
+                throw new Error(`Property ${this.name}.${String(prop)} not defined`);
         });
         return this;
     }
@@ -137,9 +154,6 @@ class AssertDSL {
         return this;
     }
 }
-exports.AssertDSL = AssertDSL;
-function assert(arg) {
+export function assert(arg) {
     return new AssertDSL(arg);
 }
-exports.assert = assert;
-//# sourceMappingURL=assert-dsl.js.map

package/dist/es/shared/await-if-async.d.ts

@@ -0,0 +1 @@
+export declare function awaitIfAsync(value: unknown): Promise<void>;

package/dist/es/shared/await-if-async.js

@@ -0,0 +1,5 @@
+export async function awaitIfAsync(value) {
+    if (typeof value?.then === "function") {
+        await value;
+    }
+}

package/dist/{shared → es/shared}/disposable.d.ts

@@ -1,4 +1,3 @@
 export interface IDisposable<T> {
     dispose: () => T;
 }
-//# sourceMappingURL=disposable.d.ts.map

package/dist/es/shared/disposable.js

@@ -0,0 +1 @@
+export {};

package/dist/{shared → es/shared}/index.d.ts

@@ -1,7 +1,8 @@
+export * from "./api-client";
 export * from "./assert-dsl";
+export * from "./await-if-async";
 export * from "./disposable";
 export * from "./optional";
 export * from "./promise-race";
 export * from "./runnable";
 export * from "./safe-call";
-//# sourceMappingURL=index.d.ts.map