remult 0.14.7 → 0.14.8

package/esm/src/tests/entityForCustomFilter.js

@@ -0,0 +1,44 @@
+var entityForCustomFilter_1;
+import { __decorate, __metadata } from "tslib";
+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 { getDbNameProvider } from '../filter/filter-consumer-bridge-to-sql-request';
+let entityForCustomFilter = entityForCustomFilter_1 = class entityForCustomFilter extends EntityBase {
+};
+entityForCustomFilter.filter = Filter.createCustom(async (remult, c) => {
+    let r = [];
+    if (c.oneAndThree)
+        r.push({ id: [1, 3] });
+    if (c.two)
+        r.push({ id: 2 });
+    if (c.dbOneOrThree) {
+        let meta = remult.repo(entityForCustomFilter_1).metadata;
+        const e = await getDbNameProvider(meta);
+        r.push({
+            $and: [
+                SqlDatabase.customFilter(async (x) => x.sql = e.nameOf(meta.fields.id) + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
+                ArrayEntityDataProvider.customFilter(x => x.id == 1 || x.id == 3)
+            ]
+        });
+    }
+    return { $and: r };
+});
+entityForCustomFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
+entityForCustomFilter.testNumericValue = Filter.createCustom((r, val) => ({ id: val }));
+entityForCustomFilter.testObjectValue = Filter.createCustom((r, val) => ({ id: val.val }));
+__decorate([
+    Fields.integer(),
+    __metadata("design:type", Number)
+], entityForCustomFilter.prototype, "id", void 0);
+entityForCustomFilter = entityForCustomFilter_1 = __decorate([
+    Entity('entityForCustomFilter', { allowApiCrud: true })
+], entityForCustomFilter);
+export { entityForCustomFilter };
+let entityForCustomFilter1 = class entityForCustomFilter1 extends entityForCustomFilter {
+};
+entityForCustomFilter1 = __decorate([
+    Entity('entityForCustomFilter1', { allowApiCrud: true })
+], entityForCustomFilter1);
+export { entityForCustomFilter1 };

package/esm/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/src/tests/entityWithValidationsOnColumn.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from "tslib";
+import { Entity, EntityBase, Fields } from '../remult3';
+let entityWithValidationsOnColumn = class entityWithValidationsOnColumn extends EntityBase {
+};
+__decorate([
+    Fields.integer(),
+    __metadata("design:type", Number)
+], entityWithValidationsOnColumn.prototype, "myId", void 0);
+__decorate([
+    Fields.string({
+        validate: (t, c) => {
+            if (!t.name || t.name.length < 3)
+                c.error = 'invalid on column';
+        }
+    }),
+    __metadata("design:type", String)
+], entityWithValidationsOnColumn.prototype, "name", void 0);
+entityWithValidationsOnColumn = __decorate([
+    Entity('', { allowApiCrud: true })
+], entityWithValidationsOnColumn);
+export { entityWithValidationsOnColumn };

package/esm/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/src/tests/frontend-database-tests-setup.spec.js

@@ -0,0 +1,38 @@
+import { addDatabaseToTest, itWithFocus } from "../shared-tests/db-tests-setup";
+import { InMemoryDataProvider } 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.setDataProvider(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.setDataProvider(new InMemoryDataProvider());
+        let remult = new Remult();
+        let db = new MockRestDataProvider(r);
+        remult.setDataProvider(db);
+        await what({ db, remult, createEntity: async (x) => remult.repo(x) });
+    }, focus);
+}
+addDatabaseToTest(testRest);
+import '../shared-tests/';

package/esm/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/src/tests/h.js

@@ -0,0 +1,35 @@
+var h_1;
+import { __decorate, __metadata } from "tslib";
+import { Field, Entity, EntityBase, FieldType, Fields } from '../remult3';
+let h = h_1 = class h extends EntityBase {
+};
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], h.prototype, "id", void 0);
+__decorate([
+    Field(() => h_1),
+    __metadata("design:type", h)
+], h.prototype, "refH", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], h.prototype, "refHId", void 0);
+h = h_1 = __decorate([
+    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
+    })
+], h);
+export { h };

package/esm/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/src/tests/remult-3-entities.js

@@ -0,0 +1,72 @@
+import { __decorate, __metadata } from "tslib";
+import { EntityBase, Field, Entity, Fields } from "../remult3";
+import { Status } from "./testModel/models";
+let Products = class Products {
+};
+__decorate([
+    Fields.integer(),
+    __metadata("design:type", Number)
+], Products.prototype, "id", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], Products.prototype, "name", void 0);
+__decorate([
+    Fields.number(),
+    __metadata("design:type", Number)
+], Products.prototype, "price", void 0);
+__decorate([
+    Fields.boolean(),
+    __metadata("design:type", Boolean)
+], Products.prototype, "archived", void 0);
+__decorate([
+    Fields.date(),
+    __metadata("design:type", Date)
+], Products.prototype, "availableFrom", void 0);
+Products = __decorate([
+    Entity('Products')
+], Products);
+export { Products };
+let r;
+let Categories = class Categories extends EntityBase {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
+    }
+};
+__decorate([
+    Fields.number({
+        dbName: 'CategoryID'
+    }),
+    __metadata("design:type", Number)
+], Categories.prototype, "id", void 0);
+__decorate([
+    Fields.string({ allowNull: true }),
+    __metadata("design:type", String)
+], Categories.prototype, "categoryName", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], Categories.prototype, "description", void 0);
+__decorate([
+    Fields.number({
+        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)
+    }),
+    __metadata("design:type", Number)
+], Categories.prototype, "categoryNameLengthAsync", void 0);
+__decorate([
+    Field(() => Status),
+    __metadata("design:type", Status)
+], Categories.prototype, "status", void 0);
+Categories = __decorate([
+    Entity('Categories', {
+        allowApiCrud: true
+    })
+], Categories);
+export { Categories };

package/esm/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/src/tests/tasks.js

@@ -0,0 +1,24 @@
+import { __decorate, __metadata } from "tslib";
+import { Entity, EntityBase, Fields } from '../remult3';
+let tasks = class tasks extends EntityBase {
+    constructor() {
+        super(...arguments);
+        this.completed = false;
+    }
+};
+__decorate([
+    Fields.integer(),
+    __metadata("design:type", Number)
+], tasks.prototype, "id", void 0);
+__decorate([
+    Fields.string(),
+    __metadata("design:type", String)
+], tasks.prototype, "name", void 0);
+__decorate([
+    Fields.boolean(),
+    __metadata("design:type", Boolean)
+], tasks.prototype, "completed", void 0);
+tasks = __decorate([
+    Entity('tasks', { allowApiCrud: true })
+], tasks);
+export { tasks };

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

@@ -0,0 +1,34 @@
+import './frontend-database-tests-setup.spec';
+import { Remult } from "../context";
+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>;
+export declare const ActionTestConfig: {
+    db: InMemoryDataProvider;
+};
+export declare function testSql(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testInMemoryDb(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testRestDb(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testAllDataProviders(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare class MockRestDataProvider implements DataProvider {
+    private remult;
+    constructor(remult: Remult);
+    getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    supportsCustomFilter: boolean;
+}

package/esm/src/tests/testHelper.spec.js

@@ -0,0 +1,217 @@
+import './frontend-database-tests-setup.spec';
+import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from "../context";
+import { DataApi, serializeError } from "../data-api";
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { RestEntityDataProvider } from "../data-providers/rest-data-provider";
+import { SqlDatabase } from "../data-providers/sql-database";
+import { WebSqlDataProvider } from "../data-providers/web-sql-data-provider";
+import { Action, actionInfo, serverActionField } from "../server-action";
+import { testConfiguration } from '../shared-tests/entityWithValidations';
+import { TestDataApiResponse } from './TestDataApiResponse';
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 999999;
+//actionInfo.runningOnServer = false;
+export function itForEach(name, arrayOfT, runAsync) {
+    arrayOfT.forEach(i => {
+        it(name + ' - ' + i, (done) => {
+            runAsync(i).catch(e => {
+                fail(e);
+                done();
+            }).then(done, e => {
+                fail(e);
+                done();
+            });
+        });
+    });
+}
+export function fitForEach(name, arrayOfT, runAsync) {
+    arrayOfT.forEach(i => {
+        fit(name + ' - ' + i, (done) => {
+            runAsync(i).catch(e => {
+                fail(e);
+                done();
+            }).then(done, e => {
+                fail(e);
+                done();
+            });
+        });
+    });
+}
+export async function testAsIfOnBackend(what) {
+    try {
+        actionInfo.runningOnServer = true;
+        await what();
+    }
+    finally {
+        actionInfo.runningOnServer = false;
+    }
+}
+export const ActionTestConfig = {
+    db: new InMemoryDataProvider()
+};
+Action.provider = {
+    delete: undefined,
+    get: undefined,
+    post: async (urlreq, data) => {
+        return await new Promise((res, r) => {
+            let found = false;
+            actionInfo.allActions.forEach(action => {
+                action[serverActionField].
+                    __register((url, queue, allowed, what) => {
+                    if (Remult.apiBaseUrl + '/' + url == urlreq) {
+                        found = true;
+                        let t = new TestDataApiResponse();
+                        actionInfo.runningOnServer = true;
+                        t.success = data => {
+                            res(data);
+                            actionInfo.runningOnServer = false;
+                        };
+                        t.error = data => {
+                            r(JSON.parse(JSON.stringify(serializeError(data))));
+                            actionInfo.runningOnServer = false;
+                        };
+                        let remult = new Remult();
+                        remult.setDataProvider(ActionTestConfig.db);
+                        what(JSON.parse(JSON.stringify(data)), remult, t);
+                    }
+                });
+            });
+            if (!found) {
+                r("did not find " + urlreq);
+            }
+        });
+    },
+    put: undefined
+};
+export async function testSql(runAsync) {
+    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;
+            default:
+                await sql.execute("drop table if exists " + r.name);
+        }
+    }
+    let remult = new Remult();
+    remult.setDataProvider(sql);
+    await runAsync({ db: sql, remult });
+}
+export async function testInMemoryDb(runAsync) {
+    let remult = new Remult();
+    let db = new InMemoryDataProvider();
+    remult.setDataProvider(db);
+    await runAsync({ db, remult });
+}
+export async function testRestDb(runAsync) {
+    let r = new Remult();
+    r.setDataProvider(new InMemoryDataProvider());
+    let remult = new Remult();
+    let db = new MockRestDataProvider(r);
+    remult.setDataProvider(db);
+    await runAsync({ db, remult });
+}
+export async function testAllDataProviders(runAsync) {
+    await testSql(runAsync);
+    await testInMemoryDb(runAsync);
+    await testRestDb(runAsync);
+}
+function urlToReq(url) {
+    let args = new Map();
+    let params = url?.split('?')[1]?.split('&');
+    if (params)
+        for (const p of params) {
+            if (!p)
+                continue;
+            let z = p.split('=');
+            let key = decodeURIComponent(z[0]);
+            let value = decodeURIComponent(z[1]);
+            let x = args.get(key);
+            if (x === undefined) {
+                args.set(key, value);
+            }
+            else if (Array.isArray(x))
+                x.push(value);
+            else
+                args.set(key, [args.get(key), value]);
+        }
+    let req = {
+        get: (key) => {
+            let r = args.get(key);
+            if (r !== undefined) {
+                r.toString();
+            }
+            return r;
+        }
+    };
+    return req;
+}
+export class MockRestDataProvider {
+    constructor(remult) {
+        this.remult = remult;
+        this.supportsCustomFilter = true;
+    }
+    getEntityDataProvider(metadata) {
+        let dataApi = new DataApi(this.remult.repo(metadata.entityType), this.remult);
+        return new RestEntityDataProvider("", new HttpProviderBridgeToRestDataProviderHttpProvider({
+            delete: async (url) => {
+                let urlSplit = url.split('/');
+                let r = new TestDataApiResponse();
+                let result;
+                r.deleted = () => { };
+                try {
+                    testConfiguration.restDbRunningOnServer = true;
+                    await dataApi.delete(r, urlSplit[urlSplit.length - 1]);
+                }
+                finally {
+                    testConfiguration.restDbRunningOnServer = false;
+                }
+                return result;
+            },
+            get: async (url) => {
+                let r = new TestDataApiResponse();
+                let result;
+                r.success = data => { result = data; };
+                try {
+                    testConfiguration.restDbRunningOnServer = true;
+                    await dataApi.httpGet(r, urlToReq(url));
+                }
+                finally {
+                    testConfiguration.restDbRunningOnServer = false;
+                }
+                return result;
+            },
+            post: async (url, data) => {
+                let r = new TestDataApiResponse();
+                let result;
+                r.created = data => { result = data; };
+                r.success = data => { result = data; };
+                try {
+                    testConfiguration.restDbRunningOnServer = true;
+                    await dataApi.httpPost(r, urlToReq(url), data);
+                }
+                finally {
+                    testConfiguration.restDbRunningOnServer = false;
+                }
+                return result;
+            },
+            put: async (url, data) => {
+                let urlSplit = url.split('/');
+                let r = new TestDataApiResponse();
+                let result;
+                r.success = data => { result = data; };
+                try {
+                    testConfiguration.restDbRunningOnServer = true;
+                    await dataApi.put(r, urlSplit[urlSplit.length - 1], data);
+                }
+                finally {
+                    testConfiguration.restDbRunningOnServer = false;
+                }
+                return result;
+            }
+        }), metadata);
+    }
+    transaction(action) {
+        throw new Error('Method not implemented.');
+    }
+}

package/esm/src/tests/testModel/models.d.ts

@@ -0,0 +1,16 @@
+export declare class Status {
+    id: number;
+    name: string;
+    static open: Status;
+    static closed: Status;
+    static hold: Status;
+    constructor(id: number, name: string);
+}
+export declare class TestStatus {
+    id?: string;
+    caption?: string;
+    static open: TestStatus;
+    static closed: TestStatus;
+    static hold: TestStatus;
+    constructor(id?: string, caption?: string);
+}

package/esm/src/tests/testModel/models.js

@@ -0,0 +1,31 @@
+var Status_1, TestStatus_1;
+import { __decorate, __metadata } from "tslib";
+import { ValueListFieldType } from "../../remult3";
+let Status = Status_1 = class Status {
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+};
+Status.open = new Status_1(0, "open");
+Status.closed = new Status_1(1, "closed");
+Status.hold = new Status_1(2, "hold");
+Status = Status_1 = __decorate([
+    ValueListFieldType(),
+    __metadata("design:paramtypes", [Number, String])
+], Status);
+export { Status };
+let TestStatus = TestStatus_1 = class TestStatus {
+    constructor(id, caption) {
+        this.id = id;
+        this.caption = caption;
+    }
+};
+TestStatus.open = new TestStatus_1();
+TestStatus.closed = new TestStatus_1('cc');
+TestStatus.hold = new TestStatus_1(undefined, 'hh');
+TestStatus = TestStatus_1 = __decorate([
+    ValueListFieldType(),
+    __metadata("design:paramtypes", [String, String])
+], TestStatus);
+export { TestStatus };

package/esm/src/validators.d.ts

@@ -0,0 +1,14 @@
+import { FieldRef } from "./remult3";
+export declare class Validators {
+    static required: ((entity: any, col: FieldRef<any, string>, message?: any) => void) & {
+        withMessage: (message: string) => (entity: any, col: FieldRef<any, string>) => void;
+        defaultMessage: string;
+    };
+    static unique: ((entity: any, col: FieldRef<any, any>, message?: any) => Promise<void>) & {
+        withMessage: (message: string) => (entity: any, col: FieldRef<any, any>) => Promise<void>;
+        defaultMessage: string;
+    };
+    static uniqueOnBackend: ((entity: any, col: FieldRef<any, any>, message?: any) => Promise<void>) & {
+        withMessage: (message: string) => (entity: any, col: FieldRef<any, any>) => Promise<void>;
+    };
+}

package/esm/src/validators.js

@@ -0,0 +1,33 @@
+import { isBackend } from "./context";
+export class Validators {
+}
+Validators.required = Object.assign((entity, col, message = undefined) => {
+    if (!col.value || typeof (col.value) === "string" && col.value.trim().length == 0)
+        col.error = message || Validators.required.defaultMessage;
+}, {
+    withMessage: (message) => {
+        return (entity, col) => Validators.required(entity, col, message);
+    },
+    defaultMessage: 'Should not be empty'
+});
+Validators.unique = Object.assign(async (entity, col, message = undefined) => {
+    if (!col.entityRef)
+        throw "unique validation may only work on columns that are attached to an entity";
+    if (col.entityRef.isNew() || col.valueChanged()) {
+        if (await col.entityRef.repository.count({ [col.metadata.key]: col.value }))
+            col.error = message || Validators.unique.defaultMessage;
+    }
+}, {
+    withMessage: (message) => {
+        return (entity, col) => Validators.unique(entity, col, message);
+    },
+    defaultMessage: 'already exists'
+});
+Validators.uniqueOnBackend = Object.assign(async (entity, col, message = undefined) => {
+    if (isBackend())
+        return Validators.unique(entity, col, message);
+}, {
+    withMessage: (message) => {
+        return (entity, col) => Validators.uniqueOnBackend(entity, col, message);
+    }
+});

package/esm/urlBuilder.d.ts

@@ -0,0 +1,6 @@
+export declare class UrlBuilder {
+    url: string;
+    constructor(url: string);
+    add(key: string, value: any): void;
+    addObject(object: any, suffix?: string): void;
+}

package/esm/urlBuilder.js

@@ -0,0 +1,19 @@
+export class UrlBuilder {
+    constructor(url) {
+        this.url = url;
+    }
+    add(key, value) {
+        if (this.url.indexOf('?') >= 0)
+            this.url += '&';
+        else
+            this.url += '?';
+        this.url += encodeURIComponent(key) + '=' + encodeURIComponent(value);
+    }
+    addObject(object, suffix = '') {
+        if (object != undefined)
+            for (var key in object) {
+                let val = object[key];
+                this.add(key + suffix, val);
+            }
+    }
+}