remult 0.17.2 → 0.18.0

package/esm/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/src/live-query/SubscriptionChannel.d.ts

@@ -0,0 +1,41 @@
+import { Remult } from '../../index';
+export declare const streamUrl = "stream";
+export interface SubscriptionListener<type> {
+    next(message: type): void;
+    error(err: any): void;
+    complete(): void;
+}
+export declare 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";
+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 declare class SubscriptionChannel<messageType> {
+    channelKey: string;
+    constructor(channelKey: string);
+    publish(message: messageType, remult?: Remult): void;
+    subscribe(next: (message: messageType) => void, remult?: Remult): any;
+    subscribe(listener: Partial<SubscriptionListener<messageType>>): any;
+}

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

@@ -0,0 +1,121 @@
+import { remult as defaultRemult, Sort } from '../../index';
+import { getId } from '../remult3/getId';
+import { v4 as uuid } from 'uuid';
+import { getLiveQueryChannel } from '../data-api';
+export const streamUrl = 'stream';
+//@internal
+export class LiveQuerySubscriber {
+    constructor(repo, query, userId) {
+        this.repo = repo;
+        this.query = query;
+        this.unsubscribe = () => { };
+        this.defaultQueryState = [];
+        this.listeners = [];
+        this.id = uuid();
+        this.queryChannel = getLiveQueryChannel(this.id, userId);
+    }
+    sendDefaultState(onResult) {
+        onResult(this.createReducerType(() => [...this.defaultQueryState], this.allItemsMessage(this.defaultQueryState)));
+    }
+    async setAllItems(result) {
+        const items = await Promise.all(result.map(item => this.repo.fromJson(item)));
+        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.orderBy) {
+                    const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.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) {
+        for (const m of messages) {
+            switch (m.type) {
+                case "add":
+                case "replace":
+                    m.data.item = await this.repo.fromJson(m.data.item);
+                    break;
+                case "all":
+                    this.setAllItems(m.data);
+            }
+        }
+        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 => getId(this.repo.metadata, x) === message.data.oldId ? message.data.item : x);
+                            break;
+                        }
+                        case "add":
+                            items = items.filter(x => getId(this.repo.metadata, x) !== getId(this.repo.metadata, message.data.item));
+                            items.push(message.data.item);
+                            break;
+                        case "remove":
+                            items = items.filter(x => getId(this.repo.metadata, x) !== message.data.id);
+                            break;
+                    }
+                    ;
+                }
+                return items;
+            });
+        }, messages);
+    }
+}
+export const liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
+export class SubscriptionChannel {
+    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/src/live-query/SubscriptionServer.d.ts

@@ -0,0 +1,38 @@
+export interface SubscriptionServer {
+    publishMessage<T>(channel: string, message: T): 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/src/live-query/SubscriptionServer.js

@@ -0,0 +1,108 @@
+import { findOptionsFromJson } from '../data-providers/rest-data-provider';
+/* @internal*/
+export class LiveQueryPublisher {
+    constructor(subscriptionServer, liveQueryStorage, performWithRequest) {
+        this.subscriptionServer = subscriptionServer;
+        this.liveQueryStorage = liveQueryStorage;
+        this.performWithRequest = performWithRequest;
+        this.debugFileSaver = (x) => { };
+    }
+    runPromise(p) { }
+    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.performWithRequest(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 {
+    constructor() {
+        this.debugFileSaver = (x) => { };
+        this.queries = [];
+        this.removeCountForTesting = 0;
+    }
+    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;
+    }
+    async add(query) {
+        this.queries.push({ ...query, lastUsed: new Date().toISOString() });
+        this.debug();
+    }
+    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/src/remult-proxy.d.ts

@@ -1,2 +1,2 @@
-import { Remult } from "./context";
+import type { Remult } from "./context";
 export declare const remult: Remult;

package/esm/src/remult-proxy.js

@@ -1,12 +1,51 @@
-import { Remult } from "./context";
-import { RepositoryImplementation } from "./remult3";
-let defaultRemult = new Remult();
 /*@internal*/
 export class RemultProxy {
     constructor() {
         /*@internal*/
-        this.remultFactory = () => defaultRemult;
-        this.repo = (...args) => this.remultFactory().repo(...args);
+        this.remultFactory = () => RemultProxy.defaultRemult;
+        //@ts-ignore
+        this.repo = (...args) => {
+            let self = this;
+            return {
+                addEventListener: (...args2) => self.remultFactory().repo(...args).addEventListener(...args2),
+                count: (...args2) => self.remultFactory().repo(...args).count(...args2),
+                create: (...args2) => self.remultFactory().repo(...args).create(...args2),
+                delete: (args2) => self.remultFactory().repo(...args).delete(args2),
+                find: (...args2) => self.remultFactory().repo(...args).find(...args2),
+                findFirst: (...args2) => self.remultFactory().repo(...args).findFirst(...args2),
+                findId: (...args2) => self.remultFactory().repo(...args).findId(...args2),
+                fromJson: (...args2) => self.remultFactory().repo(...args).fromJson(...args2),
+                getEntityRef: (...args2) => self.remultFactory().repo(...args).getEntityRef(...args2),
+                insert: (args2) => self.remultFactory().repo(...args).insert(args2),
+                liveQuery: (...args2) => self.remultFactory().repo(...args).liveQuery(...args2),
+                get metadata() {
+                    return self.remultFactory().repo(...args).metadata;
+                },
+                query: (...args2) => self.remultFactory().repo(...args).query(...args2),
+                save: (args2) => self.remultFactory().repo(...args).save(args2),
+                update: (...args2) => self.remultFactory().repo(...args).update(...args2),
+            };
+        };
+    }
+    /* @internal*/
+    get liveQuerySubscriber() { return this.remultFactory().liveQuerySubscriber; }
+    ;
+    /* @internal*/
+    set liveQuerySubscriber(val) { this.remultFactory().liveQuerySubscriber = val; }
+    ;
+    /* @internal*/
+    get liveQueryStorage() { return this.remultFactory().liveQueryStorage; }
+    ;
+    /* @internal*/
+    set liveQueryStorage(val) { this.remultFactory().liveQueryStorage = val; }
+    ;
+    /* @internal*/
+    get liveQueryPublisher() {
+        return this.remultFactory().liveQueryPublisher;
+    }
+    /* @internal*/
+    set liveQueryPublisher(val) {
+        this.remultFactory().liveQueryPublisher = val;
     }
     call(backendMethod, self, ...args) {
         return this.remultFactory().call(backendMethod, self, ...args);
@@ -17,6 +56,7 @@ export class RemultProxy {
     get dataProvider() { return this.remultFactory().dataProvider; }
     ;
     set dataProvider(provider) { this.remultFactory().dataProvider = provider; }
+    /*@internal*/
     get repCache() { return this.remultFactory().repCache; }
     ;
     authenticated() {
@@ -33,7 +73,7 @@ export class RemultProxy {
     }
     /*@internal*/
     resetFactory() {
-        this.remultFactory = () => defaultRemult;
+        this.remultFactory = () => RemultProxy.defaultRemult;
     }
     get user() {
         return this.remultFactory().user;
@@ -47,6 +87,11 @@ export class RemultProxy {
     set apiClient(client) {
         this.remultFactory().apiClient = client;
     }
+    get subscriptionServer() {
+        return this.remultFactory().subscriptionServer;
+    }
+    set subscriptionServer(value) {
+        this.remultFactory().subscriptionServer = value;
+    }
 }
 export const remult = new RemultProxy();
-RepositoryImplementation.defaultRemult = remult;

package/esm/src/remult3/RepositoryImplementation.d.ts

@@ -5,13 +5,12 @@ import { EntityMetadata, FieldRef, FieldsRef, EntityFilter, FindOptions, Reposit
 import { ClassType } from "../../classType";
 import { Remult, Unobserve } from "../context";
 import { entityEventListener } from "../__EntityValueProvider";
-import { DataProvider, EntityDataProvider } from "../data-interfaces";
+import { DataProvider, EntityDataProvider, EntityDataProviderFindOptions } from "../data-interfaces";
 import { RefSubscriber } from ".";
 export declare class RepositoryImplementation<entityType> implements Repository<entityType> {
     private entity;
-    private remult;
+    remult: Remult;
     private dataProvider;
-    static defaultRemult: Remult;
     createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
     private _info;
     private __edp;
@@ -42,7 +41,9 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     private getRefForExistingRow;
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    liveQuery(options?: FindOptions<entityType>): any;
     find(options: FindOptions<entityType>): Promise<entityType[]>;
+    buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
     private mapRawDataToResult;
     count(where?: EntityFilter<entityType>): Promise<number>;
     private cache;
@@ -51,7 +52,6 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     create(item?: Partial<OmitEB<entityType>>): entityType;
     fromJson(json: any, newRow?: boolean): Promise<entityType>;
     findId(id: any, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
-    private translateWhereToFilter;
 }
 export declare function __updateEntityBasedOnWhere<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>, r: T): void;
 export declare type EntityOptionsFactory = (remult: Remult) => EntityOptions;
@@ -89,6 +89,7 @@ declare abstract class rowHelperBase<T> {
     copyDataToObject(): any;
     originalValues: any;
     saveOriginalData(): void;
+    saveMoreOriginalData(): void;
     validate(): Promise<boolean>;
     __validateEntity(): Promise<void>;
     __performColumnAndEntityValidations(): Promise<void>;
@@ -106,6 +107,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     get apiInsertAllowed(): boolean;
     metadata: EntityMetadata<T>;
     getId(): any;
+    saveMoreOriginalData(): void;
     private _wasDeleted;
     wasDeleted(): boolean;
     undoChanges(): void;
@@ -118,6 +120,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     delete(): Promise<void>;
     loadDataFrom(data: any, loadItems?: FieldMetadata[]): Promise<void>;
     id: any;
+    originalId: any;
     getOriginalId(): any;
     private calcServerExpression;
     isNew(): boolean;
@@ -175,7 +178,6 @@ export declare class columnDefsImpl implements FieldMetadata {
     private settings;
     private entityDefs;
     constructor(settings: FieldOptions, entityDefs: EntityFullInfo<any>, remult: Remult);
-    dbNamePromise: Promise<string>;
     getDbName(): Promise<string>;
     options: FieldOptions<any, any>;
     target: ClassType<any>;
@@ -217,7 +219,10 @@ export declare class Fields {
     static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
 }
@@ -320,4 +325,8 @@ declare class SubscribableImp implements Subscribable {
         reportObserved: () => void;
     }): Unobserve;
 }
+export declare function getEntityMetadata<entityType>(entity: EntityMetadataOverloads<entityType>): EntityMetadata<entityType>;
+export declare function getRepository<entityType>(entity: RepositoryOverloads<entityType>): Repository<entityType>;
+export declare type EntityMetadataOverloads<entityType> = Repository<entityType> | EntityMetadata<entityType> | ClassType<entityType>;
+export declare type RepositoryOverloads<entityType> = Repository<entityType> | ClassType<entityType>;
 export {};