remult 0.22.2 → 0.22.3

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

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

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

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

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

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

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

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

@@ -1,20 +0,0 @@
-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);
-            }
-    }
-}

package/esm/test-servers/shared/Task.d.ts

@@ -1,9 +0,0 @@
-import { Remult } from '../../core/src/context';
-export declare class Task {
-    id: string;
-    title: string;
-    completed: boolean;
-    static testForbidden(): void;
-    static testStaticRemult(): Promise<number>;
-    static testInjectedRemult(remult?: Remult): Promise<number>;
-}

package/esm/test-servers/shared/Task.js

@@ -1,32 +0,0 @@
-import { Entity, Fields } from '../../core/src/remult3';
-import { Validators } from '../../core/src/validators';
-import { BackendMethod } from '../../core/src/server-action';
-import { remult } from '../../core/src/remult-proxy';
-import { isBackend } from '../../core/src/context';
-@Entity("tasks", {
-    allowApiCrud: true
-})
-export class Task {
-    @Fields.uuid()
-    id;
-    @Fields.string({
-        validate: (r, c) => {
-            if (isBackend())
-                Validators.required(r, c);
-        }
-    })
-    title = '';
-    @Fields.boolean()
-    completed = false;
-    @BackendMethod({ allowed: false })
-    static testForbidden() {
-    }
-    @BackendMethod({ allowed: true })
-    static async testStaticRemult() {
-        return await remult.repo(Task).count();
-    }
-    @BackendMethod({ allowed: true })
-    static async testInjectedRemult(remult) {
-        return await remult.repo(Task).count();
-    }
-}

package/esm/test.d.ts

@@ -1,5 +0,0 @@
-export type ClassType<T> = {
-    new (...args: any[]): T;
-};
-export declare function Field1<valueType>(valueType: () => ClassType<valueType>): (target: any, context: ClassFieldDecoratorContext<any, valueType | undefined> | string) => void;
-export declare function createdAt(): (target: any, context: string | ClassFieldDecoratorContext<any, Date>) => void;

package/esm/test.js

@@ -1,6 +0,0 @@
-export function Field1(valueType) {
-    return (target, context) => { };
-}
-export function createdAt() {
-    return Field1(() => Date);
-}