@entity-access/server-pages 1.0.8 → 1.0.11

package/src/routes/api/entity/query/get.ts

@@ -0,0 +1,19 @@
+import Inject from "@entity-access/entity-access/dist/di/di.js";
+import EntityContext from "@entity-access/entity-access/dist/model/EntityContext.js";
+import Page from "../../../../Page.js";
+import EntityAccessServer from "../../../../services/EntityAccessServer.js";
+
+export default class extends Page {
+
+    @Inject
+    private db: EntityContext;
+
+    async all(params: any) {
+        const entity = this.childPath[0];
+        return this.json(await EntityAccessServer.query(this.db, {
+            entity,
+            ... params
+        }));
+    }
+
+}

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/socket/SocketNamespace.ts

@@ -0,0 +1,90 @@
+/* eslint-disable no-console */
+import Inject, { ServiceProvider, injectServiceKeysSymbol } from "@entity-access/entity-access/dist/di/di.js";
+import type SocketService from "./SocketService.js";
+import { parse } from "cookie";
+import { Namespace, Server, Socket } from "socket.io";
+import { camelToChain } from "../core/camelToChain.js";
+import TokenService from "../services/TokenService.js";
+import CookieService from "../services/CookieService.js";
+import SessionUser from "../core/SessionUser.js";
+
+
+export function Receive(target, key) {
+    const method = target[key] as (socket: Socket, ... a: any) => any;
+    target[key] = async function(this: SocketNamespace, ... a: any[]) {
+        const types = method[injectServiceKeysSymbol] as any[];
+        if (types) {
+            for (let index = a.length; index < types.length; index++) {
+                const element = ServiceProvider.resolve(this, types[index]);
+                a.push(element);
+            }
+        }
+        return method.apply(this, a);
+    };
+}
+
+export function Send(target: typeof SocketNamespace, key) {
+    const value = function(this: SocketNamespace, room, ... args: any[]) {
+        return target.server?.to(room)?.emit(key, ... args);
+    };
+    return {
+        value
+    };
+}
+
+export default abstract class SocketNamespace {
+
+    public static server: Namespace;
+
+    public static attach(server: Server, name?: string) {
+        if (!name) {
+            name = this.name;
+            if (name.endsWith("Namespace")) {
+                name = name.substring(0, name.length - "Namespace".length);
+            }
+            name = camelToChain(name);
+        }
+        console.log(`Listening Sockets on /${name}`);
+        const s = server.of("/" + name);
+        this.server = s;
+        const tokenService = ServiceProvider.resolve(this,TokenService);
+        const cookieService = ServiceProvider.resolve(this, CookieService);
+        s.on("connection", (socket) => {
+            socket.onAny(async (methodName, ... args: any[]) => {
+                const cookies = parse(socket.request.headers.cookie);
+                const cookie = cookies[tokenService.authCookieName];
+                const sessionUser = await cookieService.createSessionUserFromCookie(cookie, socket.handshake.address);
+                const scope = ServiceProvider.createScope(this);
+                try {
+                    scope.add(SessionUser, sessionUser);
+                    const socketEvent = scope.create(this as any);
+                    (socketEvent as any).socket = socket;
+                    const method = socketEvent[methodName];
+                    const types = method[injectServiceKeysSymbol] as any[];
+                    if (types) {
+                        for (let index = args.length; index < types.length; index++) {
+                            const element = scope.resolve(types[index]);
+                            args.push(element);
+                        }
+                    }
+                    await socketEvent[methodName](... args);
+                } catch (error) {
+                    console.error(error);
+                } finally {
+                    scope.dispose();
+                }
+            });
+        });
+    }
+
+    protected room: string;
+
+    protected socket: Socket;
+
+    abstract join(... a: any[]);
+
+    leave() {
+        return this.socket.leave(this.room);
+    }
+
+}

package/src/socket/SocketService.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import Inject, { RegisterSingleton } from "@entity-access/entity-access/dist/di/di.js";
+import { Http2SecureServer } from "http2";
+import { Server as HttpServer } from "http";
+import { Server as HttpsServer } from "https";
+import { parse } from "cookie";
+
+import { Server, Socket } from "socket.io";
+import CookieService from "../services/CookieService.js";
+import TokenService from "../services/TokenService.js";
+
+@RegisterSingleton
+export default class SocketService {
+
+    @Inject
+    private tokenService: TokenService;
+
+    @Inject
+    private cookieService: CookieService;
+
+    private server: Server;
+
+    constructor() {
+        this.server = new Server();
+    }
+
+    attach(server: Http2SecureServer | HttpsServer | HttpServer): Server {
+
+        this.server.attach(server);
+
+        return this.server;
+    }
+
+}