remult 0.22.2 → 0.22.3

package/esm/core/server/expressBridge.js

@@ -1,938 +0,0 @@
-import { Action, actionInfo, classBackendMethodsArray, serverActionField } from '../src/server-action';
-import { DataApi, serializeError } from '../src/data-api';
-import { allEntities, Remult, RemultAsyncLocalStorage } from '../src/context';
-import { Entity, Fields, getEntityKey, IdEntity } from '../src/remult3';
-import { LiveQueryPublisher, InMemoryLiveQueryStorage } from '../src/live-query/SubscriptionServer';
-import { liveQueryKeepAliveRoute, streamUrl } from '../src/live-query/SubscriptionChannel';
-import { initDataProvider } from './initDataProvider';
-import { SseSubscriptionServer } from "../SseSubscriptionServer";
-;
-export function createRemultServerCore(options, serverCoreOptions) {
-    if (!options) {
-        options = {};
-    }
-    if (!options.subscriptionServer) {
-        options.subscriptionServer = new SseSubscriptionServer();
-    }
-    if (options.logApiEndPoints === undefined)
-        options.logApiEndPoints = true;
-    actionInfo.runningOnServer = true;
-    if (options.defaultGetLimit) {
-        DataApi.defaultGetLimit = options.defaultGetLimit;
-    }
-    if (!options.queueStorage) {
-        options.queueStorage = new InMemoryQueueStorage();
-    }
-    let dataProvider = initDataProvider(options.dataProvider);
-    if (options.ensureSchema === undefined)
-        options.ensureSchema = true;
-    RemultAsyncLocalStorage.enable();
-    const entitiesMetaData = [];
-    dataProvider = dataProvider.then(async (dp) => {
-        var remult = new Remult(dp);
-        await new Promise((res) => {
-            RemultAsyncLocalStorage.instance.run(remult, async () => {
-                if (options.ensureSchema) {
-                    let started = false;
-                    const startConsoleLog = () => {
-                        if (started)
-                            return;
-                        started = true;
-                        console.time("Ensure Schema");
-                    };
-                    entitiesMetaData.push(...options.entities.map(e => remult.repo(e).metadata));
-                    if (dp.ensureSchema) {
-                        startConsoleLog();
-                        await dp.ensureSchema(entitiesMetaData);
-                    }
-                    for (const item of [options.liveQueryStorage, options.queueStorage]) {
-                        if (item?.ensureSchema) {
-                            startConsoleLog();
-                            await item.ensureSchema();
-                        }
-                    }
-                    if (started)
-                        console.timeEnd("Ensure Schema");
-                }
-                if (options.initApi)
-                    await options.initApi(remult);
-                res({});
-            });
-        });
-        return dp;
-    });
-    {
-        let allControllers = [];
-        if (!options.entities)
-            options.entities = [...allEntities];
-        if (options.entities)
-            allControllers.push(...options.entities);
-        if (options.controllers)
-            allControllers.push(...options.controllers);
-        options.controllers = allControllers;
-    }
-    if (options.rootPath === undefined)
-        options.rootPath = '/api';
-    actionInfo.runningOnServer = true;
-    let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider, serverCoreOptions, entitiesMetaData);
-    return bridge;
-}
-;
-/* @internal*/
-export class RemultServerImplementation {
-    queue;
-    options;
-    dataProvider;
-    coreOptions;
-    entitiesMetaData;
-    liveQueryStorage = new InMemoryLiveQueryStorage();
-    constructor(queue, options, dataProvider, coreOptions, entitiesMetaData) {
-        this.queue = queue;
-        this.options = options;
-        this.dataProvider = dataProvider;
-        this.coreOptions = coreOptions;
-        this.entitiesMetaData = entitiesMetaData;
-        if (options.liveQueryStorage)
-            this.liveQueryStorage = options.liveQueryStorage;
-        if (options.subscriptionServer)
-            this.subscriptionServer = options.subscriptionServer;
-    }
-    withRemultPromise(request, what) {
-        return new Promise((resolve, error) => {
-            return this.withRemult(request, undefined, () => {
-                try {
-                    what().then(resolve).catch(error);
-                }
-                catch (err) {
-                    error(err);
-                }
-            });
-        });
-    }
-    getEntities() {
-        //TODO - consider using entitiesMetaData - but it may require making it all awaitable
-        var r = new Remult();
-        return this.options.entities.map(x => r.repo(x).metadata);
-    }
-    runWithSerializedJsonContextData = async (jsonContextData, entityKey, what) => {
-        for (const e of this.options.entities) {
-            let key = getEntityKey(e);
-            if (key === entityKey) {
-                await this.runWithRemult(async (remult) => {
-                    remult.user = jsonContextData.user;
-                    if (this.options.contextSerializer) {
-                        await this.options.contextSerializer.deserialize(jsonContextData.context, {
-                            remult,
-                            get liveQueryStorage() {
-                                return remult.liveQueryStorage;
-                            },
-                            set liveQueryStorage(value) {
-                                remult.liveQueryStorage = value;
-                            }
-                        });
-                    }
-                    await what(remult.repo(e));
-                });
-                return;
-            }
-        }
-        throw new Error("Couldn't find entity " + entityKey);
-    };
-    ;
-    subscriptionServer;
-    withRemult = (req, res, next) => {
-        this.process(async () => { next(); })(req, res);
-    };
-    routeImpl;
-    getRouteImpl() {
-        if (!this.routeImpl) {
-            this.routeImpl = new RouteImplementation(this.coreOptions);
-            this.registerRouter(this.routeImpl);
-        }
-        return this.routeImpl;
-    }
-    handle(req, gRes) {
-        return this.getRouteImpl().handle(req, gRes);
-    }
-    registeredRouter = false;
-    registerRouter(r) {
-        if (this.registeredRouter)
-            throw "Router already registered";
-        this.registeredRouter = true;
-        {
-            for (const c of this.options.controllers) {
-                let z = c[classBackendMethodsArray];
-                if (z)
-                    for (const a of z) {
-                        let x = a[serverActionField];
-                        if (!x) {
-                            throw 'failed to set server action, did you forget the BackendMethod Decorator?';
-                        }
-                        this.addAction(x, r);
-                    }
-            }
-            if (this.hasQueue)
-                this.addAction({
-                    __register: x => {
-                        x(Action.apiUrlForJobStatus, false, () => true, async (data, req, res) => {
-                            let job = await this.queue.getJobInfo(data.queuedJobId);
-                            let userId = undefined;
-                            if (req?.user)
-                                userId = req.user.id;
-                            if (job.userId == '')
-                                job.userId = undefined;
-                            if (userId != job.userId)
-                                res.forbidden();
-                            else
-                                res.success(job.info);
-                        });
-                    }, doWork: undefined
-                }, r);
-            if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
-                const streamPath = this.options.rootPath + '/' + streamUrl;
-                r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
-                    remult.subscriptionServer.openHttpServerStream(origReq, origRes);
-                }));
-                r.route(streamPath + '/subscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
-                    const body = remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult);
-                }));
-                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
-                    remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult, true);
-                }));
-            }
-            r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
-                res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(await this.coreOptions.getRequestBody(origReq)));
-            }));
-        }
-        this.options.entities.forEach(e => {
-            let key = getEntityKey(e);
-            if (key != undefined)
-                this.add(key, c => {
-                    return new DataApi(c.repo(e), c);
-                }, r);
-        });
-    }
-    async serializeContext(remult) {
-        let result = {
-            user: remult.user,
-            context: undefined
-        };
-        if (this.options.contextSerializer) {
-            result.context = await this.options.contextSerializer.serialize(remult);
-        }
-        return result;
-    }
-    add(key, dataApiFactory, r) {
-        let myRoute = this.options.rootPath + '/' + key;
-        if (this.options.logApiEndPoints)
-            console.info("[remult] " + myRoute);
-        r.route(myRoute)
-            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c)))).put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).put(res, '', await this.coreOptions.getRequestBody(orig))))
-            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
-            .post(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).httpPost(res, req, await this.coreOptions.getRequestBody(orig), () => this.serializeContext(c))));
-        r.route(myRoute + '/:id')
-            //@ts-ignore
-            .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
-            //@ts-ignore
-            .put(this.process(async (c, req, res, reqInfo, _, orig) => dataApiFactory(c).put(res, reqInfo.params.id, await this.coreOptions.getRequestBody(orig))))
-            //@ts-ignore
-            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
-    }
-    //runs with remult but without init request
-    async runWithRemult(what) {
-        let remult = new Remult();
-        remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
-        remult.dataProvider = (await this.dataProvider);
-        remult.subscriptionServer = this.subscriptionServer;
-        remult.liveQueryStorage = this.liveQueryStorage;
-        await new Promise(res => {
-            RemultAsyncLocalStorage.instance.run(remult, async () => {
-                res(await what(remult));
-            });
-        });
-    }
-    process(what) {
-        return async (req, origRes) => {
-            const genReq = this.coreOptions.buildGenericRequestInfo(req);
-            if (!genReq.query) {
-                genReq.query = req["_tempQuery"];
-            }
-            if (!genReq.params)
-                genReq.params = req["_tempParams"];
-            let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
-            await this.runWithRemult(async (remult) => {
-                if (req) {
-                    let user;
-                    if (this.options.getUser)
-                        user = await this.options.getUser(req);
-                    else {
-                        user = req['user'];
-                        if (!user)
-                            user = req['auth'];
-                    }
-                    if (user)
-                        remult.user = (user);
-                    if (this.options.initRequest) {
-                        await this.options.initRequest(req, {
-                            remult,
-                            get liveQueryStorage() {
-                                return remult.liveQueryStorage;
-                            },
-                            set liveQueryStorage(value) {
-                                remult.liveQueryStorage = value;
-                            }
-                        });
-                    }
-                }
-                await what(remult, myReq, myRes, genReq, origRes, req);
-            });
-        };
-    }
-    ;
-    async getRemult(req) {
-        let remult;
-        await this.process(async (c) => {
-            remult = c;
-        })(req, undefined);
-        return remult;
-    }
-    hasQueue = false;
-    addAction(action, r) {
-        action.__register((url, queue, allowed, what) => {
-            let myUrl = this.options.rootPath + '/' + url;
-            let tag = (() => {
-                let split = url.split('/');
-                if (split.length == 1)
-                    return 'Static Backend Methods';
-                else
-                    return split[0];
-            })();
-            this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
-            if (this.options.logApiEndPoints)
-                console.info("[remult] " + myUrl);
-            if (queue) {
-                this.hasQueue = true;
-                this.queue.mapQueuedAction(myUrl, what);
-            }
-            r.route(myUrl).post(this.process(async (remult, req, res, _, __, orig) => {
-                if (queue) {
-                    let r = {
-                        queuedJobId: await this.queue.submitJob(myUrl, remult, await this.coreOptions.getRequestBody(orig))
-                    };
-                    res.success(r);
-                }
-                else
-                    return what(await this.coreOptions.getRequestBody(orig), remult, res);
-            }));
-        });
-    }
-    openApiDoc(options) {
-        if (!options.version)
-            options.version = "1.0.0";
-        let spec = {
-            info: { title: options.title, version: options.version },
-            openapi: "3.0.0",
-            //swagger: "2.0",
-            "components": {
-                "schemas": {},
-                "securitySchemes": {
-                    "bearerAuth": {
-                        "scheme": "bearer",
-                        "bearerFormat": "JWT",
-                        "type": "http"
-                    }
-                }
-            },
-            paths: {}
-        };
-        let validationError = {
-            "400": {
-                "description": "Error: Bad Request",
-                "content": {
-                    "application/json": {
-                        "schema": {
-                            "$ref": "#/components/schemas/InvalidResponse"
-                        }
-                    }
-                }
-            }
-        };
-        let security = {
-            "security": [
-                {
-                    "bearerAuth": []
-                }
-            ]
-        };
-        let secureBase = (condition, def, item) => {
-            if (condition === undefined)
-                condition = def;
-            if (condition != false) {
-                if (condition != true) {
-                    item = { ...item, ...security };
-                    item.responses["403"] = { description: "forbidden" };
-                }
-                return item;
-            }
-        };
-        for (const meta of this.getEntities()) {
-            let key = meta.key;
-            let parameters = [];
-            if (key) {
-                let mutationKey = key;
-                let properties = {};
-                let mutationProperties = {};
-                for (const f of meta.fields) {
-                    let type = f.valueType == String ? "string" :
-                        f.valueType == Boolean ? "boolean" :
-                            f.valueType == Date ? "string" :
-                                f.valueType == Number ? "number" :
-                                    "object";
-                    if (f.options.includeInApi !== false) {
-                        properties[f.key] = {
-                            type
-                        };
-                        if (f.options.allowApiUpdate !== false) {
-                            mutationProperties[f.key] = {
-                                type
-                            };
-                        }
-                        parameters.push({
-                            "name": f.key,
-                            "in": "query",
-                            "description": "filter equal to " + f.key + ". See [more filtering options](https://remult.dev/docs/rest-api.html#filter)",
-                            "required": false,
-                            "style": "simple",
-                            type
-                        });
-                    }
-                }
-                spec.components.schemas[key] = {
-                    type: "object",
-                    properties
-                };
-                if (JSON.stringify(properties) !== JSON.stringify(mutationProperties)) {
-                    mutationKey += 'Mutation';
-                    spec.components.schemas[mutationKey] = {
-                        type: "object",
-                        properties: mutationProperties
-                    };
-                }
-                let definition = {
-                    "$ref": "#/components/schemas/" + key
-                };
-                let secure = (condition, def, item) => {
-                    item.tags = [meta.key];
-                    if (condition === undefined)
-                        condition = meta.options.allowApiCrud;
-                    return secureBase(condition, def, item);
-                };
-                let apiPath = spec.paths[this.options.rootPath + '/' + key] = {};
-                let apiPathWithId = spec.paths[this.options.rootPath + '/' + key + "/{id}"] = {};
-                //https://github.com/2fd/open-api.d.ts
-                apiPath.get = secure(meta.options.allowApiRead, true, {
-                    description: "return an array of " + key + ". supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)",
-                    parameters: [{
-                            "name": "_limit",
-                            "in": "query",
-                            "description": "limit the number of returned rows, default 100",
-                            "required": false,
-                            "style": "simple",
-                            "schema": { "type": "integer" }
-                        },
-                        {
-                            "name": "_page",
-                            "in": "query",
-                            "description": "to be used for paging",
-                            "required": false,
-                            "schema": { "type": "integer" }
-                        },
-                        {
-                            "name": "_sort",
-                            "in": "query",
-                            "description": "the columns to sort on",
-                            "required": false,
-                            "schema": { "type": "string" }
-                        },
-                        {
-                            "name": "_order",
-                            "in": "query",
-                            "description": "the sort order to user for the columns in `_sort`",
-                            "required": false,
-                            "schema": { "type": "string" }
-                        }, ...parameters],
-                    responses: {
-                        "200": {
-                            "description": "returns an array of " + key,
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "type": "array",
-                                        "items": definition
-                                    }
-                                }
-                            }
-                        },
-                    }
-                });
-                let idParameter = {
-                    "name": "id",
-                    "in": "path",
-                    "description": "id of " + key,
-                    "required": true,
-                    "schema": { "type": "string" },
-                };
-                let itemInBody = {
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/" + mutationKey
-                                }
-                            }
-                        }
-                    }
-                };
-                apiPath.post = secure(meta.options.allowApiInsert, false, {
-                    //"summary": "insert a " + key,
-                    //"description": "insert a " + key,
-                    "produces": ["application/json"],
-                    ...itemInBody,
-                    "responses": {
-                        "201": {
-                            "description": "Created",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/" + key
-                                    }
-                                }
-                            }
-                        },
-                        ...validationError
-                    }
-                });
-                apiPathWithId.get = secure(meta.options.allowApiRead, true, {
-                    parameters: [idParameter],
-                    responses: {
-                        "200": {
-                            // "description": "returns an item of " + key,
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/" + key
-                                    }
-                                }
-                            }
-                        },
-                    }
-                });
-                apiPathWithId.put = secure(meta.options.allowApiUpdate, false, {
-                    //"summary": "Update a " + key,
-                    //"description": "Update a " + key,
-                    "produces": ["application/json"],
-                    "parameters": [
-                        idParameter
-                    ],
-                    ...itemInBody,
-                    "responses": {
-                        "200": {
-                            "description": "successful operation",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/" + key
-                                    }
-                                }
-                            }
-                        },
-                        ...validationError
-                    }
-                });
-                apiPathWithId.delete = secure(meta.options.allowApiDelete, false, {
-                    //      "summary": "Delete a " + key,
-                    //      "description": "Delete a " + key,
-                    "produces": ["application/json"],
-                    "parameters": [
-                        idParameter
-                    ],
-                    "responses": {
-                        "204": {
-                            "description": "Deleted"
-                        },
-                        ...validationError
-                    }
-                });
-            }
-        }
-        for (const b of this.backendMethodsOpenApi) {
-            spec.paths[b.path] = {
-                post: secureBase(b.allowed, false, {
-                    "produces": ["application/json"],
-                    "tags": [b.tag],
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    properties: {
-                                        "args": {
-                                            "type": "array",
-                                            "items": { "type": "string" }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    "responses": {
-                        "201": {
-                            "description": "Created",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "type": "object",
-                                        properties: {
-                                            "data": {
-                                                "type": "object"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        ...validationError
-                    }
-                })
-            };
-        }
-        spec.components.schemas["InvalidResponse"] = {
-            "type": "object",
-            properties: {
-                "message": {
-                    "type": "string"
-                },
-                "modelState": {
-                    "type": "object"
-                }
-            }
-        };
-        return spec;
-    }
-    /* internal */
-    backendMethodsOpenApi = [];
-}
-class ExpressRequestBridgeToDataApiRequest {
-    r;
-    get(key) {
-        return this.r.query[key];
-    }
-    constructor(r) {
-        this.r = r;
-    }
-}
-class ExpressResponseBridgeToDataApiResponse {
-    r;
-    req;
-    forbidden() {
-        this.setStatus(403).end();
-    }
-    setStatus(status) {
-        return this.r.status(status);
-    }
-    constructor(r, req) {
-        this.r = r;
-        this.req = req;
-    }
-    progress(progress) {
-    }
-    success(data) {
-        this.r.json(data);
-    }
-    created(data) {
-        this.setStatus(201).json(data);
-    }
-    deleted() {
-        this.setStatus(204).end();
-    }
-    notFound() {
-        this.setStatus(404).end();
-    }
-    error(data) {
-        data = serializeError(data);
-        console.error({
-            message: data.message,
-            stack: data.stack?.split('\n'),
-            url: this.req.url,
-            method: this.req.method
-        });
-        this.setStatus(400).json(data);
-        ;
-    }
-}
-function throwError() {
-    throw "Invalid";
-}
-class inProcessQueueHandler {
-    storage;
-    constructor(storage) {
-        this.storage = storage;
-    }
-    async submitJob(url, req, body) {
-        let id = await this.storage.createJob(url, req.user ? req.user.id : undefined);
-        let job = await this.storage.getJobInfo(id);
-        this.actions.get(url)(body, req, {
-            error: error => job.setErrorResult(serializeError(error)),
-            success: result => job.setResult(result),
-            progress: progress => job.setProgress(progress),
-            created: () => { throw Error("Created response not expected for queue"); },
-            deleted: () => { throw Error("deleted response not expected for queue"); },
-            notFound: () => { throw Error("notFound response not expected for queue"); },
-            forbidden: () => job.setErrorResult("Forbidden")
-        });
-        return id;
-    }
-    mapQueuedAction(url, what) {
-        this.actions.set(url, what);
-    }
-    actions = new Map();
-    async getJobInfo(queuedJobId) {
-        return await this.storage.getJobInfo(queuedJobId);
-    }
-}
-class InMemoryQueueStorage {
-    async getJobInfo(queuedJobId) {
-        return this.jobs.get(queuedJobId);
-    }
-    async createJob(url, userId) {
-        let id = this.jobs.size.toString();
-        this.jobs.set(id, {
-            info: {
-                done: false
-            },
-            userId: userId,
-            setErrorResult: (error) => {
-                let job = this.jobs.get(id);
-                job.info.done = true;
-                job.info.error = error;
-            },
-            setResult: (result) => {
-                let job = this.jobs.get(id);
-                job.info.done = true;
-                job.info.result = result;
-            },
-            setProgress: (progress) => {
-                let job = this.jobs.get(id);
-                job.info.progress = progress;
-            }
-        });
-        return id;
-    }
-    jobs = new Map();
-}
-let test = 0;
-export class EntityQueueStorage {
-    repo;
-    constructor(repo) {
-        this.repo = repo;
-    }
-    sync = Promise.resolve();
-    doSync(what) {
-        return this.sync = this.sync.then(() => what());
-    }
-    async getJobInfo(queuedJobId) {
-        let q = await this.repo.findId(queuedJobId, { useCache: false });
-        let lastProgress = undefined;
-        return {
-            userId: q.userId,
-            info: {
-                done: q.done,
-                error: q.error ? JSON.parse(q.result) : undefined,
-                result: q.done && !q.error ? JSON.parse(q.result) : undefined,
-                progress: q.progress
-            },
-            setErrorResult: async (error) => {
-                await this.sync;
-                q.error = true;
-                q.done = true;
-                q.result = JSON.stringify(error);
-                q.doneTime = new Date();
-                q.progress = 1;
-                await this.doSync(() => q._.save());
-            },
-            setResult: async (result) => {
-                await this.sync;
-                q.done = true;
-                q.result = JSON.stringify(result);
-                q.doneTime = new Date();
-                await this.doSync(() => q._.save());
-            },
-            setProgress: async (progress) => {
-                if (progress === 0)
-                    return;
-                let now = new Date();
-                if (lastProgress && now.valueOf() - lastProgress.valueOf() < 200)
-                    return;
-                lastProgress = new Date();
-                await this.sync;
-                q.progress = progress;
-                await this.doSync(() => q._.save());
-            }
-        };
-    }
-    async createJob(url, userId) {
-        let q = this.repo.create();
-        q.userId = userId;
-        q.submitTime = new Date();
-        q.url = url;
-        await q._.save();
-        return q.id;
-    }
-}
-class RouteImplementation {
-    coreOptions;
-    constructor(coreOptions) {
-        this.coreOptions = coreOptions;
-    }
-    map = new Map();
-    route(path) {
-        //consider using:
-        //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
-        //* https://github.com/pillarjs/path-to-regexp
-        let r = path.toLowerCase();
-        let m = new Map();
-        this.map.set(r, m);
-        const route = {
-            get: (h) => {
-                m.set("get", h);
-                return route;
-            },
-            put: (h) => {
-                m.set("put", h);
-                return route;
-            },
-            post: (h) => {
-                m.set("post", h);
-                return route;
-            },
-            delete: (h) => {
-                m.set("delete", h);
-                return route;
-            }
-        };
-        return route;
-    }
-    async handle(req, gRes) {
-        return new Promise(res => {
-            const response = new class {
-                write(data) {
-                    gRes.write(data);
-                }
-                writeHead(statusCode, headers) {
-                    gRes.writeHead(statusCode, headers);
-                    this.statusCode = statusCode;
-                    res({ statusCode });
-                }
-                flush() {
-                    if (gRes.flush)
-                        gRes.flush();
-                }
-                statusCode = 200;
-                json(data) {
-                    if (gRes !== undefined)
-                        gRes.json(data);
-                    res({ statusCode: this.statusCode, data });
-                }
-                status(statusCode) {
-                    if (gRes !== undefined)
-                        gRes.status(statusCode);
-                    this.statusCode = statusCode;
-                    return this;
-                }
-                end() {
-                    if (gRes !== undefined)
-                        gRes.end();
-                    res({
-                        statusCode: this.statusCode
-                    });
-                }
-            };
-            this.middleware(req, response, () => res(undefined));
-        });
-    }
-    middleware(origReq, res, next) {
-        const req = this.coreOptions.buildGenericRequestInfo(origReq);
-        let theUrl = req.url;
-        if (theUrl.startsWith('/')) //next sends a partial url '/api/tasks' and not the full url
-            theUrl = 'http://stam' + theUrl;
-        const url = new URL(theUrl);
-        const path = url.pathname;
-        if (!req.query) {
-            let query = {};
-            url.searchParams.forEach((val, key) => {
-                let current = query[key];
-                if (!current) {
-                    query[key] = val;
-                    return;
-                }
-                if (Array.isArray(current)) {
-                    current.push(val);
-                    return;
-                }
-                query[key] = [current, val];
-            });
-            origReq["_tempQuery"] = query;
-            req.query = query;
-        }
-        let lowerPath = path.toLowerCase();
-        let m = this.map.get(lowerPath);
-        if (m) {
-            let h = m.get(req.method.toLowerCase());
-            if (h) {
-                h(origReq, res, next);
-                return;
-            }
-        }
-        let idPosition = path.lastIndexOf('/');
-        if (idPosition >= 0) {
-            lowerPath = path.substring(0, idPosition) + '/:id';
-            m = this.map.get(lowerPath);
-            if (m) {
-                let h = m.get(req.method.toLowerCase());
-                if (h) {
-                    if (!req.params) {
-                        req.params = {};
-                        origReq["_tempParams"] = req.params;
-                    }
-                    req.params.id = path.substring(idPosition + 1);
-                    h(origReq, res, next);
-                    return;
-                }
-            }
-        }
-        next();
-    }
-}
-@Entity(undefined, {
-    dbName: 'jobsInQueue'
-})
-export class JobsInQueueEntity extends IdEntity {
-    @Fields.string()
-    userId;
-    @Fields.string()
-    url;
-    @Fields.date()
-    submitTime;
-    @Fields.date()
-    doneTime;
-    @Fields.string()
-    result;
-    @Fields.boolean()
-    done;
-    @Fields.boolean()
-    error;
-    @Fields.number()
-    progress;
-}
-allEntities.splice(allEntities.indexOf(JobsInQueueEntity), 1);