remult 0.14.7 → 0.14.10

package/esm/server/expressBridge.js

@@ -0,0 +1,668 @@
+import { __decorate, __metadata } from "tslib";
+import { registerActionsOnServer } from './register-actions-on-server';
+import { registerEntitiesOnServer } from './register-entities-on-server';
+import { JsonEntityFileStorage } from './JsonEntityFileStorage';
+import { Action, actionInfo } from '../src/server-action';
+import { DataApi, serializeError } from '../src/data-api';
+import { allEntities, Remult } from '../src/context';
+import { Entity, Fields, getEntityKey } from '../src/remult3';
+import { JsonDataProvider } from '../src/data-providers/json-data-provider';
+import { IdEntity } from '../src/id-entity';
+export function remultMiddlewareBase(app, options) {
+    if (!options) {
+        options = {};
+    }
+    actionInfo.runningOnServer = true;
+    if (options.defaultGetLimit) {
+        DataApi.defaultGetLimit = options.defaultGetLimit;
+    }
+    if (!options.queueStorage) {
+        options.queueStorage = new InMemoryQueueStorage();
+    }
+    let dataProvider;
+    if (typeof options.dataProvider === "function") {
+        dataProvider = options.dataProvider();
+    }
+    else
+        dataProvider = Promise.resolve(options.dataProvider);
+    dataProvider = dataProvider.then(dp => {
+        if (dp)
+            return dp;
+        return new JsonDataProvider(new JsonEntityFileStorage('./db'));
+    });
+    if (options.initApi) {
+        dataProvider = dataProvider.then(async (dp) => {
+            var remult = new Remult(dp);
+            await options.initApi(remult);
+            return dp;
+        });
+    }
+    let bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options.initRequest, dataProvider);
+    if (options.logApiEndPoints !== undefined)
+        bridge.logApiEndPoints = options.logApiEndPoints;
+    if (options.rootPath === undefined)
+        options.rootPath = Remult.apiBaseUrl;
+    let apiArea = bridge.addArea(options.rootPath);
+    if (!options.disableAutoApi) {
+        let actions = [];
+        if (options.entities)
+            actions.push(...options.entities);
+        if (options.controllers)
+            actions.push(...options.controllers);
+        registerActionsOnServer(apiArea, actions);
+        registerEntitiesOnServer(apiArea, options.entities);
+    }
+    return Object.assign(app, {
+        getRemult: (req) => bridge.getRemult(req),
+        openApiDoc: (options) => bridge.openApiDoc(options),
+        addArea: x => bridge.addArea(x)
+    });
+}
+class ExpressBridge {
+    constructor(app, queue, initRequest, dataProvider) {
+        this.app = app;
+        this.queue = queue;
+        this.initRequest = initRequest;
+        this.dataProvider = dataProvider;
+        /* internal */
+        this.backendMethodsOpenApi = [];
+        this.logApiEndPoints = true;
+    }
+    openApiDoc(options) {
+        let r = new Remult();
+        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 e of allEntities) {
+            let meta = r.repo(e).metadata;
+            let key = getEntityKey(e);
+            let parameters = [];
+            if (key) {
+                let properties = {};
+                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";
+                    properties[f.key] = {
+                        type
+                    };
+                    parameters.push({
+                        "name": f.key,
+                        "in": "query",
+                        "description": "filter equal to " + f.key,
+                        "required": false,
+                        "style": "simple",
+                        type
+                    });
+                    parameters.push({
+                        "name": f.key + "_ne",
+                        "in": "query",
+                        "description": "filter not equal to " + f.key,
+                        "required": false,
+                        "style": "simple",
+                        type
+                    });
+                }
+                spec.components.schemas[key] = {
+                    type: "object",
+                    properties
+                };
+                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['/api/' + key] = {};
+                let apiPathWithId = spec.paths['/api/' + 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/" + key
+                                }
+                            }
+                        }
+                    }
+                };
+                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;
+    }
+    addArea(rootUrl) {
+        var r = new SiteArea(this, this.app, rootUrl, this.logApiEndPoints);
+        if (!this.firstArea) {
+            this.firstArea = r;
+        }
+        return r;
+    }
+    async getRemult(req) {
+        return this.firstArea.getRemult(req);
+    }
+}
+export class SiteArea {
+    constructor(bridge, app, rootUrl, logApiEndpoints) {
+        this.bridge = bridge;
+        this.app = app;
+        this.rootUrl = rootUrl;
+        this.logApiEndpoints = logApiEndpoints;
+    }
+    add(key, dataApiFactory) {
+        let myRoute = this.rootUrl + '/' + key;
+        if (this.logApiEndpoints)
+            console.log(myRoute);
+        this.app.route(myRoute)
+            .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
+            .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, orig.body)));
+        this.app.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, orig) => dataApiFactory(c).put(res, orig.params.id, orig.body)))
+            //@ts-ignore
+            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
+    }
+    process(what) {
+        return async (req, res) => {
+            let myReq = new ExpressRequestBridgeToDataApiRequest(req);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
+            let remult = new Remult();
+            remult.setDataProvider(await this.bridge.dataProvider);
+            if (req) {
+                let user = req['user'];
+                if (!user)
+                    user = req['auth'];
+                if (user)
+                    remult.setUser(user);
+            }
+            if (this.bridge.initRequest) {
+                await this.bridge.initRequest(remult, req);
+            }
+            what(remult, myReq, myRes, req);
+        };
+    }
+    ;
+    async getRemult(req) {
+        let remult;
+        await this.process(async (c) => {
+            remult = c;
+        })(req, undefined);
+        return remult;
+    }
+    initQueue() {
+        this.addAction({
+            __register: x => {
+                x(Action.apiUrlForJobStatus, false, () => true, async (data, req, res) => {
+                    let job = await this.bridge.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);
+                });
+            }
+        });
+        this.initQueue = () => { };
+    }
+    addAction(action) {
+        action.__register((url, queue, allowed, what) => {
+            let myUrl = this.rootUrl + '/' + url;
+            let tag = (() => {
+                let split = url.split('/');
+                if (split.length == 1)
+                    return 'Static Backend Methods';
+                else
+                    return split[0];
+            })();
+            this.bridge.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
+            if (this.logApiEndpoints)
+                console.log(myUrl);
+            if (queue) {
+                this.initQueue();
+                this.bridge.queue.mapQueuedAction(myUrl, what);
+            }
+            this.app.route(myUrl).post(this.process(async (remult, req, res, orig) => {
+                if (queue) {
+                    let r = {
+                        queuedJobId: await this.bridge.queue.submitJob(myUrl, remult, orig.body)
+                    };
+                    res.success(r);
+                }
+                else
+                    return what(orig.body, remult, res);
+            }));
+        });
+    }
+}
+export class ExpressRequestBridgeToDataApiRequest {
+    constructor(r) {
+        this.r = r;
+    }
+    get(key) {
+        return this.r.query[key];
+    }
+}
+class ExpressResponseBridgeToDataApiResponse {
+    constructor(r, req) {
+        this.r = r;
+        this.req = req;
+    }
+    forbidden() {
+        this.sendStatus(403);
+    }
+    sendStatus(status) {
+        this.r.writeHead(status).end();
+    }
+    progress(progress) {
+    }
+    success(data) {
+        this.r.json(data);
+    }
+    created(data) {
+        this.r.statusCode = 201;
+        this.r.json(data);
+    }
+    deleted() {
+        this.sendStatus(204);
+    }
+    notFound() {
+        this.sendStatus(404);
+    }
+    error(data) {
+        data = serializeError(data);
+        console.error({
+            message: data.message,
+            stack: data.stack?.split('\n'),
+            url: this.req.originalUrl ?? this.req.path,
+            method: this.req.method
+        });
+        this.r.status(400).json(data);
+    }
+}
+function throwError() {
+    throw "Invalid";
+}
+class inProcessQueueHandler {
+    constructor(storage) {
+        this.storage = storage;
+        this.actions = new Map();
+    }
+    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)
+        });
+        return id;
+    }
+    mapQueuedAction(url, what) {
+        this.actions.set(url, what);
+    }
+    async getJobInfo(queuedJobId) {
+        return await this.storage.getJobInfo(queuedJobId);
+    }
+}
+class InMemoryQueueStorage {
+    constructor() {
+        this.jobs = new Map();
+    }
+    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;
+    }
+}
+let test = 0;
+export class EntityQueueStorage {
+    constructor(repo) {
+        this.repo = repo;
+        this.sync = Promise.resolve();
+    }
+    doSync(what) {
+        return this.sync = this.sync.then(() => what());
+    }
+    async getJobInfo(queuedJobId) {
+        let q = await this.repo.findId(queuedJobId);
+        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;
+    }
+}
+let JobsInQueueEntity = class JobsInQueueEntity extends IdEntity {
+};
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], JobsInQueueEntity.prototype, "userId", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], JobsInQueueEntity.prototype, "url", void 0);
+__decorate([
+    Fields.date(),
+    __metadata("design:type", Date)
+], JobsInQueueEntity.prototype, "submitTime", void 0);
+__decorate([
+    Fields.date(),
+    __metadata("design:type", Date)
+], JobsInQueueEntity.prototype, "doneTime", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], JobsInQueueEntity.prototype, "result", void 0);
+__decorate([
+    Fields.boolean(),
+    __metadata("design:type", Boolean)
+], JobsInQueueEntity.prototype, "done", void 0);
+__decorate([
+    Fields.boolean(),
+    __metadata("design:type", Boolean)
+], JobsInQueueEntity.prototype, "error", void 0);
+__decorate([
+    Fields.number(),
+    __metadata("design:type", Number)
+], JobsInQueueEntity.prototype, "progress", void 0);
+JobsInQueueEntity = __decorate([
+    Entity(undefined, {
+        dbName: 'jobsInQueue'
+    })
+], JobsInQueueEntity);
+export { JobsInQueueEntity };
+allEntities.splice(allEntities.indexOf(JobsInQueueEntity), 1);

package/esm/server/index.d.ts

@@ -0,0 +1,4 @@
+export { JsonEntityFileStorage } from './JsonEntityFileStorage';
+export { SiteArea, queuedJobInfo, QueueStorage } from './expressBridge';
+export { registerEntitiesOnServer } from './register-entities-on-server';
+export { registerActionsOnServer } from './register-actions-on-server';

package/esm/server/index.js

@@ -0,0 +1,4 @@
+export { JsonEntityFileStorage } from './JsonEntityFileStorage';
+export { SiteArea } from './expressBridge';
+export { registerEntitiesOnServer } from './register-entities-on-server';
+export { registerActionsOnServer } from './register-actions-on-server';

package/esm/server/register-actions-on-server.d.ts

@@ -0,0 +1,3 @@
+import { SiteArea } from "./expressBridge";
+import { ClassType } from "../classType";
+export declare function registerActionsOnServer(area: SiteArea, controllers?: ClassType<any>[]): void;