remult 0.22.2 → 0.22.3

package/esm/core/src/server-action.js

@@ -1,394 +0,0 @@
-import 'reflect-metadata';
-import { Remult, allEntities, classHelpers, ClassHelper, setControllerSettings, doTransaction, isBackend } from './context';
-import { buildRestDataProvider } from "./buildRestDataProvider";
-import { SqlDatabase } from './data-providers/sql-database';
-import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef } from './remult3';
-import { remult } from './remult-proxy';
-export class Action {
-    actionUrl;
-    queue;
-    allowed;
-    constructor(actionUrl, queue, allowed) {
-        this.actionUrl = actionUrl;
-        this.queue = queue;
-        this.allowed = allowed;
-    }
-    static apiUrlForJobStatus = 'jobStatusInQueue';
-    async run(pIn, baseUrl, http) {
-        if (baseUrl === undefined)
-            baseUrl = remult.apiClient.url;
-        if (!http)
-            http = buildRestDataProvider(remult.apiClient.httpClient);
-        let r = await http.post(baseUrl + '/' + this.actionUrl, pIn);
-        let p = r;
-        if (p && p.queuedJobId) {
-            let progress = actionInfo.startBusyWithProgress();
-            try {
-                let runningJob;
-                await actionInfo.runActionWithoutBlockingUI(async () => {
-                    while (!runningJob || !runningJob.done) {
-                        if (runningJob)
-                            await new Promise(res => setTimeout(() => {
-                                res(undefined);
-                            }, 200));
-                        runningJob = await http.post(baseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId });
-                        if (runningJob.progress) {
-                            progress.progress(runningJob.progress);
-                        }
-                    }
-                });
-                if (runningJob.error)
-                    throw runningJob.error;
-                progress.progress(1);
-                return runningJob.result;
-            }
-            finally {
-                progress.close();
-            }
-        }
-        else
-            return r;
-    }
-    doWork;
-    __register(reg) {
-        reg(this.actionUrl, this.queue, this.allowed, async (d, req, res) => {
-            try {
-                var r = await this.execute(d, req, res);
-                res.success(r);
-            }
-            catch (err) {
-                if (err.isForbiddenError) // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
-                    res.forbidden();
-                else
-                    res.error(err);
-            }
-        });
-    }
-}
-export class ForbiddenError extends Error {
-    constructor() {
-        super("Forbidden");
-    }
-    isForbiddenError = true;
-}
-export class myServerAction extends Action {
-    types;
-    options;
-    originalMethod;
-    constructor(name, types, options, originalMethod) {
-        super(name, options.queue, options.allowed);
-        this.types = types;
-        this.options = options;
-        this.originalMethod = originalMethod;
-    }
-    async execute(info, remult, res) {
-        let result = { data: {} };
-        let ds = remult.dataProvider;
-        await doTransaction(remult, async () => {
-            if (!remult.isAllowedForInstance(undefined, this.options.allowed))
-                throw new ForbiddenError();
-            info.args = await prepareReceivedArgs(this.types, info.args, remult, ds, res);
-            try {
-                result.data = await this.originalMethod(info.args);
-            }
-            catch (err) {
-                throw err;
-            }
-        });
-        return result;
-    }
-}
-export const actionInfo = {
-    allActions: [],
-    runningOnServer: false,
-    runActionWithoutBlockingUI: (what) => { return what(); },
-    startBusyWithProgress: () => ({
-        progress: (percent) => { },
-        close: () => { }
-    })
-};
-export const serverActionField = Symbol('serverActionField');
-const classOptions = new Map();
-export function Controller(key) {
-    return function (target, context) {
-        let r = target;
-        classOptions.set(r, { key });
-        setControllerSettings(target, { key });
-        return target;
-    };
-}
-/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
-export function BackendMethod(options) {
-    return (target, 
-    //@ts-ignore
-    context, descriptor) => {
-        const key = typeof (context) === "string" ? context : context.name.toString();
-        const originalMethod = descriptor ? descriptor.value : target;
-        let result = originalMethod;
-        if (target.prototype !== undefined) {
-            var types = Reflect.getMetadata("design:paramtypes", target, key);
-            if (options.paramTypes)
-                types = options.paramTypes;
-            // if types are undefined - you've forgot to set: "emitDecoratorMetadata":true
-            let serverAction = new myServerAction((options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, types, options, args => originalMethod.apply(undefined, args));
-            serverAction.doWork = async (args, self, url, http) => {
-                args = prepareArgsToSend(types, args);
-                if (options.blockUser === false) {
-                    return await actionInfo.runActionWithoutBlockingUI(async () => (await serverAction.run({ args }, url, http)).data);
-                }
-                else
-                    return (await serverAction.run({ args }, url, http)).data;
-            };
-            result = async function (...args) {
-                if (!isBackend()) {
-                    return await serverAction.doWork(args, undefined);
-                }
-                else
-                    return (await originalMethod.apply(this, args));
-            };
-            registerAction(target, result);
-            result[serverActionField] = serverAction;
-            if (descriptor) {
-                descriptor.value = result;
-                return descriptor;
-            }
-            else
-                return result;
-        }
-        var types = Reflect.getMetadata("design:paramtypes", target, key);
-        if (options.paramTypes)
-            types = options.paramTypes;
-        let x = classHelpers.get(target.constructor);
-        if (!x) {
-            x = new ClassHelper();
-            classHelpers.set(target.constructor, x);
-        }
-        let serverAction = {
-            __register(reg) {
-                let c = new Remult();
-                for (const constructor of x.classes.keys()) {
-                    let controllerOptions = x.classes.get(constructor);
-                    if (!controllerOptions.key) {
-                        controllerOptions.key = c.repo(constructor).metadata.key;
-                    }
-                    reg(controllerOptions.key + '/' + (options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, options ? options.queue : false, options.allowed, async (d, req, res) => {
-                        d.args = d.args.map(x => isCustomUndefined(x) ? undefined : x);
-                        let allowed = options.allowed;
-                        try {
-                            let remult = req;
-                            let r;
-                            await doTransaction(remult, async () => {
-                                d.args = await prepareReceivedArgs(types, d.args, remult, remult.dataProvider, res);
-                                if (allEntities.includes(constructor)) {
-                                    let repo = remult.repo(constructor);
-                                    let y;
-                                    if (d.rowInfo.isNewRow) {
-                                        y = repo.create();
-                                        let rowHelper = repo.getEntityRef(y);
-                                        await rowHelper._updateEntityBasedOnApi(d.rowInfo.data);
-                                    }
-                                    else {
-                                        let rows = await repo.find({
-                                            where: {
-                                                ...repo.metadata.idMetadata.getIdFilter(d.rowInfo.id),
-                                                $and: [repo.metadata.options.apiPrefilter]
-                                            }
-                                        });
-                                        if (rows.length != 1)
-                                            throw new Error("not found or too many matches");
-                                        y = rows[0];
-                                        await repo.getEntityRef(y)._updateEntityBasedOnApi(d.rowInfo.data);
-                                    }
-                                    if (!remult.isAllowedForInstance(y, allowed))
-                                        throw new ForbiddenError();
-                                    let defs = getEntityRef(y);
-                                    await defs.__validateEntity();
-                                    try {
-                                        r = {
-                                            result: await originalMethod.apply(y, d.args),
-                                            rowInfo: {
-                                                data: await defs.toApiJson(),
-                                                isNewRow: defs.isNew(),
-                                                wasChanged: defs.wasChanged(),
-                                                id: defs.getOriginalId()
-                                            }
-                                        };
-                                    }
-                                    catch (err) {
-                                        throw defs.catchSaveErrors(err);
-                                    }
-                                }
-                                else {
-                                    let y = new constructor(remult, remult.dataProvider);
-                                    let controllerRef = getControllerRef(y, remult);
-                                    await controllerRef._updateEntityBasedOnApi(d.fields);
-                                    if (!remult.isAllowedForInstance(y, allowed))
-                                        throw new ForbiddenError();
-                                    await controllerRef.__validateEntity();
-                                    try {
-                                        r = {
-                                            result: await originalMethod.apply(y, d.args),
-                                            fields: await controllerRef.toApiJson()
-                                        };
-                                    }
-                                    catch (err) {
-                                        throw controllerRef.catchSaveErrors(err);
-                                    }
-                                }
-                            });
-                            res.success(r);
-                        }
-                        catch (err) {
-                            if (err.isForbiddenError) // got a problem in next with instance of ForbiddenError  - so replaced it with this bool
-                                res.forbidden();
-                            else
-                                res.error(err);
-                        }
-                    });
-                }
-            },
-            doWork: async function (args, self, baseUrl, http) {
-                args = prepareArgsToSend(types, args);
-                if (allEntities.includes(target.constructor)) {
-                    let defs = getEntityRef(self);
-                    await defs.__validateEntity();
-                    let classOptions = x.classes.get(self.constructor);
-                    if (!classOptions.key) {
-                        classOptions.key = defs.repository.metadata.key + "_methods";
-                    }
-                    try {
-                        let r = await (new class extends Action {
-                            execute;
-                        }(classOptions.key + "/" + (options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, options ? options.queue : false, options.allowed).run({
-                            args,
-                            rowInfo: {
-                                data: await defs.toApiJson(),
-                                isNewRow: defs.isNew(),
-                                wasChanged: defs.wasChanged(),
-                                id: defs.getOriginalId()
-                            }
-                        }, baseUrl, http));
-                        await defs._updateEntityBasedOnApi(r.rowInfo.data);
-                        return r.result;
-                    }
-                    catch (err) {
-                        throw defs.catchSaveErrors(err);
-                    }
-                }
-                else {
-                    let defs = getControllerRef(self, undefined);
-                    try {
-                        await defs.__validateEntity();
-                        let r = await (new class extends Action {
-                            execute;
-                        }(x.classes.get(self.constructor).key + "/" + (options?.apiPrefix ? (options.apiPrefix + '/') : '') + key, options ? options.queue : false, options.allowed).run({
-                            args,
-                            fields: await defs.toApiJson()
-                        }, baseUrl, http));
-                        await defs._updateEntityBasedOnApi(r.fields);
-                        return r.result;
-                    }
-                    catch (e) {
-                        throw defs.catchSaveErrors(e);
-                    }
-                }
-            }
-        };
-        result = async function (...args) {
-            if (!isBackend()) {
-                let self = this;
-                return serverAction.doWork(args, self);
-            }
-            else
-                return (await originalMethod.apply(this, args));
-        };
-        registerAction(target.constructor, result);
-        result[serverActionField] = serverAction;
-        if (descriptor) {
-            descriptor.value = result;
-            return descriptor;
-        }
-        else
-            return result;
-    };
-}
-const customUndefined = {
-    _isUndefined: true
-};
-function registerAction(target, resultMethod) {
-    (target[classBackendMethodsArray] || (target[classBackendMethodsArray] = [])).push(resultMethod);
-    actionInfo.allActions.push(resultMethod);
-}
-function isCustomUndefined(x) {
-    return x && x._isUndefined;
-}
-export class ProgressListener {
-    res;
-    constructor(res) {
-        this.res = res;
-    }
-    progress(progress) {
-        this.res.progress(progress);
-    }
-}
-export function prepareArgsToSend(types, args) {
-    if (types) {
-        for (let index = 0; index < types.length; index++) {
-            const paramType = types[index];
-            for (const type of [Remult, SqlDatabase]) {
-                if (args[index] instanceof type)
-                    args[index] = undefined;
-                else if (paramType == type) {
-                    args[index] = undefined;
-                }
-            }
-            if (args[index] != undefined) {
-                let x = { valueType: paramType };
-                x = decorateColumnSettings(x, new Remult());
-                if (x.valueConverter)
-                    args[index] = x.valueConverter.toJson(args[index]);
-                let eo = getEntitySettings(paramType, false);
-                if (eo != null) {
-                    let rh = getEntityRef(args[index]);
-                    args[index] = rh.getId();
-                }
-            }
-        }
-    }
-    return args.map(x => x !== undefined ? x : customUndefined);
-}
-export async function prepareReceivedArgs(types, args, remult, ds, res) {
-    for (let index = 0; index < args.length; index++) {
-        const element = args[index];
-        if (isCustomUndefined(element))
-            args[index] = undefined;
-    }
-    if (types)
-        for (let i = 0; i < types.length; i++) {
-            if (args.length < i) {
-                args.push(undefined);
-            }
-            if (types[i] == Remult || types[i] == Remult) {
-                args[i] = remult;
-            }
-            else if (types[i] == SqlDatabase && ds) {
-                args[i] = ds;
-            }
-            else if (types[i] == ProgressListener) {
-                args[i] = new ProgressListener(res);
-            }
-            else {
-                let x = { valueType: types[i] };
-                x = decorateColumnSettings(x, remult);
-                if (x.valueConverter)
-                    args[i] = x.valueConverter.fromJson(args[i]);
-                let eo = getEntitySettings(types[i], false);
-                if (eo != null) {
-                    if (!(args[i] === null || args[i] === undefined))
-                        args[i] = await remult.repo(types[i]).findId(args[i]);
-                }
-            }
-        }
-    return args;
-}
-export const classBackendMethodsArray = Symbol('classBackendMethodsArray');

package/esm/core/src/shared-tests/db-tests-setup.d.ts

@@ -1,32 +0,0 @@
-import { ClassType } from "../../classType";
-import { Remult } from "../context";
-import { DataProvider } from "../data-interfaces";
-import { Repository } from "../remult3";
-import { CategoriesForTesting } from "../tests/remult-3-entities";
-import { Status } from "../tests/testModel/models";
-export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
-export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean, options?: {
-    exclude?: string[];
-}): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature, key?: string): dbTestMethodSignature;
-export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare const TestDbs: {
-    restDataProvider: string;
-    mongo: string;
-    inMemory: string;
-};
-export declare type dbTestWhatSignature = ((db: {
-    db: DataProvider;
-    remult: Remult;
-    createEntity<entityType>(entity: ClassType<entityType>): Promise<Repository<entityType>>;
-}) => Promise<void>);
-export declare type dbTestMethodSignature = ((key: string, what: dbTestWhatSignature, focus: boolean) => void) & {
-    key?: string;
-};
-export declare function testAllDbs<T extends CategoriesForTesting>(key: string, doTest: (helper: {
-    remult: Remult;
-    createData: (doInsert?: (insert: (id: number, name: string, description?: string, status?: Status) => Promise<void>) => Promise<void>, entity?: {
-        new (): CategoriesForTesting;
-    }) => Promise<Repository<T>>;
-    insertFourRows: () => Promise<Repository<T>>;
-}) => Promise<any>, focus?: boolean): Promise<void>;

package/esm/core/src/shared-tests/db-tests-setup.js

@@ -1,78 +0,0 @@
-import { Remult } from "../context";
-import { InMemoryDataProvider } from "../data-providers/in-memory-database";
-import { Categories } from "../tests/remult-3-entities";
-export function itWithFocus(key, what, focus = false) {
-    if (focus) {
-        fit(key, what);
-    }
-    else
-        it(key, what);
-}
-export function testAll(key, what, focus = false, options) {
-    function runTest(m) {
-        return !options?.exclude?.includes(m.key);
-    }
-    for (const test of databasesTesters) {
-        if (runTest(test))
-            test(key, what, focus);
-    }
-    loadedTests.push(x => {
-        if (runTest(x))
-            x(key, what, focus);
-    });
-}
-const databasesTesters = [];
-const loadedTests = [];
-export function addDatabaseToTest(tester, key) {
-    tester.key = key;
-    for (const test of loadedTests) {
-        test(tester);
-    }
-    databasesTesters.push(tester);
-    return tester;
-}
-export function testInMemory(key, what, focus = false) {
-    itWithFocus(key + " - in memory", async () => {
-        let db = new InMemoryDataProvider();
-        let remult = new Remult(db);
-        await what({ db, remult, createEntity: async (x) => remult.repo(x) });
-    }, focus);
-}
-export const TestDbs = {
-    restDataProvider: "restDataProvider",
-    mongo: "mongo",
-    inMemory: 'in memory'
-};
-addDatabaseToTest(testInMemory, TestDbs.inMemory);
-export async function testAllDbs(key, doTest, focus = false) {
-    testAll(key, async ({ remult, createEntity }) => {
-        let createData = async (doInsert, entity) => {
-            if (!entity)
-                entity = Categories;
-            let rep = await createEntity(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;
-        };
-        await doTest({
-            remult,
-            createData,
-            insertFourRows: async () => {
-                return createData(async (i) => {
-                    await i(1, 'noam', 'x');
-                    await i(4, 'yael', 'x');
-                    await i(2, 'yoni', 'y');
-                    await i(3, 'maayan', 'y');
-                });
-            }
-        });
-    }, focus);
-}

package/esm/core/src/shared-tests/db-tests.db-tests.d.ts

@@ -1,25 +0,0 @@
-import { EntityBase, IdEntity } from "../remult3";
-export declare class stam extends EntityBase {
-    id: number;
-    title: string;
-}
-export declare class tasksWithEnum extends IdEntity {
-    title: string;
-    completed: boolean;
-    priority: Priority;
-}
-export declare enum Priority {
-    Low = 0,
-    High = 1,
-    Critical = 2
-}
-export declare class tasksWithStringEnum extends IdEntity {
-    title: string;
-    completed: boolean;
-    priority: PriorityWithString;
-}
-export declare enum PriorityWithString {
-    Low = "Low",
-    High = "High",
-    Critical = "Critical"
-}