remult 0.21.1 → 0.22.0

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

@@ -0,0 +1,226 @@
+import './frontend-database-tests-setup.spec';
+import { 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 { actionInfo, serverActionField } from "../server-action";
+import { testConfiguration } from '../shared-tests/entityWithValidations';
+import { TestDataApiResponse } from './TestDataApiResponse';
+import { remult } from '../remult-proxy';
+import { HttpProviderBridgeToRestDataProviderHttpProvider } from '../buildRestDataProvider';
+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()
+};
+remult.apiClient.httpClient = {
+    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 ('/api/' + 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;
+                        };
+                        t.forbidden = () => {
+                            r({ status: 403, message: "forbidden" });
+                            actionInfo.runningOnServer = false;
+                        };
+                        let remult = new Remult();
+                        remult.dataProvider = (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.dataProvider = (sql);
+    await runAsync({ db: sql, remult });
+}
+export async function testInMemoryDb(runAsync) {
+    let db = new InMemoryDataProvider();
+    remult.dataProvider = (db);
+    await runAsync({ db, remult });
+}
+export async function testRestDb(runAsync) {
+    let r = new Remult();
+    r.dataProvider = (new InMemoryDataProvider());
+    let remult = new Remult();
+    let db = new MockRestDataProvider(r);
+    remult.dataProvider = (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 {
+    remult;
+    constructor(remult) {
+        this.remult = remult;
+    }
+    getEntityDataProvider(metadata) {
+        let dataApi = new DataApi(this.remult.repo(metadata.entityType), this.remult);
+        return new RestEntityDataProvider(() => "", () => createMockHttpDataProvider(dataApi), metadata);
+    }
+    transaction(action) {
+        throw new Error('Method not implemented.');
+    }
+    isProxy = true;
+}
+export function createMockHttpDataProvider(dataApi) {
+    return 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), async () => "");
+            }
+            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, async () => ({}));
+            }
+            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;
+        }
+    });
+}

package/esm/core/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 | undefined;
+    caption?: string | undefined;
+    static open: TestStatus;
+    static closed: TestStatus;
+    static hold: TestStatus;
+    constructor(id?: string | undefined, caption?: string | undefined);
+}

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

@@ -0,0 +1,25 @@
+import { ValueListFieldType } from "../../remult3";
+@ValueListFieldType()
+export class Status {
+    id;
+    name;
+    static open = new Status(0, "open");
+    static closed = new Status(1, "closed");
+    static hold = new Status(2, "hold");
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+}
+@ValueListFieldType()
+export class TestStatus {
+    id;
+    caption;
+    static open = new TestStatus();
+    static closed = new TestStatus('cc');
+    static hold = new TestStatus(undefined, 'hh');
+    constructor(id, caption) {
+        this.id = id;
+        this.caption = caption;
+    }
+}

package/esm/core/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?: undefined) => void) & {
+        withMessage: (message: string) => (entity: any, col: FieldRef<any, string>) => void;
+        defaultMessage: string;
+    };
+    static unique: ((entity: any, col: FieldRef<any, any>, message?: undefined) => Promise<void>) & {
+        withMessage: (message: string) => (entity: any, col: FieldRef<any, any>) => Promise<void>;
+        defaultMessage: string;
+    };
+    static uniqueOnBackend: ((entity: any, col: FieldRef<any, any>, message?: undefined) => Promise<void>) & {
+        withMessage: (message: string) => (entity: any, col: FieldRef<any, any>) => Promise<void>;
+    };
+}

package/esm/core/src/validators.js

@@ -0,0 +1,33 @@
+import { isBackend } from "./context";
+export class Validators {
+    static 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'
+    });
+    static 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'
+    });
+    static 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/core/src/valueConverters.d.ts

@@ -0,0 +1,13 @@
+import { ValueConverter } from "./column-interfaces";
+export declare class ValueConverters {
+    static readonly Date: ValueConverter<Date>;
+    static readonly DateOnly: ValueConverter<Date>;
+    static readonly DateOnlyString: ValueConverter<Date>;
+    static readonly Boolean: ValueConverter<Boolean>;
+    static readonly Number: ValueConverter<number>;
+    static readonly String: ValueConverter<String>;
+    static readonly Integer: ValueConverter<number>;
+    static readonly Default: Required<ValueConverter<any>>;
+    static readonly JsonString: ValueConverter<any>;
+    static readonly JsonValue: ValueConverter<any>;
+}

package/esm/core/src/valueConverters.js

@@ -0,0 +1,197 @@
+import { InputTypes } from "../inputTypes";
+export class ValueConverters {
+    static Date = {
+        toJson: (val) => {
+            if (val === null)
+                return null;
+            if (!val)
+                return '';
+            if (typeof (val) === "string")
+                val = new Date(val);
+            if (val instanceof Date) {
+                return val.toISOString();
+            }
+            else {
+                throw new Error("Expected date but got " + val);
+            }
+        },
+        fromJson: (val) => {
+            if (val === null)
+                return null;
+            if (val == undefined)
+                return undefined;
+            if (val == '')
+                return undefined;
+            if (val.startsWith('0000-00-00'))
+                return undefined;
+            return new Date(Date.parse(val));
+        },
+        toDb: x => x,
+        fromDb: val => {
+            if (typeof val === "number")
+                val = new Date(val);
+            if (typeof (val) === "string")
+                val = new Date(val);
+            if (val && !(val instanceof Date))
+                throw "expected date but got " + val;
+            return val;
+        },
+        fromInput: x => ValueConverters.Date.fromJson(x),
+        toInput: x => ValueConverters.Date.toJson(x),
+        displayValue: (val) => {
+            if (!val)
+                return '';
+            return val.toLocaleString();
+        }
+    };
+    static DateOnly = {
+        fromInput: x => ValueConverters.DateOnly.fromJson(x),
+        toInput: x => ValueConverters.DateOnly.toJson(x),
+        toJson: (val) => {
+            var d = val;
+            if (typeof d === "string" || typeof (d) === "number")
+                d = new Date(d);
+            if (!d || d == null)
+                return null;
+            if (d.getHours() == 0)
+                return new Date(d.valueOf() - d.getTimezoneOffset() * 60000).toISOString().substring(0, 10);
+            else
+                return d.toISOString().substring(0, 10);
+        },
+        fromJson: (value) => {
+            if (!value || value == '' || value == '0000-00-00')
+                return null;
+            let d = new Date(Date.parse(value));
+            d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
+            return d;
+        },
+        inputType: InputTypes.date,
+        toDb: (val) => {
+            if (!val)
+                return null;
+            return ValueConverters.DateOnly.fromJson(ValueConverters.DateOnly.toJson(val));
+        } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
+        ,
+        fromDb: (val) => {
+            return ValueConverters.Date.fromDb(val);
+        },
+        fieldTypeInDb: 'date',
+        displayValue: (value) => {
+            if (!value)
+                return '';
+            return value.toLocaleDateString(undefined);
+        }
+    };
+    static DateOnlyString = {
+        ...ValueConverters.DateOnly,
+        toDb: (d) => {
+            let val = ValueConverters.DateOnly.toJson(d);
+            if (!val)
+                return undefined;
+            return val.replace(/-/g, '');
+        },
+        fromDb: (val) => {
+            if (val === null)
+                return null;
+            if (!val)
+                return undefined;
+            return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
+        }
+    };
+    static Boolean = {
+        toDb: (val) => val,
+        inputType: InputTypes.checkbox,
+        fromDb: (value) => {
+            return ValueConverters.Boolean.fromJson(value);
+        },
+        fromJson: value => {
+            if (typeof value === "boolean")
+                return value;
+            if (value === 1)
+                return true;
+            if (value !== undefined && value !== null) {
+                return value.toString().trim().toLowerCase() == 'true';
+            }
+            return value;
+        },
+        toJson: x => x,
+        fromInput: x => ValueConverters.Boolean.fromJson(x),
+        toInput: x => ValueConverters.Boolean.toJson(x)
+    };
+    static Number = {
+        fromDb: value => {
+            if (value === null)
+                return null;
+            if (value !== undefined)
+                return +value;
+            return undefined;
+        },
+        toDb: value => value,
+        fromJson: value => ValueConverters.Number.fromDb(value),
+        toJson: value => ValueConverters.Number.toDb(value),
+        fromInput: (x, type) => {
+            let r = +x;
+            if (!x)
+                return undefined;
+            return r;
+        },
+        toInput: (x, type) => {
+            return x?.toString();
+        },
+        inputType: InputTypes.number
+    };
+    static String = {
+        fromDb: enforceString,
+        toDb: enforceString,
+        fromJson: enforceString,
+        toJson: enforceString,
+        fromInput: enforceString,
+        toInput: enforceString,
+    };
+    static Integer = {
+        ...ValueConverters.Number,
+        toJson: value => {
+            let val = ValueConverters.Number.toDb(value);
+            if (!val)
+                return val;
+            return +(+val).toFixed(0);
+        },
+        toDb: value => ValueConverters.Integer.toJson(value),
+        fieldTypeInDb: 'integer'
+    };
+    static Default = {
+        fromJson: x => x,
+        toJson: x => x,
+        fromDb: x => ValueConverters.JsonString.fromDb(x),
+        toDb: x => ValueConverters.JsonString.toDb(x),
+        fromInput: x => ValueConverters.Default.fromJson(x),
+        toInput: x => ValueConverters.Default.toJson(x),
+        displayValue: x => x + '',
+        fieldTypeInDb: '',
+        inputType: 'text'
+    };
+    static JsonString = {
+        fromJson: x => x,
+        toJson: x => x,
+        fromDb: x => x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined,
+        toDb: x => x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined,
+        fromInput: x => ValueConverters.JsonString.fromJson(x),
+        toInput: x => ValueConverters.JsonString.toJson(x)
+    };
+    static JsonValue = {
+        fromJson: x => x,
+        toJson: x => x,
+        fromDb: x => x,
+        toDb: x => x,
+        fromInput: x => ValueConverters.JsonString.fromJson(x),
+        toInput: x => ValueConverters.JsonString.toJson(x),
+        fieldTypeInDb: 'json'
+    };
+}
+function enforceString(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof (value) !== "string")
+        return value.toString();
+    return value;
+}

package/esm/core/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/core/urlBuilder.js

@@ -0,0 +1,20 @@
+export class UrlBuilder {
+    url;
+    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);
+            }
+    }
+}