remult 0.16.3-exp.4 → 0.16.4

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/src/shared-tests/db-tests-setup.d.ts

@@ -6,7 +6,7 @@ import { CategoriesForTesting } from "../tests/remult-3-entities";
 import { Status } from "../tests/testModel/models";
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
 export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature): dbTestMethodSignature;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare type dbTestWhatSignature = (db: {
     db: DataProvider;

package/esm/src/shared-tests/db-tests-setup.js

@@ -22,6 +22,7 @@ export function addDatabaseToTest(tester) {
         test(tester);
     }
     databasesTesters.push(tester);
+    return tester;
 }
 export function testInMemory(key, what, focus = false) {
     itWithFocus(key + " - in memory", async () => {

package/esm/src/valueConverters.js

@@ -100,6 +100,8 @@ ValueConverters.Boolean = {
     fromJson: value => {
         if (typeof value === "boolean")
             return value;
+        if (value === 1)
+            return true;
         if (value !== undefined && value !== null) {
             return value.toString().trim().toLowerCase() == 'true';
         }

package/package.json

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

package/remult-knex/index.js

@@ -257,7 +257,7 @@ var KnexEntityDataProvider = /** @class */ (function () {
     };
     KnexEntityDataProvider.prototype.insert = function (data) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, resultFilter, insertObject, _a, _b, x, v, key, e_3_1, insert, result, newId_1;
+            var e, resultFilter, insertObject, _a, _b, x, v, key, e_3_1, insert, newId_1, result, result;
             var e_3, _c;
             var _this = this;
             return tslib_1.__generator(this, function (_d) {
@@ -304,18 +304,26 @@ var KnexEntityDataProvider = /** @class */ (function () {
                         return [7 /*endfinally*/];
                     case 10:
                         insert = this.knex(e.entityName).insert(insertObject);
-                        if (!remult3_1.isAutoIncrement(this.entity.idMetadata.field)) return [3 /*break*/, 12];
-                        return [4 /*yield*/, insert.returning(this.entity.idMetadata.field.key)];
+                        if (!remult3_1.isAutoIncrement(this.entity.idMetadata.field)) return [3 /*break*/, 15];
+                        if (!(this.knex.client.config.client === 'mysql2')) return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.knex(e.entityName).insert(insertObject, this.entity.idMetadata.field.key)];
                     case 11:
                         result = _d.sent();
-                        newId_1 = result[0].id;
-                        resultFilter = new filter_interfaces_1.Filter(function (x) { return x.isEqualTo(_this.entity.idMetadata.field, newId_1); });
+                        newId_1 = result[0];
                         return [3 /*break*/, 14];
-                    case 12: return [4 /*yield*/, insert];
+                    case 12: return [4 /*yield*/, insert.returning(this.entity.idMetadata.field.key)];
                     case 13:
-                        _d.sent();
+                        result = _d.sent();
+                        newId_1 = result[0].id;
                         _d.label = 14;
-                    case 14: return [2 /*return*/, this.find({ where: resultFilter }).then(function (y) {
+                    case 14:
+                        resultFilter = new filter_interfaces_1.Filter(function (x) { return x.isEqualTo(_this.entity.idMetadata.field, newId_1); });
+                        return [3 /*break*/, 17];
+                    case 15: return [4 /*yield*/, insert];
+                    case 16:
+                        _d.sent();
+                        _d.label = 17;
+                    case 17: return [2 /*return*/, this.find({ where: resultFilter }).then(function (y) {
                             return y[0];
                         })];
                 }

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/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -1,5 +1,6 @@
 import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
 export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
 export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 import '../shared-tests';

package/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testMongo = exports.testPostgresImplementation = exports.testKnexPGSqlImpl = void 0;
+exports.testMongo = exports.testPostgresImplementation = exports.mySqlTest = exports.testKnexPGSqlImpl = void 0;
 var tslib_1 = require("tslib");
 var context_1 = require("../context");
 var remult_knex_1 = require("../../remult-knex");
@@ -87,6 +87,16 @@ if (true)
             filename: ":memory:"
         },
     }), "sqlite3"));
+exports.mySqlTest = db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    client: 'mysql2',
+    connection: {
+        user: 'root',
+        password: 'MASTERKEY',
+        host: '127.0.0.1',
+        database: 'test'
+    }
+    //debug: true
+}), "mysql2"));
 var pg = postgres_1.createPostgresConnection({
     autoCreateTables: false
 });

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/live-query/EventSourceLiveQuery.d.ts

@@ -0,0 +1,5 @@
+import { LiveQueryClient } from './LiveQuery';
+export declare class EventSourceLiveQuery extends LiveQueryClient {
+    private wrapMessage?;
+    constructor(wrapMessage?: (what: () => void) => void);
+}

package/src/live-query/EventSourceLiveQuery.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceLiveQuery = void 0;
+var tslib_1 = require("tslib");
+var LiveQuery_1 = require("./LiveQuery");
+var fetch_event_source_1 = require("@microsoft/fetch-event-source");
+var remult_proxy_1 = require("../remult-proxy");
+var EventSourceLiveQuery = /** @class */ (function (_super) {
+    tslib_1.__extends(EventSourceLiveQuery, _super);
+    function EventSourceLiveQuery(wrapMessage) {
+        var _this = _super.call(this, new EventSourceLiveQueryProvider(wrapMessage)) || this;
+        _this.wrapMessage = wrapMessage;
+        return _this;
+    }
+    return EventSourceLiveQuery;
+}(LiveQuery_1.LiveQueryClient));
+exports.EventSourceLiveQuery = EventSourceLiveQuery;
+var EventSourceLiveQueryProvider = /** @class */ (function () {
+    function EventSourceLiveQueryProvider(wrapMessage, url, jwtToken) {
+        if (url === void 0) { url = undefined; }
+        this.wrapMessage = wrapMessage;
+        this.url = url;
+        this.jwtToken = jwtToken;
+        this.lastId = 0;
+        if (!this.wrapMessage)
+            this.wrapMessage = function (x) { return x(); };
+        if (!this.url) {
+            this.url = remult_proxy_1.remult.apiClient.url + '/' + LiveQuery_1.streamUrl;
+        }
+    }
+    EventSourceLiveQueryProvider.prototype.openStreamAndReturnCloseFunction = function (clientId, onMessage) {
+        var _this = this;
+        var ctrl = new AbortController();
+        var headers = {
+            "client-id": clientId
+        };
+        if (this.jwtToken) {
+            headers["Authorization"] = "Bearer " + this.jwtToken;
+        }
+        fetch_event_source_1.fetchEventSource(this.url, {
+            headers: headers,
+            onmessage: function (message) {
+                var mid = +message.id;
+                if (mid <= _this.lastId && _this.lastId - mid < 10)
+                    return;
+                _this.lastId = mid;
+                console.log(message.data);
+                if (message.event !== 'keep-alive') {
+                    _this.wrapMessage(function () { return onMessage(message); });
+                }
+            },
+            onopen: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    return [2 /*return*/];
+                });
+            }); },
+            signal: ctrl.signal,
+        });
+        return function () { return ctrl.abort(); };
+    };
+    return EventSourceLiveQueryProvider;
+}());

package/src/live-query/EventSourceLiveQueryProvider.d.ts

@@ -0,0 +1,6 @@
+import { LiveQueryProvider, MessageHandler } from "./LiveQuery";
+export declare class EventSourceLiveQueryProvider implements LiveQueryProvider {
+    private wrapMessage?;
+    constructor(wrapMessage?: (what: () => void) => void);
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
+}

package/src/live-query/EventSourceLiveQueryProvider.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceLiveQueryProvider = void 0;
+var remult_proxy_1 = require("../remult-proxy");
+var LiveQuery_1 = require("./LiveQuery");
+var EventSourceLiveQueryProvider = /** @class */ (function () {
+    function EventSourceLiveQueryProvider(wrapMessage) {
+        this.wrapMessage = wrapMessage;
+        if (!this.wrapMessage)
+            this.wrapMessage = function (x) { return x(); };
+    }
+    EventSourceLiveQueryProvider.prototype.openStreamAndReturnCloseFunction = function (clientId, onMessage) {
+        var _this = this;
+        var source = new EventSource(remult_proxy_1.remult.apiClient.url + '/' + LiveQuery_1.streamUrl + "?id=" + clientId, {
+            withCredentials: true
+        });
+        source.onmessage = function (e) {
+            _this.wrapMessage(function () {
+                return onMessage(JSON.parse(e.data));
+            });
+        };
+        return new Promise(function (res) {
+            source.onopen = function (e) {
+                res(function () {
+                    source.close();
+                });
+            };
+        });
+    };
+    return EventSourceLiveQueryProvider;
+}());
+exports.EventSourceLiveQueryProvider = EventSourceLiveQueryProvider;

package/src/live-query/LiveQuery.d.ts

@@ -0,0 +1,67 @@
+import { EntityOrderBy, FindOptions, Remult, Repository, RestDataProviderHttpProvider } from '../../index';
+import { Allowed } from '../context';
+import { ServerEventDispatcher } from './LiveQueryManager';
+export declare const streamUrl = "stream1";
+export interface LiveQueryProvider {
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
+}
+export declare type MessageHandler = (message: {
+    data: any;
+    event: string;
+}) => void;
+export declare class LiveQueryClient {
+    lqp: LiveQueryProvider;
+    private provider?;
+    clientId: any;
+    private queries;
+    private channels;
+    constructor(lqp: LiveQueryProvider, provider?: RestDataProviderHttpProvider);
+    runPromise(p: Promise<any>): Promise<any>;
+    close(): void;
+    subscribeChannel<T>(key: string, onResult: (item: T) => void): () => void;
+    private closeIfNoListeners;
+    subscribe<entityType>(repo: Repository<entityType>, options: FindOptions<entityType>, onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): () => void;
+    closeListener: Promise<VoidFunction>;
+    private openIfNoOpened;
+}
+export declare type listener = (message: any) => void;
+export interface SubscribeToQueryArgs<entityType = any> {
+    entityKey: string;
+    orderBy?: EntityOrderBy<entityType>;
+}
+export declare type liveQueryMessage = {
+    type: "all";
+    data: any[];
+} | {
+    type: "add";
+    data: any;
+} | {
+    type: 'replace';
+    data: {
+        oldId: any;
+        item: any;
+    };
+} | {
+    type: "remove";
+    data: {
+        id: any;
+    };
+};
+export interface SubscribeResult {
+    result: [];
+    id: string;
+}
+export interface ChannelSubscribe {
+    clientId: string;
+    channel: string;
+    remove: boolean;
+}
+export declare class AMessageChannel<messageType> {
+    private subscribedAllowed;
+    userCanSubscribe(channel: string, remult: Remult): boolean;
+    private key;
+    constructor(key: (string | ((remult: Remult) => string)), subscribedAllowed: Allowed);
+    send(what: messageType, remult?: Remult): void;
+    subscribe(client: LiveQueryClient, onValue: (value: messageType) => void, remult?: Remult): void;
+    dispatcher: ServerEventDispatcher;
+}