remult 0.21.1 → 0.22.0

package/esm/src/shared-tests/deleteAll.d.ts

@@ -1,2 +1,2 @@
-import { Repository } from "../remult3";
+import { Repository } from '../remult3';
 export declare function deleteAll<entityType>(r: Repository<entityType>): Promise<Repository<entityType>>;

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

@@ -1,4 +1,4 @@
 export async function deleteAll(r) {
-    await Promise.all((await r.find()).map(x => r.delete(x)));
+    await Promise.all((await r.find()).map((x) => r.delete(x)));
     return r;
 }

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

@@ -46,7 +46,7 @@ entityWithValidations = entityWithValidations_1 = __decorate([
                 t._.fields.name.error = 'invalid';
             if (!testConfiguration.restDbRunningOnServer)
                 entityWithValidations_1.savingRowCount++;
-        }
+        },
     }),
     __metadata("design:paramtypes", [Remult])
 ], entityWithValidations);

package/esm/src/shared-tests/test-custom-id-column.spec.js

@@ -1,13 +1,13 @@
 import { Entity, EntityBase, Fields } from '../remult3';
 import { describeClass } from '../remult3/DecoratorReplacer';
 import { testAll } from './db-tests-setup';
-describe("custom id column", () => {
-    testAll("basic test", async ({ createEntity }) => {
+describe('custom id column', () => {
+    testAll('basic test', async ({ createEntity }) => {
         let type = class extends EntityBase {
         };
         describeClass(type, Entity('custom', { allowApiCrud: true }), {
             a: Fields.number(),
-            b: Fields.number()
+            b: Fields.number(),
         });
         let c = await createEntity(type);
         let r = c.create();
@@ -20,7 +20,7 @@ describe("custom id column", () => {
         await r._.save();
         expect(c.metadata.idMetadata.field.key).toBe(c.metadata.fields.a.key);
     });
-    testAll("basic test id column not first column", async ({ createEntity }) => {
+    testAll('basic test id column not first column', async ({ createEntity }) => {
         let type = class extends EntityBase {
         };
         Entity('custom2', { allowApiCrud: true })(type);

package/esm/src/shared-tests/test-special-value.spec.js

@@ -1,7 +1,7 @@
 var GroupsValue_1;
 import { __decorate, __metadata } from "tslib";
-import { Entity, EntityBase, Field, FieldType, Fields } from "../remult3";
-import { testAll } from "./db-tests-setup";
+import { Entity, EntityBase, Field, FieldType, Fields } from '../remult3';
+import { testAll } from './db-tests-setup';
 let GroupsValue = GroupsValue_1 = class GroupsValue {
     constructor(value) {
         this.value = value;
@@ -18,12 +18,12 @@ let GroupsValue = GroupsValue_1 = class GroupsValue {
         return this.value.split(',');
     }
     removeGroup(group) {
-        let groups = this.value.split(",").map(x => x.trim());
+        let groups = this.value.split(',').map((x) => x.trim());
         let index = groups.indexOf(group);
         let result = '';
         if (index >= 0) {
             groups.splice(index, 1);
-            result = groups.join(", ");
+            result = groups.join(', ');
         }
         return new GroupsValue_1(result);
     }
@@ -45,10 +45,10 @@ let GroupsValue = GroupsValue_1 = class GroupsValue {
 GroupsValue = GroupsValue_1 = __decorate([
     FieldType({
         valueConverter: {
-            toJson: x => x ? x.value : '',
-            fromJson: x => new GroupsValue_1(x),
-            displayValue: x => x.value
-        }
+            toJson: (x) => (x ? x.value : ''),
+            fromJson: (x) => new GroupsValue_1(x),
+            displayValue: (x) => x.value,
+        },
     }),
     __metadata("design:paramtypes", [String])
 ], GroupsValue);
@@ -68,19 +68,19 @@ __decorate([
     __metadata("design:type", GroupsValue)
 ], testGroups.prototype, "g", void 0);
 testGroups = __decorate([
-    Entity("testGroups", { allowApiCrud: true })
+    Entity('testGroups', { allowApiCrud: true })
 ], testGroups);
-testAll("test save and load", async ({ createEntity }) => {
+testAll('test save and load', async ({ createEntity }) => {
     let re = await createEntity(testGroups);
     await re.create({ id: 1 }).save();
     let x = await re.findFirst();
     expect(x.g.evilGet()).toBe('');
-    x.g = x.g.addGroup("xx");
+    x.g = x.g.addGroup('xx');
     expect(x.$.g.valueChanged()).toBe(true);
     await x.save();
     expect(x.g.evilGet()).toBe('xx');
 });
-testAll("test2 save and load", async ({ createEntity }) => {
+testAll('test2 save and load', async ({ createEntity }) => {
     let re = await createEntity(testGroups);
     await re.create({ id: 1, g: new GroupsValue(undefined) }).save();
     let x = await re.findFirst();

package/esm/src/shared-tests/test-update-with-null.spec.js

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
-import { Entity, EntityBase, Field, Fields } from "../remult3";
-import { testAll } from "./db-tests-setup";
+import { Entity, EntityBase, Field, Fields } from '../remult3';
+import { testAll } from './db-tests-setup';
 let testNull = class testNull extends EntityBase {
     constructor() {
         super(...arguments);
@@ -23,19 +23,23 @@ __decorate([
 testNull = __decorate([
     Entity('testNull', { allowApiCrud: true })
 ], testNull);
-testAll("test that update null works", async ({ createEntity }) => {
+testAll('test that update null works', async ({ createEntity }) => {
     let r = await createEntity(testNull);
     let i = r.create({ id: 1, myCol: { value: 'abc' } });
     await i.save();
-    expect(i.myCol?.value).toBe("abc");
+    expect(i.myCol?.value).toBe('abc');
     i.myCol = null;
     expect(i.myCol).toBe(null);
     await i.save();
     expect(i.myCol).toBe(null);
 }, false);
-testAll("test number with null", async ({ createEntity }) => {
+testAll('test number with null', async ({ createEntity }) => {
     let r = await createEntity(testNull);
-    const i = await r.insert({ id: 1, myCol: { value: 'abc' }, numberWithNull: null });
+    const i = await r.insert({
+        id: 1,
+        myCol: { value: 'abc' },
+        numberWithNull: null,
+    });
     expect(i.numberWithNull).toBe(null);
     expect(await r.count({ numberWithNull: null })).toBe(1);
     i.numberWithNull = 0;

package/esm/src/sort.d.ts

@@ -1,5 +1,5 @@
-import { FieldMetadata } from "./column-interfaces";
-import { EntityMetadata, EntityOrderBy } from "./remult3";
+import { FieldMetadata } from './column-interfaces';
+import { EntityMetadata, EntityOrderBy } from './remult3';
 export declare class Sort {
     toEntityOrderBy(): EntityOrderBy<any>;
     constructor(...segments: SortSegment[]);

package/esm/src/sort.js

@@ -1,4 +1,4 @@
-import { CompoundIdField } from "./column";
+import { CompoundIdField } from './column';
 export class Sort {
     constructor(...segments) {
         this.Segments = segments;
@@ -7,10 +7,10 @@ export class Sort {
         let result = {};
         for (const seg of this.Segments) {
             if (seg.isDescending) {
-                result[seg.field.key] = "desc";
+                result[seg.field.key] = 'desc';
             }
             else
-                result[seg.field.key] = "asc";
+                result[seg.field.key] = 'asc';
         }
         return result;
     }
@@ -51,10 +51,10 @@ export class Sort {
                     let field = entityDefs.fields.find(key);
                     if (field) {
                         switch (element) {
-                            case "desc":
+                            case 'desc':
                                 sort.Segments.push({ field, isDescending: true });
                                 break;
-                            case "asc":
+                            case 'asc':
                                 sort.Segments.push({ field });
                         }
                     }
@@ -70,12 +70,12 @@ export class Sort {
             orderBy = new Sort({ field: entityMetadata.idMetadata.field });
         if (entityMetadata.idMetadata.field instanceof CompoundIdField) {
             for (const field of entityMetadata.idMetadata.field.fields) {
-                if (!orderBy.Segments.find(x => x.field == field)) {
+                if (!orderBy.Segments.find((x) => x.field == field)) {
                     orderBy.Segments.push({ field: field });
                 }
             }
         }
-        else if (!orderBy.Segments.find(x => x.field == entityMetadata.idMetadata.field)) {
+        else if (!orderBy.Segments.find((x) => x.field == entityMetadata.idMetadata.field)) {
             orderBy.Segments.push({ field: entityMetadata.idMetadata.field });
         }
         return orderBy;
@@ -84,18 +84,20 @@ export class Sort {
         if (!orderBy || Object.keys(orderBy).length === 0)
             orderBy = entityMetadata.options.defaultOrderBy;
         if (!orderBy)
-            orderBy = { [entityMetadata.idMetadata.field.key]: "asc" };
+            orderBy = {
+                [entityMetadata.idMetadata.field.key]: 'asc',
+            };
         else
             orderBy = { ...orderBy };
         if (entityMetadata.idMetadata.field instanceof CompoundIdField) {
             for (const field of entityMetadata.idMetadata.field.fields) {
                 if (!orderBy[field.key]) {
-                    orderBy[field.key] = "asc";
+                    orderBy[field.key] = 'asc';
                 }
             }
         }
         else if (!orderBy[entityMetadata.idMetadata.field.key]) {
-            orderBy[entityMetadata.idMetadata.field.key] = "asc";
+            orderBy[entityMetadata.idMetadata.field.key] = 'asc';
         }
         return orderBy;
     }

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

@@ -1,4 +1,4 @@
-import { DataApiResponse } from "../data-api";
+import { DataApiResponse } from '../data-api';
 export declare class TestDataApiResponse implements DataApiResponse {
     progress(progress: number): void;
     success(data: any): void;

package/esm/src/tests/TestDataApiResponse.js

@@ -1,8 +1,7 @@
 export class TestDataApiResponse {
-    progress(progress) {
-    }
+    progress(progress) { }
     success(data) {
-        throw new Error(('didnt expect success: ' + JSON.stringify(data)));
+        throw new Error('didnt expect success: ' + JSON.stringify(data));
     }
     forbidden() {
         throw new Error('didnt expect forbidden:');
@@ -17,6 +16,6 @@ export class TestDataApiResponse {
         throw new Error('not found');
     }
     error(data) {
-        throw new Error('error: ' + data + " " + JSON.stringify(data));
+        throw new Error('error: ' + data + ' ' + JSON.stringify(data));
     }
 }

package/esm/src/tests/createData.js

@@ -1,10 +1,10 @@
 import { InMemoryDataProvider } from '../data-providers/in-memory-database';
 import { Remult } from '../context';
-import { Categories as newCategories } from './remult-3-entities';
+import { Categories as newCategories, } from './remult-3-entities';
 import { deleteAll } from '../shared-tests/deleteAll';
 export async function createData(doInsert, entity) {
     let remult = new Remult();
-    remult.dataProvider = (new InMemoryDataProvider());
+    remult.dataProvider = new InMemoryDataProvider();
     if (!entity)
         entity = newCategories;
     let rep = await deleteAll(remult.repo(entity));

package/esm/src/tests/d.js

@@ -13,7 +13,7 @@ __decorate([
 ], d.prototype, "b", void 0);
 d = __decorate([
     Entity('d1', {
-        allowApiCrud: true
+        allowApiCrud: true,
     })
 ], d);
 export { d };

package/esm/src/tests/dWithPrefilter.js

@@ -26,7 +26,7 @@ __decorate([
 dWithPrefilter = dWithPrefilter_1 = __decorate([
     Entity('d', {
         apiPrefilter: { b: 2 },
-        allowApiCrud: true
+        allowApiCrud: true,
     })
 ], dWithPrefilter);
 export { dWithPrefilter };

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

@@ -5,12 +5,12 @@ export declare class entityForrawFilter extends EntityBase {
         oneAndThree?: boolean;
         dbOneOrThree?: boolean;
         two?: boolean;
-    }) => 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>;
+    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForrawFilter>;
+    static oneAndThree: (() => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForrawFilter>;
+    static testNumericValue: ((y: number) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForrawFilter>;
     static testObjectValue: ((y: {
         val: number;
-    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
+    }) => EntityFilter<entityForrawFilter>) & import("../filter/filter-interfaces").customFilterInfo<entityForrawFilter>;
 }
 export declare class entityForrawFilter1 extends entityForrawFilter {
 }

package/esm/src/tests/entityForCustomFilter.js

@@ -17,14 +17,22 @@ entityForrawFilter.filter = Filter.createCustom(async (c, remult) => {
         const e = await dbNamesOf(remult.repo(entityForrawFilter_1));
         r.push({
             $and: [
-                SqlDatabase.rawFilter(async (x) => x.sql = e.id + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
-                ArrayEntityDataProvider.rawFilter(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 };
 });
-entityForrawFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
+entityForrawFilter.oneAndThree = Filter.createCustom(() => ({
+    id: [1, 3],
+}));
 entityForrawFilter.testNumericValue = Filter.createCustom((val) => ({ id: val }));
 entityForrawFilter.testObjectValue = Filter.createCustom((val) => ({ id: val.val }));
 __decorate([

package/esm/src/tests/entityWithValidationsOnColumn.js

@@ -11,7 +11,7 @@ __decorate([
         validate: (t, c) => {
             if (!t.name || t.name.length < 3)
                 c.error = 'invalid on column';
-        }
+        },
     }),
     __metadata("design:type", String)
 ], entityWithValidationsOnColumn.prototype, "name", void 0);

package/esm/src/tests/frontend-database-tests-setup.spec.d.ts

@@ -1,4 +1,4 @@
-import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
+import { dbTestWhatSignature } from '../shared-tests/db-tests-setup';
 export declare function testWebSqlImpl(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare function testRest(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 import '../shared-tests/';

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

@@ -1,35 +1,35 @@
-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";
-import { MockRestDataProvider } from "./testHelper.spec";
+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';
+import { MockRestDataProvider } from './testHelper.spec';
 export function testWebSqlImpl(key, what, focus = false) {
-    itWithFocus(key + " - WebSql", async () => {
+    itWithFocus(key + ' - WebSql', async () => {
         let webSql = new WebSqlDataProvider('test');
         const sql = new SqlDatabase(webSql);
         for (const r of await (await sql.execute("select name from sqlite_master where type='table'")).rows) {
             switch (r.name) {
-                case "__WebKitDatabaseInfoTable__":
+                case '__WebKitDatabaseInfoTable__':
                     break;
-                case "sqlite_sequence":
+                case 'sqlite_sequence':
                     break;
                 default:
-                    await sql.execute("drop table if exists " + r.name);
+                    await sql.execute('drop table if exists ' + r.name);
             }
         }
         let remult = new Remult();
-        remult.dataProvider = (sql);
+        remult.dataProvider = sql;
         await what({ db: sql, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }
 addDatabaseToTest(testWebSqlImpl);
 export function testRest(key, what, focus = false) {
-    itWithFocus(key + " - Rest Provider", async () => {
+    itWithFocus(key + ' - Rest Provider', async () => {
         let r = new Remult();
-        r.dataProvider = (new InMemoryDataProvider());
+        r.dataProvider = new InMemoryDataProvider();
         let db = new MockRestDataProvider(r);
-        remult.dataProvider = (db);
+        remult.dataProvider = db;
         await what({ db, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }

package/esm/src/tests/h.js

@@ -18,18 +18,18 @@ __decorate([
 h = h_1 = __decorate([
     FieldType({
         valueConverter: {
-            toJson: x => x != undefined ? x : '',
-            fromJson: x => x ? x : null
+            toJson: (x) => (x != undefined ? x : ''),
+            fromJson: (x) => (x ? x : null),
         },
     }),
     Entity('h', {
-        saving: self => {
+        saving: (self) => {
             if (self.refH)
                 self.refHId = self.refH.id;
             else
                 self.refHId = '';
         },
-        allowApiCrud: true
+        allowApiCrud: true,
     })
 ], h);
 export { h };

package/esm/src/tests/remult-3-entities.d.ts

@@ -1,5 +1,5 @@
-import { EntityBase } from "../remult3";
-import { Status } from "./testModel/models";
+import { EntityBase } from '../remult3';
+import { Status } from './testModel/models';
 export declare class Products {
     id: number;
     name: string;

package/esm/src/tests/remult-3-entities.js

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
-import { EntityBase, Field, Entity, Fields } from "../remult3";
-import { Status } from "./testModel/models";
+import { EntityBase, Field, Entity, Fields } from '../remult3';
+import { Status } from './testModel/models';
 let Products = class Products {
 };
 __decorate([
@@ -36,7 +36,7 @@ let Categories = class Categories extends EntityBase {
 };
 __decorate([
     Fields.number({
-        dbName: 'CategoryID'
+        dbName: 'CategoryID',
     }),
     __metadata("design:type", Number)
 ], Categories.prototype, "id", void 0);
@@ -50,13 +50,13 @@ __decorate([
 ], Categories.prototype, "description", void 0);
 __decorate([
     Fields.number({
-        serverExpression: c => c.categoryName ? c.categoryName.length : undefined
+        serverExpression: (c) => c.categoryName ? c.categoryName.length : undefined,
     }),
     __metadata("design:type", Number)
 ], Categories.prototype, "categoryNameLength", void 0);
 __decorate([
     Fields.number({
-        serverExpression: (c) => Promise.resolve(c.categoryName ? c.categoryName.length : undefined)
+        serverExpression: (c) => Promise.resolve(c.categoryName ? c.categoryName.length : undefined),
     }),
     __metadata("design:type", Number)
 ], Categories.prototype, "categoryNameLengthAsync", void 0);
@@ -66,7 +66,7 @@ __decorate([
 ], Categories.prototype, "status", void 0);
 Categories = __decorate([
     Entity('Categories', {
-        allowApiCrud: true
+        allowApiCrud: true,
     })
 ], Categories);
 export { Categories };

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

@@ -1,9 +1,9 @@
 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";
+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';
 export declare function itForEach<T>(name: string, arrayOfT: T[], runAsync: (item: T) => Promise<any>): void;
 export declare function fitForEach<T>(name: string, arrayOfT: T[], runAsync: (item: T) => Promise<any>): void;
 export declare function testAsIfOnBackend(what: () => Promise<any>): Promise<void>;
@@ -31,6 +31,6 @@ export declare class MockRestDataProvider implements DataProvider {
     constructor(remult: Remult);
     getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsRawFilter: boolean;
+    isProxy: boolean;
 }
-export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("../data-interfaces").RestDataProviderHttpProvider;
+export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import('../data-interfaces').RestDataProviderHttpProvider;