@entity-access/server-pages 1.0.7 → 1.0.10

package/src/services/EntityAccessServer.ts

@@ -0,0 +1,121 @@
+/* eslint-disable no-console */
+import SchemaRegistry from "@entity-access/entity-access/dist/decorators/SchemaRegistry.js";
+import EntityContext from "@entity-access/entity-access/dist/model/EntityContext.js";
+import { StringHelper } from "./StringHelper.js";
+import EntityQuery from "@entity-access/entity-access/dist/model/EntityQuery.js";
+import GraphService from "./GraphService.js";
+
+export type IQueryMethod = [string, string, ... any[]];
+
+const replaceArgs = (code: string, p: any, args: any[]) => {
+    let index = 0;
+    for (const iterator of args) {
+        const name = "p" + index;
+        code = StringHelper.replaceAll(code, "@" + index, "p." + name);
+        p[name] = iterator;
+        index++;
+    }
+    return StringHelper.replaceAll(code, "Sql_1.Sql", "Sql");
+};
+
+export interface IEntityQueryOptions {
+    entity: string;
+    methods: string | IQueryMethod[];
+    start: number;
+    size: number;
+    split: boolean;
+    trace: boolean;
+    cache: number;
+    count: boolean;
+    function: string;
+    args: string | any[];
+    traceFunc?(text: string);
+};
+
+export default class EntityAccessServer {
+
+    public static async query(db: EntityContext, options: IEntityQueryOptions) {
+
+        db.verifyFilters = true;
+        db.raiseEvents = true;
+
+        const {
+            entity: name,
+            start = 0,
+            size = 100,
+            trace,
+            function: queryFunction
+        } = options;
+        let {
+            count = false,
+            methods,
+            args = "[]"
+        } = options;
+        const entityClass = SchemaRegistry.classForName(name);
+
+        if (!entityClass) {
+            return;
+        }
+
+        if (typeof methods === "string") {
+            methods = JSON.parse(methods);
+        }
+
+        if (typeof args === "string") {
+            args = JSON.parse(args);
+        }
+
+        if (typeof count === "string") {
+            count = count === "true";
+        }
+
+        const events = db.eventsFor(entityClass, true);
+
+        let q = queryFunction
+            ? events[queryFunction](... args) as EntityQuery<any>
+            : events.filter(db.query(entityClass));
+
+        if (methods) {
+            for (const [method, code, ... methodArgs] of methods) {
+                const p = {};
+                if (method === "include") {
+                    q = q[method](code);
+                    continue;
+                }
+                const arrow = replaceArgs(code, p, methodArgs);
+                q = q[method](p, `(p) => ${arrow}`);
+            }
+        }
+
+        const oq = q;
+
+        if (start > 0) {
+            q = q.offset(start);
+            count = true;
+        }
+        if (size > 0) {
+            q = q.limit(size);
+        }
+
+        if (count) {
+            const total = await oq.count();
+            if (trace) {
+                q = q.trace(console.log);
+            }
+            return GraphService.prepareGraph({
+                total,
+                items: await q.toArray()
+            });
+        }
+
+        if (trace) {
+            q = q.trace(console.log);
+        }
+        return GraphService.prepareGraph({
+            total: 0,
+            items: await q.toArray()
+        });
+
+    }
+
+}

package/src/services/GraphService.ts

@@ -0,0 +1,86 @@
+import SchemaRegistry from "@entity-access/entity-access/dist/decorators/SchemaRegistry.js";
+import ModelService from "./ModelService.js";
+
+export default class GraphService {
+
+    static toGraph = Symbol("toGraph");
+
+    static appendToGraph = Symbol("toGraph");
+
+    static prepareGraph(body) {
+        const r = this.prepare(body, new Map());
+        return r;
+    }
+
+    private static prepare(body: any, visited: Map<any, any>) {
+
+        if (Array.isArray(body)) {
+            const r = [];
+            for (const iterator of body) {
+                r.push(this.prepare(iterator, visited));
+            }
+            return r;
+        }
+
+        if(!body) {
+            return body;
+        }
+
+        if (typeof body !== "object") {
+            return body;
+        }
+
+        if (body instanceof Date) {
+            return body;
+        }
+
+        let $id = visited.get(body);
+        if ($id) {
+            return { $ref: $id };
+        }
+        $id = visited.size + 1;
+        visited.set(body, $id);
+
+        const appendToGraph = body[this.appendToGraph]?.() ?? {};
+
+        const copy = {
+            $id,
+            ... appendToGraph
+        };
+
+        // check constructor
+        const { constructor } = Object.getPrototypeOf(body);
+        if(constructor !== Object) {
+            copy["$type"] = SchemaRegistry.entityNameForClass(constructor);
+        }
+
+        body = body[this.toGraph]?.() ?? body;
+        for (const key in body) {
+
+            if (ModelService.ignore(constructor, key)) {
+                continue;
+            }
+
+            if (Object.prototype.hasOwnProperty.call(body, key)) {
+                const element = body[key];
+                copy[key] = this.prepare(element, visited);
+                continue;
+            }
+            const e = body[key];
+            switch(typeof e) {
+                case "number":
+                case "boolean":
+                case "bigint":
+                case "string":
+                    copy[key] = e;
+                    continue;
+                case "object":
+                    if (e instanceof Date) {
+                        copy[key] = e;
+                    }
+                    continue;
+            }
+        }
+        return copy;
+    }
+}

package/src/services/IndentedStringWriter.ts

@@ -0,0 +1,33 @@
+export default class IndentedStringWriter {
+
+    public get indent(): number {
+        return this.indention;
+    }
+    public set indent(value: number) {
+        this.indention = value;
+        let p = "";
+        for (let index = 0; index < value; index++) {
+            p += this.indentChar;
+        }
+        this.prefix = p;
+    }
+
+    private indention: number = 0;
+    private prefix = "";
+    private content = "";
+
+    constructor(private indentChar = "    ") {
+
+    }
+
+    public writeLine(text: string = "") {
+        for (const iterator of text.split("\n")) {
+            this.content = this.content.concat(this.prefix, iterator.trimStart(), "\n");
+        }
+    }
+
+    public toString() {
+        return this.content;
+    }
+
+}

package/src/services/ModelService.ts

@@ -0,0 +1,257 @@
+import { IColumn, IEntityRelation } from "@entity-access/entity-access/dist/decorators/IColumn.js";
+import SchemaRegistry from "@entity-access/entity-access/dist/decorators/SchemaRegistry.js";
+import EntityType, { addColumnSymbol } from "@entity-access/entity-access/dist/entity-query/EntityType.js";
+import EntityContext from "@entity-access/entity-access/dist/model/EntityContext.js";
+import IndentedStringWriter from "./IndentedStringWriter.js";
+import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
+import { IClassOf } from "@entity-access/entity-access/dist/decorators/IClassOf.js";
+
+const modelProperties = Symbol("modelProperty");
+
+interface IModelProperty {
+    type?: string;
+    name?: string;
+    enum?: readonly string[];
+    help?: string;
+    ignore?: boolean;
+    readonly?: boolean;
+}
+
+interface IModelProperties {
+    [key: string]: IModelProperty;
+}
+
+export function JsonProperty(mp: IModelProperty = {}) {
+    return (target, name) => {
+        mp.type ??= (Reflect as any).getMetadata("design:type", target, name);
+        mp.name ??= name;
+        (target[modelProperties] ??= {})[name] = mp;;
+    };
+}
+
+export const IgnoreJsonProperty=  JsonProperty({ ignore: true });
+
+export const ReadOnlyJsonProperty =  JsonProperty({ readonly: true });
+
+export interface IEntityKey {
+    name: string;
+    type: string;
+}
+
+export interface IEntityPropertyInfo extends IEntityKey {
+    isNullable?: boolean;
+}
+
+export interface IEntityNavigationProperty extends IEntityKey {
+    isCollection?: boolean;
+}
+
+export interface IEntityModel {
+    name?: string;
+    keys?: IEntityKey[];
+    properties?: IEntityPropertyInfo[];
+    navigationProperties?: IEntityNavigationProperty[];
+}
+
+const columnFrom = (c: IColumn): IEntityPropertyInfo => {
+    return {
+        name: c.name,
+        type: c.type?.name ?? c.type.toString(),
+        isNullable: !!c.nullable
+    };
+};
+
+const relationFrom = (r: IEntityRelation): IEntityNavigationProperty => {
+    return {
+        name: r.name,
+        isCollection: r.isCollection,
+        type: r.relatedEntity.entityName
+    };
+};
+
+const modelFrom = (type: EntityType): IEntityModel => {
+    const model: IEntityModel = {
+        name: type.entityName,
+        keys: type.keys.map(columnFrom),
+        properties: type.columns.map(columnFrom),
+        navigationProperties: type.relations.map(relationFrom)
+    };
+    return model;
+};
+
+const getJSType = (column: { type?: any, enum?: readonly string[]}) => {
+    const { type, enum: enumValues } = column;
+    if (enumValues) {
+        return enumValues.map((x) => JSON.stringify(x)).join(" | ");
+    }
+    switch(type) {
+        case Number:
+            return "number";
+        case BigInt:
+            return "bigint";
+        case String:
+            return "string";
+        case Boolean:
+            return "boolean";
+        case Date:
+        case DateTime:
+            return "DateTime";
+    }
+    if (typeof type == "function") {
+        const mps = type.prototype[modelProperties];
+        if (mps) {
+            return `{ ${ Object.entries<IModelProperty>(mps).map(([key, p]) => `${key}?: ${getJSType(p)}`).join(";") } }`;
+        }
+        return type.name;
+    }
+    return "any";
+};
+
+const getDefaults = (column: IColumn): [string, any] => {
+    if (column.generated) {
+        return;
+    }
+    if (column.key) {
+        return;
+    }
+    if (column.fkRelation) {
+        return;
+    }
+    const { type, enum: enumValues } = column;
+    if (enumValues) {
+        return [ column.name,  JSON.stringify(enumValues[0])];
+    }
+    switch(type) {
+        case Number:
+            return [column.name, "0"];
+        case BigInt:
+            return [column.name, "0n"];
+        case String:
+            return [column.name, `""`];
+        case Boolean:
+            return [column.name, "false"];
+        case Date:
+            return [column.name, "new DefaultFactory(() => new Date())"];
+        case DateTime:
+            return [column.name, "new DefaultFactory(() => new DateTime())"];
+    }
+    return;
+};
+
+export default class ModelService {
+
+    public static ignore(t: IClassOf<any>, key: string) {
+        return (t.prototype?.[modelProperties] as IModelProperties)?.[key]?.ignore;
+    }
+
+    public static getModel(context: EntityContext) {
+        const model = [] as IEntityModel[];
+
+        for (const [type] of context.model.sources) {
+            const entityType = context.model.getEntityType(type);
+            model.push(modelFrom(entityType));
+        }
+        return model;
+    }
+
+    public static getModelDeclaration(context: EntityContext) {
+        const writer = new IndentedStringWriter("\t");
+        writer.writeLine(`import DateTime from "@web-atoms/date-time/dist/DateTime";
+            import type IClrEntity from "@web-atoms/entity/dist/models/IClrEntity";
+            import { ICollection, IGeometry, IModel, Model, DefaultFactory } from "@web-atoms/entity/dist/services/BaseEntityService";
+        `);
+
+        for (const [type] of context.model.sources) {
+            const entityType = context.model.getEntityType(type);
+
+            const entityName = entityType.entityName;
+            const name = entityType.typeClass.name;
+
+            const defaults = [] as string[];
+
+            writer.writeLine(`export interface I${name} extends IClrEntity {`);
+            writer.indent++;
+
+            const enums = [] as string[];
+
+            const set = new Set<string>();
+
+            const keys = [] as string[];
+
+            const mps = type.prototype[modelProperties] as IModelProperties;
+            for (const column of entityType.columns) {
+
+                if (column.key) {
+                    keys.push(column.name);
+                }
+
+                set.add(column.name);
+
+                const jsonProperties = mps?.[column.name];
+
+                if (jsonProperties?.ignore) {
+                    continue;
+                }
+
+                const isReadonly = column.generated || jsonProperties?.readonly ? " readonly " : "";
+
+                if (jsonProperties?.help) {
+                    writer.writeLine(`/** ${jsonProperties.help} */`);
+                }
+
+                if (column.enum) {
+                    enums.push(`export const ${name}${column.name[0].toUpperCase()}${column.name.substring(1)}Array = ${JSON.stringify(column.enum.map((x) => ({label: x, value: x})))};`);
+                }
+                const jsType = getJSType(column);
+                if (column.nullable) {
+                    writer.writeLine(`${isReadonly}${column.name}?: ${jsType} | null;`);
+                } else {
+                    writer.writeLine(`${isReadonly}${column.name}?: ${jsType};`);
+                    const defs = getDefaults(column);
+                    if (defs) {
+                        const [k, v] = defs;
+                        defaults.push(`${k}: ${v}`);
+                    }
+                }
+            }
+
+            // additional model properties...
+            if (mps) {
+                for (const [key, property] of Object.entries(mps)) {
+                    if (set.has(key)) {
+                        continue;
+                    }
+                    const jsType = getJSType(property);
+                    if (property.help) {
+                        writer.writeLine(`/** ${property.help} */`);
+                    }
+                    writer.writeLine(`${key}?: ${jsType};`);
+                }
+            }
+
+            for (const relation of entityType.relations) {
+                if (relation.isCollection) {
+                    writer.writeLine(`${relation.name}?: ICollection<I${relation.relatedTypeClass.name}>;`);
+                } else {
+                    writer.writeLine(`${relation.name}?: I${relation.relatedTypeClass.name};`);
+                }
+            }
+            writer.indent--;
+            writer.writeLine(`}`);
+
+            writer.writeLine();
+            if (enums.length) {
+                for (const iterator of enums) {
+                    writer.writeLine(iterator);
+                }
+                writer.writeLine();
+            }
+
+            writer.writeLine(`export const ${name}: IModel<I${name}> = new Model<I${name}>("${entityName}", ${JSON.stringify(keys)}, { ${defaults.join(",")} });`);
+            writer.writeLine();
+        }
+
+        return writer.toString();
+    }
+
+}

package/src/services/StringHelper.ts

@@ -0,0 +1,31 @@
+export const StringHelper = {
+    replaceAll: (text: string, search: string, replace: string) => {
+        if (!text || !search) {
+            return text;
+        }
+        let index = 0;
+        do {
+            index = text.indexOf(search, index);
+            if (index === -1) {
+                break;
+            }
+            text = text.substring(0, index) + replace + text.substring(index + search.length);
+        } while(true);
+        return text;
+    },
+
+    remove00: (text: string) => {
+        if (!text) {
+            return text;
+        }
+        return text.replace(/\x00/g, "");
+    },
+
+    extractFloat: (text: string, def: number = 0) => {
+        const group = /(\d+)/.exec(text);
+        if (group?.length) {
+            return parseFloat( group[0]);
+        }
+        return def;
+    }
+};

package/src/sleep.ts

@@ -0,0 +1,12 @@
+export default function sleep(ms: number, signal?: AbortSignal) {
+    if (signal?.aborted) {
+        return 1;
+    }
+    return new Promise<void>((resolve, reject) => {
+        const id = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(id);
+            resolve();
+        });
+    });
+}