@social-mail/social-mail-hosted-web 1.0.2

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

@@ -0,0 +1,208 @@
+import { CancelToken } from "@web-atoms/core/dist/core/types";
+import IClrEntity from "../models/IClrEntity";
+import { EntityContext } from "../models/IEntityModel";
+import IPagedList from "../models/IPagedList";
+import BaseEntityService, { IBulkDeleteModel, IBulkUpdateModel, IModel, IQueryMethod } from "./BaseEntityService";
+import Query from "./Query";
+import { QueryProcessor } from "./QueryProcessor";
+
+const replacer = /(\.[a-z0-9\_])|([a-z0-9\_]\())/ig;
+
+const convertToSafe = (text: string) => {
+    return text.replace(replacer, (x) => {
+        if (x.endsWith("(")) {
+            return x[0] + "?.(";
+        }
+        return "?" + x;
+    });
+};
+
+function sleep(n) {
+    return new Promise((resolve, reject) => {
+        setTimeout(resolve, n);
+    });
+}
+
+export class EntitySet<T> {
+
+    public readonly name: string;
+
+    public get all() {
+        const a = [];
+        for (const key in this.primary) {
+            if (Object.prototype.hasOwnProperty.call(this.primary, key)) {
+                const element = this.primary[key];
+                a.push(element);
+            }
+        }
+        return a;
+    }
+
+    private primary: {[key: string]: T} = {};
+
+    constructor(model: IModel<T>, protected readonly entityService: MockBaseEntityService) {
+        this.name = model.name;
+    }
+
+    public add(... items: Array<Partial<T>>) {
+        for (const item of items) {
+            this.save(item as any);
+        }
+    }
+
+    public save(item: T) {
+        const model = this.entityService.entityContext.for(this.name);
+        const keys = this.keys(item);
+        const existing = this.find(keys);
+        if (existing) {
+            for (const key in item) {
+                if (Object.prototype.hasOwnProperty.call(item, key)) {
+                    const element = item[key];
+                    existing[key] = element;
+                }
+            }
+            return;
+        }
+        for (const property of model.properties) {
+            if (!item.hasOwnProperty(property.name)) {
+                item[property.name] = null;
+            }
+        }
+        this.primary[JSON.stringify(keys)] = item;
+    }
+
+    public delete(item: T) {
+        const model = this.entityService.entityContext.for(this.name);
+        const keys = this.keys(item);
+        delete this.primary[JSON.stringify(keys)];
+    }
+
+    public keys(item: T) {
+        const model = this.entityService.entityContext.for(this.name);
+        const keys = [];
+        for (const iterator of model.keys) {
+            keys.push(item[iterator.name]);
+        }
+        return keys;
+    }
+
+    public find(keys: any[]) {
+        const key = JSON.stringify(keys);
+        return this.primary[key];
+    }
+
+}
+
+class MockEntityRestService {
+
+    constructor(private es: MockBaseEntityService) {}
+
+    public async query(
+        entity: string,
+        methods: {
+            methods: IQueryMethod[],
+            start: number,
+            size: number
+        },
+        ct: CancelToken
+    ): Promise<IPagedList<IClrEntity>> {
+        await sleep(200);
+        if (ct.cancelled) {
+            throw new Error("cancelled");
+        }
+        const model = this.es.entityContext.for(entity);
+        let all = this.es.set({ name: entity}).all;
+        for (const iterator of methods.methods) {
+            for (const key in iterator) {
+                if (Object.prototype.hasOwnProperty.call(iterator, key)) {
+                    const [expression, ... pl] = iterator[key];
+                    let fx = convertToSafe(expression) as any;
+                    for (let index = 0; index < pl.length; index++) {
+                        fx = fx.replaceAll(`@${index}`, `p[${index}]`);
+                    }
+                    // tslint:disable-next-line: no-eval
+                    fx = eval(`(p) => ${fx}`)(pl);
+                    // tslint:disable-next-line: ban-types
+                    all = (all[key] as Function).apply(all, fx);
+                }
+            }
+        }
+        const total = all.length;
+        if (methods.start) {
+            while (methods.start > 0) {
+                all = all.shift();
+            }
+        }
+        if (methods.size) {
+            all.length = methods.size;
+        }
+        return Promise.resolve({
+            items: all,
+            total
+        });
+    }
+
+    public async insert(body: IClrEntity): Promise<IClrEntity> {
+        await sleep(100);
+        this.es.set({ name: body.$type}).add(body);
+        return Promise.resolve(body);
+    }
+
+    public async save(body: IClrEntity): Promise<IClrEntity> {
+        await sleep(100);
+        this.es.set({ name: body.$type}).add(body);
+        return Promise.resolve(body);
+    }
+
+    public async delete(body: IClrEntity): Promise<void> {
+        await sleep(100);
+        this.es.set({ name: body.$type}).delete(body);
+        return Promise.resolve();
+    }
+
+    public async bulkSave(body: IBulkUpdateModel): Promise<void> {
+        await sleep(100);
+        for (const entity of body.keys) {
+            const model = this.es.set({ name: entity.$type});
+            const keys = model.keys(entity);
+            const existing = model.find(keys);
+            if (existing) {
+                for (const key in body.update) {
+                    if (Object.prototype.hasOwnProperty.call(body.update, key)) {
+                        const element = body.update[key];
+                        existing[key] = element;
+                    }
+                }
+            }
+        }
+        return Promise.resolve();
+    }
+
+    public async bulkDelete(body: IBulkDeleteModel): Promise<void> {
+        await sleep(100);
+        for (const entity of body.keys) {
+            const model = this.es.set({ name: entity.$type});
+            model.delete(entity);
+        }
+        return Promise.resolve();
+    }
+
+}
+
+export default class MockBaseEntityService extends BaseEntityService {
+
+    public queryProcessor: QueryProcessor = "DotNet";
+
+    public entityContext: EntityContext;
+
+    private local: { [key: string]: any } = {};
+
+    public seed() {
+        // tslint:disable-next-line: no-console
+        console.warn("Please override seed method for data");
+    }
+
+    public set<T>(m: IModel<T>): EntitySet<T> {
+        return this.local[m.name] ??= new EntitySet(m, this);
+    }
+}

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

@@ -0,0 +1,420 @@
+import DateTime from "@web-atoms/date-time/dist/DateTime";
+import IPagedList from "../models/IPagedList";
+import type BaseEntityService from "./BaseEntityService";
+import type { ICollection, IListParams, IModel, IPagedListParams, IQueryMethod } from "./BaseEntityService";
+import StringHelper from "./StringHelper";
+
+export type stepTypes = "Day" | "Month" | "Year" | "Week" | "Hour";
+
+const replacer = /(===)|(!==)|(\(\s*\{)|(\.[a-zA-Z0-9]+)|([a-zA-Z0-9]+\s*\:\s*\{?)/g;
+
+export const convertToLinq = (x: string) => {
+    x = x.replace(/(\s+)|((CastAs|EF)\_[0-9]\.default\.)/g, (s, first, second) => {
+        if (s === first) {
+            return " ";
+        }
+        if (s.startsWith("EF")) {
+            return "EF.";
+        }
+        if (s.startsWith("CastAs")) {
+            return "CastAs.";
+        }
+        return s;
+    });
+    replacer.lastIndex = 0;
+    x = x.replace(replacer, (s) => {
+        switch (s) {
+            case "===": return "==";
+            case "!==": return "!=";
+            case "({": return "( new {";
+            case ".some": return ".Any";
+            case ".map": return ".Select";
+            case ".filter": return ".Where";
+            case ".find": return ".FirstOrDefault";
+            case ".includes": return ".Contains";
+        }
+        if (s.endsWith("{")) {
+            const index = s.indexOf(":");
+            const v = s.substring(0, index) + " = new {";
+            return v;
+        }
+        const trimmed = s.trim();
+        if (trimmed.endsWith(":")) {
+            return trimmed.substring(0, trimmed.length - 1) + " = ";
+        }
+        if (s.startsWith(".") && s.length > 2) {
+            return s[0] + s[1].toUpperCase() + s.substring(2);
+        }
+        // return s.toUpperCase();
+        return s;
+    });
+    // reduce white space...
+    return x;
+};
+
+export function append<T>(original: T[], ... item: T[]) {
+    if (original) {
+        return [ ... original, ... item];
+    }
+    return [...item];
+}
+
+export interface IIncludedQuery<T, TR> extends Required<Query<T>> {
+    thenInclude<TP>(path: (x: TR) => TP): IIncludedQuery<T, TP>;
+}
+
+export interface IIncludedArrayQuery<T, TR, TRA extends TR[]> extends Required<Query<T>> {
+    thenInclude<TP>(q: (x: TR) => TP[]): IIncludedArrayQuery<T, TP, TP[]>;
+    thenInclude<TP>(q: (x: TR) => TP): IIncludedQuery<T, TP>;
+}
+
+export type Func<T, TR> = (x: T) => TR;
+
+export type SelectWithFunc<T, TI, TR> = (x: T, y: ICollection<TI>) => TR;
+
+export interface IDateRange {
+    startDate: DateTime,
+    endDate: DateTime
+}
+
+export interface IEntityWithDateRange<T> {
+    entity: T,
+    range: IDateRange
+}
+
+export class QueryComposer<Q> {
+
+    private query: string = "p => x => ";
+    private parameters: any = {};
+    private index = 0;
+
+    constructor(private separator = " || ") {
+
+    }
+
+    public add<P>(p: P, q: (p: P) => (item: Q) => any) {
+        if (this.index) {
+            this.query += this.separator;
+        }
+        const suffix = `_${this.index++}`;
+        let text = q.toString();
+        const pfn = StringHelper.findParameter(text).trim();
+        text = text.substring(text.indexOf("=>") + 2);
+        const xfn = StringHelper.findParameter(text).trim();
+        const target = this.parameters;
+        for (const key in p) {
+            if (Object.prototype.hasOwnProperty.call(p, key)) {
+                const element = p[key];
+                const name = `${key}${suffix}`;
+                target[name] = element;
+                text = text.split(`${pfn}.${key}`).join(`p.${name}`);
+                text = text.split(`${xfn}.`).join(`x.`);
+            }
+        }
+        text = text.substring(text.indexOf("=>") + 2);
+        this.query += text;
+    }
+
+    public asQuery(): any[] {
+        return [this.parameters, this.query];
+    }
+
+}
+
+interface IQueryContext {
+    service: BaseEntityService;    
+    name: string;
+    traceQuery?: boolean;
+    queryFunction?: string;
+    args?: any[];
+    queryProcessor?: "DotNet" | "JavaScript"
+}
+
+export default class Query<T> {
+
+    constructor(
+        private context: IQueryContext,
+        private methods: IQueryMethod[] = []
+    ) {
+        if (!methods) {
+            throw new Error("Methods cannot be empty");
+        }
+    }
+
+    public where<TR>(q: (x: T) => any): Query<T>;
+    public where<TP>(p: TP, q: (p: TP) => (x: T) => any): Query<T>;
+    public where<TP>(tOrP: TP | T, q?: (p: TP) => (x: T) => any): Query<T> {
+        return this.process("where", tOrP, q) as any;
+    }
+
+    public joinDateRange(
+        start: DateTime,
+        end: DateTime,
+        step: stepTypes): Query<IEntityWithDateRange<T>> {
+        return this.append(["joinDateRange", "@0,@1,@2", start, end, step] );
+    }
+
+    public selectWith<TI, TR>(model: IModel<TI>, q: SelectWithFunc<T, TI, TR>): Query<TR>;
+    public selectWith<TI, TR, TP = any>(model: IModel<TI>,tp: TP, q: (p: TP) => SelectWithFunc<T, TI, TR>): Query<TR>;
+    public selectWith<TI, TR, TP = any>(
+        model: IModel<TI>,
+        tOrP: TP | (SelectWithFunc<T, TI, TR>),
+        q?: (p: TP) => SelectWithFunc<T, TI, TR>): Query<TR> {
+        const nq = this.append(["selectWith" as any, model.name]);
+        return nq.process("select", tOrP, q as any) as any;
+    }
+
+    public select<TR>(q: (x: T) => TR): Query<TR>;
+    public select<TR, TP = any>(tp: TP, q: (p: TP) => (x: T) => TR): Query<TR>;
+    public select<TR, TP = any>(tOrP: TP | ((x: T) => TR), q?: (p: TP) => (x: T) => TR): Query<TR> {
+        return this.process("select", tOrP, q) as any;
+    }
+
+    /**
+     * @param args any[]
+     * @returns Query<T>
+     */
+    public whereLinq(query: TemplateStringsArray, ...args: any[]): Query<T> {
+        let filters = "";
+        const params = [];
+        for (let index = 0; index < args.length; index++) {
+            const element = args[index];
+            const raw = query.raw[index];
+            if (raw) {
+                filters += raw;
+            }
+            const pi = `@${index}`;
+            filters += pi;
+            params.push(element);
+        }
+        const last = query.raw[args.length];
+        if (last) {
+            filters += last;
+        }
+        // return new Query(this.ec, this.name, append(this.filter, { query: filters, parameters: params }),
+        //     this.orderBys,
+        //     this.includeProps);
+        return this.append(["where", filters, ...params]);
+    }
+
+    public selectLinq<TR>(query: TemplateStringsArray, ...args: any[]): Query<TR> {
+        let filters = "";
+        const params = [];
+        for (let index = 0; index < args.length; index++) {
+            const element = args[index];
+            const raw = query.raw[index];
+            if (raw) {
+                filters += raw;
+            }
+            const pi = `@${index}`;
+            filters += pi;
+            params.push(element);
+        }
+        const last = query.raw[args.length];
+        if (last) {
+            filters += last;
+        }
+        return this.append(["select", filters, ...params] );
+    }
+
+    public join<TInner, TKey>(model: IModel<TInner>, left: (x: T) => TKey, right: (x: TInner) => TKey)
+        : Query<{ entity: T, inner: TInner }> {
+        return this.append(["join" as any, model.name, this.convertToLinq(left.toString()), this.convertToLinq(right.toString())] ) as any;
+    }
+
+    public leftJoin<TInner, TKey>(model: IModel<TInner>, left: (x: T) => TKey, right: (x: TInner) => TKey)
+    : Query<{ entity: T, inner: TInner }> {
+    return this.append(["leftJoin" as any, model.name, this.convertToLinq(left.toString()), this.convertToLinq(right.toString())] ) as any;
+}
+
+    public include<TR>(q: (x: T) => TR[]): IIncludedArrayQuery<T, TR, TR[]>;
+    public include<TR>(q: (x: T) => TR): IIncludedQuery<T, TR>;
+    public include<TR>(... q: string[]): Query<T>;
+    public include<TR>(tOrP: ((x: T) => any) | string, ... q: string[]): IIncludedQuery<T, TR> | Query<T> {
+        if (typeof tOrP === "string") {
+            return this.append(
+                ["include", tOrP],
+                ... q.map((s) => ["include", s] as IQueryMethod)) as any;
+        }
+        const select = this.convertToLinq(tOrP.toString());
+        return this.append(["include", select] ) as any;
+    }
+
+    public async firstOrDefault(p: IListParams = {}): Promise<T> {
+        const lp = p as IPagedListParams;
+        lp.size = 1;
+        lp.start = 0;
+        lp.count = false;
+        const list = await this.toPagedList(lp);
+        return list.items[0];
+    }
+
+    public orderBy<TR>(q: (x: T) => TR): Query<T>;
+    public orderBy<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
+    public orderBy<TP, TR>(tOrP: TP | T, q?: (p: TP) => (x: T) => TR): Query<T> {
+        return this.process("orderBy", tOrP, q);
+    }
+
+    public orderByDescending<TR>(q: (x: T) => TR): Query<T>;
+    public orderByDescending<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
+    public orderByDescending<TP, TR>(tOrP: TP | T, q?: (p: TP) => (x: T) => TR): Query<T> {
+        return this.process("orderByDescending", tOrP, q);
+    }
+
+    public thenBy<TR>(q: (x: T) => TR): Query<T>;
+    public thenBy<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
+    public thenBy<TP, TR>(tOrP: TP | T, q?: (p: TP) => (x: T) => TR): Query<T> {
+        return this.process("thenBy", tOrP, q);
+    }
+
+    public thenByDescending<TR>(q: (x: T) => TR): Query<T>;
+    public thenByDescending<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
+    public thenByDescending<TP, TR>(tOrP: TP | T, q?: (p: TP) => (x: T) => TR): Query<T> {
+        return this.process("thenByDescending", tOrP, q);
+    }
+
+    public trace(): Query<T> {
+        this.context.traceQuery = true;
+        return this;
+    }
+
+    /**
+     * Warning, will return all the items from the query, please use `toPagedList`
+     * for better performance
+     * @param cancelToken Cancel Token to cancel the query
+     * @returns Promise<T[]>
+     */
+    public async toArray({
+        cancelToken,
+        doNotResolve,
+        hideActivityIndicator,
+        cacheSeconds,
+        cacheVersion
+    }: IListParams = {}): Promise<T[]> {
+        const r = await this.toPagedList({
+            size: -1,
+            count: false,
+            cacheSeconds,
+            cancelToken,
+            doNotResolve,
+            hideActivityIndicator,
+            cacheVersion
+        });
+        return r.items;
+    }
+
+    public toPagedList(
+        {
+            start = 0,
+            size = 100,
+            cancelToken,
+            cacheVersion = "1",
+            hideActivityIndicator,
+            splitInclude = false,
+            cacheSeconds = 0,
+            count = true
+        }: IPagedListParams = {}): Promise<IPagedList<T>> {
+        let url;
+
+        const {
+            traceQuery,
+            name,
+            service,
+            queryFunction,
+            args
+        } = this.context;
+
+        const trace = traceQuery;
+        const methods = JSON.stringify(this.methods);
+        const fm = new URLSearchParams();
+        fm.append("methods", methods);
+        if (start) {
+            fm.append("start", start.toString());
+        }
+        if (size) {
+            fm.append("size", size.toString());
+        }
+        fm.append("count", count.toString());
+        if(trace) {
+            fm.append("trace", trace ? "true" : "false");
+        }
+        if (queryFunction) {
+            fm.append("function", queryFunction);
+            fm.append("args", JSON.stringify(args ?? "[]"));
+        }
+        const encodedMethods = fm.toString();
+        if (encodedMethods.length > 1824) {
+            if (cacheSeconds > 0) {
+                throw new Error("Generated query too big for caching");
+            }
+            url = `${service.url}methods/${name}`;
+            return (service as any).postJson({
+                url,
+                cancelToken,
+                body: {
+                    methods: this.methods,
+                    start,
+                    size,
+                    split: splitInclude,
+                    count,
+                    trace,
+                    function: queryFunction || void 0,
+                    args: queryFunction ? args : void 0
+                }
+            });
+        }
+        if (cacheSeconds > 0) {
+            fm.append("cache", cacheSeconds.toString());
+            fm.append("cv", cacheVersion);
+        } else {
+        }
+        url  = `${service.url}query/${name}?${fm.toString()}`;
+        // @ts-ignore
+        return service.getJson({
+            url,
+            cancelToken,
+            hideActivityIndicator
+        });
+    }
+
+    protected thenInclude(a): any {
+        const select = this.convertToLinq(a.toString());
+        return this.append(["thenInclude", select]);
+    }
+
+    private append<T>(... methods: IQueryMethod[]) {
+        return new Query<T>(this.context, [ ... this.methods, ... methods ]);
+    }
+
+    private process<TP, TR>(name: any, tOrP: TP | T, q?: (p: TP) => (x: T) => TR): Query<T> {
+
+        if (!q) {
+            const select = this.convertToLinq(tOrP.toString());
+            return this.append<T>([name , select]);
+        }
+
+        const pl = [];
+        let i = 0;
+        const p = tOrP as any;
+        let text = q(p).toString();
+        const pfn = StringHelper.findParameter(q.toString()).trim();
+        for (const key in p) {
+            if (Object.prototype.hasOwnProperty.call(p, key)) {
+                const element = p[key];
+                const pn = `@${i++}`;
+                text = text.split(`${pfn}.${key}`).join(pn);
+                pl.push(element);
+            }
+        }
+        text = this.convertToLinq(text);
+        return this.append([name , text, ...pl]);
+    }
+
+    private convertToLinq(text: string) {
+        if(this.context.queryProcessor === "DotNet") {
+            return convertToLinq(text);
+        }
+        return text.replace(/\s+/g, " ");
+    }
+
+}

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

@@ -0,0 +1 @@
+export type QueryProcessor = "DotNet" | "JavaScript";

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

@@ -0,0 +1,24 @@
+export default class StringHelper {
+
+    public static findParameter(f: any): string {
+        let text: string = f.toString();
+        let i = text.indexOf("=>");
+        if (i !== -1) {
+            text = text.substring(0, i);
+        }
+        i = text.indexOf("(");
+        if (i === -1) {
+            return text;
+        }
+        text = text.substring(i + 1);
+        i = text.indexOf(")");
+        return text.substring(0, i);
+    }
+
+    public static contains(left: string, right: string): boolean {
+        if (!left) {
+            return !right;
+        }
+        return left.toLowerCase().includes(right.toLowerCase());
+    }
+}