remult 0.22.3 → 0.22.4

package/esm/core/src/live-query/SseSubscriptionClient.js

@@ -0,0 +1,86 @@
+import { buildRestDataProvider } from "../buildRestDataProvider";
+import { remult } from "../remult-proxy";
+import { actionInfo } from "../server-action";
+import { streamUrl } from "./SubscriptionChannel";
+export class SseSubscriptionClient {
+    openConnection(onReconnect) {
+        let connectionId;
+        const channels = new Map();
+        const provider = buildRestDataProvider(remult.apiClient.httpClient);
+        let connected = false;
+        let source;
+        const client = {
+            close() {
+                source.close();
+            },
+            async subscribe(channel, handler) {
+                let listeners = channels.get(channel);
+                if (!listeners) {
+                    channels.set(channel, listeners = []);
+                    await subscribeToChannel(channel);
+                }
+                listeners.push(handler);
+                return () => {
+                    listeners.splice(listeners.indexOf(handler, 1));
+                    if (listeners.length == 0) {
+                        actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
+                            channel: channel,
+                            clientId: connectionId
+                        }));
+                        channels.delete(channel);
+                    }
+                };
+            },
+        };
+        const createConnectionPromise = () => new Promise((res) => {
+            createConnection();
+            function createConnection() {
+                if (source)
+                    source.close();
+                source = new EventSource(remult.apiClient.url + '/' + streamUrl, {
+                    withCredentials: true
+                });
+                source.onmessage = e => {
+                    let message = JSON.parse(e.data);
+                    const listeners = channels.get(message.channel);
+                    if (listeners)
+                        listeners.forEach(x => x(message.data));
+                };
+                source.onerror = e => {
+                    console.error("Live Query Event Source Error", e);
+                    source.close();
+                    setTimeout(() => {
+                        createConnection();
+                    }, 500);
+                };
+                source.addEventListener("connectionId", async (e) => {
+                    //@ts-ignore
+                    connectionId = e.data;
+                    if (connected) {
+                        for (const channel of channels.keys()) {
+                            await subscribeToChannel(channel);
+                        }
+                        onReconnect();
+                    }
+                    else {
+                        connected = true;
+                        res(client);
+                    }
+                });
+            }
+        });
+        return createConnectionPromise();
+        async function subscribeToChannel(channel) {
+            const result = await actionInfo.runActionWithoutBlockingUI(() => {
+                return provider.post(remult.apiClient.url + '/' + streamUrl + '/subscribe', {
+                    channel: channel,
+                    clientId: connectionId
+                });
+            });
+            if (result === ConnectionNotFoundError) {
+                await createConnectionPromise();
+            }
+        }
+    }
+}
+export const ConnectionNotFoundError = "client connection not found";

package/esm/core/src/live-query/SubscriptionChannel.d.ts

@@ -0,0 +1,72 @@
+import { FindOptions, Remult } from '../../index';
+import type { LiveQueryChangeInfo, RepositoryImplementation } from '../remult3';
+export declare const streamUrl = "stream";
+export declare class LiveQuerySubscriber<entityType> {
+    private repo;
+    private query;
+    sendDefaultState(onResult: (info: LiveQueryChangeInfo<entityType>) => void): void;
+    queryChannel: string;
+    subscribeCode: () => void;
+    unsubscribe: VoidFunction;
+    setAllItems(result: any[]): Promise<void>;
+    private allItemsMessage;
+    forListeners(what: (listener: (((reducer: (prevState: entityType[]) => entityType[]) => void))) => void, changes: LiveQueryChange[]): void;
+    private createReducerType;
+    handle(messages: LiveQueryChange[]): Promise<void>;
+    defaultQueryState: entityType[];
+    listeners: SubscriptionListener<LiveQueryChangeInfo<entityType>>[];
+    id: any;
+    constructor(repo: RepositoryImplementation<entityType>, query: SubscribeToQueryArgs<entityType>, userId: string);
+}
+export interface SubscriptionListener<type> {
+    next(message: type): void;
+    error(err: any): void;
+    complete(): void;
+}
+export type Unsubscribe = VoidFunction;
+export interface SubscriptionClientConnection {
+    subscribe(channel: string, onMessage: (message: any) => void, onError: (err: any) => void): Promise<Unsubscribe>;
+    close(): void;
+}
+export interface SubscriptionClient {
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare const liveQueryKeepAliveRoute = "_liveQueryKeepAlive";
+interface SubscribeToQueryArgs<entityType = any> {
+    entityKey: string;
+    options: FindOptions<entityType>;
+}
+export declare type LiveQueryChange = {
+    type: "all";
+    data: any[];
+} | {
+    type: "add";
+    data: any;
+} | {
+    type: 'replace';
+    data: {
+        oldId: any;
+        item: any;
+    };
+} | {
+    type: "remove";
+    data: {
+        id: any;
+    };
+};
+export interface SubscribeResult {
+    result: [];
+    queryChannel: string;
+}
+export interface ServerEventChannelSubscribeDTO {
+    clientId: string;
+    channel: string;
+}
+export declare class SubscriptionChannel<messageType> {
+    channelKey: string;
+    constructor(channelKey: string);
+    publish(message: messageType, remult?: Remult): void;
+    subscribe(next: (message: messageType) => void, remult?: Remult): Promise<Unsubscribe>;
+    subscribe(listener: Partial<SubscriptionListener<messageType>>): Promise<Unsubscribe>;
+}
+export {};

package/esm/core/src/live-query/SubscriptionChannel.js

@@ -0,0 +1,123 @@
+import { remult as defaultRemult, Sort } from '../../index';
+import { v4 as uuid } from 'uuid';
+import { getLiveQueryChannel } from '../data-api';
+export const streamUrl = 'stream';
+//@internal
+export class LiveQuerySubscriber {
+    repo;
+    query;
+    sendDefaultState(onResult) {
+        onResult(this.createReducerType(() => [...this.defaultQueryState], this.allItemsMessage(this.defaultQueryState)));
+    }
+    queryChannel;
+    subscribeCode;
+    unsubscribe = () => { };
+    async setAllItems(result) {
+        const items = await this.repo.fromJsonArray(result, this.query.options.load);
+        this.forListeners(listener => {
+            listener(x => {
+                return items;
+            });
+        }, this.allItemsMessage(items));
+    }
+    allItemsMessage(items) {
+        return [
+            {
+                type: "all",
+                data: items
+            }
+        ];
+    }
+    forListeners(what, changes) {
+        what(reducer => {
+            this.defaultQueryState = reducer(this.defaultQueryState);
+            if (changes.find(c => c.type === "add" || c.type === "replace")) {
+                if (this.query.options.orderBy) {
+                    const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.options.orderBy);
+                    this.defaultQueryState.sort((a, b) => o.compare(a, b));
+                }
+            }
+        });
+        for (const l of this.listeners) {
+            what(reducer => {
+                l.next(this.createReducerType(reducer, changes));
+            });
+        }
+    }
+    createReducerType(applyChanges, changes) {
+        return {
+            applyChanges,
+            changes,
+            items: this.defaultQueryState
+        };
+    }
+    async handle(messages) {
+        {
+            let x = messages.filter(({ type }) => type == "add" || type == "replace");
+            let loadedItems = await this.repo.fromJsonArray(x.map(m => m.data.item), this.query.options.load);
+            for (let index = 0; index < x.length; index++) {
+                const element = x[index];
+                element.data.item = loadedItems[index];
+            }
+        }
+        this.forListeners(listener => {
+            listener(items => {
+                if (!items)
+                    items = [];
+                for (const message of messages) {
+                    switch (message.type) {
+                        case "all":
+                            this.setAllItems(message.data);
+                            break;
+                        case "replace": {
+                            items = items.map(x => this.repo.metadata.idMetadata.getId(x) === message.data.oldId ? message.data.item : x);
+                            break;
+                        }
+                        case "add":
+                            items = items.filter(x => this.repo.metadata.idMetadata.getId(x) !== this.repo.metadata.idMetadata.getId(message.data.item));
+                            items.push(message.data.item);
+                            break;
+                        case "remove":
+                            items = items.filter(x => this.repo.metadata.idMetadata.getId(x) !== message.data.id);
+                            break;
+                    }
+                    ;
+                }
+                return items;
+            });
+        }, messages);
+    }
+    defaultQueryState = [];
+    listeners = [];
+    id = uuid();
+    constructor(repo, query, userId) {
+        this.repo = repo;
+        this.query = query;
+        this.queryChannel = getLiveQueryChannel(this.id, userId);
+    }
+}
+export const liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
+export class SubscriptionChannel {
+    channelKey;
+    constructor(channelKey) {
+        this.channelKey = channelKey;
+    }
+    publish(message, remult) {
+        remult = remult || defaultRemult;
+        remult.subscriptionServer.publishMessage(this.channelKey, message);
+    }
+    //@internal
+    subscribe(next, remult) {
+        remult = remult || defaultRemult;
+        let listener = next;
+        if (typeof (next) === "function") {
+            listener = {
+                next
+            };
+        }
+        listener.error ??= () => { };
+        listener.complete ??= () => { };
+        return remult.liveQuerySubscriber.subscribeChannel(this.channelKey, listener);
+    }
+}
+//TODO2 - consider moving the queued job mechanism into this.

package/esm/core/src/live-query/SubscriptionServer.d.ts

@@ -0,0 +1,53 @@
+import { itemChange } from '../context';
+import { Repository } from '../remult3';
+export interface SubscriptionServer {
+    publishMessage<T>(channel: string, message: T): Promise<void>;
+}
+export declare type PerformWithContext = (serializedRequest: any, entityKey: string, what: (repo: Repository<any>) => Promise<void>) => Promise<void>;
+export declare class LiveQueryPublisher implements LiveQueryChangesListener {
+    private subscriptionServer;
+    private liveQueryStorage;
+    performWithContext: PerformWithContext;
+    constructor(subscriptionServer: () => SubscriptionServer, liveQueryStorage: () => LiveQueryStorage, performWithContext: PerformWithContext);
+    runPromise(p: Promise<any>): void;
+    debugFileSaver: (x: any) => void;
+    itemChanged(entityKey: string, changes: itemChange[]): Promise<void>;
+}
+export interface LiveQueryChangesListener {
+    itemChanged(entityKey: string, changes: itemChange[]): Promise<void>;
+}
+export interface LiveQueryStorage {
+    add(query: StoredQuery): Promise<void>;
+    remove(queryId: string): Promise<void>;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+export declare class InMemoryLiveQueryStorage implements LiveQueryStorage {
+    debugFileSaver: (x: any) => void;
+    debug(): void;
+    keepAliveAndReturnUnknownQueryIds(ids: string[]): Promise<string[]>;
+    queries: (StoredQuery & {
+        lastUsed: string;
+    })[];
+    constructor();
+    add(query: StoredQuery): Promise<void>;
+    removeCountForTesting: number;
+    remove(id: any): Promise<void>;
+    forEach(entityKey: string, handle: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+}
+export interface StoredQuery {
+    entityKey: string;
+    id: string;
+    data: any;
+}
+export interface QueryData {
+    findOptionsJson: any;
+    requestJson: any;
+    lastIds: any[];
+}

package/esm/core/src/live-query/SubscriptionServer.js

@@ -0,0 +1,111 @@
+import { findOptionsFromJson } from '../data-providers/rest-data-provider';
+/* @internal*/
+export class LiveQueryPublisher {
+    subscriptionServer;
+    liveQueryStorage;
+    performWithContext;
+    constructor(subscriptionServer, liveQueryStorage, performWithContext) {
+        this.subscriptionServer = subscriptionServer;
+        this.liveQueryStorage = liveQueryStorage;
+        this.performWithContext = performWithContext;
+    }
+    runPromise(p) { }
+    debugFileSaver = (x) => { };
+    async itemChanged(entityKey, changes) {
+        //TODO 2 - optimize so that the user will get their messages first. Based on user id
+        await (this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
+            let query = { ...q.data };
+            await this.performWithContext(query.requestJson, entityKey, async (repo) => {
+                const messages = [];
+                const currentItems = await repo.find(findOptionsFromJson(query.findOptionsJson, repo.metadata));
+                const currentIds = currentItems.map(x => repo.getEntityRef(x).getId());
+                for (const id of query.lastIds.filter(y => !currentIds.includes(y))) {
+                    let c = changes.find(c => c.oldId == id);
+                    if (c === undefined || id != c.oldId || !currentIds.includes(c.id))
+                        messages.push({
+                            type: "remove",
+                            data: {
+                                id: id
+                            }
+                        });
+                }
+                for (const item of currentItems) {
+                    const itemRef = repo.getEntityRef(item);
+                    let c = changes.find(c => c.id == itemRef.getId());
+                    if (c !== undefined && query.lastIds.includes(c.oldId)) {
+                        messages.push({
+                            type: "replace",
+                            data: {
+                                oldId: c.oldId,
+                                item: itemRef.toApiJson()
+                            }
+                        });
+                    }
+                    else if (!query.lastIds.includes(itemRef.getId())) {
+                        messages.push({
+                            type: "add",
+                            data: { item: itemRef.toApiJson() }
+                        });
+                    }
+                }
+                this.debugFileSaver({
+                    query: q.id,
+                    currentIds,
+                    changes,
+                    lastIds: query.lastIds,
+                    messages
+                });
+                query.lastIds = currentIds;
+                await setData(query);
+                if (messages.length > 0)
+                    this.subscriptionServer().publishMessage(q.id, messages);
+            });
+        }));
+    }
+}
+export class InMemoryLiveQueryStorage {
+    debugFileSaver = (x) => { };
+    debug() {
+        this.debugFileSaver(this.queries);
+    }
+    async keepAliveAndReturnUnknownQueryIds(ids) {
+        const result = [];
+        for (const id of ids) {
+            let q = this.queries.find(q => q.id === id);
+            if (q) {
+                q.lastUsed = new Date().toISOString();
+            }
+            else
+                result.push(id);
+        }
+        this.debug();
+        return result;
+    }
+    queries = [];
+    constructor() {
+    }
+    async add(query) {
+        this.queries.push({ ...query, lastUsed: new Date().toISOString() });
+        this.debug();
+    }
+    removeCountForTesting = 0;
+    async remove(id) {
+        this.queries = this.queries.filter(q => q.id !== id);
+        this.removeCountForTesting++;
+        this.debug();
+    }
+    async forEach(entityKey, handle) {
+        let d = new Date();
+        d.setMinutes(d.getMinutes() - 5);
+        this.queries = this.queries.filter(x => x.lastUsed > d.toISOString());
+        for (const q of this.queries) {
+            if (q.entityKey === entityKey) {
+                await handle({
+                    query: q,
+                    setData: async (data) => { q.data = data; },
+                });
+            }
+        }
+        this.debug();
+    }
+}

package/esm/core/src/live-query/live-query-tests.spec.d.ts

@@ -0,0 +1,6 @@
+export declare class eventTestEntity {
+    id: number;
+    title: string;
+    selectUser: string;
+    birthDate: Date;
+}