remult 0.16.3-exp.4 → 0.16.4

package/esm/remult-knex/index.js

@@ -153,8 +153,15 @@ class KnexEntityDataProvider {
         }
         let insert = this.knex(e.entityName).insert(insertObject);
         if (isAutoIncrement(this.entity.idMetadata.field)) {
-            let result = await insert.returning(this.entity.idMetadata.field.key);
-            let newId = result[0].id;
+            let newId;
+            if (this.knex.client.config.client === 'mysql2') {
+                let result = await this.knex(e.entityName).insert(insertObject, this.entity.idMetadata.field.key);
+                newId = result[0];
+            }
+            else {
+                let result = await insert.returning(this.entity.idMetadata.field.key);
+                newId = result[0].id;
+            }
             resultFilter = new Filter(x => x.isEqualTo(this.entity.idMetadata.field, newId));
         }
         else

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

@@ -53,6 +53,16 @@ if (true)
             filename: ":memory:"
         },
     }), "sqlite3"));
+export const mySqlTest = addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    client: 'mysql2',
+    connection: {
+        user: 'root',
+        password: 'MASTERKEY',
+        host: '127.0.0.1',
+        database: 'test'
+    }
+    //debug: true
+}), "mysql2"));
 let pg = createPostgresConnection({
     autoCreateTables: false
 });

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/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/esm/src/live-query/EventSourceLiveQuery.js

@@ -0,0 +1,48 @@
+import { LiveQueryClient, streamUrl } from './LiveQuery';
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import { remult } from '../remult-proxy';
+export class EventSourceLiveQuery extends LiveQueryClient {
+    constructor(wrapMessage) {
+        super(new EventSourceLiveQueryProvider(wrapMessage));
+        this.wrapMessage = wrapMessage;
+    }
+}
+class EventSourceLiveQueryProvider {
+    constructor(wrapMessage, url = undefined, jwtToken) {
+        this.wrapMessage = wrapMessage;
+        this.url = url;
+        this.jwtToken = jwtToken;
+        this.lastId = 0;
+        if (!this.wrapMessage)
+            this.wrapMessage = x => x();
+        if (!this.url) {
+            this.url = remult.apiClient.url + '/' + streamUrl;
+        }
+    }
+    openStreamAndReturnCloseFunction(clientId, onMessage) {
+        const ctrl = new AbortController();
+        const headers = {
+            "client-id": clientId
+        };
+        if (this.jwtToken) {
+            headers["Authorization"] = "Bearer " + this.jwtToken;
+        }
+        fetchEventSource(this.url, {
+            headers,
+            onmessage: message => {
+                const 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(() => onMessage(message));
+                }
+            },
+            onopen: async () => {
+            },
+            signal: ctrl.signal,
+        });
+        return () => ctrl.abort();
+    }
+}

package/esm/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/esm/src/live-query/EventSourceLiveQueryProvider.js

@@ -0,0 +1,24 @@
+import { remult } from "../remult-proxy";
+import { streamUrl } from "./LiveQuery";
+export class EventSourceLiveQueryProvider {
+    constructor(wrapMessage) {
+        this.wrapMessage = wrapMessage;
+        if (!this.wrapMessage)
+            this.wrapMessage = x => x();
+    }
+    openStreamAndReturnCloseFunction(clientId, onMessage) {
+        const source = new EventSource(remult.apiClient.url + '/' + streamUrl + "?id=" + clientId, {
+            withCredentials: true
+        });
+        source.onmessage = e => {
+            this.wrapMessage(() => onMessage(JSON.parse(e.data)));
+        };
+        return new Promise((res) => {
+            source.onopen = e => {
+                res(() => {
+                    source.close();
+                });
+            };
+        });
+    }
+}

package/esm/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;
+}

package/esm/src/live-query/LiveQuery.js

@@ -0,0 +1,222 @@
+import { getEntityRef, remult as defaultRemult, Sort } from '../../index';
+import { v4 as uuid } from 'uuid';
+import { RestEntityDataProvider } from '../data-providers/rest-data-provider';
+import { buildRestDataProvider } from '../context';
+export const streamUrl = 'stream1';
+class LiveQueryOnFrontEnd {
+    constructor(repo, query) {
+        this.repo = repo;
+        this.query = query;
+        this.items = [];
+        this.listeners = [];
+    }
+    async setAllItems(result) {
+        const items = await Promise.all(result.map(item => this.repo.fromJson(item)));
+        this.forListeners(listener => {
+            listener(x => {
+                return items;
+            });
+        });
+    }
+    forListeners(what) {
+        for (const l of this.listeners) {
+            what(l);
+        }
+    }
+    async handle(message) {
+        const sort = (items) => {
+            if (this.query.orderBy) {
+                const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.orderBy);
+                items.sort((a, b) => o.compare(a, b));
+            }
+            return items;
+        };
+        switch (message.type) {
+            case "all":
+                this.setAllItems(message.data);
+                break;
+            case "replace": {
+                const item = await this.repo.fromJson(message.data.item);
+                this.forListeners(listener => {
+                    listener(items => {
+                        if (!items)
+                            items = [];
+                        return sort(items.map(x => this.repo.getEntityRef(x).getId() === message.data.oldId ? item : x));
+                    });
+                });
+                break;
+            }
+            case "add":
+                {
+                    const item = await this.repo.fromJson(message.data.item);
+                    this.forListeners(listener => listener(items => {
+                        if (!items)
+                            items = [];
+                        items.push(item);
+                        return sort(items);
+                    }));
+                    break;
+                }
+            case "remove":
+                this.forListeners(listener => listener(items => {
+                    if (!items)
+                        items = [];
+                    return this.items.filter(x => getEntityRef(x).getId() !== message.data.id);
+                }));
+                break;
+        }
+        ;
+    }
+}
+class MessageChannel {
+    constructor() {
+        this.listeners = [];
+    }
+    async handle(message) {
+        for (const l of this.listeners) {
+            l(message);
+        }
+    }
+}
+export class LiveQueryClient {
+    constructor(lqp, provider) {
+        this.lqp = lqp;
+        this.provider = provider;
+        this.clientId = uuid();
+        this.queries = new Map();
+        this.channels = new Map();
+    }
+    runPromise(p) {
+        return p;
+    }
+    close() {
+        this.queries.clear();
+        this.channels.clear();
+        this.closeIfNoListeners();
+    }
+    subscribeChannel(key, onResult) {
+        let onUnsubscribe = () => { };
+        this.openIfNoOpened().then(() => {
+            let q = this.channels.get(key);
+            if (!q) {
+                this.channels.set(key, q = new MessageChannel());
+                this.provider.post(defaultRemult.apiClient.url + '/' + streamUrl, {
+                    channel: key,
+                    clientId: this.clientId,
+                    remove: false
+                });
+            }
+            else {
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    this.channels.delete(key);
+                }
+                this.closeIfNoListeners();
+            };
+        });
+        return () => {
+            onUnsubscribe();
+        };
+    }
+    closeIfNoListeners() {
+        if (this.queries.size === 0 && this.channels.size === 0) {
+            this.runPromise(this.closeListener.then(x => x()));
+            this.closeListener = undefined;
+        }
+    }
+    subscribe(repo, options, onResult) {
+        let alive = true;
+        let onUnsubscribe = () => { };
+        this.runPromise(this.openIfNoOpened().then(() => repo.buildEntityDataProviderFindOptions(options)
+            .then(opts => {
+            if (!alive)
+                return;
+            const { url, filterObject } = new RestEntityDataProvider(() => defaultRemult.apiClient.url + '/' + repo.metadata.key, () => this.provider, repo.metadata)
+                .buildFindRequest(opts);
+            const eventTypeKey = JSON.stringify({ url, filterObject });
+            let q = this.queries.get(eventTypeKey);
+            if (!q) {
+                this.queries.set(eventTypeKey, q = new LiveQueryOnFrontEnd(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
+                url.add("__action", 'subscribe|' + this.clientId);
+                const thenResult = (r) => {
+                    this.runPromise(q.setAllItems(r.result));
+                    q.id = r.id;
+                };
+                if (filterObject) {
+                    this.runPromise(this.provider.post(url.url, filterObject).then(thenResult));
+                }
+                else
+                    this.runPromise(this.provider.get(url.url).then(thenResult));
+            }
+            else {
+                onResult(x => q.items);
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    this.queries.delete(eventTypeKey);
+                }
+                this.closeIfNoListeners();
+            };
+        })));
+        return () => {
+            alive = false;
+            onUnsubscribe();
+        };
+    }
+    openIfNoOpened() {
+        if (!this.provider) {
+            this.provider = buildRestDataProvider(defaultRemult.apiClient.httpClient);
+        }
+        if (!this.closeListener)
+            return this.runPromise(this.closeListener = this.lqp.openStreamAndReturnCloseFunction(this.clientId, message => {
+                for (const q of this.queries.values()) {
+                    if (q.id === message.event) {
+                        this.runPromise(q.handle(message.data));
+                    }
+                }
+                const channel = this.channels.get(message.event);
+                if (channel) {
+                    channel.handle(message.data);
+                }
+            }));
+        return this.closeListener;
+    }
+}
+export class AMessageChannel {
+    constructor(key, subscribedAllowed) {
+        this.subscribedAllowed = subscribedAllowed;
+        if (typeof key === "string")
+            this.key = () => key;
+        else
+            this.key = key;
+    }
+    userCanSubscribe(channel, remult) {
+        if (!remult)
+            remult = defaultRemult;
+        if (channel == this.key(remult) && remult.isAllowed(this.subscribedAllowed))
+            return true;
+        return false;
+    }
+    send(what, remult) {
+        if (!this.dispatcher)
+            throw new Error("Message couldn't be send since no dispatcher was set");
+        this.dispatcher.sendChannelMessage(this.key(remult || defaultRemult), what);
+    }
+    subscribe(client, onValue, remult) {
+        client.subscribeChannel(this.key(remult || defaultRemult), onValue);
+    }
+}
+/*
+[V] use entity normal http route for this - with __action.
+[] move id from header to url in stream registration.
+[] transaction accumulates messages.
+[] on unsubscribe, also unsubscribe on server
+[] consolidate channel & query
+[] fix stream api url on server
+[] remove client id from header
+*/ 

package/esm/src/live-query/LiveQueryManager.d.ts

@@ -0,0 +1,33 @@
+import { Remult } from '../..';
+import { Repository, EntityRef, FindOptions } from '../remult3';
+import { LiveQueryProvider } from '../data-api';
+import { liveQueryMessage } from './LiveQuery';
+export declare class LiveQueryManager implements LiveQueryProvider {
+    private dispatcher;
+    constructor(dispatcher: ServerEventDispatcher);
+    subscribe(repo: Repository<any>, clientId: string, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
+    clients: clientInfo[];
+    sendMessage(key: string, message: liveQueryMessage): void;
+    hasListeners(ref: EntityRef<any>): boolean;
+    runPromise(p: Promise<any>): void;
+    saved(ref: EntityRef<any>): void;
+    deleted(ref: EntityRef<any>): void;
+}
+export interface clientInfo {
+    clientId: string;
+    queries: ({
+        id: string;
+        repo: Repository<any>;
+        findOptions: FindOptions<any>;
+        ids: any[];
+    })[];
+}
+export interface ServerEventDispatcher {
+    sendQueryMessage(message: ServerEventMessage): void;
+    sendChannelMessage<T>(channel: string, message: any): void;
+}
+export interface ServerEventMessage {
+    clientId: string;
+    queryId: string;
+    message: liveQueryMessage;
+}

package/esm/src/live-query/LiveQueryManager.js

@@ -0,0 +1,97 @@
+import { v4 as uuid } from 'uuid';
+export class LiveQueryManager {
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+        this.clients = [];
+    }
+    subscribe(repo, clientId, findOptions, remult, ids) {
+        let client = this.clients.find(c => c.clientId === clientId);
+        if (!client) {
+            this.clients.push(client = { clientId: clientId, queries: [] });
+        }
+        const id = uuid();
+        console.log({ ids });
+        client.queries.push({
+            id,
+            findOptions: findOptions,
+            repo,
+            ids
+        });
+        return id;
+    }
+    sendMessage(key, message) {
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === key) {
+                    this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
+                }
+            }
+        }
+    }
+    hasListeners(ref) {
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key)
+                    return true;
+            }
+        }
+        return false;
+    }
+    runPromise(p) {
+    }
+    //TODO - reconsider usage of zone
+    saved(ref) {
+        const isNew = ref.isNew();
+        const origId = isNew ? ref.getId() : ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    this.runPromise(q.repo.find(q.findOptions).then(currentItems => {
+                        const currentIds = currentItems.map(x => q.repo.getEntityRef(x).getId());
+                        const sendMessage = (message) => {
+                            console.log({ message: message.type });
+                            this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
+                        };
+                        console.log({ ids: q.ids, currentIds });
+                        for (const id of q.ids.filter(y => !currentIds.includes(y))) {
+                            if (id != origId || !currentIds.includes(ref.getId()))
+                                sendMessage({
+                                    type: "remove",
+                                    data: {
+                                        id: id
+                                    }
+                                });
+                        }
+                        for (const item of currentItems) {
+                            const itemRef = q.repo.getEntityRef(item);
+                            if (itemRef.getId() == ref.getId() && q.ids.includes(origId)) {
+                                sendMessage({
+                                    type: "replace",
+                                    data: {
+                                        oldId: origId,
+                                        item: itemRef.toApiJson()
+                                    }
+                                });
+                            }
+                            else if (!q.ids.includes(itemRef.getId())) {
+                                sendMessage({
+                                    type: "add",
+                                    data: { item: itemRef.toApiJson() }
+                                });
+                            }
+                        }
+                        q.ids = currentIds;
+                    }));
+                }
+            }
+        }
+    }
+    deleted(ref) {
+        if (!this.hasListeners(ref))
+            return;
+        this.sendMessage(ref.metadata.key, {
+            type: "remove",
+            data: { id: ref.getId() }
+        });
+    }
+}