remult 0.21.1 → 0.22.0

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

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

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

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

package/esm/core/src/shared-tests/entityWithValidations.d.ts

@@ -0,0 +1,14 @@
+import { ClassType } from '../../classType';
+import { Remult } from '../context';
+import { EntityBase, Repository } from '../remult3';
+export declare var testConfiguration: {
+    restDbRunningOnServer: boolean;
+};
+export declare class entityWithValidations extends EntityBase {
+    private remult;
+    myId: number;
+    name: string;
+    static savingRowCount: number;
+    constructor(remult: Remult);
+    static create4RowsInDp(createEntity: (entity: ClassType<any>) => Promise<Repository<entityWithValidations>>): Promise<Repository<entityWithValidations>>;
+}

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

@@ -0,0 +1,43 @@
+import { Entity, EntityBase, Fields } from '../remult3';
+export var testConfiguration = { restDbRunningOnServer: false };
+@Entity('', {
+    allowApiCrud: true,
+    saving: async (t) => {
+        if (!t.name || t.name.length < 3)
+            t._.fields.name.error = 'invalid';
+        if (!testConfiguration.restDbRunningOnServer)
+            entityWithValidations.savingRowCount++;
+    }
+})
+export class entityWithValidations extends EntityBase {
+    remult;
+    @Fields.integer()
+    myId;
+    @Fields.string()
+    name;
+    static savingRowCount = 0;
+    constructor(remult) {
+        super();
+        this.remult = remult;
+    }
+    static async create4RowsInDp(createEntity) {
+        let s = await createEntity(entityWithValidations);
+        let c = s.create();
+        c.myId = 1;
+        c.name = 'noam';
+        await c._.save();
+        c = s.create();
+        c.myId = 2;
+        c.name = 'yael';
+        await c._.save();
+        c = s.create();
+        c.myId = 3;
+        c.name = 'yoni';
+        await c._.save();
+        c = s.create();
+        c.myId = 4;
+        c.name = 'maayan';
+        await c._.save();
+        return s;
+    }
+}

package/esm/core/src/shared-tests/index.d.ts

@@ -0,0 +1,4 @@
+import './db-tests.db-tests';
+import './test-custom-id-column.spec';
+import './test-special-value.spec';
+import './test-update-with-null.spec';

package/esm/core/src/shared-tests/index.js

@@ -0,0 +1,4 @@
+import './db-tests.db-tests';
+import './test-custom-id-column.spec';
+import './test-special-value.spec';
+import './test-update-with-null.spec';

package/esm/core/src/shared-tests/test-custom-id-column.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,67 @@
+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 }) => {
+        let type = class extends EntityBase {
+            a;
+            b;
+        };
+        describeClass(type, Entity('custom', { allowApiCrud: true }), {
+            a: Fields.number(),
+            b: Fields.number()
+        });
+        let c = await createEntity(type);
+        let r = c.create();
+        r.a = 1;
+        r.b = 1;
+        await r._.save();
+        r = c.create();
+        r.a = 2;
+        r.b = 2;
+        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 }) => {
+        let type = class extends EntityBase {
+            a;
+            id;
+        };
+        Entity('custom2', { allowApiCrud: true })(type);
+        Fields.number()(type.prototype, 'a');
+        Fields.number()(type.prototype, 'id');
+        let c = await createEntity(type);
+        let r = c.create();
+        r.a = 1;
+        r.id = 5;
+        await r._.save();
+        r = c.create();
+        r.a = 2;
+        r.id = 6;
+        await r._.save();
+        expect(r._.repository.metadata.idMetadata.field.key).toBe(r._.fields.id.metadata.key);
+        expect((await c.findId(6)).a).toBe(2);
+    });
+});
+//typing game
+// var z = <Z>(y: Z) => {
+// }
+// z<number>(1);
+// function myBackendMethod<T>(types: T, values: values<T>) {
+// }
+// type values<T> = {
+//     [Property in keyof T]: T[Property] extends new (...args: any[]) => infer R ? R : any;
+// };
+// const a1 = AccountManager;
+// const a = {
+//     a: String.prototype,
+//     b: AccountManager.prototype
+// };
+// var zzz: AccountManager = undefined!;
+// myBackendMethod({
+//     a: String,
+//     b: AccountManager
+// }, {
+//     b: new AccountManager(),
+//     a: "asdf"
+// })

package/esm/core/src/shared-tests/test-special-value.spec.d.ts

@@ -0,0 +1,10 @@
+export declare class GroupsValue {
+    private readonly value;
+    hasAny(): boolean;
+    constructor(value: string);
+    evilGet(): string;
+    listGroups(): string[];
+    removeGroup(group: string): GroupsValue;
+    addGroup(group: string): GroupsValue;
+    selected(group: string): boolean;
+}

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

@@ -0,0 +1,73 @@
+import { Entity, EntityBase, Field, FieldType, Fields } from "../remult3";
+import { testAll } from "./db-tests-setup";
+@FieldType({
+    valueConverter: {
+        toJson: x => x ? x.value : '',
+        fromJson: x => new GroupsValue(x),
+        displayValue: x => x.value
+    }
+})
+export class GroupsValue {
+    value;
+    hasAny() {
+        return this.value != '';
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    evilGet() {
+        return this.value;
+    }
+    listGroups() {
+        if (!this.value)
+            return [];
+        return this.value.split(',');
+    }
+    removeGroup(group) {
+        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(", ");
+        }
+        return new GroupsValue(result);
+    }
+    addGroup(group) {
+        let r = this.value;
+        if (r)
+            r += ', ';
+        else
+            r = '';
+        r += group;
+        return new GroupsValue(r);
+    }
+    selected(group) {
+        if (!this.value)
+            return false;
+        return this.value.indexOf(group) >= 0;
+    }
+}
+@Entity("testGroups", { allowApiCrud: true })
+class testGroups extends EntityBase {
+    @Fields.integer()
+    id = 0;
+    @Field(() => GroupsValue)
+    g;
+}
+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");
+    expect(x.$.g.valueChanged()).toBe(true);
+    await x.save();
+    expect(x.g.evilGet()).toBe('xx');
+});
+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();
+    expect(x.g.evilGet()).toBe('');
+});

package/esm/core/src/shared-tests/test-update-with-null.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+import { Entity, EntityBase, Field, Fields } from "../remult3";
+import { testAll } from "./db-tests-setup";
+@Entity('testNull', { allowApiCrud: true })
+class testNull extends EntityBase {
+    @Fields.integer()
+    id = 0;
+    @Field(undefined, { allowNull: true })
+    myCol;
+    @Fields.integer({ allowNull: true })
+    numberWithNull = null;
+}
+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");
+    i.myCol = null;
+    expect(i.myCol).toBe(null);
+    await i.save();
+    expect(i.myCol).toBe(null);
+}, false);
+testAll("test number with null", async ({ createEntity }) => {
+    let r = await createEntity(testNull);
+    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;
+    await i.save();
+    expect(i.numberWithNull).toBe(0);
+    expect(await r.count({ numberWithNull: null })).toBe(0);
+}, false);

package/esm/core/src/sort.d.ts

@@ -0,0 +1,16 @@
+import { FieldMetadata } from "./column-interfaces";
+import { EntityMetadata, EntityOrderBy } from "./remult3";
+export declare class Sort {
+    toEntityOrderBy(): EntityOrderBy<any>;
+    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>;
+}
+export interface SortSegment {
+    field: FieldMetadata;
+    isDescending?: boolean;
+}

package/esm/core/src/sort.js

@@ -0,0 +1,103 @@
+import { CompoundIdField } from "./column";
+export class Sort {
+    toEntityOrderBy() {
+        let result = {};
+        for (const seg of this.Segments) {
+            if (seg.isDescending) {
+                result[seg.field.key] = "desc";
+            }
+            else
+                result[seg.field.key] = "asc";
+        }
+        return result;
+    }
+    constructor(...segments) {
+        this.Segments = segments;
+    }
+    Segments;
+    reverse() {
+        let r = new Sort();
+        for (const s of this.Segments) {
+            r.Segments.push({ field: s.field, isDescending: !s.isDescending });
+        }
+        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;
+        let sort;
+        if (orderBy) {
+            sort = new Sort();
+            for (const key in orderBy) {
+                if (Object.prototype.hasOwnProperty.call(orderBy, key)) {
+                    const element = orderBy[key];
+                    let field = entityDefs.fields.find(key);
+                    if (field) {
+                        switch (element) {
+                            case "desc":
+                                sort.Segments.push({ field, isDescending: true });
+                                break;
+                            case "asc":
+                                sort.Segments.push({ field });
+                        }
+                    }
+                }
+            }
+        }
+        return sort;
+    }
+    static createUniqueSort(entityMetadata, orderBy) {
+        if (!orderBy || Object.keys(orderBy).length === 0)
+            orderBy = Sort.translateOrderByToSort(entityMetadata, entityMetadata.options.defaultOrderBy);
+        if (!orderBy)
+            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)) {
+                    orderBy.Segments.push({ field: field });
+                }
+            }
+        }
+        else if (!orderBy.Segments.find(x => x.field == entityMetadata.idMetadata.field)) {
+            orderBy.Segments.push({ field: entityMetadata.idMetadata.field });
+        }
+        return orderBy;
+    }
+    static createUniqueEntityOrderBy(entityMetadata, orderBy) {
+        if (!orderBy || Object.keys(orderBy).length === 0)
+            orderBy = entityMetadata.options.defaultOrderBy;
+        if (!orderBy)
+            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";
+                }
+            }
+        }
+        else if (!orderBy[entityMetadata.idMetadata.field.key]) {
+            orderBy[entityMetadata.idMetadata.field.key] = "asc";
+        }
+        return orderBy;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { EntityMetadata } from './remult3';
+export interface SqlImplementation {
+    getLimitSqlSyntax(limit: number, offset: number): any;
+    createCommand(): SqlCommand;
+    transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
+    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
+    supportsJsonColumnType?: boolean;
+}
+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/core/src/sql-command.js

@@ -0,0 +1 @@
+export {};

package/esm/core/src/test.d.ts

@@ -0,0 +1,3 @@
+import 'core-js/es7/reflect';
+import 'zone.js/dist/zone';
+import 'zone.js/dist/zone-testing';

package/esm/core/src/test.js

@@ -0,0 +1,12 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+import 'core-js/es7/reflect';
+import 'zone.js/dist/zone';
+import 'zone.js/dist/zone-testing';
+import { getTestBed } from '@angular/core/testing';
+import { BrowserDynamicTestingModule, platformBrowserDynamicTesting } from '@angular/platform-browser-dynamic/testing';
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting());
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/esm/core/src/tests/Done.d.ts

@@ -0,0 +1,5 @@
+export declare class Done {
+    happened: boolean;
+    ok(): void;
+    test(message?: string): void;
+}

package/esm/core/src/tests/Done.js

@@ -0,0 +1,9 @@
+export class Done {
+    happened = false;
+    ok() {
+        this.happened = true;
+    }
+    test(message = 'expected to be done') {
+        expect(this.happened).toBe(true, message);
+    }
+}

package/esm/core/src/tests/RowProvider.spec.d.ts

@@ -0,0 +1,16 @@
+import { ArrayEntityDataProvider } from "../data-providers/array-entity-data-provider";
+import { Remult } from '../context';
+import { CategoriesForTesting } from './remult-3-entities';
+import { EntityMetadata, Repository } from '../remult3';
+export declare class Language {
+    id: number;
+    caption: string;
+    static Hebrew: Language;
+    static Russian: Language;
+    constructor(id: number, caption: string);
+}
+export declare function insertFourRows(): Promise<[Repository<CategoriesForTesting>, Remult]>;
+export declare class myDp extends ArrayEntityDataProvider {
+    constructor(entity: EntityMetadata);
+    update(id: any, data: any): Promise<any>;
+}