remult 0.16.3-exp.4 → 0.16.3

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-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/expressBridge.d.ts

@@ -59,6 +59,8 @@ export interface GenericResponse {
 }
 export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
+    static enable(): void;
+    static disable(): void;
     constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
     run(remult: Remult, callback: VoidFunction): void;
     getRemult(): Remult;

package/esm/server/expressBridge.js

@@ -30,6 +30,7 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
+    RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
@@ -63,6 +64,18 @@ export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
+    static enable() {
+        remult.remultFactory = () => {
+            const r = RemultAsyncLocalStorage.instance.getRemult();
+            if (r)
+                return r;
+            else
+                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+        };
+    }
+    static disable() {
+        remult.resetFactory();
+    }
     run(remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -71,19 +84,12 @@ export class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw new Error("can't use static remult in this environment, `async_hooks` were not found");
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
         return this.remultObjectStorage.getStore();
     }
 }
 RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
-remult.remultFactory = () => {
-    const r = RemultAsyncLocalStorage.instance.getRemult();
-    if (r)
-        return r;
-    else
-        throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-};
 class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;

package/esm/server/initAsyncHooks.js

@@ -2,7 +2,6 @@ import { AsyncLocalStorage } from 'async_hooks';
 import { RemultAsyncLocalStorage } from './expressBridge';
 let init = false;
 export function initAsyncHooks() {
-    return;
     if (init)
         return;
     init = true;

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/my-test.backend-spec.js

@@ -1,8 +1,12 @@
+import { Remult } from "../context";
 import { KnexDataProvider } from '../../remult-knex';
 import { config } from 'dotenv';
 import { testKnexPGSqlImpl, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
 import { entityWithValidations } from "../shared-tests/entityWithValidations";
 import { SqlDatabase } from "../data-providers/sql-database";
+import { RemultAsyncLocalStorage } from "../../server/expressBridge";
+import { initAsyncHooks } from "../../server/initAsyncHooks";
+import { remult } from "../remult-proxy";
 config();
 testPostgresImplementation("default order by", async ({ createEntity }) => {
     let s = await entityWithValidations.create4RowsInDp(createEntity);
@@ -57,3 +61,47 @@ testKnexPGSqlImpl("knex filter2", async ({ createEntity }) => {
         }
     })).length).toBe(3);
 }, false);
+it("test async hooks and static remult", async () => {
+    let gotException = true;
+    try {
+        RemultAsyncLocalStorage.instance.getRemult();
+        gotException = false;
+    }
+    catch { }
+    expect(gotException).toBe(true);
+    initAsyncHooks();
+    expect(RemultAsyncLocalStorage.instance.getRemult()).toBe(undefined);
+    RemultAsyncLocalStorage.enable();
+    try {
+        remult.isAllowed(false);
+        gotException = false;
+    }
+    catch { }
+    expect(gotException).toBe(true);
+    const promises = [];
+    RemultAsyncLocalStorage.instance.run(new Remult(), () => {
+        remult.user = { id: 'noam' };
+        promises.push(new Promise(res => {
+            setTimeout(() => {
+                expect(remult.user.id).toBe('noam');
+                res({});
+            }, 10);
+        }));
+        RemultAsyncLocalStorage.instance.run(new Remult(), () => {
+            remult.user = { id: 'yoni' };
+            promises.push(new Promise(res => {
+                setTimeout(() => {
+                    expect(remult.user.id).toBe('yoni');
+                    res({});
+                }, 10);
+            }));
+        });
+        promises.push(new Promise(res => {
+            setTimeout(() => {
+                expect(remult.user.id).toBe('noam');
+                res({});
+            }, 10);
+        }));
+    });
+    await Promise.all(promises);
+});

package/esm/src/remult-proxy.js

@@ -31,6 +31,10 @@ export class RemultProxy {
     clearAllCache() {
         return this.remultFactory().clearAllCache();
     }
+    /*@internal*/
+    resetFactory() {
+        this.remultFactory = () => defaultRemult;
+    }
     get user() {
         return this.remultFactory().user;
     }

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'
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.16.3-exp.4",
+    "version": "0.16.3",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",

package/postgres/postgresColumnSyntax.d.ts

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

package/postgres/postgresColumnSyntax.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postgresColumnSyntax = void 0;
+var valueConverters_1 = require("../valueConverters");
+function postgresColumnSyntax(x, dbName) {
+    var 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_1.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;
+}
+exports.postgresColumnSyntax = postgresColumnSyntax;

package/remult-middleware.d.ts

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

package/remult-middleware.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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); }
+    });
+    return expressBridge_1.remultMiddlewareBase(app, options);
+}
+exports.remultMiddleware = remultMiddleware;
+var middleware = /** @class */ (function () {
+    function middleware() {
+        this.map = new Map();
+    }
+    middleware.prototype.route = function (path) {
+        //consider using:
+        //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
+        //* https://github.com/pillarjs/path-to-regexp
+        var r = path.toLowerCase();
+        var m = new Map();
+        this.map.set(r, m);
+        var route = {
+            get: function (h) {
+                m.set("get", h);
+                return route;
+            },
+            put: function (h) {
+                m.set("put", h);
+                return route;
+            },
+            post: function (h) {
+                m.set("post", h);
+                return route;
+            },
+            delete: function (h) {
+                m.set("delete", h);
+                return route;
+            }
+        };
+        return route;
+    };
+    middleware.prototype.handleRequest = function (req, res, next) {
+        var lowerPath = req.path.toLowerCase();
+        var m = this.map.get(lowerPath);
+        if (m) {
+            var h = m.get(req.method.toLowerCase());
+            if (h) {
+                h(req, res, next);
+                return;
+            }
+        }
+        var idPosition = req.path.lastIndexOf('/');
+        if (idPosition >= 0) {
+            lowerPath = req.path.substring(0, idPosition) + '/:id';
+            m = this.map.get(lowerPath);
+            if (m) {
+                var h = m.get(req.method.toLowerCase());
+                if (h) {
+                    req.params.id = req.path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        next();
+    };
+    return middleware;
+}());

package/server/expressBridge.d.ts

@@ -59,6 +59,8 @@ export interface GenericResponse {
 }
 export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
+    static enable(): void;
+    static disable(): void;
     constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
     run(remult: Remult, callback: VoidFunction): void;
     getRemult(): Remult;

package/server/expressBridge.js

@@ -40,6 +40,7 @@ function createRemultServer(options) {
             }
         });
     }); });
+    RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var remult;
@@ -90,6 +91,18 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
     function RemultAsyncLocalStorage(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
+    RemultAsyncLocalStorage.enable = function () {
+        remult_proxy_1.remult.remultFactory = function () {
+            var r = RemultAsyncLocalStorage.instance.getRemult();
+            if (r)
+                return r;
+            else
+                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+        };
+    };
+    RemultAsyncLocalStorage.disable = function () {
+        remult_proxy_1.remult.resetFactory();
+    };
     RemultAsyncLocalStorage.prototype.run = function (remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -98,7 +111,7 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
     };
     RemultAsyncLocalStorage.prototype.getRemult = function () {
         if (!this.remultObjectStorage) {
-            throw new Error("can't use static remult in this environment, `async_hooks` were not found");
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
         return this.remultObjectStorage.getStore();
     };
@@ -106,13 +119,6 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
     return RemultAsyncLocalStorage;
 }());
 exports.RemultAsyncLocalStorage = RemultAsyncLocalStorage;
-remult_proxy_1.remult.remultFactory = function () {
-    var r = RemultAsyncLocalStorage.instance.getRemult();
-    if (r)
-        return r;
-    else
-        throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-};
 var RemultServerImplementation = /** @class */ (function () {
     function RemultServerImplementation(queue, options, dataProvider) {
         this.queue = queue;

package/server/initAsyncHooks.js

@@ -5,7 +5,6 @@ var async_hooks_1 = require("async_hooks");
 var expressBridge_1 = require("./expressBridge");
 var init = false;
 function initAsyncHooks() {
-    return;
     if (init)
         return;
     init = true;

package/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/server/register-actions-on-server.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerActionsOnServer = void 0;
+var tslib_1 = require("tslib");
+var server_action_1 = require("../src/server-action");
+function registerActionsOnServer(area, controllers) {
+    var e_1, _a, e_2, _b;
+    var addAction = function (a) {
+        var x = a[server_action_1.serverActionField];
+        if (!x) {
+            throw 'failed to set server action, did you forget the BackendMethod Decorator?';
+        }
+        area.addAction(x);
+    };
+    server_action_1.actionInfo.runningOnServer = true;
+    if (controllers && controllers.length > 0) {
+        try {
+            for (var controllers_1 = tslib_1.__values(controllers), controllers_1_1 = controllers_1.next(); !controllers_1_1.done; controllers_1_1 = controllers_1.next()) {
+                var c = controllers_1_1.value;
+                var z = c[server_action_1.classBackendMethodsArray];
+                if (z)
+                    try {
+                        for (var z_1 = (e_2 = void 0, tslib_1.__values(z)), z_1_1 = z_1.next(); !z_1_1.done; z_1_1 = z_1.next()) {
+                            var a = z_1_1.value;
+                            addAction(a);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (z_1_1 && !z_1_1.done && (_b = z_1.return)) _b.call(z_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (controllers_1_1 && !controllers_1_1.done && (_a = controllers_1.return)) _a.call(controllers_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    else
+        server_action_1.actionInfo.allActions.forEach(function (a) {
+            addAction(a);
+        });
+}
+exports.registerActionsOnServer = registerActionsOnServer;

package/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/server/register-entities-on-server.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEntitiesOnServer = void 0;
+var remult3_1 = require("../src/remult3");
+var context_1 = require("../src/context");
+var data_api_1 = require("../src/data-api");
+function registerEntitiesOnServer(area, entities) {
+    if (!entities)
+        entities = context_1.allEntities;
+    //add Api Entries
+    entities.forEach(function (e) {
+        var key = remult3_1.getEntityKey(e);
+        if (key != undefined)
+            area.add(key, function (c) {
+                return new data_api_1.DataApi(c.repo(e), c);
+            });
+    });
+}
+exports.registerEntitiesOnServer = registerEntitiesOnServer;

package/src/backend-tests/my-test.backend-spec.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
+var context_1 = require("../context");
 var remult_knex_1 = require("../../remult-knex");
 var dotenv_1 = require("dotenv");
 var backend_database_test_setup_backend_spec_1 = require("./backend-database-test-setup.backend-spec");
 var entityWithValidations_1 = require("../shared-tests/entityWithValidations");
 var sql_database_1 = require("../data-providers/sql-database");
+var expressBridge_1 = require("../../server/expressBridge");
+var initAsyncHooks_1 = require("../../server/initAsyncHooks");
+var remult_proxy_1 = require("../remult-proxy");
 dotenv_1.config();
 backend_database_test_setup_backend_spec_1.testPostgresImplementation("default order by", function (_a) {
     var createEntity = _a.createEntity;
@@ -158,3 +162,56 @@ backend_database_test_setup_backend_spec_1.testKnexPGSqlImpl("knex filter2", fun
         });
     });
 }, false);
+it("test async hooks and static remult", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var gotException, promises;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                gotException = true;
+                try {
+                    expressBridge_1.RemultAsyncLocalStorage.instance.getRemult();
+                    gotException = false;
+                }
+                catch (_b) { }
+                expect(gotException).toBe(true);
+                initAsyncHooks_1.initAsyncHooks();
+                expect(expressBridge_1.RemultAsyncLocalStorage.instance.getRemult()).toBe(undefined);
+                expressBridge_1.RemultAsyncLocalStorage.enable();
+                try {
+                    remult_proxy_1.remult.isAllowed(false);
+                    gotException = false;
+                }
+                catch (_c) { }
+                expect(gotException).toBe(true);
+                promises = [];
+                expressBridge_1.RemultAsyncLocalStorage.instance.run(new context_1.Remult(), function () {
+                    remult_proxy_1.remult.user = { id: 'noam' };
+                    promises.push(new Promise(function (res) {
+                        setTimeout(function () {
+                            expect(remult_proxy_1.remult.user.id).toBe('noam');
+                            res({});
+                        }, 10);
+                    }));
+                    expressBridge_1.RemultAsyncLocalStorage.instance.run(new context_1.Remult(), function () {
+                        remult_proxy_1.remult.user = { id: 'yoni' };
+                        promises.push(new Promise(function (res) {
+                            setTimeout(function () {
+                                expect(remult_proxy_1.remult.user.id).toBe('yoni');
+                                res({});
+                            }, 10);
+                        }));
+                    });
+                    promises.push(new Promise(function (res) {
+                        setTimeout(function () {
+                            expect(remult_proxy_1.remult.user.id).toBe('noam');
+                            res({});
+                        }, 10);
+                    }));
+                });
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });

package/src/remult-proxy.js

@@ -60,6 +60,10 @@ var RemultProxy = /** @class */ (function () {
     RemultProxy.prototype.clearAllCache = function () {
         return this.remultFactory().clearAllCache();
     };
+    /*@internal*/
+    RemultProxy.prototype.resetFactory = function () {
+        this.remultFactory = function () { return defaultRemult; };
+    };
     Object.defineProperty(RemultProxy.prototype, "user", {
         get: function () {
             return this.remultFactory().user;

package/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/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;