remult 0.14.21 → 0.14.24

package/esm/index.d.ts

@@ -19,4 +19,4 @@ export { Filter } from './src/filter/filter-interfaces';
 export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
-export { ValueConverters } from './valueConverters';
+export { ValueConverters } from './src/valueConverters';

package/esm/index.js

@@ -18,4 +18,4 @@ export { Filter } from './src/filter/filter-interfaces';
 export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
-export { ValueConverters } from './valueConverters';
+export { ValueConverters } from './src/valueConverters';

package/esm/postgres/schema-builder.js

@@ -1,7 +1,7 @@
 import { allEntities } from '../src/context';
 import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
 import { isAutoIncrement } from '../src/remult3';
-import { ValueConverters } from '../valueConverters';
+import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
     let result = dbName;
     if (x.valueType == Number) {

package/esm/remult-express.d.ts

@@ -2,4 +2,10 @@ import { RemultMiddlewareOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultMiddlewareOptions & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): import("./server/expressBridge").RemultExpressBridge;
+}): import("express-serve-static-core").Router & {
+    getRemult: (req: any) => Promise<import(".").Remult>;
+    openApiDoc: (options: {
+        title: string;
+    }) => any;
+    addArea: (x: any) => any;
+};

package/esm/remult-express.js

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

package/esm/remult-fastify.d.ts

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

package/esm/remult-fastify.js

@@ -0,0 +1,57 @@
+import { buildRemultServer } from './server/expressBridge';
+export function remultFastify(options) {
+    function fastifyHandler(handler) {
+        const response = (req, res) => {
+            const myRes = {
+                status(statusCode) {
+                    res.status(statusCode);
+                    return myRes;
+                },
+                end() {
+                    res.send();
+                },
+                json(data) {
+                    res.send(data);
+                }
+            };
+            handler(req, myRes, () => { });
+        };
+        return response;
+    }
+    let api;
+    const pluginFunction = async (instance, options) => {
+        //@ts-ignore
+        let fastifyRouter = {
+            route(path) {
+                let r = {
+                    delete(handler) {
+                        instance.delete(path, fastifyHandler(handler));
+                        return r;
+                    },
+                    get(handler) {
+                        instance.get(path, fastifyHandler(handler));
+                        return r;
+                    }, post(handler) {
+                        instance.post(path, fastifyHandler(handler));
+                        return r;
+                    }, put(handler) {
+                        instance.put(path, fastifyHandler(handler));
+                        return r;
+                    },
+                };
+                return r;
+            },
+        };
+        api = buildRemultServer(fastifyRouter, options);
+    };
+    const getApi = () => {
+        if (!api)
+            throw "Please call fastify's register before using this method";
+        return api;
+    };
+    return Object.assign(pluginFunction, {
+        addArea: x => getApi().addArea(x),
+        getRemult: x => getApi().getRemult(x),
+        openApiDoc: x => getApi().openApiDoc(x)
+    });
+}

package/esm/remult-knex/index.js

@@ -3,7 +3,7 @@ import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfac
 import { getDbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
 import { allEntities, Remult } from "../src/context";
 import { isAutoIncrement } from "../src/remult3";
-import { ValueConverters } from "../valueConverters";
+import { ValueConverters } from "../src/valueConverters";
 import { CompoundIdField } from '../src/column';
 export class KnexDataProvider {
     constructor(knex) {

package/esm/remult-middleware.d.ts

@@ -1,2 +1,8 @@
 import { RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): ((req: any, res: any, next: any) => void) & {
+    getRemult: (req: any) => Promise<import(".").Remult>;
+    openApiDoc: (options: {
+        title: string;
+    }) => any;
+    addArea: (x: any) => any;
+};

package/esm/remult-middleware.js

@@ -1,10 +1,12 @@
-import { remultMiddlewareBase } from './server/expressBridge';
+import { buildRemultServer } 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)
+    const server = buildRemultServer(m, options);
+    return Object.assign((req, res, next) => m.handleRequest(req, res, next), {
+        getRemult: (req) => server.getRemult(req),
+        openApiDoc: (options) => server.openApiDoc(options),
+        addArea: x => server.addArea(x)
     });
-    return remultMiddlewareBase(app, options);
 }
 class middleware {
     constructor() {

package/esm/server/expressBridge.d.ts

@@ -1,7 +1,7 @@
 import { queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
 import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
-import { AllowedForInstance, Remult } from '../src/context';
+import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
@@ -22,20 +22,34 @@ export declare type RemultMiddlewareOptions = {
     bodyParser?: boolean;
     rootPath?: string;
 };
-export declare function remultMiddlewareBase(app: GenericRouter, options: RemultMiddlewareOptions): RemultExpressBridge;
-export interface RemultExpressBridge extends GenericRequestHandler {
+export declare function buildRemultServer(app: GenericRouter, options: RemultMiddlewareOptions): RemultServer;
+export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
+export interface RemultExpressBridge extends GenericRequestHandler, RemultServer {
+}
+export interface RemultServer {
     getRemult(req: GenericRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
     }): any;
     addArea(rootUrl: string): any;
 }
+export declare type GenericRouter = {
+    route(path: string): SpecificRoute;
+};
+export declare type SpecificRoute = {
+    get(handler: GenericRequestHandler): SpecificRoute;
+    put(handler: GenericRequestHandler): SpecificRoute;
+    post(handler: GenericRequestHandler): SpecificRoute;
+    delete(handler: GenericRequestHandler): SpecificRoute;
+};
 export interface GenericRequest {
     url: string;
     method?: any;
     body?: any;
     query?: any;
     params?: any;
+    user?: UserInfo;
+    auth?: UserInfo;
 }
 export interface GenericResponse {
     json(data: any): any;
@@ -43,16 +57,6 @@ export interface GenericResponse {
     setStatus?(statusCode: number): GenericResponse;
     end(): any;
 }
-export declare type GenericRouter = GenericRequestHandler & {
-    route(path: string): SpecificRoute;
-};
-export declare type SpecificRoute = {
-    get(handler: GenericRequestHandler): SpecificRoute;
-    put(handler: GenericRequestHandler): SpecificRoute;
-    post(handler: GenericRequestHandler): SpecificRoute;
-    delete(handler: GenericRequestHandler): SpecificRoute;
-};
-export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 declare class ExpressBridge {
     private app;
     queue: inProcessQueueHandler;

package/esm/server/expressBridge.js

@@ -8,7 +8,7 @@ import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { JsonDataProvider } from '../src/data-providers/json-data-provider';
 import { IdEntity } from '../src/id-entity';
-export function remultMiddlewareBase(app, options) {
+export function buildRemultServer(app, options) {
     if (!options) {
         options = {};
     }
@@ -52,11 +52,7 @@ export function remultMiddlewareBase(app, options) {
         registerActionsOnServer(apiArea, actions);
         registerEntitiesOnServer(apiArea, options.entities);
     }
-    return Object.assign(app, {
-        getRemult: (req) => bridge.getRemult(req),
-        openApiDoc: (options) => bridge.openApiDoc(options),
-        addArea: x => bridge.addArea(x)
-    });
+    return bridge;
 }
 ;
 class ExpressBridge {

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

@@ -3,22 +3,41 @@ import axios from 'axios';
 import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
 import { Entity, Fields } from '../remult3';
 import { Action, BackendMethod } from '../server-action';
-Remult.apiBaseUrl = 'http://localhost:3001/api';
-const path = Remult.apiBaseUrl + '/tasks';
-fit("works", async () => {
+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],
+];
+function test(name, test) {
+    for (const [env, port] of environments) {
+        const theTest = async () => {
+            Remult.apiBaseUrl = `http://localhost:${port}/api`;
+            path = Remult.apiBaseUrl + '/tasks';
+            await test();
+        };
+        const testName = env + ` ${port}: ${name}`;
+        fit(testName, theTest);
+    }
+}
+test("works", async () => {
     const repo = await create3Tasks();
     const tasks = await repo.find({ where: { completed: true } });
     expect(tasks.length).toBe(1);
     await repo.save({ ...tasks[0], completed: false });
     expect(await repo.count({ completed: true })).toBe(0);
 });
-fit("test multiple items", async () => {
+test("test multiple items", async () => {
     const repo = await create3Tasks();
     expect(await repo.count({
         title: { "!=": ["a", "c"] }
     })).toBe(1);
 });
-fit("validation", async () => {
+test("validation", async () => {
     const r = await create3Tasks();
     let err = undefined;
     try {
@@ -35,7 +54,7 @@ fit("validation", async () => {
         }
     });
 });
-fit("forbidden", async () => {
+test("forbidden", async () => {
     let err = undefined;
     try {
         await Task.testForbidden();
@@ -45,7 +64,7 @@ fit("forbidden", async () => {
     }
     expect(err.httpStatusCode).toEqual(403);
 });
-fit("test http 404", async () => {
+test("test http 404", async () => {
     const repo = create3Tasks();
     const task = await (await repo).findFirst();
     let result = await axios.get(path + "/" + task.id);
@@ -60,13 +79,18 @@ fit("test http 404", async () => {
     }
     expect(error.response.status).toBe(404);
 });
-fit("test http 201", async () => {
+test("test http 201", async () => {
     let result = await axios.post(path, { title: "z", id: "" });
     expect(result.data.title).toBe("z");
     expect(result.status).toBe(201);
     result = await axios.delete(path + "/" + result.data.id);
     expect(result.status).toBe(204);
 });
+test("test regular api call", async () => {
+    await create3Tasks();
+    let result = await axios.get(Remult.apiBaseUrl + "/test");
+    expect(result.data.result).toBe(3);
+});
 let Task = class Task {
     constructor() {
         this.title = '';

package/esm/src/remult3/RepositoryImplementation.js

@@ -3,7 +3,7 @@ import { allEntities, Remult, isBackend, queryConfig as queryConfig, setControll
 import { entityFilterToJson, Filter } from "../filter/filter-interfaces";
 import { Sort } from "../sort";
 import { v4 as uuid } from 'uuid';
-import { ValueConverters } from "../../valueConverters";
+import { ValueConverters } from "../valueConverters";
 import { filterHelper } from "../filter/filter-interfaces";
 import { assign } from "../../assign";
 let classValidatorValidate = undefined;

package/esm/src/server-action.js

@@ -46,7 +46,7 @@ export class Action {
                 res.success(r);
             }
             catch (err) {
-                if (err instanceof ForbiddenError)
+                if (err.isForbiddenError) // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
                     res.forbidden();
                 else
                     res.error(err);
@@ -58,6 +58,7 @@ Action.apiUrlForJobStatus = 'jobStatusInQueue';
 class ForbiddenError extends Error {
     constructor() {
         super("Forbidden");
+        this.isForbiddenError = true;
     }
 }
 export class myServerAction extends Action {

package/esm/src/valueConverters.d.ts

@@ -0,0 +1,12 @@
+import { ValueConverter } from "./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/src/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'
+};

package/index.d.ts

@@ -19,4 +19,4 @@ export { Filter } from './src/filter/filter-interfaces';
 export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
-export { ValueConverters } from './valueConverters';
+export { ValueConverters } from './src/valueConverters';

package/index.js

@@ -55,5 +55,5 @@ var urlBuilder_1 = require("./urlBuilder");
 Object.defineProperty(exports, "UrlBuilder", { enumerable: true, get: function () { return urlBuilder_1.UrlBuilder; } });
 var validators_1 = require("./src/validators");
 Object.defineProperty(exports, "Validators", { enumerable: true, get: function () { return validators_1.Validators; } });
-var valueConverters_1 = require("./valueConverters");
+var valueConverters_1 = require("./src/valueConverters");
 Object.defineProperty(exports, "ValueConverters", { enumerable: true, get: function () { return valueConverters_1.ValueConverters; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.14.21",
+    "version": "0.14.24",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -32,9 +32,29 @@
             "require": "./remult-middleware.js",
             "import": "./esm/remult-middleware.js"
         },
+        "./remult-fastify": {
+            "require": "./remult-fastify.js",
+            "import": "./esm/remult-fastify.js"
+        },
+        "./postgres": {
+            "require": "./postgres/index.js",
+            "import": "./esm/postgres/index.js"
+        },
         "./postgres/schema-builder": {
             "require": "./postgres/schema-builder.js",
             "import": "./esm/postgres/schema-builder.js"
+        },
+        "./remult-knex": {
+            "require": "./remult-knex/index.js",
+            "import": "./esm/remult-knex/index.js"
+        },
+        "./remult-mongo": {
+            "require": "./remult-mongo.js",
+            "import": "./esm/remult-mongo.js"
+        },
+        "./graphql": {
+            "require": "./graphql.js",
+            "import": "./esm/graphql.js"
         }
     }
 }

package/postgres/schema-builder.js

@@ -5,7 +5,7 @@ var tslib_1 = require("tslib");
 var context_1 = require("../src/context");
 var filter_consumer_bridge_to_sql_request_1 = require("../src/filter/filter-consumer-bridge-to-sql-request");
 var remult3_1 = require("../src/remult3");
-var valueConverters_1 = require("../valueConverters");
+var valueConverters_1 = require("../src/valueConverters");
 function postgresColumnSyntax(x, dbName) {
     var result = dbName;
     if (x.valueType == Number) {

package/remult-express.d.ts

@@ -2,4 +2,10 @@ import { RemultMiddlewareOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultMiddlewareOptions & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): import("./server/expressBridge").RemultExpressBridge;
+}): import("express-serve-static-core").Router & {
+    getRemult: (req: any) => Promise<import(".").Remult>;
+    openApiDoc: (options: {
+        title: string;
+    }) => any;
+    addArea: (x: any) => any;
+};

package/remult-express.js

@@ -15,6 +15,11 @@ function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    return expressBridge_1.remultMiddlewareBase(app, options);
+    var server = expressBridge_1.buildRemultServer(app, options);
+    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); }
+    });
 }
 exports.remultExpress = remultExpress;

package/remult-fastify.d.ts

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

package/remult-fastify.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultFastify = void 0;
+var tslib_1 = require("tslib");
+var expressBridge_1 = require("./server/expressBridge");
+function remultFastify(options) {
+    var _this = this;
+    function fastifyHandler(handler) {
+        var response = function (req, res) {
+            var myRes = {
+                status: function (statusCode) {
+                    res.status(statusCode);
+                    return myRes;
+                },
+                end: function () {
+                    res.send();
+                },
+                json: function (data) {
+                    res.send(data);
+                }
+            };
+            handler(req, myRes, function () { });
+        };
+        return response;
+    }
+    var api;
+    var pluginFunction = function (instance, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var fastifyRouter;
+        return tslib_1.__generator(this, function (_a) {
+            fastifyRouter = {
+                route: function (path) {
+                    var r = {
+                        delete: function (handler) {
+                            instance.delete(path, fastifyHandler(handler));
+                            return r;
+                        },
+                        get: function (handler) {
+                            instance.get(path, fastifyHandler(handler));
+                            return r;
+                        }, post: function (handler) {
+                            instance.post(path, fastifyHandler(handler));
+                            return r;
+                        }, put: function (handler) {
+                            instance.put(path, fastifyHandler(handler));
+                            return r;
+                        },
+                    };
+                    return r;
+                },
+            };
+            api = expressBridge_1.buildRemultServer(fastifyRouter, options);
+            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); }
+    });
+}
+exports.remultFastify = remultFastify;

package/remult-knex/index.js

@@ -7,7 +7,7 @@ var filter_interfaces_1 = require("../src/filter/filter-interfaces");
 var filter_consumer_bridge_to_sql_request_1 = require("../src/filter/filter-consumer-bridge-to-sql-request");
 var context_1 = require("../src/context");
 var remult3_1 = require("../src/remult3");
-var valueConverters_1 = require("../valueConverters");
+var valueConverters_1 = require("../src/valueConverters");
 var column_1 = require("../src/column");
 var KnexDataProvider = /** @class */ (function () {
     function KnexDataProvider(knex) {

package/remult-middleware.d.ts

@@ -1,2 +1,8 @@
 import { RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): ((req: any, res: any, next: any) => void) & {
+    getRemult: (req: any) => Promise<import(".").Remult>;
+    openApiDoc: (options: {
+        title: string;
+    }) => any;
+    addArea: (x: any) => any;
+};

package/remult-middleware.js

@@ -4,10 +4,12 @@ exports.remultMiddleware = void 0;
 var expressBridge_1 = require("./server/expressBridge");
 function remultMiddleware(options) {
     var m = new middleware();
-    var app = Object.assign(function (req, res, next) { return m.handleRequest(req, res, next); }, {
-        route: function (path) { return m.route(path); }
+    var server = expressBridge_1.buildRemultServer(m, options);
+    return Object.assign(function (req, res, next) { return m.handleRequest(req, res, next); }, {
+        getRemult: function (req) { return server.getRemult(req); },
+        openApiDoc: function (options) { return server.openApiDoc(options); },
+        addArea: function (x) { return server.addArea(x); }
     });
-    return expressBridge_1.remultMiddlewareBase(app, options);
 }
 exports.remultMiddleware = remultMiddleware;
 var middleware = /** @class */ (function () {

package/server/expressBridge.d.ts

@@ -1,7 +1,7 @@
 import { queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
 import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
-import { AllowedForInstance, Remult } from '../src/context';
+import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
@@ -22,20 +22,34 @@ export declare type RemultMiddlewareOptions = {
     bodyParser?: boolean;
     rootPath?: string;
 };
-export declare function remultMiddlewareBase(app: GenericRouter, options: RemultMiddlewareOptions): RemultExpressBridge;
-export interface RemultExpressBridge extends GenericRequestHandler {
+export declare function buildRemultServer(app: GenericRouter, options: RemultMiddlewareOptions): RemultServer;
+export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
+export interface RemultExpressBridge extends GenericRequestHandler, RemultServer {
+}
+export interface RemultServer {
     getRemult(req: GenericRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
     }): any;
     addArea(rootUrl: string): any;
 }
+export declare type GenericRouter = {
+    route(path: string): SpecificRoute;
+};
+export declare type SpecificRoute = {
+    get(handler: GenericRequestHandler): SpecificRoute;
+    put(handler: GenericRequestHandler): SpecificRoute;
+    post(handler: GenericRequestHandler): SpecificRoute;
+    delete(handler: GenericRequestHandler): SpecificRoute;
+};
 export interface GenericRequest {
     url: string;
     method?: any;
     body?: any;
     query?: any;
     params?: any;
+    user?: UserInfo;
+    auth?: UserInfo;
 }
 export interface GenericResponse {
     json(data: any): any;
@@ -43,16 +57,6 @@ export interface GenericResponse {
     setStatus?(statusCode: number): GenericResponse;
     end(): any;
 }
-export declare type GenericRouter = GenericRequestHandler & {
-    route(path: string): SpecificRoute;
-};
-export declare type SpecificRoute = {
-    get(handler: GenericRequestHandler): SpecificRoute;
-    put(handler: GenericRequestHandler): SpecificRoute;
-    post(handler: GenericRequestHandler): SpecificRoute;
-    delete(handler: GenericRequestHandler): SpecificRoute;
-};
-export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 declare class ExpressBridge {
     private app;
     queue: inProcessQueueHandler;

package/server/expressBridge.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.ExpressRequestBridgeToDataApiRequest = exports.SiteArea = exports.remultMiddlewareBase = void 0;
+exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.ExpressRequestBridgeToDataApiRequest = exports.SiteArea = exports.buildRemultServer = void 0;
 var tslib_1 = require("tslib");
 var register_actions_on_server_1 = require("./register-actions-on-server");
 var register_entities_on_server_1 = require("./register-entities-on-server");
@@ -11,7 +11,7 @@ var context_1 = require("../src/context");
 var remult3_1 = require("../src/remult3");
 var json_data_provider_1 = require("../src/data-providers/json-data-provider");
 var id_entity_1 = require("../src/id-entity");
-function remultMiddlewareBase(app, options) {
+function buildRemultServer(app, options) {
     var _this = this;
     if (!options) {
         options = {};
@@ -64,13 +64,9 @@ function remultMiddlewareBase(app, options) {
         register_actions_on_server_1.registerActionsOnServer(apiArea, actions);
         register_entities_on_server_1.registerEntitiesOnServer(apiArea, options.entities);
     }
-    return Object.assign(app, {
-        getRemult: function (req) { return bridge.getRemult(req); },
-        openApiDoc: function (options) { return bridge.openApiDoc(options); },
-        addArea: function (x) { return bridge.addArea(x); }
-    });
+    return bridge;
 }
-exports.remultMiddlewareBase = remultMiddlewareBase;
+exports.buildRemultServer = buildRemultServer;
 ;
 var ExpressBridge = /** @class */ (function () {
     function ExpressBridge(app, queue, initRequest, dataProvider) {

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

@@ -6,9 +6,51 @@ var axios_1 = require("axios");
 var context_1 = require("../context");
 var remult3_1 = require("../remult3");
 var server_action_1 = require("../server-action");
-context_1.Remult.apiBaseUrl = 'http://localhost:3001/api';
+context_1.Remult.apiBaseUrl = 'http://localhost:3003/api';
 var path = context_1.Remult.apiBaseUrl + '/tasks';
-fit("works", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+var environments = [
+    ["next", 3000],
+    ["nest", 3001],
+    ["koa", 3002],
+    ["fastify", 3003],
+    ["express", 3004],
+    ["middleware", 3005],
+];
+function test(name, test) {
+    var e_1, _a;
+    var _this = this;
+    var _loop_1 = function (env, port) {
+        var theTest = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        context_1.Remult.apiBaseUrl = "http://localhost:" + port + "/api";
+                        path = context_1.Remult.apiBaseUrl + '/tasks';
+                        return [4 /*yield*/, test()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        var testName = env + (" " + port + ": " + name);
+        fit(testName, theTest);
+    };
+    try {
+        for (var environments_1 = tslib_1.__values(environments), environments_1_1 = environments_1.next(); !environments_1_1.done; environments_1_1 = environments_1.next()) {
+            var _b = tslib_1.__read(environments_1_1.value, 2), env = _b[0], port = _b[1];
+            _loop_1(env, port);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (environments_1_1 && !environments_1_1.done && (_a = environments_1.return)) _a.call(environments_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+test("works", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var repo, tasks, _a;
     return tslib_1.__generator(this, function (_b) {
         switch (_b.label) {
@@ -30,7 +72,7 @@ fit("works", function () { return tslib_1.__awaiter(void 0, void 0, void 0, func
         }
     });
 }); });
-fit("test multiple items", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+test("test multiple items", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var repo, _a;
     return tslib_1.__generator(this, function (_b) {
         switch (_b.label) {
@@ -47,7 +89,7 @@ fit("test multiple items", function () { return tslib_1.__awaiter(void 0, void 0
         }
     });
 }); });
-fit("validation", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+test("validation", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var r, err, error_1;
     return tslib_1.__generator(this, function (_a) {
         switch (_a.label) {
@@ -78,7 +120,7 @@ fit("validation", function () { return tslib_1.__awaiter(void 0, void 0, void 0,
         }
     });
 }); });
-fit("forbidden", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+test("forbidden", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var err, error_2;
     return tslib_1.__generator(this, function (_a) {
         switch (_a.label) {
@@ -101,7 +143,7 @@ fit("forbidden", function () { return tslib_1.__awaiter(void 0, void 0, void 0,
         }
     });
 }); });
-fit("test http 404", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+test("test http 404", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var repo, task, result, error, err_1;
     return tslib_1.__generator(this, function (_a) {
         switch (_a.label) {
@@ -134,7 +176,7 @@ fit("test http 404", function () { return tslib_1.__awaiter(void 0, void 0, void
         }
     });
 }); });
-fit("test http 201", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+test("test http 201", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var result;
     return tslib_1.__generator(this, function (_a) {
         switch (_a.label) {
@@ -151,6 +193,21 @@ fit("test http 201", function () { return tslib_1.__awaiter(void 0, void 0, void
         }
     });
 }); });
+test("test regular api call", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, axios_1.default.get(context_1.Remult.apiBaseUrl + "/test")];
+            case 2:
+                result = _a.sent();
+                expect(result.data.result).toBe(3);
+                return [2 /*return*/];
+        }
+    });
+}); });
 var Task = /** @class */ (function () {
     function Task() {
         this.title = '';
@@ -188,8 +245,8 @@ var Task = /** @class */ (function () {
 exports.Task = Task;
 function create3Tasks() {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var remult, taskRepo, _a, _b, task, e_1_1, _c, _d;
-        var e_1, _e;
+        var remult, taskRepo, _a, _b, task, e_2_1, _c, _d;
+        var e_2, _e;
         return tslib_1.__generator(this, function (_f) {
             switch (_f.label) {
                 case 0:
@@ -215,14 +272,14 @@ function create3Tasks() {
                     return [3 /*break*/, 3];
                 case 6: return [3 /*break*/, 9];
                 case 7:
-                    e_1_1 = _f.sent();
-                    e_1 = { error: e_1_1 };
+                    e_2_1 = _f.sent();
+                    e_2 = { error: e_2_1 };
                     return [3 /*break*/, 9];
                 case 8:
                     try {
                         if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
                     }
-                    finally { if (e_1) throw e_1.error; }
+                    finally { if (e_2) throw e_2.error; }
                     return [7 /*endfinally*/];
                 case 9:
                     _c = expect;

package/src/remult3/RepositoryImplementation.js

@@ -7,7 +7,7 @@ var context_1 = require("../context");
 var filter_interfaces_1 = require("../filter/filter-interfaces");
 var sort_1 = require("../sort");
 var uuid_1 = require("uuid");
-var valueConverters_1 = require("../../valueConverters");
+var valueConverters_1 = require("../valueConverters");
 var filter_interfaces_2 = require("../filter/filter-interfaces");
 var assign_1 = require("../../assign");
 var classValidatorValidate = undefined;

package/src/server-action.js

@@ -81,7 +81,7 @@ var Action = /** @class */ (function () {
                         return [3 /*break*/, 3];
                     case 2:
                         err_1 = _a.sent();
-                        if (err_1 instanceof ForbiddenError)
+                        if (err_1.isForbiddenError) // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
                             res.forbidden();
                         else
                             res.error(err_1);
@@ -98,7 +98,9 @@ exports.Action = Action;
 var ForbiddenError = /** @class */ (function (_super) {
     tslib_1.__extends(ForbiddenError, _super);
     function ForbiddenError() {
-        return _super.call(this, "Forbidden") || this;
+        var _this = _super.call(this, "Forbidden") || this;
+        _this.isForbiddenError = true;
+        return _this;
     }
     return ForbiddenError;
 }(Error));

package/src/valueConverters.d.ts

@@ -0,0 +1,12 @@
+import { ValueConverter } from "./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/src/valueConverters.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueConverters = void 0;
+var tslib_1 = require("tslib");
+var inputTypes_1 = require("../inputTypes");
+var ValueConverters = /** @class */ (function () {
+    function ValueConverters() {
+    }
+    ValueConverters.Date = {
+        toJson: function (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: function (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: function (x) { return x; },
+        fromDb: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.Date.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Date.toJson(x); },
+        displayValue: function (val) {
+            if (!val)
+                return '';
+            return val.toLocaleString();
+        }
+    };
+    ValueConverters.DateOnly = {
+        fromInput: function (x) { return ValueConverters.DateOnly.fromJson(x); },
+        toInput: function (x) { return ValueConverters.DateOnly.toJson(x); },
+        toJson: function (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: function (value) {
+            if (!value || value == '' || value == '0000-00-00')
+                return null;
+            var d = new Date(Date.parse(value));
+            d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
+            return d;
+        },
+        inputType: inputTypes_1.InputTypes.date,
+        toDb: function (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: function (val) {
+            var d = val;
+            if (!d)
+                return null;
+            return val;
+        },
+        fieldTypeInDb: 'date',
+        displayValue: function (value) {
+            if (!value)
+                return '';
+            return value.toLocaleDateString(undefined);
+        }
+    };
+    ValueConverters.DateOnlyString = tslib_1.__assign(tslib_1.__assign({}, ValueConverters.DateOnly), { toDb: function (d) {
+            var val = ValueConverters.DateOnly.toJson(d);
+            if (!val)
+                return undefined;
+            return val.replace(/-/g, '');
+        }, fromDb: function (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: function (val) { return val; },
+        inputType: inputTypes_1.InputTypes.checkbox,
+        fromDb: function (value) {
+            return ValueConverters.Boolean.fromJson(value);
+        },
+        fromJson: function (value) {
+            if (typeof value === "boolean")
+                return value;
+            if (value !== undefined && value !== null) {
+                return value.toString().trim().toLowerCase() == 'true';
+            }
+            return value;
+        },
+        toJson: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.Boolean.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Boolean.toJson(x); }
+    };
+    ValueConverters.Number = {
+        fromDb: function (value) {
+            if (value === null)
+                return null;
+            if (value !== undefined)
+                return +value;
+            return undefined;
+        },
+        toDb: function (value) { return value; },
+        fromJson: function (value) { return ValueConverters.Number.fromDb(value); },
+        toJson: function (value) { return ValueConverters.Number.toDb(value); },
+        fromInput: function (x, type) {
+            var r = +x;
+            if (!x)
+                return undefined;
+            return r;
+        },
+        toInput: function (x, type) {
+            return x === null || x === void 0 ? void 0 : x.toString();
+        },
+        inputType: inputTypes_1.InputTypes.number
+    };
+    ValueConverters.Integer = tslib_1.__assign(tslib_1.__assign({}, ValueConverters.Number), { toJson: function (value) {
+            var val = ValueConverters.Number.toDb(value);
+            if (!val)
+                return val;
+            return +(+val).toFixed(0);
+        }, toDb: function (value) { return ValueConverters.Integer.toJson(value); }, fieldTypeInDb: 'integer' });
+    ValueConverters.Default = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return ValueConverters.JsonString.fromDb(x); },
+        toDb: function (x) { return ValueConverters.JsonString.toDb(x); },
+        fromInput: function (x) { return ValueConverters.Default.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Default.toJson(x); }
+    };
+    ValueConverters.JsonString = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined; },
+        toDb: function (x) { return x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined; },
+        fromInput: function (x) { return ValueConverters.JsonString.fromJson(x); },
+        toInput: function (x) { return ValueConverters.JsonString.toJson(x); }
+    };
+    ValueConverters.JsonValue = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return x; },
+        toDb: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.JsonString.fromJson(x); },
+        toInput: function (x) { return ValueConverters.JsonString.toJson(x); },
+        fieldTypeInDb: 'json'
+    };
+    return ValueConverters;
+}());
+exports.ValueConverters = ValueConverters;