remult 0.21.1 → 0.22.0

package/esm/server/expressBridge.js

@@ -1,14 +1,12 @@
 import { __decorate, __metadata } from "tslib";
-import { Action, actionInfo, classBackendMethodsArray, serverActionField } from '../src/server-action';
-import { DataApi, serializeError } from '../src/data-api';
-import { allEntities, Remult } from '../src/context';
-import { Entity, Fields, getEntityKey, IdEntity } from '../src/remult3';
-import { remult } from '../src/remult-proxy';
-import { LiveQueryPublisher, InMemoryLiveQueryStorage } from '../src/live-query/SubscriptionServer';
-import { liveQueryKeepAliveRoute, streamUrl } from '../src/live-query/SubscriptionChannel';
+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";
-;
+import { SseSubscriptionServer, } from '../SseSubscriptionServer';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -40,21 +38,24 @@ export function createRemultServerCore(options, serverCoreOptions) {
                         if (started)
                             return;
                         started = true;
-                        console.time("Ensure Schema");
+                        console.time('Ensure Schema');
                     };
-                    entitiesMetaData.push(...options.entities.map(e => remult.repo(e).metadata));
+                    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]) {
+                    for (const item of [
+                        options.liveQueryStorage,
+                        options.queueStorage,
+                    ]) {
                         if (item?.ensureSchema) {
                             startConsoleLog();
                             await item.ensureSchema();
                         }
                     }
                     if (started)
-                        console.timeEnd("Ensure Schema");
+                        console.timeEnd('Ensure Schema');
                 }
                 if (options.initApi)
                     await options.initApi(remult);
@@ -79,37 +80,6 @@ export function createRemultServerCore(options, serverCoreOptions) {
     let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider, serverCoreOptions, entitiesMetaData);
     return bridge;
 }
-;
-export class RemultAsyncLocalStorage {
-    constructor(remultObjectStorage) {
-        this.remultObjectStorage = remultObjectStorage;
-    }
-    static enable() {
-        remult.remultFactory = () => {
-            const r = RemultAsyncLocalStorage.instance.getRemult();
-            if (r)
-                return r;
-            else
-                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-        };
-    }
-    static disable() {
-        remult.resetFactory();
-    }
-    run(remult, callback) {
-        if (this.remultObjectStorage)
-            this.remultObjectStorage.run(remult, callback);
-        else
-            callback();
-    }
-    getRemult() {
-        if (!this.remultObjectStorage) {
-            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
-        }
-        return this.remultObjectStorage.getStore();
-    }
-}
-RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
 /* @internal*/
 export class RemultServerImplementation {
     constructor(queue, options, dataProvider, coreOptions, entitiesMetaData) {
@@ -133,7 +103,7 @@ export class RemultServerImplementation {
                                 },
                                 set liveQueryStorage(value) {
                                     remult.liveQueryStorage = value;
-                                }
+                                },
                             });
                         }
                         await what(remult.repo(e));
@@ -144,7 +114,9 @@ export class RemultServerImplementation {
             throw new Error("Couldn't find entity " + entityKey);
         };
         this.withRemult = (req, res, next) => {
-            this.process(async () => { next(); })(req, res);
+            this.process(async () => {
+                next();
+            })(req, res);
         };
         this.registeredRouter = false;
         this.hasQueue = false;
@@ -170,9 +142,8 @@ export class RemultServerImplementation {
     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);
+        return this.options.entities.map((x) => r.repo(x).metadata);
     }
-    ;
     getRouteImpl() {
         if (!this.routeImpl) {
             this.routeImpl = new RouteImplementation(this.coreOptions);
@@ -185,7 +156,7 @@ export class RemultServerImplementation {
     }
     registerRouter(r) {
         if (this.registeredRouter)
-            throw "Router already registered";
+            throw 'Router already registered';
         this.registeredRouter = true;
         {
             for (const c of this.options.controllers) {
@@ -201,7 +172,7 @@ export class RemultServerImplementation {
             }
             if (this.hasQueue)
                 this.addAction({
-                    __register: x => {
+                    __register: (x) => {
                         x(Action.apiUrlForJobStatus, false, () => true, async (data, req, res) => {
                             let job = await this.queue.getJobInfo(data.queuedJobId);
                             let userId = undefined;
@@ -215,17 +186,19 @@ export class RemultServerImplementation {
                                 res.success(job.info);
                         });
                     },
-                    doWork: undefined
+                    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);
                 }));
             }
@@ -233,10 +206,10 @@ export class RemultServerImplementation {
                 res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(await this.coreOptions.getRequestBody(origReq)));
             }));
         }
-        this.options.entities.forEach(e => {
+        this.options.entities.forEach((e) => {
             let key = getEntityKey(e);
             if (key != undefined)
-                this.add(key, c => {
+                this.add(key, (c) => {
                     return new DataApi(c.repo(e), c);
                 }, r);
         });
@@ -244,7 +217,7 @@ export class RemultServerImplementation {
     async serializeContext(remult) {
         let result = {
             user: remult.user,
-            context: undefined
+            context: undefined,
         };
         if (this.options.contextSerializer) {
             result.context = await this.options.contextSerializer.serialize(remult);
@@ -254,9 +227,10 @@ export class RemultServerImplementation {
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.info("[remult] " + myRoute);
+            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))))
+            .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')
@@ -271,10 +245,10 @@ export class RemultServerImplementation {
     async runWithRemult(what) {
         let remult = new Remult();
         remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
-        remult.dataProvider = (await this.dataProvider);
+        remult.dataProvider = await this.dataProvider;
         remult.subscriptionServer = this.subscriptionServer;
         remult.liveQueryStorage = this.liveQueryStorage;
-        await new Promise(res => {
+        await new Promise((res) => {
             RemultAsyncLocalStorage.instance.run(remult, async () => {
                 res(await what(remult));
             });
@@ -284,10 +258,10 @@ export class RemultServerImplementation {
         return async (req, origRes) => {
             const genReq = this.coreOptions.buildGenericRequestInfo(req);
             if (!genReq.query) {
-                genReq.query = req["_tempQuery"];
+                genReq.query = req['_tempQuery'];
             }
             if (!genReq.params)
-                genReq.params = req["_tempParams"];
+                genReq.params = req['_tempParams'];
             let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
             let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
             await this.runWithRemult(async (remult) => {
@@ -301,7 +275,7 @@ export class RemultServerImplementation {
                             user = req['auth'];
                     }
                     if (user)
-                        remult.user = (user);
+                        remult.user = user;
                     if (this.options.initRequest) {
                         await this.options.initRequest(req, {
                             remult,
@@ -310,7 +284,7 @@ export class RemultServerImplementation {
                             },
                             set liveQueryStorage(value) {
                                 remult.liveQueryStorage = value;
-                            }
+                            },
                         });
                     }
                 }
@@ -318,7 +292,6 @@ export class RemultServerImplementation {
             });
         };
     }
-    ;
     async getRemult(req) {
         let remult;
         await this.process(async (c) => {
@@ -338,7 +311,7 @@ export class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.info("[remult] " + myUrl);
+                console.info('[remult] ' + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);
@@ -346,7 +319,7 @@ export class RemultServerImplementation {
             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))
+                        queuedJobId: await this.queue.submitJob(myUrl, remult, await this.coreOptions.getRequestBody(orig)),
                     };
                     res.success(r);
                 }
@@ -357,41 +330,41 @@ export class RemultServerImplementation {
     }
     openApiDoc(options) {
         if (!options.version)
-            options.version = "1.0.0";
+            options.version = '1.0.0';
         let spec = {
             info: { title: options.title, version: options.version },
-            openapi: "3.0.0",
+            openapi: '3.0.0',
             //swagger: "2.0",
-            "components": {
-                "schemas": {},
-                "securitySchemes": {
-                    "bearerAuth": {
-                        "scheme": "bearer",
-                        "bearerFormat": "JWT",
-                        "type": "http"
-                    }
-                }
+            components: {
+                schemas: {},
+                securitySchemes: {
+                    bearerAuth: {
+                        scheme: 'bearer',
+                        bearerFormat: 'JWT',
+                        type: 'http',
+                    },
+                },
             },
-            paths: {}
+            paths: {},
         };
         let validationError = {
-            "400": {
-                "description": "Error: Bad Request",
-                "content": {
-                    "application/json": {
-                        "schema": {
-                            "$ref": "#/components/schemas/InvalidResponse"
-                        }
-                    }
-                }
-            }
+            '400': {
+                description: 'Error: Bad Request',
+                content: {
+                    'application/json': {
+                        schema: {
+                            $ref: '#/components/schemas/InvalidResponse',
+                        },
+                    },
+                },
+            },
         };
         let security = {
-            "security": [
+            security: [
                 {
-                    "bearerAuth": []
-                }
-            ]
+                    bearerAuth: [],
+                },
+            ],
         };
         let secureBase = (condition, def, item) => {
             if (condition === undefined)
@@ -399,7 +372,7 @@ export class RemultServerImplementation {
             if (condition != false) {
                 if (condition != true) {
                     item = { ...item, ...security };
-                    item.responses["403"] = { description: "forbidden" };
+                    item.responses['403'] = { description: 'forbidden' };
                 }
                 return item;
             }
@@ -412,43 +385,49 @@ export class RemultServerImplementation {
                 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";
+                    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
+                            type,
                         };
                         if (f.options.allowApiUpdate !== false) {
                             mutationProperties[f.key] = {
-                                type
+                                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
+                            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
+                    type: 'object',
+                    properties,
                 };
                 if (JSON.stringify(properties) !== JSON.stringify(mutationProperties)) {
                     mutationKey += 'Mutation';
                     spec.components.schemas[mutationKey] = {
-                        type: "object",
-                        properties: mutationProperties
+                        type: 'object',
+                        properties: mutationProperties,
                     };
                 }
                 let definition = {
-                    "$ref": "#/components/schemas/" + key
+                    $ref: '#/components/schemas/' + key,
                 };
                 let secure = (condition, def, item) => {
                     item.tags = [meta.key];
@@ -456,195 +435,196 @@ export class RemultServerImplementation {
                         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}"] = {};
+                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" }
+                    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: '_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: '_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],
+                            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
-                                    }
-                                }
-                            }
+                        '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" },
+                    name: 'id',
+                    in: 'path',
+                    description: 'id of ' + key,
+                    required: true,
+                    schema: { type: 'string' },
                 };
                 let itemInBody = {
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/" + mutationKey
-                                }
-                            }
-                        }
-                    }
+                    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"],
+                    produces: ['application/json'],
                     ...itemInBody,
-                    "responses": {
-                        "201": {
-                            "description": "Created",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/" + key
-                                    }
-                                }
-                            }
+                    responses: {
+                        '201': {
+                            description: 'Created',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/' + key,
+                                    },
+                                },
+                            },
                         },
-                        ...validationError
-                    }
+                        ...validationError,
+                    },
                 });
                 apiPathWithId.get = secure(meta.options.allowApiRead, true, {
                     parameters: [idParameter],
                     responses: {
-                        "200": {
+                        '200': {
                             // "description": "returns an item of " + key,
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/" + 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
-                    ],
+                    produces: ['application/json'],
+                    parameters: [idParameter],
                     ...itemInBody,
-                    "responses": {
-                        "200": {
-                            "description": "successful operation",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/" + key
-                                    }
-                                }
-                            }
+                    responses: {
+                        '200': {
+                            description: 'successful operation',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/' + key,
+                                    },
+                                },
+                            },
                         },
-                        ...validationError
-                    }
+                        ...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"
+                    produces: ['application/json'],
+                    parameters: [idParameter],
+                    responses: {
+                        '204': {
+                            description: 'Deleted',
                         },
-                        ...validationError
-                    }
+                        ...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",
+                    produces: ['application/json'],
+                    tags: [b.tag],
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
                                     properties: {
-                                        "args": {
-                                            "type": "array",
-                                            "items": { "type": "string" }
-                                        }
-                                    }
-                                }
-                            }
-                        }
+                                        args: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
                     },
-                    "responses": {
-                        "201": {
-                            "description": "Created",
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "type": "object",
+                    responses: {
+                        '201': {
+                            description: 'Created',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
                                         properties: {
-                                            "data": {
-                                                "type": "object"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
+                                            data: {
+                                                type: 'object',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
                         },
-                        ...validationError
-                    }
-                })
+                        ...validationError,
+                    },
+                }),
             };
         }
-        spec.components.schemas["InvalidResponse"] = {
-            "type": "object",
+        spec.components.schemas['InvalidResponse'] = {
+            type: 'object',
             properties: {
-                "message": {
-                    "type": "string"
+                message: {
+                    type: 'string',
                 },
-                "modelState": {
-                    "type": "object"
-                }
-            }
+                modelState: {
+                    type: 'object',
+                },
+            },
         };
         return spec;
     }
@@ -668,8 +648,7 @@ class ExpressResponseBridgeToDataApiResponse {
     setStatus(status) {
         return this.r.status(status);
     }
-    progress(progress) {
-    }
+    progress(progress) { }
     success(data) {
         this.r.json(data);
     }
@@ -688,14 +667,13 @@ class ExpressResponseBridgeToDataApiResponse {
             message: data.message,
             stack: data.stack?.split('\n'),
             url: this.req.url,
-            method: this.req.method
+            method: this.req.method,
         });
         this.setStatus(400).json(data);
-        ;
     }
 }
 function throwError() {
-    throw "Invalid";
+    throw 'Invalid';
 }
 class inProcessQueueHandler {
     constructor(storage) {
@@ -706,13 +684,19 @@ class inProcessQueueHandler {
         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")
+            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;
     }
@@ -734,7 +718,7 @@ class InMemoryQueueStorage {
         let id = this.jobs.size.toString();
         this.jobs.set(id, {
             info: {
-                done: false
+                done: false,
             },
             userId: userId,
             setErrorResult: (error) => {
@@ -750,7 +734,7 @@ class InMemoryQueueStorage {
             setProgress: (progress) => {
                 let job = this.jobs.get(id);
                 job.info.progress = progress;
-            }
+            },
         });
         return id;
     }
@@ -762,7 +746,7 @@ export class EntityQueueStorage {
         this.sync = Promise.resolve();
     }
     doSync(what) {
-        return this.sync = this.sync.then(() => what());
+        return (this.sync = this.sync.then(() => what()));
     }
     async getJobInfo(queuedJobId) {
         let q = await this.repo.findId(queuedJobId, { useCache: false });
@@ -773,7 +757,7 @@ export class EntityQueueStorage {
                 done: q.done,
                 error: q.error ? JSON.parse(q.result) : undefined,
                 result: q.done && !q.error ? JSON.parse(q.result) : undefined,
-                progress: q.progress
+                progress: q.progress,
             },
             setErrorResult: async (error) => {
                 await this.sync;
@@ -801,7 +785,7 @@ export class EntityQueueStorage {
                 await this.sync;
                 q.progress = progress;
                 await this.doSync(() => q._.save());
-            }
+            },
         };
     }
     async createJob(url, userId) {
@@ -827,34 +811,36 @@ class RouteImplementation {
         this.map.set(r, m);
         const route = {
             get: (h) => {
-                m.set("get", h);
+                m.set('get', h);
                 return route;
             },
             put: (h) => {
-                m.set("put", h);
+                m.set('put', h);
                 return route;
             },
             post: (h) => {
-                m.set("post", h);
+                m.set('post', h);
                 return route;
             },
             delete: (h) => {
-                m.set("delete", h);
+                m.set('delete', h);
                 return route;
-            }
+            },
         };
         return route;
     }
     async handle(req, gRes) {
-        return new Promise(res => {
-            const response = new class {
+        return new Promise((res) => {
+            const response = new (class {
                 constructor() {
                     this.statusCode = 200;
                 }
                 write(data) {
+                    ;
                     gRes.write(data);
                 }
                 writeHead(statusCode, headers) {
+                    ;
                     gRes.writeHead(statusCode, headers);
                     this.statusCode = statusCode;
                     res({ statusCode });
@@ -878,17 +864,18 @@ class RouteImplementation {
                     if (gRes !== undefined)
                         gRes.end();
                     res({
-                        statusCode: this.statusCode
+                        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
+        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;
@@ -906,7 +893,7 @@ class RouteImplementation {
                 }
                 query[key] = [current, val];
             });
-            origReq["_tempQuery"] = query;
+            origReq['_tempQuery'] = query;
             req.query = query;
         }
         let lowerPath = path.toLowerCase();
@@ -927,7 +914,7 @@ class RouteImplementation {
                 if (h) {
                     if (!req.params) {
                         req.params = {};
-                        origReq["_tempParams"] = req.params;
+                        origReq['_tempParams'] = req.params;
                     }
                     req.params.id = path.substring(idPosition + 1);
                     h(origReq, res, next);
@@ -974,7 +961,7 @@ __decorate([
 ], JobsInQueueEntity.prototype, "progress", void 0);
 JobsInQueueEntity = __decorate([
     Entity(undefined, {
-        dbName: 'jobsInQueue'
+        dbName: 'jobsInQueue',
     })
 ], JobsInQueueEntity);
 export { JobsInQueueEntity };