remult 0.14.29 → 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.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 = [];
+    {
+        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, initRequest, dataProvider) {
-        this.app = app;
+class RemultServerImplementation {
+    constructor(queue, options, dataProvider) {
         this.queue = queue;
-        this.initRequest = initRequest;
+        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,115 +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 = 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) {
@@ -624,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],
+    // ["next", 3000],
+    // ["nest", 3001],
     ["koa", 3002],
     ["fastify", 3003],
     ["express", 3004],
-    ["middleware", 3005],
-    ["optine", 3006],
-    ["fresh", 8000],
+    ["generic server", 3005],
 ];
 function test(name, test) {
     for (const [env, port] of environments) {

package/esm/src/context.d.ts

@@ -40,12 +40,7 @@ export declare class Remult {
     /** Returns the current user's info */
     get user(): UserInfo;
     /** Set's the current user info */
-    setUser(info: UserInfo | {
-        sub?: string;
-        name?: string;
-        permissions?: string[];
-        username?: string;
-    }): Promise<void>;
+    setUser(info: UserInfo): Promise<void>;
     private _user;
     private _userChangeEvent;
     /** Checks if a user was authenticated */

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.29",
+    "version": "0.14.32",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -28,14 +28,18 @@
             "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",
             "import": "./esm/remult-fastify.js"
         },
+        "./remult-fresh": {
+            "require": "./remult-fresh.js",
+            "import": "./esm/remult-fresh.js"
+        },
         "./postgres": {
             "require": "./postgres/index.js",
             "import": "./esm/postgres/index.js"

package/readme.md

@@ -35,13 +35,13 @@
 
 ### Status
 
-Remult is **production-ready** and, in fact, used in production apps since 2017. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
+Remult is **production-ready** and, in fact, used in production apps since 2018. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
 
 ## Motivation
 
 Full-stack web development is (still) too complicated. **Simple CRUD, a common requirement of any business application, should be simple to build, maintain, and extend** when the need arises.
 
-Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult let you write TypeScript code you can follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
+Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult helps building fullstack apps using only TypeScript code you can easily follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
 
 Other frameworks tend to fall into either too much abstraction (no-code, low-code, BaaS) or partial abstraction (MVC frameworks, GraphQL, ORMs, API generators, code generators), and tend to be opinionated regarding the development tool-chain, deployment environment, configuration/conventions or DSL. Remult attempts to strike a better balance.
 

package/remult-express.d.ts

@@ -1,11 +1,6 @@
-import { RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultExpress(options?: RemultMiddlewareOptions & {
+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.d.ts

@@ -1,3 +1,3 @@
 import type { FastifyPluginCallback } from 'fastify';
-import { RemultServer, RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultMiddlewareOptions): FastifyPluginCallback & RemultServer;
+import { RemultServer, RemultServerOptions } from './server/expressBridge';
+export declare function remultFastify(options: RemultServerOptions): FastifyPluginCallback & RemultServer;

package/remult-fastify.js

@@ -23,8 +23,8 @@ function remultFastify(options) {
         };
         return response;
     }
-    var api;
-    var pluginFunction = function (instance, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+    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) {
             fastifyRouter = {
@@ -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

@@ -0,0 +1,17 @@
+import { RemultServerOptions, RemultServer } from "./server/expressBridge";
+export declare function remultFresh(options: RemultServerOptions, response: FreshResponse): RemultFresh;
+export interface RemultFresh extends RemultServer {
+    freshHandler(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+}
+export interface FreshRequest {
+    url: string;
+    method: string;
+    json: () => Promise<any>;
+}
+export interface FreshContext {
+    next: () => Promise<any>;
+}
+export interface FreshResponse {
+    new (body?: any | undefined, init?: ResponseInit): any;
+    json(data: unknown, init?: ResponseInit): any;
+}