remult 0.14.33 → 0.15.0

package/README.md

@@ -27,7 +27,7 @@
 </div>
 <hr/>
 
-[Getting Started](#getting-started) | [Documentation](#documentation) | [Example App](#example-app)
+[Getting Started](#getting-started) | [Documentation](#documentation) | [Example Apps](#example-apps)
 
 ## What is Remult?
 
@@ -222,9 +222,11 @@ The best way to learn Remult is by following a tutorial of a simple Todo web app
 ## Documentation
 The [documentation](https://remult.dev/docs) covers the main features of Remult. However, it is still a work-in-progress.
 
-## Example App
+## Example Apps
 
-[CRM demo](https://github.com/remult/crm-demo) with a React + [MUI](https://mui.com) front-end and Postgres database.
+* Fullstack TodoMVC example with React and Express. ([Source code](https://github.com/remult/TodoMVC-eample) | [CodeSandbox](https://codesandbox.io/s/github/remult/TodoMVC-example?file=/src/frontend/App.tsx))
+
+* [CRM demo](https://github.com/remult/crm-demo) with a React + [MUI](https://mui.com) front-end and Postgres database.
 
 ## Contributing
 Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).

package/esm/postgres/postgresColumnSyntax.d.ts

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../src/column-interfaces';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;

package/esm/postgres/postgresColumnSyntax.js

@@ -0,0 +1,30 @@
+import { ValueConverters } from '../valueConverters';
+export function postgresColumnSyntax(x, dbName) {
+    let result = dbName;
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb)
+            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}

package/esm/remult-express.js

@@ -1,5 +1,5 @@
 import * as express from 'express';
-import { buildRemultServer } from './server/expressBridge';
+import { createRemultServer } from './server/expressBridge';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -12,7 +12,7 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    const server = buildRemultServer(options);
+    const server = createRemultServer(options);
     server.registerRouter(app);
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),

package/esm/remult-fastify.js

@@ -1,4 +1,4 @@
-import { buildRemultServer } from './server/expressBridge';
+import { createRemultServer } from './server/expressBridge';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {
@@ -18,7 +18,7 @@ export function remultFastify(options) {
         };
         return response;
     }
-    const api = buildRemultServer(options);
+    const api = createRemultServer(options);
     const pluginFunction = async (instance, op) => {
         //@ts-ignore
         let fastifyRouter = {

package/esm/remult-fresh.d.ts

@@ -1,7 +1,12 @@
-import { RemultServerOptions, RemultServer } from "./server/expressBridge";
+import { RemultServerOptions, GenericRequest } from "./server/expressBridge";
+import { Remult } from "./src/context";
 export declare function remultFresh(options: RemultServerOptions, response: FreshResponse): RemultFresh;
-export interface RemultFresh extends RemultServer {
-    freshHandler(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+export interface RemultFresh {
+    getRemult(req: GenericRequest): Promise<Remult>;
+    openApiDoc(options: {
+        title: string;
+    }): any;
+    handle(req: FreshRequest, ctx: FreshContext): Promise<any>;
 }
 export interface FreshRequest {
     url: string;

package/esm/remult-fresh.js

@@ -1,9 +1,10 @@
-import { buildRemultServer } from "./server/expressBridge";
+import { createRemultServer } from "./server/expressBridge";
 export function remultFresh(options, response) {
-    const server = buildRemultServer(options);
-    const orig = server.handle;
-    return Object.assign(server, {
-        freshHandler: async (req, ctx) => {
+    const server = createRemultServer(options);
+    return {
+        getRemult: r => server.getRemult(r),
+        openApiDoc: x => server.openApiDoc(x),
+        handle: async (req, ctx) => {
             const theReq = {
                 method: req.method,
                 url: req.url,
@@ -16,7 +17,7 @@ export function remultFresh(options, response) {
                     break;
             }
             let init = {};
-            const res = await orig(theReq);
+            const res = await server.handle(theReq);
             if (res) {
                 init.status = res.statusCode;
                 if (res.data) {
@@ -30,7 +31,7 @@ export function remultFresh(options, response) {
             }
             ;
         }
-    });
+    };
 }
 ;
 ;

package/esm/remult-middleware.d.ts

@@ -0,0 +1,2 @@
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;

package/esm/remult-middleware.js

@@ -0,0 +1,65 @@
+import { remultMiddlewareBase } from './server/expressBridge';
+export function remultMiddleware(options) {
+    const m = new middleware();
+    let app = Object.assign((req, res, next) => m.handleRequest(req, res, next), {
+        route: (path) => m.route(path)
+    });
+    return remultMiddlewareBase(app, options);
+}
+class middleware {
+    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;
+    }
+    handleRequest(req, res, next) {
+        let lowerPath = req.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 = req.path.lastIndexOf('/');
+        if (idPosition >= 0) {
+            lowerPath = req.path.substring(0, idPosition) + '/:id';
+            m = this.map.get(lowerPath);
+            if (m) {
+                let h = m.get(req.method.toLowerCase());
+                if (h) {
+                    req.params.id = req.path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        next();
+    }
+}

package/esm/server/JsonEntityFileStorage.d.ts

@@ -1,7 +1,10 @@
-import { JsonEntityStorage } from '../index';
+import { JsonDataProvider, JsonEntityStorage } from '../index';
 export declare class JsonEntityFileStorage implements JsonEntityStorage {
     private folderPath;
     getItem(entityDbName: string): string;
     setItem(entityDbName: string, json: string): void;
     constructor(folderPath: string);
 }
+export declare class JsonFileDataProvider extends JsonDataProvider {
+    constructor(folderPath: string);
+}

package/esm/server/JsonEntityFileStorage.js

@@ -1,5 +1,6 @@
 import * as path from 'path';
 import * as fs from 'fs';
+import { JsonDataProvider } from '../index';
 export class JsonEntityFileStorage {
     constructor(folderPath) {
         this.folderPath = folderPath;
@@ -18,3 +19,6 @@ export class JsonEntityFileStorage {
         return fs.writeFileSync(path.join(this.folderPath, entityDbName) + '.json', json);
     }
 }
+export class JsonFileDataProvider extends JsonDataProvider {
+    constructor(folderPath) { super(new JsonEntityFileStorage(folderPath)); }
+}

package/esm/server/expressBridge.d.ts

@@ -20,7 +20,7 @@ export declare type RemultServerOptions = {
     controllers?: ClassType<any>[];
     rootPath?: string;
 };
-export declare function buildRemultServer(options: RemultServerOptions): RemultServer;
+export declare function createRemultServer(options?: RemultServerOptions): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;

package/esm/server/expressBridge.js

@@ -1,12 +1,10 @@
 import { __decorate, __metadata } from "tslib";
-import { JsonEntityFileStorage } from './JsonEntityFileStorage';
 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(options) {
+export function createRemultServer(options) {
     if (!options) {
         options = {};
     }
@@ -23,10 +21,10 @@ export function buildRemultServer(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) => {

package/esm/server/index.d.ts

@@ -1,2 +1,2 @@
-export { JsonEntityFileStorage } from './JsonEntityFileStorage';
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

package/esm/server/index.js

@@ -1,2 +1,2 @@
-export { JsonEntityFileStorage } from './JsonEntityFileStorage';
-export { buildRemultServer } from './expressBridge';
+export { createRemultServer } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

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;

package/esm/server/register-actions-on-server.js

@@ -0,0 +1,24 @@
+import { serverActionField, actionInfo, classBackendMethodsArray } from '../src/server-action';
+export function registerActionsOnServer(area, controllers) {
+    var addAction = (a) => {
+        let x = a[serverActionField];
+        if (!x) {
+            throw 'failed to set server action, did you forget the BackendMethod Decorator?';
+        }
+        area.addAction(x);
+    };
+    actionInfo.runningOnServer = true;
+    if (controllers && controllers.length > 0) {
+        for (const c of controllers) {
+            let z = c[classBackendMethodsArray];
+            if (z)
+                for (const a of z) {
+                    addAction(a);
+                }
+        }
+    }
+    else
+        actionInfo.allActions.forEach((a) => {
+            addAction(a);
+        });
+}

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

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

package/esm/server/register-entities-on-server.js

@@ -0,0 +1,15 @@
+import { getEntityKey } from "../src/remult3";
+import { allEntities } from "../src/context";
+import { DataApi } from "../src/data-api";
+export function registerEntitiesOnServer(area, entities) {
+    if (!entities)
+        entities = allEntities;
+    //add Api Entries
+    entities.forEach(e => {
+        let key = getEntityKey(e);
+        if (key != undefined)
+            area.add(key, c => {
+                return new DataApi(c.repo(e), c);
+            });
+    });
+}

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

@@ -1,18 +1,22 @@
 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 = [
-    ["next", 3000],
-    ["nest", 3001],
-    ["koa", 3002],
-    ["fastify", 3003],
-    ["express", 3004],
-    ["generic server", 3005],
-    ["optine", 3006],
+// ["next", 3000],
+// ["nest", 3001],
+// ["koa", 3002],
+// ["fastify", 3003],
+// ["express", 3004],
+// ["generic server", 3005],
+// ["optine", 3006],
+// ["fresh", 8000]
 ];
 function test(name, test) {
     for (const [env, port] of environments) {
@@ -92,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);
+    }
+}
+it("test fresh", async () => {
+    const api = remultFresh({ entities: [Categories],
+        dataProvider: new InMemoryDataProvider(),
+        rootPath: '/api' }, FreshResponseTest);
+    const r = await api.handle({
+        url: '/api/Categories',
+        json() {
+            return undefined;
+        },
+        method: "get"
+    }, {
+        next() {
+            return undefined;
+        },
+    });
+    expect(r.body).toEqual([]);
+});
 let Task = class Task {
     constructor() {
         this.title = '';

package/esm/valueConverters.d.ts

@@ -0,0 +1,12 @@
+import { ValueConverter } from "./src/column-interfaces";
+export declare class ValueConverters {
+    static readonly Date: ValueConverter<Date>;
+    static readonly DateOnly: ValueConverter<Date>;
+    static readonly DateOnlyString: ValueConverter<Date>;
+    static readonly Boolean: ValueConverter<Boolean>;
+    static readonly Number: ValueConverter<number>;
+    static readonly Integer: ValueConverter<number>;
+    static readonly Default: ValueConverter<any>;
+    static readonly JsonString: ValueConverter<any>;
+    static readonly JsonValue: ValueConverter<any>;
+}

package/esm/valueConverters.js

@@ -0,0 +1,169 @@
+import { InputTypes } from "./inputTypes";
+export class ValueConverters {
+}
+ValueConverters.Date = {
+    toJson: (val) => {
+        if (!val)
+            return '';
+        if (typeof (val) === "string")
+            val = new Date(val);
+        if (val instanceof Date) {
+            return val.toISOString();
+        }
+        else {
+            console.log("ToJsonError", val);
+            throw new Error("Expected date but got val");
+        }
+    },
+    fromJson: (val) => {
+        if (val == undefined)
+            return undefined;
+        if (val == '')
+            return undefined;
+        if (val.startsWith('0000-00-00'))
+            return undefined;
+        return new Date(Date.parse(val));
+    },
+    toDb: x => x,
+    fromDb: x => x,
+    fromInput: x => ValueConverters.Date.fromJson(x),
+    toInput: x => ValueConverters.Date.toJson(x),
+    displayValue: (val) => {
+        if (!val)
+            return '';
+        return val.toLocaleString();
+    }
+};
+ValueConverters.DateOnly = {
+    fromInput: x => ValueConverters.DateOnly.fromJson(x),
+    toInput: x => ValueConverters.DateOnly.toJson(x),
+    toJson: (val) => {
+        var d = val;
+        if (typeof d === "string" || typeof (d) === "number")
+            d = new Date(d);
+        if (!d || d == null)
+            return null;
+        if (d.getHours() == 0)
+            return new Date(d.valueOf() - d.getTimezoneOffset() * 60000).toISOString().substring(0, 10);
+        else
+            return d.toISOString().substring(0, 10);
+    },
+    fromJson: (value) => {
+        if (!value || value == '' || value == '0000-00-00')
+            return null;
+        let d = new Date(Date.parse(value));
+        d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
+        return d;
+    },
+    inputType: InputTypes.date,
+    toDb: (val) => {
+        if (!val)
+            return null;
+        return ValueConverters.DateOnly.fromJson(ValueConverters.DateOnly.toJson(val));
+    } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
+    ,
+    fromDb: (val) => {
+        var d = val;
+        if (!d)
+            return null;
+        return val;
+    },
+    fieldTypeInDb: 'date',
+    displayValue: (value) => {
+        if (!value)
+            return '';
+        return value.toLocaleDateString(undefined);
+    }
+};
+ValueConverters.DateOnlyString = {
+    ...ValueConverters.DateOnly,
+    toDb: (d) => {
+        let val = ValueConverters.DateOnly.toJson(d);
+        if (!val)
+            return undefined;
+        return val.replace(/-/g, '');
+    },
+    fromDb: (val) => {
+        if (val === null)
+            return null;
+        if (!val)
+            return undefined;
+        return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
+    }
+};
+ValueConverters.Boolean = {
+    toDb: (val) => val,
+    inputType: InputTypes.checkbox,
+    fromDb: (value) => {
+        return ValueConverters.Boolean.fromJson(value);
+    },
+    fromJson: value => {
+        if (typeof value === "boolean")
+            return value;
+        if (value !== undefined && value !== null) {
+            return value.toString().trim().toLowerCase() == 'true';
+        }
+        return value;
+    },
+    toJson: x => x,
+    fromInput: x => ValueConverters.Boolean.fromJson(x),
+    toInput: x => ValueConverters.Boolean.toJson(x)
+};
+ValueConverters.Number = {
+    fromDb: value => {
+        if (value === null)
+            return null;
+        if (value !== undefined)
+            return +value;
+        return undefined;
+    },
+    toDb: value => value,
+    fromJson: value => ValueConverters.Number.fromDb(value),
+    toJson: value => ValueConverters.Number.toDb(value),
+    fromInput: (x, type) => {
+        let r = +x;
+        if (!x)
+            return undefined;
+        return r;
+    },
+    toInput: (x, type) => {
+        return x?.toString();
+    },
+    inputType: InputTypes.number
+};
+ValueConverters.Integer = {
+    ...ValueConverters.Number,
+    toJson: value => {
+        let val = ValueConverters.Number.toDb(value);
+        if (!val)
+            return val;
+        return +(+val).toFixed(0);
+    },
+    toDb: value => ValueConverters.Integer.toJson(value),
+    fieldTypeInDb: 'integer'
+};
+ValueConverters.Default = {
+    fromJson: x => x,
+    toJson: x => x,
+    fromDb: x => ValueConverters.JsonString.fromDb(x),
+    toDb: x => ValueConverters.JsonString.toDb(x),
+    fromInput: x => ValueConverters.Default.fromJson(x),
+    toInput: x => ValueConverters.Default.toJson(x)
+};
+ValueConverters.JsonString = {
+    fromJson: x => x,
+    toJson: x => x,
+    fromDb: x => x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined,
+    toDb: x => x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined,
+    fromInput: x => ValueConverters.JsonString.fromJson(x),
+    toInput: x => ValueConverters.JsonString.toJson(x)
+};
+ValueConverters.JsonValue = {
+    fromJson: x => x,
+    toJson: x => x,
+    fromDb: x => x,
+    toDb: x => x,
+    fromInput: x => ValueConverters.JsonString.fromJson(x),
+    toInput: x => ValueConverters.JsonString.toJson(x),
+    fieldTypeInDb: 'json'
+};