remult 0.17.3 → 0.18.0

package/src/remult3/remult3.d.ts

@@ -1,7 +1,8 @@
 import { ClassType } from "../../classType";
 import { FieldMetadata } from "../column-interfaces";
 import { Unobserve } from "../context";
-import { EntityOptions as EntityOptions } from "../entity";
+import { LiveQueryChange, SubscriptionListener, Unsubscribe } from "../live-query/SubscriptionChannel";
+import { EntityOptions } from "../entity";
 import { SortSegment } from "../sort";
 import { entityEventListener } from "../__EntityValueProvider";
 export interface EntityRef<entityType> extends Subscribable {
@@ -15,7 +16,8 @@ export interface EntityRef<entityType> extends Subscribable {
     wasDeleted(): boolean;
     fields: FieldsRef<entityType>;
     error: string;
-    getId(): any;
+    getId(): idType<entityType>;
+    getOriginalId(): idType<entityType>;
     repository: Repository<entityType>;
     metadata: EntityMetadata<entityType>;
     toApiJson(): any;
@@ -94,24 +96,70 @@ export interface IdMetadata<entityType = any> {
     isIdField(col: FieldMetadata): boolean;
     createIdInFilter(items: entityType[]): EntityFilter<entityType>;
 }
+/** Metadata for an `Entity`, this metadata can be used in the user interface to provide a richer UI experience  */
 export interface EntityMetadata<entityType = any> {
-    readonly idMetadata: IdMetadata<entityType>;
+    /** The Entity's key also used as it's url  */
     readonly key: string;
+    /** Metadata for the Entity's fields */
     readonly fields: FieldsMetadata<entityType>;
+    /** A human readable caption for the entity. Can be used to achieve a consistent caption for a field throughout the app
+     * @example
+     * <h1>Create a new item in {taskRepo.metadata.caption}</h1>
+    */
     readonly caption: string;
+    /** The options send to the `Entity`'s decorator */
     readonly options: EntityOptions;
+    /** The class type of the entity */
     readonly entityType: ClassType<entityType>;
+    /** true if the current user is allowed to update an entity instance
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiUpdateAllowed){
+     *   //Allow user to edit the entity
+     * }
+    */
     readonly apiUpdateAllowed: boolean;
+    /** true if the current user is allowed to read from entity
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiReadAllowed){
+     *   taskRepo.find()
+     * }
+     */
     readonly apiReadAllowed: boolean;
+    /** true if the current user is allowed to delete an entity instance
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiDeleteAllowed){
+     *   //display delete button
+     * }
+    */
     readonly apiDeleteAllowed: boolean;
+    /** true if the current user is allowed to create an entity instance
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiInsertAllowed){
+     *   //display insert button
+     * }
+    */
     readonly apiInsertAllowed: boolean;
+    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
+    /** Metadata for the Entity's id */
+    readonly idMetadata: IdMetadata<entityType>;
 }
 export declare type OmitEB<T> = Omit<T, keyof import('./RepositoryImplementation').EntityBase>;
+export declare type idType<entityType> = entityType extends {
+    id?: number;
+} ? number : entityType extends {
+    id?: string;
+} ? string : (string | number);
 /**used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
+    /** returns a result array based on the provided options */
+    liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
     /** returns the first item that matchers the `where` condition
      * @example
      * await taskRepo.findFirst({ completed:false })
@@ -120,16 +168,12 @@ export interface Repository<entityType> {
      *      */
     findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>): Promise<entityType>;
     /** returns the items that matches the idm the result is cached unless specified differently in the `options` parameter */
-    findId(id: entityType extends {
-        id?: number;
-    } ? number : entityType extends {
-        id?: string;
-    } ? string : (string | number), options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
+    findId(id: idType<entityType>, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
     /**  An alternative form of fetching data from the API server, which is intended for operating on large numbers of entity objects.
      *
      * It also has it's own paging mechanism that can be used n paging scenarios.
      *
-     * The `query` method doesn't return an array (as the `find` method) and instead returns an `iteratable` `QueryResult` object
+     * The `query` method doesn't return an array (as the `find` method) and instead returns an `iterable` `QueryResult` object
      * which supports iterations using the JavaScript `for await` statement.
      * @example
      * for await (const task of taskRepo.query()) {
@@ -179,10 +223,21 @@ export interface Repository<entityType> {
     fromJson(x: any, isNew?: boolean): Promise<entityType>;
     /** returns an `entityRef` for an item returned by `create`, `find` etc... */
     getEntityRef(item: entityType): EntityRef<entityType>;
-    /**The metadata for the `entity` */
+    /**The metadata for the `entity`
+     * @See [EntityMetadata](https://remult.dev/docs/ref_entitymetadata.html)
+    */
     metadata: EntityMetadata<entityType>;
     addEventListener(listener: entityEventListener<entityType>): Unobserve;
 }
+export interface LiveQuery<entityType> {
+    subscribe(next: (info: LiveQueryChangeInfo<entityType>) => void): Unsubscribe;
+    subscribe(listener: Partial<SubscriptionListener<LiveQueryChangeInfo<entityType>>>): Unsubscribe;
+}
+export interface LiveQueryChangeInfo<entityType> {
+    items: entityType[];
+    changes: LiveQueryChange[];
+    applyChanges(prevState: entityType[]): entityType[];
+}
 export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
     /** Determines the number of rows returned by the request, on the browser the default is 100 rows
      * @example
@@ -224,6 +279,8 @@ export declare type EntityFilter<entityType> = {
 export declare type ValueFilter<valueType> = valueType | valueType[] | {
     $ne?: valueType | valueType[];
     "!="?: valueType | valueType[];
+    $in?: valueType[];
+    $nin?: valueType[];
 };
 export declare type ComparisonValueFilter<valueType> = ValueFilter<valueType> & {
     $gt?: valueType;

package/src/remult3/remult3.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+;

package/src/server-action.d.ts

@@ -19,6 +19,10 @@ export declare abstract class Action<inParam, outParam> implements ActionInterfa
     protected abstract execute(info: inParam, req: Remult, res: DataApiResponse): Promise<outParam>;
     __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void): void;
 }
+export declare class ForbiddenError extends Error {
+    constructor();
+    isForbiddenError: true;
+}
 export declare class myServerAction extends Action<inArgs, result> {
     private types;
     private options;
@@ -38,7 +42,7 @@ export interface BackendMethodOptions<type> {
 export declare const actionInfo: {
     allActions: any[];
     runningOnServer: boolean;
-    runActionWithoutBlockingUI: (what: () => Promise<any>) => Promise<any>;
+    runActionWithoutBlockingUI: <T>(what: () => Promise<T>) => Promise<T>;
     startBusyWithProgress: () => {
         progress: (percent: number) => void;
         close: () => void;

package/src/server-action.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.classBackendMethodsArray = exports.prepareReceivedArgs = exports.prepareArgsToSend = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.serverActionField = exports.actionInfo = exports.myServerAction = exports.Action = void 0;
+exports.classBackendMethodsArray = exports.prepareReceivedArgs = exports.prepareArgsToSend = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.serverActionField = exports.actionInfo = exports.myServerAction = exports.ForbiddenError = exports.Action = void 0;
 var tslib_1 = require("tslib");
 require("reflect-metadata");
 var context_1 = require("./context");
+var buildRestDataProvider_1 = require("./buildRestDataProvider");
 var sql_database_1 = require("./data-providers/sql-database");
 var remult3_1 = require("./remult3");
+var remult_proxy_1 = require("./remult-proxy");
 var Action = /** @class */ (function () {
     function Action(actionUrl, queue, allowed) {
         this.actionUrl = actionUrl;
@@ -20,9 +22,9 @@ var Action = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         if (baseUrl === undefined)
-                            baseUrl = remult3_1.RepositoryImplementation.defaultRemult.apiClient.url;
+                            baseUrl = remult_proxy_1.remult.apiClient.url;
                         if (!http)
-                            http = context_1.buildRestDataProvider(remult3_1.RepositoryImplementation.defaultRemult.apiClient.httpClient);
+                            http = buildRestDataProvider_1.buildRestDataProvider(remult_proxy_1.remult.apiClient.httpClient);
                         return [4 /*yield*/, http.post(baseUrl + '/' + this.actionUrl, pIn)];
                     case 1:
                         r = _a.sent();
@@ -109,6 +111,7 @@ var ForbiddenError = /** @class */ (function (_super) {
     }
     return ForbiddenError;
 }(Error));
+exports.ForbiddenError = ForbiddenError;
 var myServerAction = /** @class */ (function (_super) {
     tslib_1.__extends(myServerAction, _super);
     function myServerAction(name, types, options, originalMethod) {
@@ -127,12 +130,11 @@ var myServerAction = /** @class */ (function (_super) {
                     case 0:
                         result = { data: {} };
                         ds = remult.dataProvider;
-                        return [4 /*yield*/, ds.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        return [4 /*yield*/, context_1.doTransaction(remult, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                 var _a, _b, err_2;
                                 return tslib_1.__generator(this, function (_c) {
                                     switch (_c.label) {
                                         case 0:
-                                            remult.dataProvider = (ds);
                                             if (!remult.isAllowedForInstance(undefined, this.options.allowed))
                                                 throw new ForbiddenError();
                                             _a = info;
@@ -256,7 +258,7 @@ function BackendMethod(options) {
                         controllerOptions.key = c.repo(constructor).metadata.key;
                     }
                     reg(controllerOptions.key + '/' + key, options ? options.queue : false, options.allowed, function (d, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var allowed, remult_1, ds, r_1, err_3;
+                        var allowed, remult_1, r_1, err_3;
                         var _this = this;
                         return tslib_1.__generator(this, function (_a) {
                             switch (_a.label) {
@@ -267,16 +269,14 @@ function BackendMethod(options) {
                                 case 1:
                                     _a.trys.push([1, 3, , 4]);
                                     remult_1 = req;
-                                    ds = remult_1.dataProvider;
-                                    return [4 /*yield*/, ds.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    return [4 /*yield*/, context_1.doTransaction(remult_1, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                             var _a, repo, y, rowHelper, rows, defs, err_4, y, controllerRef, err_5;
                                             var _b, _c, _d;
                                             return tslib_1.__generator(this, function (_e) {
                                                 switch (_e.label) {
                                                     case 0:
-                                                        remult_1.dataProvider = (ds);
                                                         _a = d;
-                                                        return [4 /*yield*/, prepareReceivedArgs(types, d.args, remult_1, ds, res)];
+                                                        return [4 /*yield*/, prepareReceivedArgs(types, d.args, remult_1, remult_1.dataProvider, res)];
                                                     case 1:
                                                         _a.args = _e.sent();
                                                         if (!context_1.allEntities.includes(constructor)) return [3 /*break*/, 13];
@@ -330,7 +330,7 @@ function BackendMethod(options) {
                                                         throw defs.catchSaveErrors(err_4);
                                                     case 12: return [3 /*break*/, 20];
                                                     case 13:
-                                                        y = new constructor(remult_1, ds);
+                                                        y = new constructor(remult_1, remult_1.dataProvider);
                                                         controllerRef = remult3_1.getControllerRef(y, remult_1);
                                                         return [4 /*yield*/, controllerRef._updateEntityBasedOnApi(d.fields)];
                                                     case 14:

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;
@@ -60,14 +67,13 @@ function testInMemory(key, what, focus) {
     var _this = this;
     if (focus === void 0) { focus = false; }
     itWithFocus(key + " - in memory", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var remult, db;
+        var db, remult;
         var _this = this;
         return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    remult = new context_1.Remult();
                     db = new in_memory_database_1.InMemoryDataProvider();
-                    remult.dataProvider = (db);
+                    remult = new context_1.Remult(db);
                     return [4 /*yield*/, what({ db: db, remult: remult, createEntity: function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
                                 return [2 /*return*/, remult.repo(x)];
                             }); }); } })];
@@ -79,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

@@ -21,6 +21,9 @@ var entityWithValidationsOnColumn_1 = require("../tests/entityWithValidationsOnC
 var validators_1 = require("../validators");
 var models_1 = require("../tests/testModel/models");
 var id_entity_1 = require("../id-entity");
+var DecoratorReplacer_1 = require("../remult3/DecoratorReplacer");
+var data_provider_live_query_storage_1 = require("../../live-query/data-provider-live-query-storage");
+var uuid_1 = require("uuid");
 db_tests_setup_1.testAll("what", function (_a) {
     var remult = _a.remult, createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
@@ -346,7 +349,7 @@ db_tests_setup_1.testAll("put with validations on entity fails", function (_a) {
         });
     });
 });
-db_tests_setup_1.testAll("test date with null works", function (_a) {
+db_tests_setup_1.testAll("test date only with null works", function (_a) {
     var createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
         var repo, r, _b;
@@ -367,6 +370,60 @@ db_tests_setup_1.testAll("test date with null works", function (_a) {
                     return [4 /*yield*/, repo.count({ d: null })];
                 case 4:
                     _b.apply(void 0, [_c.sent()]).toBe(1);
+                    r.d = new Date(1976, 5, 16);
+                    return [4 /*yield*/, r.save()];
+                case 5:
+                    _c.sent();
+                    expect(r.d.getFullYear()).toBe(1976);
+                    return [4 /*yield*/, repo.findFirst()];
+                case 6:
+                    r = _c.sent();
+                    expect(r.d.getFullYear()).toBe(1976);
+                    r.d = null;
+                    return [4 /*yield*/, r.save()];
+                case 7:
+                    _c.sent();
+                    expect(r.d).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("test date with null works", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, r, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(testDateWithNull)];
+                case 1:
+                    repo = _c.sent();
+                    r = repo.create({ id: 0 });
+                    return [4 /*yield*/, r.save()];
+                case 2:
+                    _c.sent();
+                    return [4 /*yield*/, repo.findFirst()];
+                case 3:
+                    r = _c.sent();
+                    expect(r.fullDate).toBeNull("expected null after");
+                    _b = expect;
+                    return [4 /*yield*/, repo.count({ fullDate: null })];
+                case 4:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    r.fullDate = new Date(1976, 5, 16);
+                    return [4 /*yield*/, r.save()];
+                case 5:
+                    _c.sent();
+                    expect(r.fullDate.getFullYear()).toBe(1976);
+                    return [4 /*yield*/, repo.findFirst()];
+                case 6:
+                    r = _c.sent();
+                    expect(r.fullDate.getFullYear()).toBe(1976);
+                    r.fullDate = null;
+                    return [4 /*yield*/, r.save()];
+                case 7:
+                    _c.sent();
+                    expect(r.fullDate).toBeNull();
                     return [2 /*return*/];
             }
         });
@@ -393,6 +450,7 @@ var testDateWithNull = /** @class */ (function (_super) {
     function testDateWithNull() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
         _this.id = 0;
+        _this.fullDate = null;
         return _this;
     }
     tslib_1.__decorate([
@@ -403,6 +461,10 @@ var testDateWithNull = /** @class */ (function (_super) {
         remult3_1.Fields.dateOnly({ allowNull: true }),
         tslib_1.__metadata("design:type", Date)
     ], testDateWithNull.prototype, "d", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.date({ allowNull: true }),
+        tslib_1.__metadata("design:type", Date)
+    ], testDateWithNull.prototype, "fullDate", void 0);
     testDateWithNull = tslib_1.__decorate([
         remult3_1.Entity('testDateWithNull', { allowApiCrud: true })
     ], testDateWithNull);
@@ -582,7 +644,7 @@ db_tests_setup_1.testAll("test paging with complex object", function (_a) {
             }
         });
     });
-});
+}, false);
 db_tests_setup_1.testAll("test paging with complex object_2", function (_a) {
     var remult = _a.remult, createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
@@ -696,7 +758,7 @@ db_tests_setup_1.testAll("test that it works with inheritance", function (_a) {
         var c, id, _b, _c, _d;
         return tslib_1.__generator(this, function (_e) {
             switch (_e.label) {
-                case 0: return [4 /*yield*/, createEntity(entityForCustomFilter_1.entityForCustomFilter1)];
+                case 0: return [4 /*yield*/, createEntity(entityForCustomFilter_1.entityForrawFilter1)];
                 case 1:
                     c = _e.sent();
                     id = 0;
@@ -712,15 +774,15 @@ db_tests_setup_1.testAll("test that it works with inheritance", function (_a) {
                     return [3 /*break*/, 2];
                 case 5:
                     _b = expect;
-                    return [4 /*yield*/, (c.count(entityForCustomFilter_1.entityForCustomFilter1.oneAndThree()))];
+                    return [4 /*yield*/, (c.count(entityForCustomFilter_1.entityForrawFilter1.oneAndThree()))];
                 case 6:
                     _b.apply(void 0, [_e.sent()]).toBe(2);
                     _c = expect;
-                    return [4 /*yield*/, (c.findFirst(entityForCustomFilter_1.entityForCustomFilter1.testNumericValue(2)))];
+                    return [4 /*yield*/, (c.findFirst(entityForCustomFilter_1.entityForrawFilter1.testNumericValue(2)))];
                 case 7:
                     _c.apply(void 0, [(_e.sent()).id]).toBe(2);
                     _d = expect;
-                    return [4 /*yield*/, (c.findFirst(entityForCustomFilter_1.entityForCustomFilter1.testObjectValue({ val: 2 })))];
+                    return [4 /*yield*/, (c.findFirst(entityForCustomFilter_1.entityForrawFilter1.testObjectValue({ val: 2 })))];
                 case 8:
                     _d.apply(void 0, [(_e.sent()).id]).toBe(2);
                     return [2 /*return*/];
@@ -1086,7 +1148,7 @@ db_tests_setup_1.testAllDbs("get array works with filter in body", function (_a)
                                 return undefined;
                             }
                         }, {
-                            status_in: '[1, 2]'
+                            "status.in": '[1, 2]'
                         })];
                 case 2:
                     _b.sent();
@@ -1366,7 +1428,7 @@ var testFilter = /** @class */ (function () {
         this.b = '';
         this.c = '';
     }
-    testFilter.search = filter_interfaces_1.Filter.createCustom(function (remult, str) { return ({
+    testFilter.search = filter_interfaces_1.Filter.createCustom(function (str, remult) { return ({
         $and: [{
                 $or: [
                     { a: 'a' },
@@ -1627,3 +1689,73 @@ db_tests_setup_1.testAll("test transaction rollback", function (_a) {
         });
     });
 });
+db_tests_setup_1.testAll("test date", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var e, r, item;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    e = /** @class */ (function () {
+                        function class_4() {
+                            this.a = 0;
+                            this.d = new Date();
+                        }
+                        return class_4;
+                    }());
+                    DecoratorReplacer_1.describeClass(e, remult3_1.Entity("tdate", { allowApiCrud: true }), {
+                        a: remult3_1.Fields.number(),
+                        d: remult3_1.Fields.date()
+                    });
+                    return [4 /*yield*/, createEntity(e)];
+                case 1:
+                    r = _b.sent();
+                    return [4 /*yield*/, r.insert({ a: 1, d: new Date(1976, 5, 16) })];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, r.findFirst()];
+                case 3:
+                    item = _b.sent();
+                    expect(item.d.getFullYear()).toBe(1976);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("test live query storage", function (_a) {
+    var db = _a.db, remult = _a.remult;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var x, id, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    x = new data_provider_live_query_storage_1.DataProviderLiveQueryStorage(db);
+                    if (!db.ensureSchema) return [3 /*break*/, 2];
+                    return [4 /*yield*/, x.ensureSchema()];
+                case 1:
+                    _c.sent();
+                    _c.label = 2;
+                case 2:
+                    id = uuid_1.v4();
+                    return [4 /*yield*/, x.add({ id: id, entityKey: 'x', data: "noam" })];
+                case 3:
+                    _c.sent();
+                    return [4 /*yield*/, x.forEach("x", function (args) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                expect(args.query.data).toBe("noam");
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 4:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, x.keepAliveAndReturnUnknownQueryIds([id])];
+                case 5:
+                    _b.apply(void 0, [(_c.sent())]).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false, {
+    exclude: [db_tests_setup_1.TestDbs.restDataProvider]
+});

package/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/src/sort.js

@@ -51,6 +51,24 @@ var Sort = /** @class */ (function () {
         }
         return r;
     };
+    Sort.prototype.compare = function (a, b) {
+        var r = 0;
+        for (var i = 0; i < this.Segments.length; i++) {
+            var seg = this.Segments[i];
+            var left = a[seg.field.key];
+            var 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;
+    };
     Sort.translateOrderByToSort = function (entityDefs, orderBy) {
         if (!orderBy)
             return undefined;

package/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/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 {
 }