remult 0.14.31 → 0.14.32

package/esm/server/expressBridge.js

@@ -1,14 +1,12 @@
 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 { 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 } from '../src/remult3';
 import { JsonDataProvider } from '../src/data-providers/json-data-provider';
 import { IdEntity } from '../src/id-entity';
-export function buildRemultServer(app, options) {
+export function buildRemultServer(options) {
     if (!options) {
         options = {};
     }
@@ -37,33 +35,158 @@ export function buildRemultServer(app, options) {
             return dp;
         });
     }
-    let bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options, 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 = [];
+    {
+        let allControllers = [];
+        if (!options.entities)
+            options.entities = [...allEntities];
         if (options.entities)
-            actions.push(...options.entities);
+            allControllers.push(...options.entities);
         if (options.controllers)
-            actions.push(...options.controllers);
-        registerActionsOnServer(apiArea, actions);
-        registerEntitiesOnServer(apiArea, options.entities);
+            allControllers.push(...options.controllers);
+        options.controllers = allControllers;
     }
+    if (options.rootPath === undefined)
+        options.rootPath = Remult.apiBaseUrl;
+    actionInfo.runningOnServer = true;
+    let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     return bridge;
 }
 ;
-class ExpressBridge {
-    constructor(app, queue, options, dataProvider) {
-        this.app = app;
+class RemultServerImplementation {
+    constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.registeredRouter = false;
+        this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
-        this.logApiEndPoints = true;
+    }
+    handle(req, gRes) {
+        if (!this.routeImpl) {
+            this.routeImpl = new RouteImplementation();
+            this.registerRouter(this.routeImpl);
+        }
+        return this.routeImpl.handle(req, gRes);
+    }
+    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);
+                        });
+                    }
+                }, r);
+        }
+        this.options.entities.forEach(e => {
+            let key = getEntityKey(e);
+            if (key != undefined)
+                this.add(key, c => {
+                    return new DataApi(c.repo(e), c);
+                }, r);
+        });
+    }
+    add(key, dataApiFactory, r) {
+        let myRoute = this.options.rootPath + '/' + key;
+        if (this.options.logApiEndPoints)
+            console.log(myRoute);
+        r.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)));
+        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, 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.dataProvider);
+            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.setUser(user);
+            }
+            if (this.options.initRequest) {
+                await this.options.initRequest(remult, req);
+            }
+            what(remult, myReq, myRes, req);
+        };
+    }
+    ;
+    async getRemult(req) {
+        let remult;
+        await this.process(async (c) => {
+            remult = c;
+        })(req, undefined);
+        return remult;
+    }
+    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.log(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, orig.body)
+                    };
+                    res.success(r);
+                }
+                else
+                    return what(orig.body, remult, res);
+            }));
+        });
     }
     openApiDoc(options) {
         let r = new Remult();
@@ -115,7 +238,7 @@ class ExpressBridge {
                 return item;
             }
         };
-        for (const e of allEntities) {
+        for (const e of this.options.entities) {
             let meta = r.repo(e).metadata;
             let key = getEntityKey(e);
             let parameters = [];
@@ -352,120 +475,6 @@ class ExpressBridge {
         };
         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;
-                if (this.bridge.options.getUser)
-                    user = await this.bridge.options.getUser(req);
-                else {
-                    user = req['user'];
-                    if (!user)
-                        user = req['auth'];
-                }
-                if (user)
-                    remult.setUser(user);
-            }
-            if (this.bridge.options.initRequest) {
-                await this.bridge.options.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) {
@@ -629,6 +638,114 @@ export class EntityQueueStorage {
         return q.id;
     }
 }
+class RouteImplementation {
+    constructor() {
+        this.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 {
+                constructor() {
+                    this.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(req, res, next) {
+        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];
+            });
+            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(req, 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 = {};
+                    req.params.id = path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        next();
+    }
+}
 let JobsInQueueEntity = class JobsInQueueEntity extends IdEntity {
 };
 __decorate([

package/esm/server/index.d.ts

@@ -1,4 +1,2 @@
 export { JsonEntityFileStorage } from './JsonEntityFileStorage';
-export { SiteArea, queuedJobInfo, QueueStorage } from './expressBridge';
-export { registerEntitiesOnServer } from './register-entities-on-server';
-export { registerActionsOnServer } from './register-actions-on-server';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';

package/esm/server/index.js

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

package/esm/src/backend-tests/test-http-server.backend-spec.js

@@ -6,14 +6,12 @@ import { Action, BackendMethod } from '../server-action';
 Remult.apiBaseUrl = 'http://localhost:3003/api';
 let path = Remult.apiBaseUrl + '/tasks';
 const environments = [
-// ["next", 3000],
-// ["nest", 3001],
-// ["koa", 3002],
-// ["fastify", 3003],
-// ["express", 3004],
-// ["middleware", 3005],
-// ["optine", 3006],
-// ["fresh", 8000],
+    // ["next", 3000],
+    // ["nest", 3001],
+    ["koa", 3002],
+    ["fastify", 3003],
+    ["express", 3004],
+    ["generic server", 3005],
 ];
 function test(name, test) {
     for (const [env, port] of environments) {

package/graphql.d.ts

@@ -1,5 +1,5 @@
-import { RemultExpressBridge } from "./server/expressBridge";
-export declare function remultGraphql(api: RemultExpressBridge): {
+import { RemultServer } from "./server/expressBridge";
+export declare function remultGraphql(api: RemultServer): {
     rootValue: {};
     schema: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.14.31",
+    "version": "0.14.32",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -28,9 +28,9 @@
             "require": "./remult-express.js",
             "import": "./esm/remult-express.js"
         },
-        "./remult-middleware": {
-            "require": "./remult-middleware.js",
-            "import": "./esm/remult-middleware.js"
+        "./server": {
+            "require": "./server/index.js",
+            "import": "./esm/server/index.js"
         },
         "./remult-fastify": {
             "require": "./remult-fastify.js",

package/remult-express.d.ts

@@ -1,11 +1,6 @@
-import { RemultServerOptions } from './server/expressBridge';
+import * as express from 'express';
+import { RemultServer, RemultServerOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultServerOptions & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): import("express-serve-static-core").Router & {
-    getRemult: (req: any) => Promise<import(".").Remult>;
-    openApiDoc: (options: {
-        title: string;
-    }) => any;
-    addArea: (x: any) => void;
-};
+}): express.RequestHandler & RemultServer;

package/remult-express.js

@@ -15,11 +15,12 @@ function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    var server = expressBridge_1.buildRemultServer(app, options);
+    var server = expressBridge_1.buildRemultServer(options);
+    server.registerRouter(app);
     return Object.assign(app, {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
-        addArea: function (x) { return server.addArea(x); }
+        registerRouter: function (x) { return server.registerRouter(x); }
     });
 }
 exports.remultExpress = remultExpress;

package/remult-fastify.js

@@ -23,7 +23,7 @@ function remultFastify(options) {
         };
         return response;
     }
-    var api;
+    var api = expressBridge_1.buildRemultServer(options);
     var pluginFunction = function (instance, op) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var fastifyRouter;
         return tslib_1.__generator(this, function (_a) {
@@ -48,19 +48,14 @@ function remultFastify(options) {
                     return r;
                 },
             };
-            api = expressBridge_1.buildRemultServer(fastifyRouter, options);
+            api.registerRouter(fastifyRouter);
             return [2 /*return*/];
         });
     }); };
-    var getApi = function () {
-        if (!api)
-            throw "Please call fastify's register before using this method";
-        return api;
-    };
     return Object.assign(pluginFunction, {
-        addArea: function (x) { return getApi().addArea(x); },
-        getRemult: function (x) { return getApi().getRemult(x); },
-        openApiDoc: function (x) { return getApi().openApiDoc(x); }
+        getRemult: function (x) { return api.getRemult(x); },
+        openApiDoc: function (x) { return api.openApiDoc(x); },
+        handle: function (req, res) { return api.handle(req, res); }
     });
 }
 exports.remultFastify = remultFastify;

package/remult-fresh.d.ts

@@ -1,8 +1,7 @@
 import { RemultServerOptions, RemultServer } from "./server/expressBridge";
-import { Remult } from "./src/context";
 export declare function remultFresh(options: RemultServerOptions, response: FreshResponse): RemultFresh;
 export interface RemultFresh extends RemultServer {
-    handle(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+    freshHandler(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
 }
 export interface FreshRequest {
     url: string;
@@ -11,12 +10,8 @@ export interface FreshRequest {
 }
 export interface FreshContext {
     next: () => Promise<any>;
-    state: FreshRemultState;
 }
 export interface FreshResponse {
     new (body?: any | undefined, init?: ResponseInit): any;
     json(data: unknown, init?: ResponseInit): any;
 }
-export interface FreshRemultState {
-    remult: Remult;
-}

package/remult-fresh.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultFresh = void 0;
 var tslib_1 = require("tslib");
-var remult_middleware_1 = require("./remult-middleware");
+var expressBridge_1 = require("./server/expressBridge");
 function remultFresh(options, response) {
     var _this = this;
-    var mw = remult_middleware_1.remultMiddleware(options);
-    var orig = mw.handle;
-    return tslib_1.__assign(tslib_1.__assign({}, mw), {
-        handle: function (req, ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var theReq, _a, _b, init, res, remult;
+    var server = expressBridge_1.buildRemultServer(options);
+    var orig = server.handle;
+    return Object.assign(server, {
+        freshHandler: function (req, ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var theReq, _a, _b, init, res;
             return tslib_1.__generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -25,7 +25,6 @@ function remultFresh(options, response) {
                         }
                         return [3 /*break*/, 3];
                     case 1:
-                        console.log(req);
                         _b = theReq;
                         return [4 /*yield*/, req.json()];
                     case 2:
@@ -36,22 +35,17 @@ function remultFresh(options, response) {
                         return [4 /*yield*/, orig(theReq)];
                     case 4:
                         res = _c.sent();
-                        if (!res) return [3 /*break*/, 5];
-                        if (res.statusCode)
+                        if (res) {
                             init.status = res.statusCode;
-                        if (res.data) {
-                            console.log({ init: init, res: res });
-                            return [2 /*return*/, response.json(res.data, init)];
+                            if (res.data) {
+                                return [2 /*return*/, response.json(res.data, init)];
+                            }
+                            else
+                                return [2 /*return*/, new response(undefined, init)];
+                        }
+                        else {
+                            return [2 /*return*/, ctx.next()];
                         }
-                        else
-                            return [2 /*return*/, new response(undefined, init)];
-                        return [3 /*break*/, 7];
-                    case 5: return [4 /*yield*/, mw.getRemult(req)];
-                    case 6:
-                        remult = _c.sent();
-                        ctx.state.remult = remult;
-                        return [2 /*return*/, ctx.next()];
-                    case 7:
                         ;
                         return [2 /*return*/];
                 }
@@ -61,3 +55,4 @@ function remultFresh(options, response) {
 }
 exports.remultFresh = remultFresh;
 ;
+;