remult 0.18.1-exp.30 → 0.18.1-exp.32

package/esm/index.d.ts

@@ -26,3 +26,4 @@ export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
 export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
 export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';
+export { DataProviderLiveQueryStorage } from './live-query/data-provider-live-query-storage';

package/esm/index.js

@@ -24,3 +24,4 @@ export { remult } from './src/remult-proxy';
 //export { getId } from './src/remult3/getId';
 export { InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
 export { SubscriptionChannel } from './src/live-query/SubscriptionChannel';
+export { DataProviderLiveQueryStorage } from './live-query/data-provider-live-query-storage';

package/esm/live-query/data-provider-live-query-storage.d.ts

@@ -1,9 +1,12 @@
-import { DataProvider } from "../src/data-interfaces";
+import { Remult } from "../src/context";
+import { CanEnsureSchema, DataProvider } from "../src/data-interfaces";
 import { LiveQueryStorage, StoredQuery } from "../src/live-query/SubscriptionServer";
 import { Repository } from "../src/remult3";
-export declare class DataProviderLiveQueryStorage implements LiveQueryStorage {
+export declare class DataProviderLiveQueryStorage implements LiveQueryStorage, CanEnsureSchema {
     repo: Promise<Repository<LiveQueryStorageEntity>>;
+    dataProvider: Promise<DataProvider>;
     constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    ensureSchema(remult: Remult): Promise<void>;
     add({ id, entityKey, data }: StoredQuery): void;
     remove(queryId: string): void;
     forEach(entityKey: string, callback: (args: {
@@ -16,6 +19,6 @@ declare class LiveQueryStorageEntity {
     id: string;
     entityKey: string;
     data: any;
-    lastUsed: Date;
+    lastUsedIso: string;
 }
 export {};

package/esm/live-query/data-provider-live-query-storage.js

@@ -4,13 +4,17 @@ import { Remult } from "../src/context";
 import { Entity, Fields } from "../src/remult3";
 export class DataProviderLiveQueryStorage {
     constructor(dataProvider) {
-        this.repo = initDataProvider(dataProvider).then(dp => new Remult(dp).repo(LiveQueryStorageEntity));
+        this.dataProvider = initDataProvider(dataProvider);
+        this.repo = this.dataProvider.then(dp => new Remult(dp).repo(LiveQueryStorageEntity));
+    }
+    async ensureSchema(remult) {
+        await (await this.dataProvider).ensureSchema([(await this.repo).metadata], "Live query storage");
     }
-    //TODO - consider case where query id already exists (reconnect)
     add({ id, entityKey, data }) {
-        this.repo.then(repo => repo.insert({
-            id, entityKey, data
-        }));
+        this.repo.then(async (repo) => {
+            const q = await repo.findId(id, { createIfNotFound: true });
+            await repo.save({ ...q, entityKey, data });
+        });
     }
     remove(queryId) {
         this.repo.then(repo => repo.delete(queryId)).catch(() => { });
@@ -19,9 +23,9 @@ export class DataProviderLiveQueryStorage {
         const repo = await this.repo;
         let d = new Date();
         d.setMinutes(d.getMinutes() - 5);
+        const iso = d.toISOString();
         for (const query of await repo.find({ where: { entityKey } })) {
-            //TODO - has timezone issues - if two servers are connected from two timezones this will fail!
-            if (query.lastUsed < d)
+            if (query.lastUsedIso < iso)
                 await repo.delete(query);
             else {
                 await callback({
@@ -36,7 +40,7 @@ export class DataProviderLiveQueryStorage {
     async keepAliveAndReturnUnknownQueryIds(queryIds) {
         const repo = await this.repo;
         for (const query of await repo.find({ where: { id: queryIds } })) {
-            query.lastUsed = new Date();
+            query.lastUsedIso = new Date().toISOString();
             await repo.save(query);
             queryIds = queryIds.filter(x => x !== query.id);
         }
@@ -47,7 +51,7 @@ let LiveQueryStorageEntity = class LiveQueryStorageEntity {
     constructor() {
         this.id = '';
         this.entityKey = '';
-        this.lastUsed = new Date();
+        this.lastUsedIso = new Date().toISOString();
     }
 };
 __decorate([
@@ -63,9 +67,9 @@ __decorate([
     __metadata("design:type", Object)
 ], LiveQueryStorageEntity.prototype, "data", void 0);
 __decorate([
-    Fields.date(),
+    Fields.string(),
     __metadata("design:type", Object)
-], LiveQueryStorageEntity.prototype, "lastUsed", void 0);
+], LiveQueryStorageEntity.prototype, "lastUsedIso", void 0);
 LiveQueryStorageEntity = __decorate([
     Entity(undefined, {
         dbName: 'remult_live_query_storage'

package/esm/postgres/postgres-data-provider.d.ts

@@ -16,6 +16,7 @@ export declare class PostgresDataProvider implements SqlImplementation {
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;
     constructor(pool: PostgresPool);
+    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {
@@ -25,6 +26,5 @@ export declare function createPostgresConnection(options?: {
     connectionString?: string;
     sslInDev?: boolean;
     configuration?: "heroku" | PoolConfig;
-    autoCreateTables?: boolean;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

package/esm/postgres/postgres-data-provider.js

@@ -1,6 +1,6 @@
 import { Pool } from 'pg';
 import { Remult } from '../src/context';
-import { PostgresSchemaBuilder, verifyStructureOfAllEntities } from './schema-builder';
+import { PostgresSchemaBuilder } from './schema-builder';
 import { SqlDatabase } from '../src/data-providers/sql-database';
 export class PostgresDataProvider {
     constructor(pool) {
@@ -22,6 +22,11 @@ export class PostgresDataProvider {
     createCommand() {
         return new PostgresBridgeToSQLCommand(this.pool);
     }
+    async ensureSchema(entities, caption) {
+        var db = new SqlDatabase(this);
+        var sb = new PostgresSchemaBuilder(db);
+        await sb.ensureSchema(entities, caption);
+    }
     async transaction(action) {
         let client = await this.pool.connect();
         try {
@@ -92,8 +97,6 @@ export async function createPostgresConnection(options) {
     const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
     let remult = new Remult();
     remult.dataProvider = (db);
-    if (options.autoCreateTables === undefined || options.autoCreateTables)
-        await verifyStructureOfAllEntities(db, remult);
     return db;
 }
 export async function preparePostgresQueueStorage(sql) {
@@ -101,7 +104,6 @@ export async function preparePostgresQueueStorage(sql) {
     c.dataProvider = (sql);
     let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
-    await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);
-    await new PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata);
+    await sql.ensureSchema([e.metadata], "Queue storage");
     return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
 }

package/esm/postgres/schema-builder.d.ts

@@ -7,6 +7,7 @@ export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Re
 export declare class PostgresSchemaBuilder {
     private pool;
     verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
     addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
     verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;

package/esm/postgres/schema-builder.js

@@ -47,18 +47,30 @@ export class PostgresSchemaBuilder {
         if (!remult) {
             remult = RemultProxy.defaultRemult;
         }
-        if (PostgresSchemaBuilder.logToConsole)
-            console.time("Postgres Auto create tables and columns");
         const completed = new Set();
+        const entities = [];
         for (const entityClass of [...allEntities].reverse()) {
             let entity = remult.repo(entityClass).metadata;
             let e = await dbNamesOf(entity);
             if (completed.has(e.$entityName))
                 continue;
             completed.add(e.$entityName);
+            entities.push(entity);
+        }
+        await this.ensureSchema(entities);
+    }
+    async ensureSchema(entities, caption) {
+        //TODO - discuss this console log
+        let desc = "Ensure postgres schema";
+        if (caption)
+            desc += " - " + caption;
+        if (PostgresSchemaBuilder.logToConsole)
+            console.time(desc);
+        for (const entity of entities) {
+            let e = await dbNamesOf(entity);
             try {
                 if (!entity.options.sqlExpression) {
-                    if ((await e.$entityName).toLowerCase().indexOf('from ') < 0) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
                         await this.createIfNotExist(entity);
                         await this.verifyAllColumns(entity);
                     }
@@ -69,7 +81,7 @@ export class PostgresSchemaBuilder {
             }
         }
         if (PostgresSchemaBuilder.logToConsole)
-            console.timeEnd("Postgres Auto create tables and columns");
+            console.timeEnd(desc);
     }
     async createIfNotExist(entity) {
         var c = this.pool.createCommand();

package/esm/remult-knex/index.d.ts

@@ -11,12 +11,14 @@ export declare class KnexDataProvider implements DataProvider {
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
     static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
-    supportsrawFilter?: boolean;
+    supportsRawFilter?: boolean;
+    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
 }
 export declare type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
 export declare class KnexSchemaBuilder {
     private knex;
     verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
     addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
     verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
@@ -24,4 +26,4 @@ export declare class KnexSchemaBuilder {
     constructor(knex: Knex);
 }
 export declare function buildColumn(x: FieldMetadata, dbName: string, b: Knex.CreateTableBuilder): void;
-export declare function createKnexDataProvider(config: Knex.Config, autoCreateTables?: boolean): Promise<KnexDataProvider>;
+export declare function createKnexDataProvider(config: Knex.Config): Promise<KnexDataProvider>;

package/esm/remult-knex/index.js

@@ -1,6 +1,6 @@
 import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfaces";
 import { dbNamesOf, isDbReadonly } from "../src/filter/filter-consumer-bridge-to-sql-request";
-import { allEntities, Remult } from "../src/context";
+import { allEntities } from "../src/context";
 import { isAutoIncrement, getRepository } from "../src/remult3";
 import { ValueConverters } from "../src/valueConverters";
 import { CompoundIdField } from '../src/column';
@@ -45,6 +45,10 @@ export class KnexDataProvider {
         let r = await b.resolveWhere();
         return knex => r.forEach(y => y(knex));
     }
+    async ensureSchema(entities, caption) {
+        var sb = new KnexSchemaBuilder(this.knex);
+        await sb.ensureSchema(entities, caption);
+    }
 }
 class KnexEntityDataProvider {
     constructor(entity, knex) {
@@ -279,24 +283,31 @@ export class KnexSchemaBuilder {
     async verifyStructureOfAllEntities(remult) {
         if (!remult)
             remult = RemultProxy.defaultRemult;
+        const entities = allEntities.map(x => remult.repo(x).metadata);
+        this.ensureSchema(entities);
+    }
+    async ensureSchema(entities, caption) {
+        let desc = "ensure knex schema";
+        if (caption)
+            desc += " - " + caption;
         if (KnexSchemaBuilder.logToConsole)
-            console.time("Knex Auto create tables and columns");
-        for (const entity of allEntities) {
-            let metadata = remult.repo(entity).metadata;
+            console.time(desc);
+        for (const entity of entities) {
+            let e = await dbNamesOf(entity);
             try {
-                if (!metadata.options.sqlExpression) {
-                    if ((await metadata.getDbName()).toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(metadata);
-                        await this.verifyAllColumns(metadata);
+                if (!entity.options.sqlExpression) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
                     }
                 }
             }
             catch (err) {
-                console.error("failed verify structure of " + await metadata.getDbName() + " ", err);
+                console.error("failed verify structure of " + e.$entityName + " ", err);
             }
         }
         if (KnexSchemaBuilder.logToConsole)
-            console.timeEnd("Knex Auto create tables and columns");
+            console.timeEnd(desc);
     }
     async createIfNotExist(entity) {
         const e = await dbNamesOf(entity);
@@ -405,10 +416,8 @@ function logSql(who) {
         console.info(who.toSQL());
     return who;
 }
-export async function createKnexDataProvider(config, autoCreateTables = true) {
+export async function createKnexDataProvider(config) {
     let k = (await import('knex')).default(config);
     let result = new KnexDataProvider(k);
-    if (autoCreateTables)
-        await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));
     return result;
 }

package/esm/server/expressBridge.d.ts

@@ -19,6 +19,12 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
         toJson: (request: RequestType) => any;
         fromJson: (request: any) => RequestType;
     };
+    /** Will create tables and columns in supporting databases. default: true
+     *
+     * @description
+     * when set to true, it'll create entities that do not exist, and add columns that are missing.
+    */
+    ensureSchema?: boolean;
     getUser?: (request: RequestType) => Promise<UserInfo | undefined>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;

package/esm/server/expressBridge.js

@@ -27,19 +27,30 @@ export function createRemultServerCore(options) {
         options.queueStorage = new InMemoryQueueStorage();
     }
     let dataProvider = initDataProvider(options.dataProvider);
+    if (options.ensureSchema === undefined)
+        options.ensureSchema = true;
     RemultAsyncLocalStorage.enable();
-    if (options.initApi) {
-        dataProvider = dataProvider.then(async (dp) => {
-            var remult = new Remult(dp);
-            await new Promise((res) => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+    dataProvider = dataProvider.then(async (dp) => {
+        var remult = new Remult(dp);
+        await new Promise((res) => {
+            RemultAsyncLocalStorage.instance.run(remult, async () => {
+                if (options.ensureSchema) {
+                    if (dp.ensureSchema) {
+                        const entitiesMetadata = options.entities.map(e => remult.repo(e).metadata);
+                        await dp.ensureSchema(entitiesMetadata);
+                        for (const item of [options.liveQueryStorage, options.queueStorage]) {
+                            if (item?.ensureSchema)
+                                await item.ensureSchema(remult);
+                        }
+                    }
+                }
+                if (options.initApi)
                     await options.initApi(remult);
-                    res({});
-                });
+                res({});
             });
-            return dp;
         });
-    }
+        return dp;
+    });
     if (!options.requestSerializer) {
         options.requestSerializer = {
             toJson: x => {

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

@@ -1,10 +1,15 @@
 import { Sort } from './sort';
 import { Filter } from './filter/filter-interfaces';
 import { EntityMetadata, OmitEB } from './remult3';
+import type { Remult } from './context';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsrawFilter?: boolean;
+    supportsRawFilter?: boolean;
+    ensureSchema?(entities: EntityMetadata[], caption?: string): Promise<void>;
+}
+export interface CanEnsureSchema {
+    ensureSchema(remult: Remult): Promise<void>;
 }
 export interface EntityDataProvider {
     count(where: Filter): Promise<number>;

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -8,7 +8,7 @@ export declare class RestDataProvider implements DataProvider {
     constructor(apiProvider: () => ApiClient);
     getEntityDataProvider(entity: EntityMetadata): RestEntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsrawFilter: boolean;
+    supportsRawFilter: boolean;
 }
 export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;

package/esm/src/data-providers/rest-data-provider.js

@@ -5,7 +5,7 @@ import { actionInfo } from '../server-action';
 export class RestDataProvider {
     constructor(apiProvider) {
         this.apiProvider = apiProvider;
-        this.supportsrawFilter = true;
+        this.supportsRawFilter = true;
     }
     getEntityDataProvider(entity) {
         return new RestEntityDataProvider(() => {

package/esm/src/data-providers/sql-database.d.ts

@@ -8,6 +8,7 @@ export declare class SqlDatabase implements DataProvider {
     static getDb(remult?: Remult): SqlDatabase;
     createCommand(): SqlCommand;
     execute(sql: string): Promise<SqlResult>;
+    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;

package/esm/src/data-providers/sql-database.js

@@ -26,6 +26,10 @@ export class SqlDatabase {
     _getSourceSql() {
         return this.sql;
     }
+    async ensureSchema(entities, caption) {
+        if (this.sql.ensureSchema)
+            await this.sql.ensureSchema(entities, caption);
+    }
     getEntityDataProvider(entity) {
         return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
             if (this.createdEntities.indexOf(dbName.$entityName) < 0) {

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

@@ -11,6 +11,7 @@ export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDa
     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

@@ -23,6 +23,11 @@ export class WebSqlDataProvider {
     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 dbNamesOf(entity);
         let sql = 'drop  table if exists ' + e.$entityName;

package/esm/src/remult3/RepositoryImplementation.js

@@ -394,7 +394,7 @@ export class RepositoryImplementation {
             };
         }
         let r = await Filter.fromEntityFilter(this.metadata, where);
-        if (r && !this.dataProvider.supportsrawFilter) {
+        if (r && !this.dataProvider.supportsRawFilter) {
             r = await Filter.translateCustomWhere(r, this.metadata, this.remult);
         }
         return r;

package/esm/src/sql-command.d.ts

@@ -4,6 +4,7 @@ export interface SqlImplementation {
     createCommand(): SqlCommand;
     transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[], caption?: string): Promise<void>;
 }
 export interface SqlCommand extends SqlCommandWithParameters {
     execute(sql: string): Promise<SqlResult>;

package/esm/src/tests/testHelper.spec.d.ts

@@ -31,6 +31,6 @@ export declare class MockRestDataProvider implements DataProvider {
     constructor(remult: Remult);
     getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsrawFilter: boolean;
+    supportsRawFilter: boolean;
 }
 export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("../data-interfaces").RestDataProviderHttpProvider;

package/esm/src/tests/testHelper.spec.js

@@ -154,7 +154,7 @@ function urlToReq(url) {
 export class MockRestDataProvider {
     constructor(remult) {
         this.remult = remult;
-        this.supportsrawFilter = true;
+        this.supportsRawFilter = true;
     }
     getEntityDataProvider(metadata) {
         let dataApi = new DataApi(this.remult.repo(metadata.entityType), this.remult);

package/index.d.ts

@@ -26,3 +26,4 @@ export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
 export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
 export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';
+export { DataProviderLiveQueryStorage } from './live-query/data-provider-live-query-storage';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubscriptionChannel = exports.InMemoryLiveQueryStorage = exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.dbNamesOf = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.describeClass = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.Entity = exports.Fields = exports.Field = void 0;
+exports.DataProviderLiveQueryStorage = exports.SubscriptionChannel = exports.InMemoryLiveQueryStorage = exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.Filter = exports.CompoundIdField = exports.OneToMany = exports.Sort = exports.IdEntity = exports.EventSource = exports.isBackend = exports.Remult = exports.Allow = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.JsonDataProvider = exports.dbNamesOf = exports.CustomSqlFilterBuilder = exports.SqlDatabase = exports.WebSqlDataProvider = exports.ArrayEntityDataProvider = exports.InMemoryDataProvider = exports.RestDataProvider = exports.describeClass = exports.CaptionTransformer = exports.ValueListInfo = exports.getValueList = exports.ValueListFieldType = exports.getEntityRef = exports.getFields = exports.FieldType = exports.ControllerBase = exports.EntityBase = exports.Entity = exports.Fields = exports.Field = void 0;
 /*
  * Public API Surface of remult
  */
@@ -66,3 +66,5 @@ var SubscriptionServer_1 = require("./src/live-query/SubscriptionServer");
 Object.defineProperty(exports, "InMemoryLiveQueryStorage", { enumerable: true, get: function () { return SubscriptionServer_1.InMemoryLiveQueryStorage; } });
 var SubscriptionChannel_1 = require("./src/live-query/SubscriptionChannel");
 Object.defineProperty(exports, "SubscriptionChannel", { enumerable: true, get: function () { return SubscriptionChannel_1.SubscriptionChannel; } });
+var data_provider_live_query_storage_1 = require("./live-query/data-provider-live-query-storage");
+Object.defineProperty(exports, "DataProviderLiveQueryStorage", { enumerable: true, get: function () { return data_provider_live_query_storage_1.DataProviderLiveQueryStorage; } });

package/live-query/data-provider-live-query-storage.d.ts

@@ -1,9 +1,12 @@
-import { DataProvider } from "../src/data-interfaces";
+import { Remult } from "../src/context";
+import { CanEnsureSchema, DataProvider } from "../src/data-interfaces";
 import { LiveQueryStorage, StoredQuery } from "../src/live-query/SubscriptionServer";
 import { Repository } from "../src/remult3";
-export declare class DataProviderLiveQueryStorage implements LiveQueryStorage {
+export declare class DataProviderLiveQueryStorage implements LiveQueryStorage, CanEnsureSchema {
     repo: Promise<Repository<LiveQueryStorageEntity>>;
+    dataProvider: Promise<DataProvider>;
     constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    ensureSchema(remult: Remult): Promise<void>;
     add({ id, entityKey, data }: StoredQuery): void;
     remove(queryId: string): void;
     forEach(entityKey: string, callback: (args: {
@@ -16,6 +19,6 @@ declare class LiveQueryStorageEntity {
     id: string;
     entityKey: string;
     data: any;
-    lastUsed: Date;
+    lastUsedIso: string;
 }
 export {};

package/live-query/data-provider-live-query-storage.js

@@ -7,15 +7,44 @@ var context_1 = require("../src/context");
 var remult3_1 = require("../src/remult3");
 var DataProviderLiveQueryStorage = /** @class */ (function () {
     function DataProviderLiveQueryStorage(dataProvider) {
-        this.repo = initDataProvider_1.initDataProvider(dataProvider).then(function (dp) {
+        this.dataProvider = initDataProvider_1.initDataProvider(dataProvider);
+        this.repo = this.dataProvider.then(function (dp) {
             return new context_1.Remult(dp).repo(LiveQueryStorageEntity);
         });
     }
-    //TODO - consider case where query id already exists (reconnect)
+    DataProviderLiveQueryStorage.prototype.ensureSchema = function (remult) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.dataProvider];
+                    case 1:
+                        _b = (_a = (_c.sent())).ensureSchema;
+                        return [4 /*yield*/, this.repo];
+                    case 2: return [4 /*yield*/, _b.apply(_a, [[(_c.sent()).metadata], "Live query storage"])];
+                    case 3:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     DataProviderLiveQueryStorage.prototype.add = function (_a) {
+        var _this = this;
         var id = _a.id, entityKey = _a.entityKey, data = _a.data;
-        this.repo.then(function (repo) { return repo.insert({
-            id: id, entityKey: entityKey, data: data
+        this.repo.then(function (repo) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var q;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, repo.findId(id, { createIfNotFound: true })];
+                    case 1:
+                        q = _a.sent();
+                        return [4 /*yield*/, repo.save(tslib_1.__assign(tslib_1.__assign({}, q), { entityKey: entityKey, data: data }))];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
         }); });
     };
     DataProviderLiveQueryStorage.prototype.remove = function (queryId) {
@@ -23,7 +52,7 @@ var DataProviderLiveQueryStorage = /** @class */ (function () {
     };
     DataProviderLiveQueryStorage.prototype.forEach = function (entityKey, callback) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var repo, d, _loop_1, _a, _b, query, e_1_1;
+            var repo, d, iso, _loop_1, _a, _b, query, e_1_1;
             var e_1, _c;
             var _this = this;
             return tslib_1.__generator(this, function (_d) {
@@ -33,11 +62,12 @@ var DataProviderLiveQueryStorage = /** @class */ (function () {
                         repo = _d.sent();
                         d = new Date();
                         d.setMinutes(d.getMinutes() - 5);
+                        iso = d.toISOString();
                         _loop_1 = function (query) {
                             return tslib_1.__generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
-                                        if (!(query.lastUsed < d)) return [3 /*break*/, 2];
+                                        if (!(query.lastUsedIso < iso)) return [3 /*break*/, 2];
                                         return [4 /*yield*/, repo.delete(query)];
                                     case 1:
                                         _a.sent();
@@ -109,7 +139,7 @@ var DataProviderLiveQueryStorage = /** @class */ (function () {
                             return tslib_1.__generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
-                                        query.lastUsed = new Date();
+                                        query.lastUsedIso = new Date().toISOString();
                                         return [4 /*yield*/, repo.save(query)];
                                     case 1:
                                         _a.sent();
@@ -158,7 +188,7 @@ var LiveQueryStorageEntity = /** @class */ (function () {
     function LiveQueryStorageEntity() {
         this.id = '';
         this.entityKey = '';
-        this.lastUsed = new Date();
+        this.lastUsedIso = new Date().toISOString();
     }
     tslib_1.__decorate([
         remult3_1.Fields.string(),
@@ -173,9 +203,9 @@ var LiveQueryStorageEntity = /** @class */ (function () {
         tslib_1.__metadata("design:type", Object)
     ], LiveQueryStorageEntity.prototype, "data", void 0);
     tslib_1.__decorate([
-        remult3_1.Fields.date(),
+        remult3_1.Fields.string(),
         tslib_1.__metadata("design:type", Object)
-    ], LiveQueryStorageEntity.prototype, "lastUsed", void 0);
+    ], LiveQueryStorageEntity.prototype, "lastUsedIso", void 0);
     LiveQueryStorageEntity = tslib_1.__decorate([
         remult3_1.Entity(undefined, {
             dbName: 'remult_live_query_storage'