@social-mail/social-mail-hosted-web 1.2.18 → 1.2.21

package/node_modules/@web-atoms/entity/src/services/BaseEntityService.ts

@@ -1,14 +1,17 @@
-import { CancelToken, IDisposable } from "@web-atoms/core/dist/core/types";
+import { CancelToken } from "@web-atoms/core/dist/core/types";
 import DateTime from "@web-atoms/date-time/dist/DateTime";
 import { Cloner } from "../models/Cloner";
-import IClrEntity, { IClrEntityLike, IClrExtendedEntity } from "../models/IClrEntity";
+import IClrEntity, { IClrEntityLike } from "../models/IClrEntity";
 import IEntityModel, { EntityContext } from "../models/IEntityModel";
-import HttpSession, { IHttpRequest } from "./HttpSession";
 import mergeProperties from "./mergeProperties";
 import Query, { IDateRange, IEntityWithDateRange, stepTypes } from "./Query";
 import resolve from "./resolve";
 import { QueryProcessor } from "./QueryProcessor";
+import TaskManager from "../models/TaskManager";
+import FetchBuilder from "@web-atoms/core/dist/services/FetchBuilder";
 
+(Symbol as any).asyncDispose ??= Symbol("asyncDispose");
+(Symbol as any).dispose ??= Symbol("dispose");
 export interface IGeometry {
     latitude: number;
     longitude: number;
@@ -71,44 +74,9 @@ export interface ICollection<T> extends Array<T> {
 }
 
 const ArrayPrototype = Array.prototype as any;
-ArrayPrototype.where = ArrayPrototype.filter;
-ArrayPrototype.any = ArrayPrototype.some;
-ArrayPrototype.select = ArrayPrototype.map;
-ArrayPrototype.selectMany = function(x) {
-    const r = [];
-    for (const iterator of this) {
-        const items = x(iterator);
-        if (Array.isArray(items)) {
-            r.push(... items);
-        }
-    }
-    return r;
-};
-ArrayPrototype.firstOrDefault = function(f) {
-    if (f) {
-        return ArrayPrototype.find.apply(this, arguments);
-    }
-    return this[0];
-};
-ArrayPrototype.sum = function(f) {
-    let n = 0;
-    for (const iterator of this) {
-        n += f(iterator) ?? 0;
-    }
-    return n;
-};
-ArrayPrototype.average = function(f) {
-    if (this.length === 0) {
-        return 0;
-    }
-    let n = 0;
-    for (const iterator of this) {
-        n += f(iterator) ?? 0;
-    }
-    return n / this.length;
-};
-ArrayPrototype.orderBy = function(f) {
-    return this.sort((a, b) => {
+
+const orderBy = function (f) {
+    return [].concat(this).sort((a, b) => {
         const ak = f(a);
         const bk = f(b);
         if (typeof ak === "string") {
@@ -117,9 +85,9 @@ ArrayPrototype.orderBy = function(f) {
         return ak - bk;
     });
 };
-ArrayPrototype.thenBy = ArrayPrototype.orderBy;
-ArrayPrototype.orderByDescending = function(f) {
-    return this.sort((a, b) => {
+
+const orderByDescending = function (f) {
+    return [].concat(this).sort((a, b) => {
         const ak = f(a);
         const bk = f(b);
         if (typeof ak === "string") {
@@ -128,19 +96,109 @@ ArrayPrototype.orderByDescending = function(f) {
         return bk - ak;
     });
 };
-ArrayPrototype.thenByDescending = ArrayPrototype.orderByDescending;
-ArrayPrototype.count = function(f) {
-    if (!f) {
-        return this.length;
-    }
-    let length = 0;
-    for (const iterator of this) {
-        if (f(iterator)) {
-            length++;
-        }
+
+Object.defineProperties(ArrayPrototype, {
+    where: {
+        enumerable: false,
+        value: ArrayPrototype.filter,
+        configurable: true
+    },
+    any: {
+        enumerable: false,
+        value: ArrayPrototype.some,
+        configurable: true
+    },
+    select: {
+        enumerable: false,
+        value: ArrayPrototype.map,
+        configurable: true
+    },
+    selectMany: {
+        enumerable: false,
+        value(x) {
+            const r = [];
+            for (const iterator of this) {
+                const items = x(iterator);
+                if (Array.isArray(items)) {
+                    r.push(... items);
+                }
+            }
+            return r;        
+        },
+        configurable: true
+    },
+    firstOrDefault: {
+        enumerable: false,
+        value(f) {
+            if (f) {
+                return ArrayPrototype.find.apply(this, arguments);
+            }
+            return this[0];        
+        },
+        configurable: true
+    },
+    sum: {
+        enumerable: false,
+        value(f) {
+            let n = 0;
+            for (const iterator of this) {
+                n += f(iterator) ?? 0;
+            }
+            return n;        
+        },
+        configurable: true
+    },
+    average: {
+        enumerable: false,
+        value(f) {
+            if (this.length === 0) {
+                return 0;
+            }
+            let n = 0;
+            for (const iterator of this) {
+                n += f(iterator) ?? 0;
+            }
+            return n / this.length;        
+        },
+        configurable: true
+    },
+    orderBy: {
+        enumerable: false,
+        value: orderBy,
+        configurable: true
+    },
+    thenBy: {
+        enumerable: false,
+        value: orderBy,        configurable: false
+    },
+    orderByDescending: {
+        enumerable: false,
+        value: orderByDescending,
+        configurable: true
+    },
+    thenByDescending: {
+        enumerable: false,
+        value: orderByDescending,
+        configurable: false
+    },
+    count: {
+        enumerable: false,
+        value(f) {
+            if (!f) {
+                return this.length;
+            }
+            let length = 0;
+            for (const iterator of this) {
+                if (f(iterator)) {
+                    length++;
+                }
+            }
+            return length;        
+        },
+        configurable: false
     }
-    return length;
-};
+
+});
 
 export interface IMethod {
     select?: [string, ... any[]];
@@ -216,6 +274,11 @@ export interface IListParams {
      * Split server side includes
      */
     splitInclude?: boolean;
+
+    /**
+     * Includes encrypted $key
+     */
+    expandable?: boolean;
 }
 export interface IPagedListParams extends IListParams {
     start?: number;
@@ -223,10 +286,39 @@ export interface IPagedListParams extends IListParams {
     count?: boolean;
 }
 
-export interface IModel<T> {
+export interface IColumn {
+    name?: string;
+    type?: string;
+    length?: number;
+    dataType?: string;
+    generated?: string;
+    default?: any;
+}
+
+export interface IRelation {
+    name?: string;
+    fkMap?: { fk: string, relatedKey: string }[];
+    relatedName?: string;
+    isCollection?: boolean;
+    isInverse?: boolean;
+
+    relatedModel?: IModel<any>;
+}
+
+export interface IModelSchema {
+    name: string;
+    keys: IColumn[];
+    properties: IColumn[];
+    relations: IRelation[];
+    queries?: { [key: string]: any };
+    actions?: { [key: string]: any };
+}
+
+export interface IModel<T, TQ = any, TA = any> {
     name: string;
     create?(properties?: IClrEntityLike<T>): T;
     patch?(original: IClrEntityLike<T>, updates: IClrEntityLike<T>): T;
+    schema?: IModelSchema;
 }
 
 export class DefaultFactory {
@@ -238,7 +330,8 @@ export class Model<T> implements IModel<T> {
     constructor(
         public name: string,
         public readonly keys: string[] = [],
-        defaults: any = null
+        defaults: any = null,
+        public schema = null as IModelSchema
     ) {
         if (defaults) {
             this.defaults = [];
@@ -283,7 +376,9 @@ export class Model<T> implements IModel<T> {
     }
 }
 
-export default abstract class BaseEntityService extends HttpSession {
+export type IPrimitive = string | null | number | boolean;
+
+export default abstract class BaseEntityService extends TaskManager {
 
     public url: string = "/api/entity/";
 
@@ -301,7 +396,9 @@ export default abstract class BaseEntityService extends HttpSession {
         if (this.entityModel) {
             return this.entityModel;
         }
-        const c = await this.getJson<IEntityModel[]>({ url: `${this.url}model` });
+        using busy = this.createBusyIndicator(false);
+        const c = await FetchBuilder.get(`${this.url}model`)
+            .asJson<IEntityModel[]>();
         this.entityModel = new EntityContext(c);
         return this.entityModel;
     }
@@ -313,43 +410,152 @@ export default abstract class BaseEntityService extends HttpSession {
             ]);
     }
 
-    public query<T extends IClrEntity>(m: IModel<T>,
-            queryFunction?: string,
-            ... args: any[]): Query<T> {
+    query<T extends IClrEntity, TR>(m: IModel<T, TR>,
+            queryFunction?: keyof TR,
+            ... args: IPrimitive[]): Query<T> {
+        return new Query({
+            service: this,
+            name: m.name,
+            queryProcessor: this.queryProcessor,
+            queryFunction: queryFunction as any,
+            args
+        });
+    }
+
+    queryEntity<T extends IClrEntity, TR>(m: IModel<T, TR>,
+        entity: T,
+        queryFunction?: keyof TR,
+        ... args: IPrimitive[]): Query<T> {
+        let entityKey;
+        const { $key } = entity;
+        if (!$key) {
+            throw new Error(`Entity does not contain public/private key`);
+        }
+        entityKey = $key;
         return new Query({
             service: this,
             name: m.name,
             queryProcessor: this.queryProcessor,
-            queryFunction,
+            queryFunction: queryFunction as any,
+            entityKey,
             args
         });
     }
 
-    public delete<T extends IClrEntity>(body: T): Promise<void> {
+    as<TR>() {
+        return this as any as Query<TR>;
+    }
+
+    async delete<T extends IClrEntity>(body: T): Promise<void> {
+        using busy = this.createBusyIndicator(false);
         const url = this.url;
-        return this.deleteJson({url, body});
+        // return this.deleteJson({url, body});
+        return await FetchBuilder.delete(url).jsonBody(body).asJson();
     }
 
-    public insert(body: IClrEntity): Promise<IClrEntity> {
+    async insert(body: IClrEntity): Promise<IClrEntity> {
+        using busy = this.createBusyIndicator(false);
         const url = this.url;
-        return this.putJson({url, body});
+        // return this.putJson({url, body});
+        const result = await FetchBuilder.put(url).jsonBody(body).asJson();
+        return this.resultConverter(result);
+    }
+
+    async invoke<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: Partial<T>, ... args: any[]) {
+        using busy = this.createBusyIndicator(false);
+        // will send keys only...
+        const entity = {
+            $type: m.name
+        };
+        for(const key of m.schema.keys) {
+            entity[key.name] = argEntity[key.name];
+        }
+
+        const result = await FetchBuilder.post(`${this.url}invoke/${entity.$type}/${method as any}`)
+            .jsonBody({ entity, args })
+            .asJson<T>();
+
+        return this.resultConverter(result);
+
+        // return this.postJson({
+        //     url: `${this.url}invoke/${entity.$type}/${method as any}`,
+        //     method: "POST",
+        //     body: {
+        //         entity,
+        //         args
+        //     }
+        // }) as Promise<T>;
     }
 
-    public save<T extends IClrEntity>(body: T, cloner?: (c: Cloner<T>) => Cloner<T>): Promise<T>;
-    public save<T extends IClrEntity>(body: T[]): Promise<T[]>;
-    public async save(body: any, cloner?: (c: Cloner<any>) => Cloner<any>): Promise<any> {
+    buildRunUrl<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: Partial<T>, {
+        args = void 0 as any[],
+        cacheSeconds = 0,
+        cacheVersion = void 0 as any
+    } = {
+    }) {
+        const { $type, $key } = argEntity;
+        if (!$key) {
+            throw new Error(`Run requires encrypted $key`);
+        }
+        const usp = new URLSearchParams();
+        usp.append("key", $key);
+        if (args) {
+            usp.append("args", JSON.stringify(args));
+        }
+        if (cacheSeconds) {
+            usp.append("cache", cacheSeconds.toString());
+        }
+        if (cacheVersion) {
+            usp.append("cv", cacheVersion);
+        }
+        return `${this.url}run/${$type}/${method as any}?${usp.toString()}`;
+    }
+
+    run<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: Partial<T>, {
+        args = void 0 as any[],
+        cacheSeconds = 0,
+        cacheVersion = void 0 as any
+    } = {
+    }) {
+        const url = this.buildRunUrl(m, method, argEntity, { args, cacheSeconds, cacheVersion });
+        return FetchBuilder.get(url).jsonPostProcessor(this.resultConverter);
+    }
+
+
+    public save<T extends IClrEntity>(body: T, cloner?: (c: Cloner<T>) => Cloner<T>, trace?: boolean): Promise<T>;
+    public save<T extends IClrEntity>(body: T[], cloner?: (c: Cloner<T>) => Cloner<T>, trace?: boolean): Promise<T[]>;
+    public async save(body: any, cloner?: (c: Cloner<any>) => Cloner<any>, trace?: boolean): Promise<any> {
         if (Array.isArray(body) && body.length === 0) {
             return body;
         }
-        const url = this.url;
+        using busy = this.createBusyIndicator(false);
+        let url = this.url;
         if (body instanceof Cloner) {
             body = body.copy;
         }
+        if (trace) {
+            const hasQuery = url.includes("?");
+            if (hasQuery) {
+                url = url += "&trace=true";
+            } else {
+                url = url += "?trace=true";
+            }
+        }
         if (cloner) {
-            const c = cloner(new Cloner(body));
-            body = c.copy;
+            if (Array.isArray(body)) {
+                body = body.map((x) => cloner(new Cloner(x)).copy);
+            } else {
+                const c = cloner(new Cloner(body));
+                body = c.copy;
+            }
         }
-        const result = await this.postJson({url, body});
+        // const result = await this.postJson({
+        //     url, body
+        // });
+        let result = await FetchBuilder.post(url)
+            .jsonBody(body)
+            .asJson();
+        result = this.resultConverter(result);
         mergeProperties(result, body);
         return body;
     }
@@ -370,6 +576,7 @@ export default abstract class BaseEntityService extends HttpSession {
         update: IModifications,
         throwWhenNotFound: boolean = false): Promise<void> {
         const model = await this.model();
+        using busy = this.createBusyIndicator(false);
         const keys = [];
         for (const iterator of entities) {
             const entityType = model.for(iterator.$type);
@@ -381,13 +588,18 @@ export default abstract class BaseEntityService extends HttpSession {
         }
         const body = { keys, update, throwWhenNotFound };
         const url = `${this.url}bulk`;
-        await this.putJson({url, body});
+        let results = await FetchBuilder.post(url)
+            .jsonBody(body)
+            .asJson();
+        results = this.resultConverter(results);
+        return results;
     }
 
     public async bulkDelete<T extends IClrEntity>(
         entities: T[],
         throwWhenNotFound: boolean = false): Promise<void> {
         const model = await this.model();
+        using busy = this.createBusyIndicator(false);
         const keys = [];
         for (const iterator of entities) {
             const entityType = model.for(iterator.$type);
@@ -399,26 +611,31 @@ export default abstract class BaseEntityService extends HttpSession {
         }
         const url = `${this.url}bulk`;
         const body = { keys, throwWhenNotFound };
-        await this.deleteJson({
-            url,
-            body
-        });
-    }
-
-    protected async fetchJson<T>(options: IHttpRequest): Promise<T> {
-        if (!this.createBusyIndicator || options?.hideActivityIndicator) {
-            return await super.fetchJson(options);
-        }
-        const disposable = this.createBusyIndicator(options);
-        try {
-            return await super.fetchJson(options);
-        } finally {
-            disposable?.dispose();
-        }
+        // await this.deleteJson({
+        //     url,
+        //     body
+        // });
+        let results = await FetchBuilder.delete(url)
+            .jsonBody(body)
+            .asJson();
+        results = this.resultConverter(results);
+        return results;
     }
 
-    protected createBusyIndicator(options: IHttpRequest) {
-        return { dispose() {}};
+    // protected async fetchResponse<T>(options: IHttpRequest): Promise<T> {
+    //     if (!this.createBusyIndicator || options?.hideActivityIndicator) {
+    //         return await super.fetchResponse(options);
+    //     }
+    //     const disposable = this.createBusyIndicator(options);
+    //     try {
+    //         return await super.fetchResponse(options);
+    //     } finally {
+    //         disposable?.dispose();
+    //     }
+    // }
+
+    protected createBusyIndicator(hideActivityIndicator = false) {
+        return { [Symbol.dispose]() {}};
     }
 }
 

package/node_modules/@web-atoms/entity/src/services/HttpSession.ts

@@ -43,6 +43,7 @@ export interface IHttpRequest extends RequestInit {
     body?: any;
     cancelToken?: CancelToken;
     hideActivityIndicator?: boolean;
+    asJson?: boolean;
 }
 
 export default class HttpSession extends TaskManager {
@@ -55,8 +56,8 @@ export default class HttpSession extends TaskManager {
 
     protected resultConverter = (e) => e;
 
-    protected fetchJson<T>(options: IHttpRequest): Promise<T> {
-        return this.run(() => this.uncheckedFetchJson<T>(options));
+    protected fetchResponse<T>(options: IHttpRequest): Promise<T> {
+        return this.queueRun(() => this.uncheckedFetchJson<T>(options));
     }
 
     protected async uncheckedFetchJson<T>(options: IHttpRequest): Promise<T> {
@@ -93,7 +94,10 @@ export default class HttpSession extends TaskManager {
             // throw new Error(`Unable to convert to json\r\n${contentType}\r\n${await response.text()}`);
             throw new Error(`Unable to convert to json\r\n${contentType}}`);
         }
-        return this.resultConverter(await response.json());
+        const asJson = options.asJson ?? true;
+        if(asJson) {
+            return this.resultConverter(await response.json());
+        }
     }
 
     protected interceptFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
@@ -102,7 +106,7 @@ export default class HttpSession extends TaskManager {
 
     protected getJson<T>(options: IHttpRequest) {
         options.method = "GET";
-        return this.fetchJson<T>(options);
+        return this.fetchResponse<T>(options);
     }
 
     protected postFormModel<T>(options: IHttpRequest) {
@@ -112,7 +116,7 @@ export default class HttpSession extends TaskManager {
         }
         options.headers ??= {};
         options.headers["content-type"] = "application/x-www-form-urlencoded";
-        return this.fetchJson<T>(options);
+        return this.fetchResponse<T>(options);
     }
 
     protected postJson<T>(options: IHttpRequest) {
@@ -122,7 +126,7 @@ export default class HttpSession extends TaskManager {
         }
         options.headers ??= {};
         options.headers["content-type"] = "application/json";
-        return this.fetchJson<T>(options);
+        return this.fetchResponse<T>(options);
     }
 
     protected deleteJson<T>(options: IHttpRequest) {
@@ -132,7 +136,7 @@ export default class HttpSession extends TaskManager {
         }
         options.headers ??= {};
         options.headers["content-type"] = "application/json";
-        return this.fetchJson<T>(options);
+        return this.fetchResponse<T>(options);
     }
 
     protected putJson<T>(options: IHttpRequest) {
@@ -142,7 +146,7 @@ export default class HttpSession extends TaskManager {
         }
         options.headers ??= {};
         options.headers["content-type"] = "application/json";
-        return this.fetchJson<T>(options);
+        return this.fetchResponse<T>(options);
     }
 
 }

package/node_modules/@web-atoms/entity/src/services/MockBaseEntityService.ts

@@ -6,7 +6,7 @@ import BaseEntityService, { IBulkDeleteModel, IBulkUpdateModel, IModel, IQueryMe
 import Query from "./Query";
 import { QueryProcessor } from "./QueryProcessor";
 
-const replacer = /(\.[a-z0-9\_])|([a-z0-9\_]\())/ig;
+const replacer = /(\.[a-z0-9\_])|([a-z0-9\_]\(\))/ig;
 
 const convertToSafe = (text: string) => {
     return text.replace(replacer, (x) => {