remult 0.22.1 → 0.22.3

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

@@ -1,86 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

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