remult 0.21.1 → 0.22.0

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

@@ -0,0 +1,8 @@
+import { Remult } from '../context';
+import { EntityBase } from '../remult3';
+export declare class c extends EntityBase {
+    private remult;
+    id: number;
+    name: string;
+    constructor(remult: Remult);
+}

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

@@ -0,0 +1,13 @@
+import { Entity, EntityBase, Fields } from '../remult3';
+@Entity('c', { allowApiCrud: true })
+export class c extends EntityBase {
+    remult;
+    @Fields.integer()
+    id;
+    @Fields.string()
+    name;
+    constructor(remult) {
+        super();
+        this.remult = remult;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { Status } from './testModel/models';
+import { Remult } from '../context';
+import { CategoriesForTesting } from './remult-3-entities';
+import { Repository } from '../remult3';
+export declare function createData(doInsert?: (insert: (id: number, name: string, description?: string, status?: Status) => Promise<void>) => Promise<void>, entity?: {
+    new (): CategoriesForTesting;
+}): Promise<[Repository<CategoriesForTesting>, Remult]>;

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

@@ -0,0 +1,22 @@
+import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { Remult } from '../context';
+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());
+    if (!entity)
+        entity = newCategories;
+    let rep = await deleteAll(remult.repo(entity));
+    if (doInsert)
+        await doInsert(async (id, name, description, status) => {
+            let c = rep.create();
+            c.id = id;
+            c.categoryName = name;
+            c.description = description;
+            if (status)
+                c.status = status;
+            await rep.save(c);
+        });
+    return [rep, remult];
+}

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

@@ -0,0 +1,6 @@
+import { EntityBase } from '../remult3';
+export declare class d extends EntityBase {
+    id: number;
+    b: number;
+    static count: number;
+}

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

@@ -0,0 +1,11 @@
+import { Entity, EntityBase, Fields } from '../remult3';
+@Entity('d1', {
+    allowApiCrud: true
+})
+export class d extends EntityBase {
+    @Fields.integer()
+    id;
+    @Fields.integer()
+    b;
+    static count = 0;
+}

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

@@ -0,0 +1,7 @@
+import { EntityBase } from '../remult3';
+export declare class dWithPrefilter extends EntityBase {
+    id: number;
+    b: number;
+    static count: number;
+    doIt(): Promise<boolean>;
+}

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

@@ -0,0 +1,18 @@
+import { BackendMethod } from '../server-action';
+import { Entity, EntityBase, Fields } from '../remult3';
+@Entity('d', {
+    apiPrefilter: { b: 2 },
+    allowApiCrud: true
+})
+export class dWithPrefilter extends EntityBase {
+    @Fields.integer()
+    id;
+    @Fields.integer()
+    b;
+    static count = 0;
+    @BackendMethod({ allowed: true })
+    async doIt() {
+        dWithPrefilter.count++;
+        return true;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { EntityBase, EntityFilter } from '../remult3';
+export declare class entityForrawFilter extends EntityBase {
+    id: number;
+    static filter: ((y: {
+        oneAndThree?: boolean | undefined;
+        dbOneOrThree?: boolean | undefined;
+        two?: boolean | undefined;
+    }) => 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<entityForrawFilter>) & import("../filter/filter-interfaces").rawFilterInfo<entityForrawFilter>;
+}
+export declare class entityForrawFilter1 extends entityForrawFilter {
+}

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

@@ -0,0 +1,33 @@
+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 { dbNamesOf } from '../filter/filter-consumer-bridge-to-sql-request';
+@Entity('entityForrawFilter', { allowApiCrud: true })
+export class entityForrawFilter extends EntityBase {
+    @Fields.integer()
+    id;
+    static 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) {
+            const e = await dbNamesOf(remult.repo(entityForrawFilter));
+            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)
+                ]
+            });
+        }
+        return { $and: r };
+    });
+    static oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
+    static testNumericValue = Filter.createCustom((val) => ({ id: val }));
+    static testObjectValue = Filter.createCustom((val) => ({ id: val.val }));
+}
+@Entity('entityForrawFilter1', { allowApiCrud: true })
+export class entityForrawFilter1 extends entityForrawFilter {
+}

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

@@ -0,0 +1,5 @@
+import { EntityBase } from '../remult3';
+export declare class entityWithValidationsOnColumn extends EntityBase {
+    myId: number;
+    name: string;
+}

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

@@ -0,0 +1,13 @@
+import { Entity, EntityBase, Fields } from '../remult3';
+@Entity('', { allowApiCrud: true })
+export class entityWithValidationsOnColumn extends EntityBase {
+    @Fields.integer()
+    myId;
+    @Fields.string({
+        validate: (t, c) => {
+            if (!t.name || t.name.length < 3)
+                c.error = 'invalid on column';
+        }
+    })
+    name;
+}

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

@@ -0,0 +1,4 @@
+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/core/src/tests/frontend-database-tests-setup.spec.js

@@ -0,0 +1,37 @@
+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 () => {
+        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__":
+                    break;
+                case "sqlite_sequence":
+                    break;
+                default:
+                    await sql.execute("drop table if exists " + r.name);
+            }
+        }
+        let remult = new Remult();
+        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 () => {
+        let r = new Remult();
+        r.dataProvider = (new InMemoryDataProvider());
+        let db = new MockRestDataProvider(r);
+        remult.dataProvider = (db);
+        await what({ db, remult, createEntity: async (x) => remult.repo(x) });
+    }, focus);
+}
+addDatabaseToTest(testRest, TestDbs.restDataProvider);
+import '../shared-tests/';

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

@@ -0,0 +1,6 @@
+import { EntityBase } from '../remult3';
+export declare class h extends EntityBase {
+    id: string;
+    refH: h;
+    refHId: string;
+}

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

@@ -0,0 +1,24 @@
+import { Field, Entity, EntityBase, FieldType, Fields } from '../remult3';
+@FieldType({
+    valueConverter: {
+        toJson: x => x != undefined ? x : '',
+        fromJson: x => x ? x : null
+    },
+})
+@Entity('h', {
+    saving: self => {
+        if (self.refH)
+            self.refHId = self.refH.id;
+        else
+            self.refHId = '';
+    },
+    allowApiCrud: true
+})
+export class h extends EntityBase {
+    @Fields.string()
+    id;
+    @Field(() => h)
+    refH;
+    @Fields.string()
+    refHId;
+}

package/esm/core/src/tests/remult-3-basic-tests.spec.d.ts

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

package/esm/core/src/tests/remult-3-basic-tests.spec.js

@@ -0,0 +1,236 @@
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { Categories, Products } from './remult-3-entities';
+import { Entity, Field, Fields, getEntityRef } from "../remult3";
+import { Remult } from "../context";
+import { describeClass } from "../remult3/DecoratorReplacer";
+import { MockRestDataProvider } from "./testHelper.spec";
+describe("remult-3-basics", () => {
+    it("test the very basics", async () => {
+        let mem = new InMemoryDataProvider();
+        let c = new Remult();
+        c.dataProvider = (mem);
+        expect(await c.repo(Products).count()).toBe(0);
+        let p = c.repo(Products).create();
+        p.id = 1;
+        p.name = "noam";
+        p.price = 5;
+        p.archived = false;
+        await c.repo(Products).save(p);
+        expect(await c.repo(Products).count()).toBe(1);
+        expect(await c.repo(Products).count({ id: 1 })).toBe(1);
+        expect(await c.repo(Products).count({ id: 2 })).toBe(0);
+        p = c.repo(Products).create();
+        p.id = 2;
+        p.name = "yael";
+        p.price = 10;
+        p.archived = true;
+        await getEntityRef(p).save();
+        p = new Products();
+        p.id = 3;
+        p.name = "yoni";
+        p.price = 7;
+        p.archived = false;
+        await c.repo(Products).insert(p);
+        expect(await c.repo(Products).count()).toBe(3);
+        let products = await c.repo(Products).find({
+            where: { id: 2 }
+        });
+        expect(products[0].name).toBe("yael");
+        p = await c.repo(Products).findFirst({ id: 3 });
+        p = await c.repo(Products).findFirst({}, { where: { id: 3 } });
+        expect(p.name).toBe("yoni");
+    });
+    it("test save scenarios", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let error = false;
+        try {
+            let x = await repo.save({ id: 1, categoryName: 'a' });
+        }
+        catch {
+            error = true;
+        }
+        expect(error).toBe(true);
+    });
+    it("test save scenarios2", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let x = await repo.save(new Categories());
+        expect(x.isNew()).toBe(false);
+        expect(await repo.count()).toBe(1);
+    });
+    it("test save scenarios3", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let x = await repo.save({ categoryName: 'a' });
+        expect(x.isNew()).toBe(false);
+        expect(x._.wasChanged()).toBe(false);
+        expect(await repo.count()).toBe(1);
+        x.categoryName = 'b';
+        expect(x._.wasChanged()).toBe(true);
+        await x.save();
+        expect(x._.wasChanged()).toBe(false);
+        expect(x.categoryName).toBe('b');
+        await x.delete();
+        expect(await repo.count()).toBe(0);
+    });
+    it("test save scenarios4", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let x = await repo.insert({ id: 1, categoryName: 'a' });
+        expect(x.isNew()).toBe(false);
+        expect(x._.wasChanged()).toBe(false);
+        expect(await repo.count()).toBe(1);
+        x.categoryName = 'b';
+        expect(x._.wasChanged()).toBe(true);
+        await x.save();
+        expect(x._.wasChanged()).toBe(false);
+        expect(x.categoryName).toBe('b');
+        await x.delete();
+        expect(await repo.count()).toBe(0);
+    });
+    it("test save scenarios 5", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        await repo.insert({ id: 1, categoryName: 'a' });
+        let x = await repo.save({ id: 1, categoryName: 'c' });
+        expect(x.isNew()).toBe(false);
+        expect(x.categoryName).toBe('c');
+        expect(x._.wasChanged()).toBe(false);
+        expect(await repo.count()).toBe(1);
+        x.categoryName = 'b';
+        expect(x._.wasChanged()).toBe(true);
+        await x.save();
+        expect(x._.wasChanged()).toBe(false);
+        expect(x.categoryName).toBe('b');
+        await x.delete();
+        expect(await repo.count()).toBe(0);
+    });
+    it("test save scenarios 6", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        await repo.create({ id: 1, categoryName: 'a' }).save();
+        let x = await repo.update(1, { id: 2, categoryName: 'c' });
+        expect(x.isNew()).toBe(false);
+        expect(x.categoryName).toBe('c');
+        expect(x._.wasChanged()).toBe(false);
+        expect(await repo.count()).toBe(1);
+        expect(x.id).toBe(2);
+        expect(x.categoryName).toBe('c');
+    });
+    it("test save scenarios 7", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        await repo.create({ id: 1, categoryName: 'a' }).save();
+        let x = await repo.update(1, { id: 2, description: 'c' });
+        expect(x.isNew()).toBe(false);
+        expect(x.categoryName).toBe('a');
+        expect(x.description).toBe('c');
+    });
+    it("test delete scenarios", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let r = await repo.create({ id: 1, categoryName: 'a' }).save();
+        await r.delete();
+        expect(await repo.count()).toBe(0);
+    });
+    it("test delete scenarios 1", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let r = await repo.create({ id: 1, categoryName: 'a' }).save();
+        await repo.delete(r);
+        expect(await repo.count()).toBe(0);
+    });
+    it("test delete scenarios 2", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        await repo.create({ id: 1, categoryName: 'a' }).save();
+        await repo.delete(1);
+        expect(await repo.count()).toBe(0);
+    });
+    it("test insert works with active record and fails on existing one", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        var r = await repo.insert(repo.create({ id: 1 }));
+        expect(await repo.count()).toBe(1);
+        let ok = false;
+        try {
+            await repo.insert(r);
+            ok = true;
+        }
+        catch {
+        }
+        expect(ok).toBe(false);
+    });
+    it("save works with array", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        let repo = remult.repo(Categories);
+        let items = (await repo.insert([{ id: 1 }, { id: 2 }])).map(y => ({ ...y, categoryName: y.id.toString() }));
+        await repo.save(items);
+        expect(items[0].categoryName).toBe('1');
+    });
+    it("test update of object", async () => {
+        const product = class {
+            id = 0;
+            category;
+        };
+        describeClass(product, Entity("pr"), {
+            id: Fields.number(),
+            category: Field(() => Categories)
+        });
+        var remult = new Remult(new InMemoryDataProvider());
+        const [c1, c2] = await remult.repo(Categories).insert([{ id: 1, categoryName: 'cat1' }, { id: 2, categoryName: "cat2" }]);
+        const r = remult.repo(product);
+        let p = await r.insert({ id: 1, category: c1 });
+        expect(p.category.id).toBe(1);
+        p = await r.findId(1, { useCache: false });
+        expect(p.category.id).toBe(1);
+        p = await r.update(1, { ...p, category: c2 });
+        expect(p.id).toBe(1);
+        expect(p.category.id).toBe(2);
+        p = await r.findId(1, { useCache: false });
+        expect(p.category.id).toBe(2);
+        p = await r.update(1, {
+            ...p,
+            category: { id: 1 }
+        });
+        expect(p.id).toBe(1);
+        expect(p.category.id).toBe(1);
+        p = await r.findId(1, { useCache: false });
+        expect(p.category.id).toBe(1);
+        expect(p.category.categoryName).toBe("cat1");
+    });
+    it("test update of object data api", async () => {
+        const product = class {
+            id = 0;
+            category;
+        };
+        describeClass(product, Entity("pr", { allowApiCrud: true }), {
+            id: Fields.number(),
+            category: Field(() => Categories)
+        });
+        var sr = new Remult(new InMemoryDataProvider());
+        var dp = new MockRestDataProvider(sr);
+        var remult = new Remult(dp);
+        const [c1, c2] = await remult.repo(Categories).insert([{ id: 1, categoryName: 'cat1' }, { id: 2, categoryName: "cat2" }]);
+        const r = remult.repo(product);
+        let p = await r.insert({ id: 1, category: c1 });
+        expect(p.category.id).toBe(1);
+        p = await r.findId(1, { useCache: false });
+        expect(p.category.id).toBe(1);
+        p = await r.update(1, { ...p, category: c2 });
+        expect(p.id).toBe(1);
+        expect(p.category.id).toBe(2);
+        p = await r.findId(1, { useCache: false });
+        expect(p.category.id).toBe(2);
+        p = await r.update(1, {
+            ...p,
+            category: { id: 1 }
+        });
+        expect(p.id).toBe(1);
+        expect(p.category.id).toBe(1);
+        p = await r.findId(1, { useCache: false });
+        expect(p.category.id).toBe(1);
+        expect(p.category.categoryName).toBe("cat1");
+    });
+});

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

@@ -0,0 +1,23 @@
+import { EntityBase } from "../remult3";
+import { Status } from "./testModel/models";
+export declare class Products {
+    id: number;
+    name: string;
+    price: number;
+    archived: boolean;
+    availableFrom: Date;
+}
+export interface CategoriesForTesting extends EntityBase {
+    id: number;
+    categoryName: string;
+    description: string;
+    status: Status;
+}
+export declare class Categories extends EntityBase {
+    id: number;
+    categoryName: string;
+    description: string;
+    categoryNameLength: number;
+    categoryNameLengthAsync: number;
+    status: Status;
+}

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

@@ -0,0 +1,39 @@
+import { EntityBase, Field, Entity, Fields } from "../remult3";
+import { Status } from "./testModel/models";
+@Entity('Products')
+export class Products {
+    @Fields.integer()
+    id;
+    @Fields.string()
+    name;
+    @Fields.number()
+    price;
+    @Fields.boolean()
+    archived;
+    @Fields.date()
+    availableFrom;
+}
+let r;
+@Entity('Categories', {
+    allowApiCrud: true
+})
+export class Categories extends EntityBase {
+    @Fields.number({
+        dbName: 'CategoryID'
+    })
+    id = 0;
+    @Fields.string({ allowNull: true })
+    categoryName;
+    @Fields.string()
+    description;
+    @Fields.number({
+        serverExpression: c => c.categoryName ? c.categoryName.length : undefined
+    })
+    categoryNameLength;
+    @Fields.number({
+        serverExpression: (c) => Promise.resolve(c.categoryName ? c.categoryName.length : undefined)
+    })
+    categoryNameLengthAsync;
+    @Field(() => Status)
+    status;
+}

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

@@ -0,0 +1,6 @@
+import { EntityBase } from '../remult3';
+export declare class tasks extends EntityBase {
+    id: number;
+    name: string;
+    completed: boolean;
+}

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

@@ -0,0 +1,10 @@
+import { Entity, EntityBase, Fields } from '../remult3';
+@Entity('tasks', { allowApiCrud: true })
+export class tasks extends EntityBase {
+    @Fields.integer()
+    id;
+    @Fields.string()
+    name;
+    @Fields.boolean()
+    completed = false;
+}

package/esm/core/src/tests/test-context-as-storage.spec.js

@@ -0,0 +1 @@
+"use strict";

package/esm/core/src/tests/test-data-api/predefined-filter.spec.d.ts

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