remult 0.22.1 → 0.22.3

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

@@ -1,8 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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

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

@@ -1,24 +0,0 @@
-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

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

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

@@ -1,236 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

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

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

@@ -1,10 +0,0 @@
-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

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

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

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