remult 0.22.3 → 0.22.5

package/esm/core/server/expressBridge.js

@@ -0,0 +1,938 @@
+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);