remult 0.14.31 → 0.14.34

package/esm/server/expressBridge.js

@@ -1,14 +1,10 @@
 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 = {};
     }
@@ -25,10 +21,10 @@ export function buildRemultServer(app, options) {
     }
     else
         dataProvider = Promise.resolve(options.dataProvider);
-    dataProvider = dataProvider.then(dp => {
+    dataProvider = dataProvider.then(async (dp) => {
         if (dp)
             return dp;
-        return new JsonDataProvider(new JsonEntityFileStorage('./db'));
+        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
@@ -37,33 +33,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 +236,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,122 +473,8 @@ 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 {
+class ExpressRequestBridgeToDataApiRequest {
     constructor(r) {
         this.r = r;
     }
@@ -484,8 +491,6 @@ class ExpressResponseBridgeToDataApiResponse {
         this.setStatus(403).end();
     }
     setStatus(status) {
-        if (this.r.setStatus)
-            return this.r.setStatus(status);
         return this.r.status(status);
     }
     progress(progress) {
@@ -629,6 +634,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';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

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';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

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

@@ -1,8 +1,11 @@
 import { __decorate, __metadata } from "tslib";
 import axios from 'axios';
+import { remultFresh } from '../../remult-fresh';
 import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
+import { InMemoryDataProvider } from '../data-providers/in-memory-database';
 import { Entity, Fields } from '../remult3';
 import { Action, BackendMethod } from '../server-action';
+import { Categories } from '../tests/remult-3-entities';
 Remult.apiBaseUrl = 'http://localhost:3003/api';
 let path = Remult.apiBaseUrl + '/tasks';
 const environments = [
@@ -11,9 +14,9 @@ const environments = [
 // ["koa", 3002],
 // ["fastify", 3003],
 // ["express", 3004],
-// ["middleware", 3005],
+// ["generic server", 3005],
 // ["optine", 3006],
-// ["fresh", 8000],
+// ["fresh", 8000]
 ];
 function test(name, test) {
     for (const [env, port] of environments) {
@@ -93,6 +96,32 @@ test("test regular api call", async () => {
     let result = await axios.get(Remult.apiBaseUrl + "/test");
     expect(result.data.result).toBe(3);
 });
+class FreshResponseTest {
+    constructor(body, init) {
+        this.body = body;
+        this.init = init;
+    }
+    static json(data, init) {
+        return new this(data, init);
+    }
+}
+fit("test fresh", async () => {
+    const api = remultFresh({ entities: [Categories],
+        dataProvider: new InMemoryDataProvider(),
+        rootPath: '/api' }, FreshResponseTest);
+    const r = await api.freshHandler({
+        url: '/api/Categories',
+        json() {
+            return undefined;
+        },
+        method: "get"
+    }, {
+        next() {
+            return undefined;
+        },
+    });
+    expect(r.body).toEqual([]);
+});
 let Task = class Task {
     constructor() {
         this.title = '';

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.34",
     "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<any>;
 }
 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;
-}