remult 0.18.1-exp.34 → 0.18.1-exp.35

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

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

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

@@ -7,12 +7,11 @@ export class DataProviderLiveQueryStorage {
         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");
+    async ensureSchema() {
+        await (await this.dataProvider).ensureSchema([(await this.repo).metadata]);
     }
     async add({ id, entityKey, data }) {
         await this.repo.then(async (repo) => {
-            //TODO - talk to yoni about how this fails with non entity ref - since repo save here makes a wrong decision, since an item returns
             const q = await repo.findId(id, { createIfNotFound: true });
             await q.assign({ entityKey, data }).save();
         });

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

@@ -16,7 +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>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {

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

@@ -22,10 +22,10 @@ export class PostgresDataProvider {
     createCommand() {
         return new PostgresBridgeToSQLCommand(this.pool);
     }
-    async ensureSchema(entities, caption) {
+    async ensureSchema(entities) {
         var db = new SqlDatabase(this);
         var sb = new PostgresSchemaBuilder(db);
-        await sb.ensureSchema(entities, caption);
+        await sb.ensureSchema(entities);
     }
     async transaction(action) {
         let client = await this.pool.connect();
@@ -104,6 +104,6 @@ export async function preparePostgresQueueStorage(sql) {
     c.dataProvider = (sql);
     let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
-    await sql.ensureSchema([e.metadata], "Queue storage");
+    await sql.ensureSchema([e.metadata]);
     return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
 }

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

@@ -7,7 +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>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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

@@ -59,13 +59,7 @@ export class PostgresSchemaBuilder {
         }
         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);
+    async ensureSchema(entities) {
         for (const entity of entities) {
             let e = await dbNamesOf(entity);
             try {
@@ -80,8 +74,6 @@ export class PostgresSchemaBuilder {
                 console.error("failed verify structure of " + e.$entityName + " ", err);
             }
         }
-        if (PostgresSchemaBuilder.logToConsole)
-            console.timeEnd(desc);
     }
     async createIfNotExist(entity) {
         var c = this.pool.createCommand();

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

@@ -12,13 +12,13 @@ export declare class KnexDataProvider implements DataProvider {
     static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
     static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
     supportsRawFilter?: boolean;
-    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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/remult-knex/index.js

@@ -45,9 +45,9 @@ export class KnexDataProvider {
         let r = await b.resolveWhere();
         return knex => r.forEach(y => y(knex));
     }
-    async ensureSchema(entities, caption) {
+    async ensureSchema(entities) {
         var sb = new KnexSchemaBuilder(this.knex);
-        await sb.ensureSchema(entities, caption);
+        await sb.ensureSchema(entities);
     }
 }
 class KnexEntityDataProvider {
@@ -286,12 +286,7 @@ export class KnexSchemaBuilder {
         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(desc);
+    async ensureSchema(entities) {
         for (const entity of entities) {
             let e = await dbNamesOf(entity);
             try {
@@ -303,11 +298,9 @@ export class KnexSchemaBuilder {
                 }
             }
             catch (err) {
-                console.error("failed verify structure of " + e.$entityName + " ", err);
+                console.error("failed ensure schema of " + e.$entityName + " ", err);
             }
         }
-        if (KnexSchemaBuilder.logToConsole)
-            console.timeEnd(desc);
     }
     async createIfNotExist(entity) {
         const e = await dbNamesOf(entity);

package/esm/server/expressBridge.js

@@ -35,14 +35,26 @@ export function createRemultServerCore(options) {
         await new Promise((res) => {
             RemultAsyncLocalStorage.instance.run(remult, async () => {
                 if (options.ensureSchema) {
+                    let started = false;
+                    const startConsoleLog = () => {
+                        if (started)
+                            return;
+                        started = true;
+                        console.time("Ensure Schema");
+                    };
                     if (dp.ensureSchema) {
+                        startConsoleLog();
                         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);
+                    }
+                    for (const item of [options.liveQueryStorage, options.queueStorage]) {
+                        if (item?.ensureSchema) {
+                            startConsoleLog();
+                            await item.ensureSchema();
                         }
                     }
+                    if (started)
+                        console.timeEnd("Ensure Schema");
                 }
                 if (options.initApi)
                     await options.initApi(remult);

package/esm/server/index.d.ts

@@ -1,4 +1,5 @@
 import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
 export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,6 +1,7 @@
 import { createRemultServerCore, } from './expressBridge';
 import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export function createRemultServer(options) {
     initAsyncHooks();
     return createRemultServerCore(options);

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

@@ -1,15 +1,14 @@
 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;
-    ensureSchema?(entities: EntityMetadata[], caption?: string): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
 }
-export interface CanEnsureSchema {
-    ensureSchema(remult: Remult): Promise<void>;
+export interface Storage {
+    ensureSchema(): Promise<void>;
 }
 export interface EntityDataProvider {
     count(where: Filter): Promise<number>;

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

@@ -8,7 +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>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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,9 +26,9 @@ export class SqlDatabase {
     _getSourceSql() {
         return this.sql;
     }
-    async ensureSchema(entities, caption) {
+    async ensureSchema(entities) {
         if (this.sql.ensureSchema)
-            await this.sql.ensureSchema(entities, caption);
+            await this.sql.ensureSchema(entities);
     }
     getEntityDataProvider(entity) {
         return new ActualSQLServerDataProvider(entity, this, async (dbName) => {

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -5,15 +5,22 @@ import { Repository } from "../remult3";
 import { CategoriesForTesting } from "../tests/remult-3-entities";
 import { Status } from "../tests/testModel/models";
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
-export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature): dbTestMethodSignature;
+export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean, options?: {
+    exclude?: string[];
+}): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature, key?: string): dbTestMethodSignature;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare type dbTestWhatSignature = (db: {
+export declare const TestDbs: {
+    restDataProvider: string;
+};
+export declare type dbTestWhatSignature = ((db: {
     db: DataProvider;
     remult: Remult;
     createEntity<entityType>(entity: ClassType<entityType>): Promise<Repository<entityType>>;
-}) => Promise<void>;
-export declare type dbTestMethodSignature = (key: string, what: dbTestWhatSignature, focus: boolean) => void;
+}) => Promise<void>);
+export declare type dbTestMethodSignature = ((key: string, what: dbTestWhatSignature, focus: boolean) => void) & {
+    key?: string;
+};
 export declare function testAllDbs<T extends CategoriesForTesting>(key: string, doTest: (helper: {
     remult: Remult;
     createData: (doInsert?: (insert: (id: number, name: string, description?: string, status?: Status) => Promise<void>) => Promise<void>, entity?: {

package/esm/src/shared-tests/db-tests-setup.js

@@ -8,17 +8,23 @@ export function itWithFocus(key, what, focus = false) {
     else
         it(key, what);
 }
-export function testAll(key, what, focus = false) {
+export function testAll(key, what, focus = false, options) {
+    function runTest(m) {
+        return !options?.exclude?.includes(m.key);
+    }
     for (const test of databasesTesters) {
-        test(key, what, focus);
+        if (runTest(test))
+            test(key, what, focus);
     }
     loadedTests.push(x => {
-        x(key, what, focus);
+        if (runTest(x))
+            x(key, what, focus);
     });
 }
 const databasesTesters = [];
 const loadedTests = [];
-export function addDatabaseToTest(tester) {
+export function addDatabaseToTest(tester, key) {
+    tester.key = key;
     for (const test of loadedTests) {
         test(tester);
     }
@@ -32,6 +38,9 @@ export function testInMemory(key, what, focus = false) {
         await what({ db, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }
+export const TestDbs = {
+    restDataProvider: "restDataProvider"
+};
 databasesTesters.push(testInMemory);
 export async function testAllDbs(key, doTest, focus = false) {
     testAll(key, async ({ remult, createEntity }) => {

package/esm/src/shared-tests/db-tests.db-tests.js

@@ -7,7 +7,7 @@ import { h } from "../tests/h";
 import { Categories as newCategories } from "../tests/remult-3-entities";
 import { tasks } from "../tests/tasks";
 import { TestDataApiResponse } from "../tests/TestDataApiResponse";
-import { testAll, testAllDbs } from "./db-tests-setup";
+import { testAll, testAllDbs, TestDbs } from "./db-tests-setup";
 import { entityWithValidations, testConfiguration } from "./entityWithValidations";
 import { Remult } from "../context";
 import { dWithPrefilter } from "../tests/dWithPrefilter";
@@ -772,11 +772,13 @@ testAll("test date", async ({ createEntity }) => {
 testAll("test live query storage", async ({ db, remult }) => {
     var x = new DataProviderLiveQueryStorage(db);
     if (db.ensureSchema)
-        await x.ensureSchema(remult);
+        await x.ensureSchema();
     const id = uuid();
     await x.add({ id, entityKey: 'x', data: "noam" });
     await x.forEach("x", async (args) => {
         expect(args.query.data).toBe("noam");
     });
     expect((await x.keepAliveAndReturnUnknownQueryIds([id]))).toEqual([]);
+}, false, {
+    exclude: [TestDbs.restDataProvider]
 });

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

@@ -4,7 +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>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
 }
 export interface SqlCommand extends SqlCommandWithParameters {
     execute(sql: string): Promise<SqlResult>;

package/esm/src/tests/frontend-database-tests-setup.spec.js

@@ -1,4 +1,4 @@
-import { addDatabaseToTest, itWithFocus } from "../shared-tests/db-tests-setup";
+import { addDatabaseToTest, itWithFocus, TestDbs } from "../shared-tests/db-tests-setup";
 import { InMemoryDataProvider, remult } from "../..";
 import { Remult } from "../context";
 import { SqlDatabase } from "../data-providers/sql-database";
@@ -33,5 +33,5 @@ export function testRest(key, what, focus = false) {
         await what({ db, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }
-addDatabaseToTest(testRest);
+addDatabaseToTest(testRest, TestDbs.restDataProvider);
 import '../shared-tests/';

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

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

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

@@ -12,7 +12,7 @@ var DataProviderLiveQueryStorage = /** @class */ (function () {
             return new context_1.Remult(dp).repo(LiveQueryStorageEntity);
         });
     }
-    DataProviderLiveQueryStorage.prototype.ensureSchema = function (remult) {
+    DataProviderLiveQueryStorage.prototype.ensureSchema = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a, _b;
             return tslib_1.__generator(this, function (_c) {
@@ -21,7 +21,7 @@ var DataProviderLiveQueryStorage = /** @class */ (function () {
                     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 2: return [4 /*yield*/, _b.apply(_a, [[(_c.sent()).metadata]])];
                     case 3:
                         _c.sent();
                         return [2 /*return*/];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.18.1-exp.34",
+    "version": "0.18.1-exp.35",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",

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

@@ -16,7 +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>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
 }
 export interface PostgresCommandSource {

package/postgres/postgres-data-provider.js

@@ -31,7 +31,7 @@ var PostgresDataProvider = /** @class */ (function () {
     PostgresDataProvider.prototype.createCommand = function () {
         return new PostgresBridgeToSQLCommand(this.pool);
     };
-    PostgresDataProvider.prototype.ensureSchema = function (entities, caption) {
+    PostgresDataProvider.prototype.ensureSchema = function (entities) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var db, sb;
             return tslib_1.__generator(this, function (_a) {
@@ -39,7 +39,7 @@ var PostgresDataProvider = /** @class */ (function () {
                     case 0:
                         db = new sql_database_1.SqlDatabase(this);
                         sb = new schema_builder_1.PostgresSchemaBuilder(db);
-                        return [4 /*yield*/, sb.ensureSchema(entities, caption)];
+                        return [4 /*yield*/, sb.ensureSchema(entities)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -162,7 +162,7 @@ function preparePostgresQueueStorage(sql) {
                 case 1:
                     JobsInQueueEntity = (_a.sent()).JobsInQueueEntity;
                     e = c.repo(JobsInQueueEntity);
-                    return [4 /*yield*/, sql.ensureSchema([e.metadata], "Queue storage")];
+                    return [4 /*yield*/, sql.ensureSchema([e.metadata])];
                 case 2:
                     _a.sent();
                     return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('../server/expressBridge')); })];

package/postgres/schema-builder.d.ts

@@ -7,7 +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>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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/postgres/schema-builder.js

@@ -107,64 +107,54 @@ var PostgresSchemaBuilder = /** @class */ (function () {
             });
         });
     };
-    PostgresSchemaBuilder.prototype.ensureSchema = function (entities, caption) {
+    PostgresSchemaBuilder.prototype.ensureSchema = function (entities) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var desc, entities_1, entities_1_1, entity, e, err_1, e_2_1;
+            var entities_1, entities_1_1, entity, e, err_1, e_2_1;
             var e_2, _a;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        desc = "Ensure postgres schema";
-                        if (caption)
-                            desc += " - " + caption;
-                        if (PostgresSchemaBuilder.logToConsole)
-                            console.time(desc);
+                        _b.trys.push([0, 10, 11, 12]);
+                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
                         _b.label = 1;
                     case 1:
-                        _b.trys.push([1, 11, 12, 13]);
-                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
-                        _b.label = 2;
-                    case 2:
-                        if (!!entities_1_1.done) return [3 /*break*/, 10];
+                        if (!!entities_1_1.done) return [3 /*break*/, 9];
                         entity = entities_1_1.value;
                         return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
-                    case 3:
+                    case 2:
                         e = _b.sent();
-                        _b.label = 4;
-                    case 4:
-                        _b.trys.push([4, 8, , 9]);
-                        if (!!entity.options.sqlExpression) return [3 /*break*/, 7];
-                        if (!(e.$entityName.toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 7];
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 7, , 8]);
+                        if (!!entity.options.sqlExpression) return [3 /*break*/, 6];
+                        if (!(e.$entityName.toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 6];
                         return [4 /*yield*/, this.createIfNotExist(entity)];
-                    case 5:
+                    case 4:
                         _b.sent();
                         return [4 /*yield*/, this.verifyAllColumns(entity)];
-                    case 6:
+                    case 5:
                         _b.sent();
-                        _b.label = 7;
-                    case 7: return [3 /*break*/, 9];
-                    case 8:
+                        _b.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
                         err_1 = _b.sent();
                         console.error("failed verify structure of " + e.$entityName + " ", err_1);
-                        return [3 /*break*/, 9];
-                    case 9:
+                        return [3 /*break*/, 8];
+                    case 8:
                         entities_1_1 = entities_1.next();
-                        return [3 /*break*/, 2];
-                    case 10: return [3 /*break*/, 13];
-                    case 11:
+                        return [3 /*break*/, 1];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
                         e_2_1 = _b.sent();
                         e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 13];
-                    case 12:
+                        return [3 /*break*/, 12];
+                    case 11:
                         try {
                             if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
                         }
                         finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 13:
-                        if (PostgresSchemaBuilder.logToConsole)
-                            console.timeEnd(desc);
-                        return [2 /*return*/];
+                    case 12: return [2 /*return*/];
                 }
             });
         });

package/remult-knex/index.d.ts

@@ -12,13 +12,13 @@ export declare class KnexDataProvider implements DataProvider {
     static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
     static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
     supportsRawFilter?: boolean;
-    ensureSchema(entities: EntityMetadata<any>[], caption?: string): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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/remult-knex/index.js

@@ -84,14 +84,14 @@ var KnexDataProvider = /** @class */ (function () {
             });
         });
     };
-    KnexDataProvider.prototype.ensureSchema = function (entities, caption) {
+    KnexDataProvider.prototype.ensureSchema = function (entities) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var sb;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         sb = new KnexSchemaBuilder(this.knex);
-                        return [4 /*yield*/, sb.ensureSchema(entities, caption)];
+                        return [4 /*yield*/, sb.ensureSchema(entities)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -582,64 +582,54 @@ var KnexSchemaBuilder = /** @class */ (function () {
             });
         });
     };
-    KnexSchemaBuilder.prototype.ensureSchema = function (entities, caption) {
+    KnexSchemaBuilder.prototype.ensureSchema = function (entities) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var desc, entities_1, entities_1_1, entity, e, err_2, e_6_1;
+            var entities_1, entities_1_1, entity, e, err_2, e_6_1;
             var e_6, _a;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        desc = "ensure knex schema";
-                        if (caption)
-                            desc += " - " + caption;
-                        if (KnexSchemaBuilder.logToConsole)
-                            console.time(desc);
+                        _b.trys.push([0, 10, 11, 12]);
+                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
                         _b.label = 1;
                     case 1:
-                        _b.trys.push([1, 11, 12, 13]);
-                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
-                        _b.label = 2;
-                    case 2:
-                        if (!!entities_1_1.done) return [3 /*break*/, 10];
+                        if (!!entities_1_1.done) return [3 /*break*/, 9];
                         entity = entities_1_1.value;
                         return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
-                    case 3:
+                    case 2:
                         e = _b.sent();
-                        _b.label = 4;
-                    case 4:
-                        _b.trys.push([4, 8, , 9]);
-                        if (!!entity.options.sqlExpression) return [3 /*break*/, 7];
-                        if (!(e.$entityName.toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 7];
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 7, , 8]);
+                        if (!!entity.options.sqlExpression) return [3 /*break*/, 6];
+                        if (!(e.$entityName.toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 6];
                         return [4 /*yield*/, this.createIfNotExist(entity)];
-                    case 5:
+                    case 4:
                         _b.sent();
                         return [4 /*yield*/, this.verifyAllColumns(entity)];
-                    case 6:
+                    case 5:
                         _b.sent();
-                        _b.label = 7;
-                    case 7: return [3 /*break*/, 9];
-                    case 8:
+                        _b.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
                         err_2 = _b.sent();
-                        console.error("failed verify structure of " + e.$entityName + " ", err_2);
-                        return [3 /*break*/, 9];
-                    case 9:
+                        console.error("failed ensure schema of " + e.$entityName + " ", err_2);
+                        return [3 /*break*/, 8];
+                    case 8:
                         entities_1_1 = entities_1.next();
-                        return [3 /*break*/, 2];
-                    case 10: return [3 /*break*/, 13];
-                    case 11:
+                        return [3 /*break*/, 1];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
                         e_6_1 = _b.sent();
                         e_6 = { error: e_6_1 };
-                        return [3 /*break*/, 13];
-                    case 12:
+                        return [3 /*break*/, 12];
+                    case 11:
                         try {
                             if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
                         }
                         finally { if (e_6) throw e_6.error; }
                         return [7 /*endfinally*/];
-                    case 13:
-                        if (KnexSchemaBuilder.logToConsole)
-                            console.timeEnd(desc);
-                        return [2 /*return*/];
+                    case 12: return [2 /*return*/];
                 }
             });
         });

package/server/expressBridge.js

@@ -43,13 +43,21 @@ function createRemultServerCore(options) {
                     remult = new context_1.Remult(dp);
                     return [4 /*yield*/, new Promise(function (res) {
                             RemultAsyncLocalStorage.instance.run(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var entitiesMetadata, _a, _b, item, e_1_1;
+                                var started_1, startConsoleLog, entitiesMetadata, _a, _b, item, e_1_1;
                                 var e_1, _c;
                                 return tslib_1.__generator(this, function (_d) {
                                     switch (_d.label) {
                                         case 0:
-                                            if (!options.ensureSchema) return [3 /*break*/, 9];
-                                            if (!dp.ensureSchema) return [3 /*break*/, 9];
+                                            if (!options.ensureSchema) return [3 /*break*/, 10];
+                                            started_1 = false;
+                                            startConsoleLog = function () {
+                                                if (started_1)
+                                                    return;
+                                                started_1 = true;
+                                                console.time("Ensure Schema");
+                                            };
+                                            if (!dp.ensureSchema) return [3 /*break*/, 2];
+                                            startConsoleLog();
                                             entitiesMetadata = options.entities.map(function (e) { return remult.repo(e).metadata; });
                                             return [4 /*yield*/, dp.ensureSchema(entitiesMetadata)];
                                         case 1:
@@ -63,7 +71,8 @@ function createRemultServerCore(options) {
                                             if (!!_b.done) return [3 /*break*/, 6];
                                             item = _b.value;
                                             if (!(item === null || item === void 0 ? void 0 : item.ensureSchema)) return [3 /*break*/, 5];
-                                            return [4 /*yield*/, item.ensureSchema(remult)];
+                                            startConsoleLog();
+                                            return [4 /*yield*/, item.ensureSchema()];
                                         case 4:
                                             _d.sent();
                                             _d.label = 5;
@@ -82,12 +91,16 @@ function createRemultServerCore(options) {
                                             finally { if (e_1) throw e_1.error; }
                                             return [7 /*endfinally*/];
                                         case 9:
-                                            if (!options.initApi) return [3 /*break*/, 11];
-                                            return [4 /*yield*/, options.initApi(remult)];
+                                            if (started_1)
+                                                console.timeEnd("Ensure Schema");
+                                            _d.label = 10;
                                         case 10:
-                                            _d.sent();
-                                            _d.label = 11;
+                                            if (!options.initApi) return [3 /*break*/, 12];
+                                            return [4 /*yield*/, options.initApi(remult)];
                                         case 11:
+                                            _d.sent();
+                                            _d.label = 12;
+                                        case 12:
                                             res({});
                                             return [2 /*return*/];
                                     }

package/server/index.d.ts

@@ -1,4 +1,5 @@
 import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
 export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/server/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRemultServer = exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
+exports.createRemultServer = exports.DataProviderLiveQueryStorage = exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
 var expressBridge_1 = require("./expressBridge");
 var initAsyncHooks_1 = require("./initAsyncHooks");
 var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
 Object.defineProperty(exports, "JsonEntityFileStorage", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonEntityFileStorage; } });
 Object.defineProperty(exports, "JsonFileDataProvider", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonFileDataProvider; } });
+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; } });
 function createRemultServer(options) {
     initAsyncHooks_1.initAsyncHooks();
     return expressBridge_1.createRemultServerCore(options);

package/src/data-interfaces.d.ts

@@ -1,15 +1,14 @@
 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;
-    ensureSchema?(entities: EntityMetadata[], caption?: string): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
 }
-export interface CanEnsureSchema {
-    ensureSchema(remult: Remult): Promise<void>;
+export interface Storage {
+    ensureSchema(): Promise<void>;
 }
 export interface EntityDataProvider {
     count(where: Filter): Promise<number>;

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

@@ -8,7 +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>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;

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

@@ -37,13 +37,13 @@ var SqlDatabase = /** @class */ (function () {
     SqlDatabase.prototype._getSourceSql = function () {
         return this.sql;
     };
-    SqlDatabase.prototype.ensureSchema = function (entities, caption) {
+    SqlDatabase.prototype.ensureSchema = function (entities) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!this.sql.ensureSchema) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.sql.ensureSchema(entities, caption)];
+                        return [4 /*yield*/, this.sql.ensureSchema(entities)];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/src/shared-tests/db-tests-setup.d.ts

@@ -5,15 +5,22 @@ import { Repository } from "../remult3";
 import { CategoriesForTesting } from "../tests/remult-3-entities";
 import { Status } from "../tests/testModel/models";
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
-export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature): dbTestMethodSignature;
+export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean, options?: {
+    exclude?: string[];
+}): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature, key?: string): dbTestMethodSignature;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare type dbTestWhatSignature = (db: {
+export declare const TestDbs: {
+    restDataProvider: string;
+};
+export declare type dbTestWhatSignature = ((db: {
     db: DataProvider;
     remult: Remult;
     createEntity<entityType>(entity: ClassType<entityType>): Promise<Repository<entityType>>;
-}) => Promise<void>;
-export declare type dbTestMethodSignature = (key: string, what: dbTestWhatSignature, focus: boolean) => void;
+}) => Promise<void>);
+export declare type dbTestMethodSignature = ((key: string, what: dbTestWhatSignature, focus: boolean) => void) & {
+    key?: string;
+};
 export declare function testAllDbs<T extends CategoriesForTesting>(key: string, doTest: (helper: {
     remult: Remult;
     createData: (doInsert?: (insert: (id: number, name: string, description?: string, status?: Status) => Promise<void>) => Promise<void>, entity?: {

package/src/shared-tests/db-tests-setup.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testAllDbs = exports.testInMemory = exports.addDatabaseToTest = exports.testAll = exports.itWithFocus = void 0;
+exports.testAllDbs = exports.TestDbs = exports.testInMemory = exports.addDatabaseToTest = exports.testAll = exports.itWithFocus = void 0;
 var tslib_1 = require("tslib");
 var context_1 = require("../context");
 var in_memory_database_1 = require("../data-providers/in-memory-database");
@@ -14,13 +14,18 @@ function itWithFocus(key, what, focus) {
         it(key, what);
 }
 exports.itWithFocus = itWithFocus;
-function testAll(key, what, focus) {
+function testAll(key, what, focus, options) {
     var e_1, _a;
     if (focus === void 0) { focus = false; }
+    function runTest(m) {
+        var _a;
+        return !((_a = options === null || options === void 0 ? void 0 : options.exclude) === null || _a === void 0 ? void 0 : _a.includes(m.key));
+    }
     try {
         for (var databasesTesters_1 = tslib_1.__values(databasesTesters), databasesTesters_1_1 = databasesTesters_1.next(); !databasesTesters_1_1.done; databasesTesters_1_1 = databasesTesters_1.next()) {
             var test_1 = databasesTesters_1_1.value;
-            test_1(key, what, focus);
+            if (runTest(test_1))
+                test_1(key, what, focus);
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -31,14 +36,16 @@ function testAll(key, what, focus) {
         finally { if (e_1) throw e_1.error; }
     }
     loadedTests.push(function (x) {
-        x(key, what, focus);
+        if (runTest(x))
+            x(key, what, focus);
     });
 }
 exports.testAll = testAll;
 var databasesTesters = [];
 var loadedTests = [];
-function addDatabaseToTest(tester) {
+function addDatabaseToTest(tester, key) {
     var e_2, _a;
+    tester.key = key;
     try {
         for (var loadedTests_1 = tslib_1.__values(loadedTests), loadedTests_1_1 = loadedTests_1.next(); !loadedTests_1_1.done; loadedTests_1_1 = loadedTests_1.next()) {
             var test_2 = loadedTests_1_1.value;
@@ -78,6 +85,9 @@ function testInMemory(key, what, focus) {
     }); }, focus);
 }
 exports.testInMemory = testInMemory;
+exports.TestDbs = {
+    restDataProvider: "restDataProvider"
+};
 databasesTesters.push(testInMemory);
 function testAllDbs(key, doTest, focus) {
     if (focus === void 0) { focus = false; }

package/src/shared-tests/db-tests.db-tests.js

@@ -1731,7 +1731,7 @@ db_tests_setup_1.testAll("test live query storage", function (_a) {
                 case 0:
                     x = new data_provider_live_query_storage_1.DataProviderLiveQueryStorage(db);
                     if (!db.ensureSchema) return [3 /*break*/, 2];
-                    return [4 /*yield*/, x.ensureSchema(remult)];
+                    return [4 /*yield*/, x.ensureSchema()];
                 case 1:
                     _c.sent();
                     _c.label = 2;
@@ -1756,4 +1756,6 @@ db_tests_setup_1.testAll("test live query storage", function (_a) {
             }
         });
     });
+}, false, {
+    exclude: [db_tests_setup_1.TestDbs.restDataProvider]
 });

package/src/sql-command.d.ts

@@ -4,7 +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>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
 }
 export interface SqlCommand extends SqlCommandWithParameters {
     execute(sql: string): Promise<SqlResult>;

package/src/tests/frontend-database-tests-setup.spec.js

@@ -96,5 +96,5 @@ function testRest(key, what, focus) {
     }); }, focus);
 }
 exports.testRest = testRest;
-db_tests_setup_1.addDatabaseToTest(testRest);
+db_tests_setup_1.addDatabaseToTest(testRest, db_tests_setup_1.TestDbs.restDataProvider);
 require("../shared-tests/");