remult 0.17.3 → 0.18.0

package/esm/src/data-providers/web-sql-data-provider.d.ts

@@ -1,14 +1,17 @@
 import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
 import { SqlCommand, SqlImplementation } from "../sql-command";
 import { EntityMetadata } from "../remult3";
+import { Remult } from "../context";
 export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
     private databaseName;
     rows: {
         [tableName: string]: any;
     };
     constructor(databaseName: string, databaseSize?: number);
+    static getDb(remult?: Remult): any;
     getLimitSqlSyntax(limit: number, offset: number): string;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     dropTable(entity: EntityMetadata): Promise<void>;
     createTable(entity: EntityMetadata<any>): Promise<void>;
     createCommand(): SqlCommand;

package/esm/src/data-providers/web-sql-data-provider.js

@@ -1,6 +1,6 @@
 import { isAutoIncrement } from "../remult3";
 import { SqlDatabase } from "./sql-database";
-import { getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+import { dbNamesOf, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
 //SqlDatabase.LogToConsole = true;
 export class WebSqlDataProvider {
     constructor(databaseName, databaseSize = 2 * 1024 * 1024) {
@@ -8,41 +8,55 @@ export class WebSqlDataProvider {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
+    // return instance of websql.Database class - see @types/websql
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.db) {
+            throw "the data provider is not a WebSqlDataProvider";
+        }
+        return me.db;
+    }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }
     async entityIsUsedForTheFirstTime(entity) {
         await this.createTable(entity);
     }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            await this.createTable(entity);
+        }
+    }
     async dropTable(entity) {
-        let e = await getDbNameProvider(entity);
-        let sql = 'drop  table if exists ' + e.entityName;
+        let e = await dbNamesOf(entity);
+        let sql = 'drop  table if exists ' + e.$entityName;
         if (SqlDatabase.LogToConsole)
-            console.log(sql);
+            console.info(sql);
         await this.createCommand().execute(sql);
     }
     async createTable(entity) {
         let result = '';
-        let e = await getDbNameProvider(entity);
+        let e = await dbNamesOf(entity);
         for (const x of entity.fields) {
-            if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
+            if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
                 if (result.length != 0)
                     result += ',';
                 result += '\r\n  ';
                 if (isAutoIncrement(x)) {
                     if (x.key != entity.idMetadata.field.key)
                         throw "in web sql, autoincrement is only allowed for primary key";
-                    result += e.nameOf(x) + ' integer primary key autoincrement';
+                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
                 }
                 else {
-                    result += this.addColumnSqlSyntax(x, e.nameOf(x));
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
                     if (x.key == entity.idMetadata.field.key) {
                         result += ' primary key';
                     }
                 }
             }
         }
-        let sql = 'create table if not exists ' + e.entityName + ' (' + result + '\r\n)';
+        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
         if (SqlDatabase.LogToConsole)
             console.log(sql);
         await this.createCommand().execute(sql);

package/esm/src/entity.d.ts

@@ -1,6 +1,6 @@
 import { Allowed, AllowedForInstance } from "./context";
 import { FieldMetadata as FieldMetadata } from './column-interfaces';
-import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef } from "./remult3";
+import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from "./remult3";
 export interface EntityOptions<entityType = any> {
     /**A human readable name for the entity */
     caption?: string;
@@ -67,7 +67,7 @@ export interface EntityOptions<entityType = any> {
    */
     dbName?: string;
     /** For entities that are based on SQL expressions instead of a physical table or view*/
-    sqlExpression?: string | ((entity: FieldsMetadata<entityType>) => string | Promise<string>);
+    sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
     /** An arrow function that identifies the `id` column to use for this entity
      * @example
      * //Single column id

package/esm/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -1,7 +1,8 @@
-import { SqlCommand } from "../sql-command";
+import { SqlCommandWithParameters } from "../sql-command";
 import { Filter, FilterConsumer } from './filter-interfaces';
 import { FieldMetadata } from "../column-interfaces";
-import { EntityMetadata } from "../remult3/remult3";
+import { EntityFilter, OmitEB } from "../remult3/remult3";
+import { EntityMetadataOverloads, RepositoryOverloads } from "../remult3";
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
     private r;
     private nameProvider;
@@ -9,7 +10,7 @@ export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer
     _addWhere: boolean;
     promises: Promise<void>[];
     resolveWhere(): Promise<string>;
-    constructor(r: SqlCommand, nameProvider: dbNameProvider);
+    constructor(r: SqlCommandWithParameters, nameProvider: EntityDbNamesBase);
     custom(key: string, customItem: any): void;
     or(orElements: Filter[]): void;
     isNull(col: FieldMetadata): void;
@@ -32,19 +33,18 @@ export interface CustomSqlFilterObject {
 }
 export declare class CustomSqlFilterBuilder {
     private r;
-    constructor(r: SqlCommand);
+    constructor(r: SqlCommandWithParameters);
     sql: string;
     addParameterAndReturnSqlToken<valueType>(val: valueType, field?: FieldMetadata<valueType>): string;
+    filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<string>;
 }
-export declare function getDbNameProvider(meta: EntityMetadata): Promise<dbNameProvider>;
-export declare class dbNameProviderImpl {
-    map: Map<string, string>;
-    nameOf(field: FieldMetadata<any>): string;
-    entityName: string;
-    isDbReadonly(x: FieldMetadata): boolean;
-}
-export interface dbNameProvider {
-    nameOf(field: FieldMetadata<any>): string;
-    entityName: string;
-    isDbReadonly(x: FieldMetadata): boolean;
-}
+export declare function isDbReadonly<entityType>(field: FieldMetadata, dbNames: EntityDbNames<entityType>): boolean;
+export declare type EntityDbNamesBase = {
+    $entityName: string;
+    $dbNameOf(field: FieldMetadata<any> | string): string;
+    toString(): string;
+};
+export declare type EntityDbNames<entityType> = {
+    [Properties in keyof Required<OmitEB<entityType>>]: string;
+} & EntityDbNamesBase;
+export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>): Promise<EntityDbNames<entityType>>;

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,3 +1,5 @@
+import { getEntityMetadata } from "../remult3";
+import { SqlDatabase } from "../data-providers/sql-database";
 export class FilterConsumerBridgeToSqlRequest {
     constructor(r, nameProvider) {
         this.r = r;
@@ -44,15 +46,15 @@ export class FilterConsumerBridgeToSqlRequest {
         })());
     }
     isNull(col) {
-        this.promises.push((async () => this.addToWhere(this.nameProvider.nameOf(col) + ' is null'))());
+        this.promises.push((async () => this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is null'))());
     }
     isNotNull(col) {
-        this.promises.push((async () => this.addToWhere(this.nameProvider.nameOf(col) + ' is not null'))());
+        this.promises.push((async () => this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is not null'))());
     }
     isIn(col, val) {
         this.promises.push((async () => {
             if (val && val.length > 0)
-                this.addToWhere(this.nameProvider.nameOf(col) + " in (" + val.map(x => this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x))).join(",") + ")");
+                this.addToWhere(this.nameProvider.$dbNameOf(col) + " in (" + val.map(x => this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x))).join(",") + ")");
             else
                 this.addToWhere('1 = 0 /*isIn with no values*/');
         })());
@@ -77,12 +79,12 @@ export class FilterConsumerBridgeToSqlRequest {
     }
     containsCaseInsensitive(col, val) {
         this.promises.push((async () => {
-            this.addToWhere('lower (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')");
+            this.addToWhere('lower (' + this.nameProvider.$dbNameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')");
         })());
     }
     add(col, val, operator) {
         this.promises.push((async () => {
-            let x = this.nameProvider.nameOf(col) + ' ' + operator + ' ' + this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
+            let x = this.nameProvider.$dbNameOf(col) + ' ' + operator + ' ' + this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
             this.addToWhere(x);
         })());
     }
@@ -117,23 +119,29 @@ export class CustomSqlFilterBuilder {
             val = field.valueConverter.toDb(val);
         return this.r.addParameterAndReturnSqlToken(val);
     }
-}
-export async function getDbNameProvider(meta) {
-    var result = new dbNameProviderImpl();
-    for (const f of meta.fields) {
-        result.map.set(f.key, await f.getDbName());
+    async filterToRaw(repo, condition) {
+        return SqlDatabase.filterToRaw(repo, condition, this);
     }
-    result.entityName = await meta.getDbName();
-    return result;
 }
-export class dbNameProviderImpl {
-    constructor() {
-        this.map = new Map();
-    }
-    nameOf(field) {
-        return this.map.get(field.key);
-    }
-    isDbReadonly(x) {
-        return (x.dbReadOnly || x.isServerExpression || this.nameOf(x) != x.options.dbName);
+export function isDbReadonly(field, dbNames) {
+    return (field.dbReadOnly || field.isServerExpression || dbNames.$dbNameOf(field) != field.options.dbName);
+}
+export async function dbNamesOf(repo) {
+    var meta = getEntityMetadata(repo);
+    const result = {
+        $entityName: await meta.getDbName(),
+        toString: () => result.$entityName,
+        $dbNameOf: (field) => {
+            var key;
+            if (typeof field === "string")
+                key = field;
+            else
+                key = field.key;
+            return result[key];
+        }
+    };
+    for (const field of meta.fields) {
+        result[field.key] = await field.getDbName();
     }
+    return result;
 }

package/esm/src/filter/filter-interfaces.d.ts

@@ -6,8 +6,8 @@ export declare class Filter {
     constructor(apply?: (add: FilterConsumer) => void);
     __applyToConsumer(add: FilterConsumer): void;
     static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
-    static createCustom<entityType>(customFilterTranslator: (r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & customFilterInfo<entityType>;
-    static createCustom<entityType, argsType>(customFilterTranslator: (r: Remult, args: argsType) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): ((y: argsType) => EntityFilter<entityType>) & customFilterInfo<entityType>;
+    static createCustom<entityType>(rawFilterTranslator: (unused: never, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & rawFilterInfo<entityType>;
+    static createCustom<entityType, argsType>(rawFilterTranslator: (args: argsType, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): ((y: argsType) => EntityFilter<entityType>) & rawFilterInfo<entityType>;
     static fromEntityFilter<T>(entity: EntityMetadata<T>, whereItem: EntityFilter<T>): Filter;
     toJson(): any;
     static entityFilterToJson<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>): any;
@@ -77,9 +77,9 @@ export declare function entityFilterToJson<T>(entityDefs: EntityMetadata<T>, whe
 export declare function buildFilterFromRequestParameters(entity: EntityMetadata, filterInfo: {
     get: (key: string) => any;
 }): EntityFilter<any>;
-export interface customFilterInfo<entityType> {
-    customFilterInfo: {
+export interface rawFilterInfo<entityType> {
+    rawFilterInfo: {
         key: string;
-        customFilterTranslator: (r: Remult, args: any) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+        rawFilterTranslator: (args: any, r: Remult) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
     };
 }

package/esm/src/filter/filter-interfaces.js

@@ -14,18 +14,18 @@ export class Filter {
             return await filter();
         return filter;
     }
-    static createCustom(customFilterTranslator, key = '') {
-        let customFilterInfo = { key: key, customFilterTranslator };
+    static createCustom(rawFilterTranslator, key = '') {
+        let rawFilterInfo = { key: key, rawFilterTranslator };
         return Object.assign((x) => {
             let z = {};
             if (x == undefined)
                 x = {};
-            if (!customFilterInfo.key)
+            if (!rawFilterInfo.key)
                 throw "Usage of custom filter before a key was assigned to it";
             return {
-                [customUrlToken + customFilterInfo.key]: x
+                [customUrlToken + rawFilterInfo.key]: x
             };
-        }, { customFilterInfo });
+        }, { rawFilterInfo });
     }
     static fromEntityFilter(entity, whereItem) {
         let result = [];
@@ -79,6 +79,7 @@ export class Filter {
                                             break;
                                         case "$ne":
                                         case "!=":
+                                        case "$nin":
                                             found = true;
                                             if (Array.isArray(element)) {
                                                 result.push(fh.isNotIn(element));
@@ -86,6 +87,10 @@ export class Filter {
                                             else
                                                 result.push(fh.isDifferentFrom(element));
                                             break;
+                                        case "$in":
+                                            found = true;
+                                            result.push(fh.isIn(element));
+                                            break;
                                         case "$contains":
                                             found = true;
                                             result.push(fh.contains(element));
@@ -123,9 +128,9 @@ export class Filter {
             let r = [];
             for (const key in entity.entityType) {
                 const element = entity.entityType[key];
-                if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
-                    if (element.customFilterInfo.key == filterKey) {
-                        r.push(await Filter.fromEntityFilter(entity, await element.customFilterInfo.customFilterTranslator(remult, custom)));
+                if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
+                    if (element.rawFilterInfo.key == filterKey) {
+                        r.push(await Filter.fromEntityFilter(entity, await element.rawFilterInfo.rawFilterTranslator(custom, remult)));
                     }
                 }
             }
@@ -259,34 +264,34 @@ export class FilterSerializer {
         }));
     }
     isNull(col) {
-        this.add(col.key + "_null", true);
+        this.add(col.key + ".null", true);
     }
     isNotNull(col) {
-        this.add(col.key + "_null", false);
+        this.add(col.key + ".null", false);
     }
     isIn(col, val) {
-        this.add(col.key + "_in", val.map(x => col.valueConverter.toJson(x)));
+        this.add(col.key + ".in", val.map(x => col.valueConverter.toJson(x)));
     }
     isEqualTo(col, val) {
         this.add(col.key, col.valueConverter.toJson(val));
     }
     isDifferentFrom(col, val) {
-        this.add(col.key + '_ne', col.valueConverter.toJson(val));
+        this.add(col.key + '.ne', col.valueConverter.toJson(val));
     }
     isGreaterOrEqualTo(col, val) {
-        this.add(col.key + '_gte', col.valueConverter.toJson(val));
+        this.add(col.key + '.gte', col.valueConverter.toJson(val));
     }
     isGreaterThan(col, val) {
-        this.add(col.key + '_gt', col.valueConverter.toJson(val));
+        this.add(col.key + '.gt', col.valueConverter.toJson(val));
     }
     isLessOrEqualTo(col, val) {
-        this.add(col.key + '_lte', col.valueConverter.toJson(val));
+        this.add(col.key + '.lte', col.valueConverter.toJson(val));
     }
     isLessThan(col, val) {
-        this.add(col.key + '_lt', col.valueConverter.toJson(val));
+        this.add(col.key + '.lt', col.valueConverter.toJson(val));
     }
     containsCaseInsensitive(col, val) {
-        this.add(col.key + "_contains", val);
+        this.add(col.key + ".contains", val);
     }
 }
 export function entityFilterToJson(entityDefs, where) {
@@ -337,13 +342,13 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
         }
         let c = new filterHelper(col);
         addFilter('', val => val);
-        addFilter('_gt', val => ({ "$gt": val }));
-        addFilter('_gte', val => ({ "$gte": val }));
-        addFilter('_lt', val => ({ "$lt": val }));
-        addFilter('_lte', val => ({ "$lte": val }));
-        addFilter('_ne', val => ({ "$ne": val }));
-        addFilter('_in', val => val, true);
-        var nullFilter = filterInfo.get(col.key + "_null");
+        addFilter('.gt', val => ({ "$gt": val }));
+        addFilter('.gte', val => ({ "$gte": val }));
+        addFilter('.lt', val => ({ "$lt": val }));
+        addFilter('.lte', val => ({ "$lte": val }));
+        addFilter('.ne', val => ({ "$ne": val }));
+        addFilter('.in', val => val, true);
+        var nullFilter = filterInfo.get(col.key + ".null");
         if (nullFilter) {
             nullFilter = nullFilter.toString().trim().toLowerCase();
             switch (nullFilter) {
@@ -357,7 +362,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                     break;
             }
         }
-        addFilter('_contains', val => ({ $contains: val }), false, true);
+        addFilter('.contains', val => ({ $contains: val }), false, true);
     });
     let val = filterInfo.get('OR');
     if (val) {
@@ -370,7 +375,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
     }
     for (const key in entity.entityType) {
         const element = entity.entityType[key];
-        if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+        if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
             let custom = filterInfo.get(customUrlToken + key);
             if (custom !== undefined) {
                 where.push({ [customUrlToken + key]: custom });

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,184 @@
+import { RestDataProvider } from '../data-providers/rest-data-provider';
+import { buildRestDataProvider } from "../buildRestDataProvider";
+import { LiveQuerySubscriber, liveQueryKeepAliveRoute } from './SubscriptionChannel';
+/* @internal*/
+export class LiveQueryClient {
+    constructor(apiProvider, getUserId) {
+        this.apiProvider = apiProvider;
+        this.getUserId = getUserId;
+        this.queries = new Map();
+        this.channels = new Map();
+    }
+    wrapMessageHandling(handleMessage) {
+        var x = this.apiProvider().wrapMessageHandling;
+        if (x)
+            x(handleMessage);
+        else
+            handleMessage();
+    }
+    ;
+    runPromise(p) {
+        return p;
+    }
+    close() {
+        this.queries.clear();
+        this.channels.clear();
+        this.closeIfNoListeners();
+    }
+    async subscribeChannel(key, onResult) {
+        let onUnsubscribe = () => { };
+        const client = await this.openIfNoOpened();
+        try {
+            let q = this.channels.get(key);
+            if (!q) {
+                this.channels.set(key, q = new MessageChannel());
+                try {
+                    q.unsubscribe = await client.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value)), err => {
+                        onResult.error(err);
+                    });
+                }
+                catch (err) {
+                    onResult.error(err);
+                    throw err;
+                }
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    this.channels.delete(key);
+                    q.unsubscribe();
+                }
+                this.closeIfNoListeners();
+            };
+        }
+        catch (err) {
+            onResult.error(err);
+            throw err;
+        }
+        return () => {
+            onUnsubscribe();
+            onUnsubscribe = () => { };
+        };
+    }
+    closeIfNoListeners() {
+        if (this.client)
+            if (this.queries.size === 0 && this.channels.size === 0) {
+                this.runPromise(this.client.then(x => x.close()));
+                this.client = undefined;
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+    }
+    subscribe(repo, options, listener) {
+        let alive = true;
+        let onUnsubscribe = () => { alive = false; };
+        this.runPromise(repo.buildEntityDataProviderFindOptions(options)
+            .then(opts => {
+            if (!alive)
+                return;
+            const { createKey, subscribe } = new RestDataProvider(this.apiProvider).getEntityDataProvider(repo.metadata).buildFindRequest(opts);
+            const eventTypeKey = createKey();
+            let q = this.queries.get(eventTypeKey);
+            if (!q) {
+                this.queries.set(eventTypeKey, q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }, this.getUserId()));
+                q.subscribeCode = () => {
+                    if (q.unsubscribe) {
+                        q.unsubscribe();
+                        q.unsubscribe = () => { };
+                    }
+                    this.runPromise(this.subscribeChannel(q.queryChannel, {
+                        next: (value) => this.runPromise(q.handle(value)),
+                        complete: () => { },
+                        error: er => {
+                            q.listeners.forEach(l => l.error(er));
+                        }
+                    }).then(unsubscribeToChannel => {
+                        if (q.listeners.length == 0) {
+                            unsubscribeToChannel();
+                            return;
+                        }
+                        this.runPromise(subscribe(q.id)
+                            .then(r => {
+                            if (q.listeners.length === 0) {
+                                r.unsubscribe();
+                                unsubscribeToChannel();
+                                return;
+                            }
+                            this.runPromise(q.setAllItems(r.result));
+                            q.unsubscribe = () => {
+                                q.unsubscribe = () => { };
+                                unsubscribeToChannel();
+                                this.runPromise(r.unsubscribe());
+                            };
+                        })
+                            .catch(err => {
+                            listener.error(err);
+                        }));
+                    })).catch(err => {
+                        q.listeners.forEach(l => l.error(err));
+                    });
+                };
+                q.subscribeCode();
+            }
+            else {
+                q.sendDefaultState(listener.next);
+            }
+            q.listeners.push(listener);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(listener), 1);
+                listener.complete();
+                if (q.listeners.length == 0) {
+                    this.queries.delete(eventTypeKey);
+                    q.unsubscribe();
+                }
+                this.closeIfNoListeners();
+            };
+        })
+            .catch(err => {
+            listener.error(err);
+        }));
+        return () => {
+            onUnsubscribe();
+        };
+    }
+    openIfNoOpened() {
+        if (!this.client) {
+            this.interval = setInterval(async () => {
+                const ids = [];
+                for (const q of this.queries.values()) {
+                    ids.push(q.queryChannel);
+                }
+                if (ids.length > 0) {
+                    let p = this.apiProvider();
+                    let { actionInfo } = await import('../server-action');
+                    const invalidIds = await this.runPromise(await actionInfo.runActionWithoutBlockingUI(() => buildRestDataProvider(p.httpClient).post(p.url + '/' + liveQueryKeepAliveRoute, ids)));
+                    for (const id of invalidIds) {
+                        for (const q of this.queries.values()) {
+                            if (q.queryChannel === id)
+                                q.subscribeCode();
+                        }
+                    }
+                }
+            }, 30000);
+            return this.runPromise(this.client =
+                this.apiProvider().subscriptionClient.openConnection(() => {
+                    for (const q of this.queries.values()) {
+                        q.subscribeCode();
+                    }
+                }));
+        }
+        return this.client;
+    }
+}
+class MessageChannel {
+    constructor() {
+        this.unsubscribe = () => { };
+        this.listeners = [];
+    }
+    async handle(message) {
+        for (const l of this.listeners) {
+            l.next(message);
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import { SubscriptionClient, SubscriptionClientConnection } from "./SubscriptionChannel";
+export declare class SseSubscriptionClient implements SubscriptionClient {
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare const ConnectionNotFoundError = "client connection not found";