remult 0.17.2 → 0.18.0

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

@@ -7,17 +7,20 @@ 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";
 import { entityFilterToJson, Filter } from "../filter/filter-interfaces";
 import { d } from "../tests/d";
-import { entityForCustomFilter1 } from "../tests/entityForCustomFilter";
+import { entityForrawFilter1 } from "../tests/entityForCustomFilter";
 import { entityWithValidationsOnColumn } from "../tests/entityWithValidationsOnColumn";
 import { Validators } from "../validators";
 import { Status } from "../tests/testModel/models";
 import { IdEntity } from "../id-entity";
+import { describeClass } from "../remult3/DecoratorReplacer";
+import { DataProviderLiveQueryStorage } from "../../live-query/data-provider-live-query-storage";
+import { v4 as uuid } from 'uuid';
 testAll("what", async ({ remult, createEntity }) => {
     await (await createEntity(stam)).create({ id: 1, title: 'noam' }).save();
     expect(await remult.repo(stam).count()).toBe(1);
@@ -124,13 +127,37 @@ testAll("put with validations on entity fails", async ({ remult, createEntity })
     x = await s.find({ where: { myId: 1 } });
     expect(x[0].name).toBe('noam');
 });
-testAll("test date with null works", async ({ createEntity }) => {
+testAll("test date only with null works", async ({ createEntity }) => {
     let repo = await createEntity(testDateWithNull);
     let r = repo.create({ id: 0 });
     await r.save();
     r = await repo.findFirst();
     expect(r.d).toBeNull();
     expect(await repo.count({ d: null })).toBe(1);
+    r.d = new Date(1976, 5, 16);
+    await r.save();
+    expect(r.d.getFullYear()).toBe(1976);
+    r = await repo.findFirst();
+    expect(r.d.getFullYear()).toBe(1976);
+    r.d = null;
+    await r.save();
+    expect(r.d).toBeNull();
+}, false);
+testAll("test date with null works", async ({ createEntity }) => {
+    let repo = await createEntity(testDateWithNull);
+    let r = repo.create({ id: 0 });
+    await r.save();
+    r = await repo.findFirst();
+    expect(r.fullDate).toBeNull("expected null after");
+    expect(await repo.count({ fullDate: null })).toBe(1);
+    r.fullDate = new Date(1976, 5, 16);
+    await r.save();
+    expect(r.fullDate.getFullYear()).toBe(1976);
+    r = await repo.findFirst();
+    expect(r.fullDate.getFullYear()).toBe(1976);
+    r.fullDate = null;
+    await r.save();
+    expect(r.fullDate).toBeNull();
 }, false);
 testAll("test original value of date", async ({ createEntity }) => {
     let r = await (await createEntity(testDateWithNull)).create({ id: 1, d: new Date(1976, 6, 16) }).save();
@@ -140,6 +167,7 @@ let testDateWithNull = class testDateWithNull extends EntityBase {
     constructor() {
         super(...arguments);
         this.id = 0;
+        this.fullDate = null;
     }
 };
 __decorate([
@@ -150,6 +178,10 @@ __decorate([
     Fields.dateOnly({ allowNull: true }),
     __metadata("design:type", Date)
 ], testDateWithNull.prototype, "d", void 0);
+__decorate([
+    Fields.date({ allowNull: true }),
+    __metadata("design:type", Date)
+], testDateWithNull.prototype, "fullDate", void 0);
 testDateWithNull = __decorate([
     Entity('testDateWithNull', { allowApiCrud: true })
 ], testDateWithNull);
@@ -204,7 +236,7 @@ testAll("test paging with complex object", async ({ remult, createEntity }) => {
         i++;
     }
     expect(i).toBe(5);
-});
+}, false);
 testAll("test paging with complex object_2", async ({ remult, createEntity }) => {
     let c1 = await (await createEntity(c)).create({ id: 1, name: 'c1' }).save();
     await (await createEntity(p)).create({ id: 1, name: 'p1', c: c1 }).save();
@@ -237,13 +269,13 @@ testAll("test filter doesn't collapse", async ({ createEntity }) => {
     expect((await repo.find({ where: f })).length).toBe(2);
 });
 testAll("test that it works with inheritance", async ({ createEntity }) => {
-    let c = await createEntity(entityForCustomFilter1);
+    let c = await createEntity(entityForrawFilter1);
     for (let id = 0; id < 5; id++) {
         await c.create({ id }).save();
     }
-    expect(await (c.count(entityForCustomFilter1.oneAndThree()))).toBe(2);
-    expect((await (c.findFirst(entityForCustomFilter1.testNumericValue(2)))).id).toBe(2);
-    expect((await (c.findFirst(entityForCustomFilter1.testObjectValue({ val: 2 })))).id).toBe(2);
+    expect(await (c.count(entityForrawFilter1.oneAndThree()))).toBe(2);
+    expect((await (c.findFirst(entityForrawFilter1.testNumericValue(2)))).id).toBe(2);
+    expect((await (c.findFirst(entityForrawFilter1.testObjectValue({ val: 2 })))).id).toBe(2);
 });
 testAll("put with validations on column fails", async ({ remult, createEntity }) => {
     var s = await createEntity(entityWithValidationsOnColumn);
@@ -412,7 +444,7 @@ testAllDbs("get array works with filter in body", async ({ createData, remult })
             return undefined;
         }
     }, {
-        status_in: '[1, 2]'
+        "status.in": '[1, 2]'
     });
     d.test();
 }, false);
@@ -537,7 +569,7 @@ let testFilter = class testFilter {
         this.c = '';
     }
 };
-testFilter.search = Filter.createCustom((remult, str) => ({
+testFilter.search = Filter.createCustom((str, remult) => ({
     $and: [{
             $or: [
                 { a: 'a' },
@@ -721,3 +753,32 @@ testAll("test transaction rollback", async ({ db }) => {
     }
     expect(fail).toBe(true);
 });
+testAll("test date", async ({ createEntity }) => {
+    const e = class {
+        constructor() {
+            this.a = 0;
+            this.d = new Date();
+        }
+    };
+    describeClass(e, Entity("tdate", { allowApiCrud: true }), {
+        a: Fields.number(),
+        d: Fields.date()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, d: new Date(1976, 5, 16) });
+    let item = await r.findFirst();
+    expect(item.d.getFullYear()).toBe(1976);
+}, false);
+testAll("test live query storage", async ({ db, remult }) => {
+    var x = new DataProviderLiveQueryStorage(db);
+    if (db.ensureSchema)
+        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/sort.d.ts

@@ -5,6 +5,7 @@ export declare class Sort {
     constructor(...segments: SortSegment[]);
     Segments: SortSegment[];
     reverse(): Sort;
+    compare(a: any, b: any): number;
     static translateOrderByToSort<T>(entityDefs: EntityMetadata<T>, orderBy: EntityOrderBy<T>): Sort;
     static createUniqueSort<T>(entityMetadata: EntityMetadata<T>, orderBy: Sort): Sort;
     static createUniqueEntityOrderBy<T>(entityMetadata: EntityMetadata<T>, orderBy: EntityOrderBy<T>): EntityOrderBy<T>;

package/esm/src/sort.js

@@ -21,6 +21,24 @@ export class Sort {
         }
         return r;
     }
+    compare(a, b) {
+        let r = 0;
+        for (let i = 0; i < this.Segments.length; i++) {
+            let seg = this.Segments[i];
+            let left = a[seg.field.key];
+            let right = b[seg.field.key];
+            if (left > right)
+                r = 1;
+            else if (left < right)
+                r = -1;
+            if (r != 0) {
+                if (seg.isDescending)
+                    r *= -1;
+                return r;
+            }
+        }
+        return r;
+    }
     static translateOrderByToSort(entityDefs, orderBy) {
         if (!orderBy)
             return undefined;

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

@@ -4,11 +4,14 @@ export interface SqlImplementation {
     createCommand(): SqlCommand;
     transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
 }
-export interface SqlCommand {
-    addParameterAndReturnSqlToken(val: any): string;
+export interface SqlCommand extends SqlCommandWithParameters {
     execute(sql: string): Promise<SqlResult>;
 }
+export interface SqlCommandWithParameters {
+    addParameterAndReturnSqlToken(val: any): string;
+}
 export interface SqlResult {
     rows: any[];
     getColumnKeyInResultForIndexInSelect(index: number): string;

package/esm/src/tests/entityForCustomFilter.d.ts

@@ -1,16 +1,16 @@
 import { EntityBase, EntityFilter } from '../remult3';
-export declare class entityForCustomFilter extends EntityBase {
+export declare class entityForrawFilter extends EntityBase {
     id: number;
     static filter: ((y: {
         oneAndThree?: boolean;
         dbOneOrThree?: boolean;
         two?: boolean;
-    }) => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
-    static oneAndThree: (() => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
-    static testNumericValue: ((y: number) => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
+    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
+    static oneAndThree: (() => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
+    static testNumericValue: ((y: number) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
     static testObjectValue: ((y: {
         val: number;
-    }) => EntityFilter<entityForCustomFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForCustomFilter>;
+    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
 }
-export declare class entityForCustomFilter1 extends entityForCustomFilter {
+export declare class entityForrawFilter1 extends entityForrawFilter {
 }

package/esm/src/tests/entityForCustomFilter.js

@@ -1,44 +1,43 @@
-var entityForCustomFilter_1;
+var entityForrawFilter_1;
 import { __decorate, __metadata } from "tslib";
 import { SqlDatabase } from '../data-providers/sql-database';
 import { Entity, EntityBase, Fields } from '../remult3';
 import { Filter } from '../filter/filter-interfaces';
 import { ArrayEntityDataProvider } from '../data-providers/array-entity-data-provider';
-import { getDbNameProvider } from '../filter/filter-consumer-bridge-to-sql-request';
-let entityForCustomFilter = entityForCustomFilter_1 = class entityForCustomFilter extends EntityBase {
+import { dbNamesOf } from '../filter/filter-consumer-bridge-to-sql-request';
+let entityForrawFilter = entityForrawFilter_1 = class entityForrawFilter extends EntityBase {
 };
-entityForCustomFilter.filter = Filter.createCustom(async (remult, c) => {
+entityForrawFilter.filter = Filter.createCustom(async (c, remult) => {
     let r = [];
     if (c.oneAndThree)
         r.push({ id: [1, 3] });
     if (c.two)
         r.push({ id: 2 });
     if (c.dbOneOrThree) {
-        let meta = remult.repo(entityForCustomFilter_1).metadata;
-        const e = await getDbNameProvider(meta);
+        const e = await dbNamesOf(remult.repo(entityForrawFilter_1));
         r.push({
             $and: [
-                SqlDatabase.customFilter(async (x) => x.sql = e.nameOf(meta.fields.id) + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
-                ArrayEntityDataProvider.customFilter(x => x.id == 1 || x.id == 3)
+                SqlDatabase.rawFilter(async (x) => x.sql = e.id + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
+                ArrayEntityDataProvider.rawFilter(x => x.id == 1 || x.id == 3)
             ]
         });
     }
     return { $and: r };
 });
-entityForCustomFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
-entityForCustomFilter.testNumericValue = Filter.createCustom((r, val) => ({ id: val }));
-entityForCustomFilter.testObjectValue = Filter.createCustom((r, val) => ({ id: val.val }));
+entityForrawFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
+entityForrawFilter.testNumericValue = Filter.createCustom((val) => ({ id: val }));
+entityForrawFilter.testObjectValue = Filter.createCustom((val) => ({ id: val.val }));
 __decorate([
     Fields.integer(),
     __metadata("design:type", Number)
-], entityForCustomFilter.prototype, "id", void 0);
-entityForCustomFilter = entityForCustomFilter_1 = __decorate([
-    Entity('entityForCustomFilter', { allowApiCrud: true })
-], entityForCustomFilter);
-export { entityForCustomFilter };
-let entityForCustomFilter1 = class entityForCustomFilter1 extends entityForCustomFilter {
+], entityForrawFilter.prototype, "id", void 0);
+entityForrawFilter = entityForrawFilter_1 = __decorate([
+    Entity('entityForrawFilter', { allowApiCrud: true })
+], entityForrawFilter);
+export { entityForrawFilter };
+let entityForrawFilter1 = class entityForrawFilter1 extends entityForrawFilter {
 };
-entityForCustomFilter1 = __decorate([
-    Entity('entityForCustomFilter1', { allowApiCrud: true })
-], entityForCustomFilter1);
-export { entityForCustomFilter1 };
+entityForrawFilter1 = __decorate([
+    Entity('entityForrawFilter1', { allowApiCrud: true })
+], entityForrawFilter1);
+export { entityForrawFilter1 };

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

@@ -1,5 +1,5 @@
-import { addDatabaseToTest, itWithFocus } from "../shared-tests/db-tests-setup";
-import { InMemoryDataProvider } from "../..";
+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";
 import { WebSqlDataProvider } from "../data-providers/web-sql-data-provider";
@@ -28,11 +28,10 @@ export function testRest(key, what, focus = false) {
     itWithFocus(key + " - Rest Provider", async () => {
         let r = new Remult();
         r.dataProvider = (new InMemoryDataProvider());
-        let remult = new Remult();
         let db = new MockRestDataProvider(r);
         remult.dataProvider = (db);
         await what({ db, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }
-addDatabaseToTest(testRest);
+addDatabaseToTest(testRest, TestDbs.restDataProvider);
 import '../shared-tests/';

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

@@ -1,5 +1,6 @@
 import './frontend-database-tests-setup.spec';
 import { Remult } from "../context";
+import { DataApi } from "../data-api";
 import { DataProvider, EntityDataProvider } from "../data-interfaces";
 import { InMemoryDataProvider } from "../data-providers/in-memory-database";
 import { EntityMetadata } from "../remult3";
@@ -30,5 +31,6 @@ export declare class MockRestDataProvider implements DataProvider {
     constructor(remult: Remult);
     getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsCustomFilter: boolean;
+    supportsRawFilter: boolean;
 }
+export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("../data-interfaces").RestDataProviderHttpProvider;

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

@@ -1,5 +1,5 @@
 import './frontend-database-tests-setup.spec';
-import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from "../context";
+import { Remult } from "../context";
 import { DataApi, serializeError } from "../data-api";
 import { InMemoryDataProvider } from "../data-providers/in-memory-database";
 import { RestEntityDataProvider } from "../data-providers/rest-data-provider";
@@ -9,6 +9,7 @@ import { actionInfo, serverActionField } from "../server-action";
 import { testConfiguration } from '../shared-tests/entityWithValidations';
 import { TestDataApiResponse } from './TestDataApiResponse';
 import { remult } from '../remult-proxy';
+import { HttpProviderBridgeToRestDataProviderHttpProvider } from '../buildRestDataProvider';
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 999999;
 //actionInfo.runningOnServer = false;
 export function itForEach(name, arrayOfT, runAsync) {
@@ -103,7 +104,6 @@ export async function testSql(runAsync) {
     await runAsync({ db: sql, remult });
 }
 export async function testInMemoryDb(runAsync) {
-    let remult = new Remult();
     let db = new InMemoryDataProvider();
     remult.dataProvider = (db);
     await runAsync({ db, remult });
@@ -154,69 +154,72 @@ function urlToReq(url) {
 export class MockRestDataProvider {
     constructor(remult) {
         this.remult = remult;
-        this.supportsCustomFilter = true;
+        this.supportsRawFilter = true;
     }
     getEntityDataProvider(metadata) {
         let dataApi = new DataApi(this.remult.repo(metadata.entityType), this.remult);
-        return new RestEntityDataProvider(() => "", () => new HttpProviderBridgeToRestDataProviderHttpProvider({
-            delete: async (url) => {
-                let urlSplit = url.split('/');
-                let r = new TestDataApiResponse();
-                let result;
-                r.deleted = () => { };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.delete(r, urlSplit[urlSplit.length - 1]);
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            },
-            get: async (url) => {
-                let r = new TestDataApiResponse();
-                let result;
-                r.success = data => { result = data; };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.httpGet(r, urlToReq(url));
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            },
-            post: async (url, data) => {
-                let r = new TestDataApiResponse();
-                let result;
-                r.created = data => { result = data; };
-                r.success = data => { result = data; };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.httpPost(r, urlToReq(url), data);
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            },
-            put: async (url, data) => {
-                let urlSplit = url.split('/');
-                let r = new TestDataApiResponse();
-                let result;
-                r.success = data => { result = data; };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.put(r, urlSplit[urlSplit.length - 1], data);
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            }
-        }), metadata);
+        return new RestEntityDataProvider(() => "", () => createMockHttpDataProvider(dataApi), metadata);
     }
     transaction(action) {
         throw new Error('Method not implemented.');
     }
 }
+export function createMockHttpDataProvider(dataApi) {
+    return new HttpProviderBridgeToRestDataProviderHttpProvider({
+        delete: async (url) => {
+            let urlSplit = url.split('/');
+            let r = new TestDataApiResponse();
+            let result;
+            r.deleted = () => { };
+            try {
+                testConfiguration.restDbRunningOnServer = true;
+                await dataApi.delete(r, urlSplit[urlSplit.length - 1]);
+            }
+            finally {
+                testConfiguration.restDbRunningOnServer = false;
+            }
+            return result;
+        },
+        get: async (url) => {
+            let r = new TestDataApiResponse();
+            let result;
+            r.success = data => { result = data; };
+            try {
+                testConfiguration.restDbRunningOnServer = true;
+                await dataApi.httpGet(r, urlToReq(url), () => "");
+            }
+            finally {
+                testConfiguration.restDbRunningOnServer = false;
+            }
+            return result;
+        },
+        post: async (url, data) => {
+            let r = new TestDataApiResponse();
+            let result;
+            r.created = data => { result = data; };
+            r.success = data => { result = data; };
+            try {
+                testConfiguration.restDbRunningOnServer = true;
+                await dataApi.httpPost(r, urlToReq(url), data, () => ({}));
+            }
+            finally {
+                testConfiguration.restDbRunningOnServer = false;
+            }
+            return result;
+        },
+        put: async (url, data) => {
+            let urlSplit = url.split('/');
+            let r = new TestDataApiResponse();
+            let result;
+            r.success = data => { result = data; };
+            try {
+                testConfiguration.restDbRunningOnServer = true;
+                await dataApi.put(r, urlSplit[urlSplit.length - 1], data);
+            }
+            finally {
+                testConfiguration.restDbRunningOnServer = false;
+            }
+            return result;
+        }
+    });
+}

package/esm/src/valueConverters.js

@@ -3,6 +3,8 @@ export class ValueConverters {
 }
 ValueConverters.Date = {
     toJson: (val) => {
+        if (val === null)
+            return null;
         if (!val)
             return '';
         if (typeof (val) === "string")
@@ -11,11 +13,12 @@ ValueConverters.Date = {
             return val.toISOString();
         }
         else {
-            console.log("ToJsonError", val);
-            throw new Error("Expected date but got val");
+            throw new Error("Expected date but got " + val);
         }
     },
     fromJson: (val) => {
+        if (val === null)
+            return null;
         if (val == undefined)
             return undefined;
         if (val == '')
@@ -25,7 +28,15 @@ ValueConverters.Date = {
         return new Date(Date.parse(val));
     },
     toDb: x => x,
-    fromDb: x => x,
+    fromDb: val => {
+        if (typeof val === "number")
+            val = new Date(val);
+        if (typeof (val) === "string")
+            val = new Date(val);
+        if (val && !(val instanceof Date))
+            throw "expected date but got " + val;
+        return val;
+    },
     fromInput: x => ValueConverters.Date.fromJson(x),
     toInput: x => ValueConverters.Date.toJson(x),
     displayValue: (val) => {
@@ -63,10 +74,7 @@ ValueConverters.DateOnly = {
     } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
     ,
     fromDb: (val) => {
-        var d = val;
-        if (!d)
-            return null;
-        return val;
+        return ValueConverters.Date.fromDb(val);
     },
     fieldTypeInDb: 'date',
     displayValue: (value) => {

package/graphql.js

@@ -147,7 +147,6 @@ function remultGraphql(api) {
                 return tslib_1.__awaiter(_this, void 0, void 0, function () {
                     var _this = this;
                     return tslib_1.__generator(this, function (_b) {
-                        console.log(tslib_1.__assign({}, a.fieldNodes));
                         return [2 /*return*/, new Promise(function (res, error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                 var _this = this;
                                 return tslib_1.__generator(this, function (_a) {

package/index.d.ts

@@ -1,4 +1,5 @@
-export { Field, Fields, StringFieldOptions, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
+export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';
@@ -10,16 +11,18 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase, } from './src/data-providers/sql-database';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
-export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
+export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 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';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remult = exports.ValueConverters = exports.Validators = exports.UrlBuilder = exports.FilterConsumerBridgeToSqlRequest = 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.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.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
  */
@@ -31,6 +31,7 @@ var sql_database_1 = require("./src/data-providers/sql-database"); //V
 Object.defineProperty(exports, "SqlDatabase", { enumerable: true, get: function () { return sql_database_1.SqlDatabase; } });
 var filter_consumer_bridge_to_sql_request_1 = require("./src/filter/filter-consumer-bridge-to-sql-request");
 Object.defineProperty(exports, "CustomSqlFilterBuilder", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.CustomSqlFilterBuilder; } });
+Object.defineProperty(exports, "dbNamesOf", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_1.dbNamesOf; } });
 var json_data_provider_1 = require("./src/data-providers/json-data-provider"); //V
 Object.defineProperty(exports, "JsonDataProvider", { enumerable: true, get: function () { return json_data_provider_1.JsonDataProvider; } });
 //export * from './src/data-api'; //reconsider if to make internal
@@ -52,8 +53,6 @@ Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function ()
 Object.defineProperty(exports, "CompoundIdField", { enumerable: true, get: function () { return column_1.CompoundIdField; } });
 var filter_interfaces_1 = require("./src/filter/filter-interfaces");
 Object.defineProperty(exports, "Filter", { enumerable: true, get: function () { return filter_interfaces_1.Filter; } });
-var filter_consumer_bridge_to_sql_request_2 = require("./src/filter/filter-consumer-bridge-to-sql-request");
-Object.defineProperty(exports, "FilterConsumerBridgeToSqlRequest", { enumerable: true, get: function () { return filter_consumer_bridge_to_sql_request_2.FilterConsumerBridgeToSqlRequest; } });
 var urlBuilder_1 = require("./urlBuilder");
 Object.defineProperty(exports, "UrlBuilder", { enumerable: true, get: function () { return urlBuilder_1.UrlBuilder; } });
 var validators_1 = require("./src/validators");
@@ -62,3 +61,8 @@ var valueConverters_1 = require("./src/valueConverters");
 Object.defineProperty(exports, "ValueConverters", { enumerable: true, get: function () { return valueConverters_1.ValueConverters; } });
 var remult_proxy_1 = require("./src/remult-proxy");
 Object.defineProperty(exports, "remult", { enumerable: true, get: function () { return remult_proxy_1.remult; } });
+//export { getId } from './src/remult3/getId';
+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; } });

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

@@ -0,0 +1,23 @@
+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, Storage {
+    repo: Promise<Repository<LiveQueryStorageEntity>>;
+    dataProvider: Promise<DataProvider>;
+    constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    ensureSchema(): Promise<void>;
+    add({ id, entityKey, data }: StoredQuery): Promise<void>;
+    remove(queryId: string): Promise<void>;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+declare class LiveQueryStorageEntity extends EntityBase {
+    id: string;
+    entityKey: string;
+    data: any;
+    lastUsedIso: string;
+}
+export {};