remult 0.21.1 → 0.22.0

package/esm/core/src/context.js

@@ -0,0 +1,286 @@
+import { actionInfo, serverActionField } from './server-action';
+import { RestDataProvider } from './data-providers/rest-data-provider';
+import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
+import { LiveQueryClient } from "./live-query/LiveQueryClient";
+import { SseSubscriptionClient } from "./live-query/SseSubscriptionClient";
+import { RemultProxy, remult } from "./remult-proxy";
+import { buildRestDataProvider, isExternalHttpProvider } from "./buildRestDataProvider";
+export class RemultAsyncLocalStorage {
+    remultObjectStorage;
+    static enable() {
+        remult.remultFactory = () => {
+            const r = RemultAsyncLocalStorage.instance.getRemult();
+            if (r)
+                return r;
+            else
+                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+        };
+    }
+    static disable() {
+        remult.resetFactory();
+    }
+    constructor(remultObjectStorage) {
+        this.remultObjectStorage = remultObjectStorage;
+    }
+    run(remult, callback) {
+        if (this.remultObjectStorage)
+            this.remultObjectStorage.run(remult, callback);
+        else
+            callback();
+    }
+    getRemult() {
+        if (!this.remultObjectStorage) {
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
+        }
+        return this.remultObjectStorage.getStore();
+    }
+    static instance = new RemultAsyncLocalStorage(undefined);
+}
+export function isBackend() {
+    return actionInfo.runningOnServer || !remult.dataProvider.isProxy;
+}
+export class Remult {
+    /**Return's a `Repository` of the specific entity type
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * @see [Repository](https://remult.dev/docs/ref_repository.html)
+     * @param entity - the entity to use
+     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
+     */
+    repo(entity, dataProvider) {
+        if (dataProvider === undefined)
+            dataProvider = this.dataProvider;
+        let dpCache = this.repCache.get(dataProvider);
+        if (!dpCache)
+            this.repCache.set(dataProvider, dpCache = new Map());
+        let r = dpCache.get(entity);
+        if (!r) {
+            dpCache.set(entity, r = new RepositoryImplementation(entity, this, dataProvider));
+        }
+        return r;
+    }
+    /** Returns the current user's info */
+    user;
+    /** Checks if a user was authenticated */
+    authenticated() {
+        return this.user?.id !== undefined;
+    }
+    /** checks if the user has any of the roles specified in the parameters
+     * @example
+     * remult.isAllowed("admin")
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
+    isAllowed(roles) {
+        if (roles == undefined)
+            return undefined;
+        if (roles instanceof Array) {
+            for (const role of roles) {
+                if (this.isAllowed(role) === true) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (typeof roles === 'function') {
+            return roles(this);
+        }
+        if (typeof roles === 'boolean')
+            return roles;
+        if (typeof roles === 'string')
+            if (this.user?.roles?.indexOf(roles.toString()) >= 0)
+                return true;
+        return false;
+    }
+    /** checks if the user matches the allowedForInstance callback
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
+    isAllowedForInstance(instance, allowed) {
+        if (Array.isArray(allowed)) {
+            {
+                for (const item of allowed) {
+                    if (this.isAllowedForInstance(instance, item))
+                        return true;
+                }
+            }
+        }
+        else if (typeof (allowed) === "function") {
+            return allowed(instance, this);
+        }
+        else
+            return this.isAllowed(allowed);
+    }
+    /** The current data provider */
+    dataProvider = new RestDataProvider(() => this.apiClient);
+    /* @internal */
+    repCache = new Map();
+    constructor(provider) {
+        if (provider && provider.getEntityDataProvider) {
+            this.dataProvider = provider;
+            return;
+        }
+        if (isExternalHttpProvider(provider)) {
+            this.apiClient.httpClient = provider;
+        }
+        else if (typeof (provider) === "function")
+            this.apiClient.httpClient = provider;
+        else if (provider) {
+            const apiClient = provider;
+            if (apiClient.httpClient)
+                this.apiClient.httpClient = apiClient.httpClient;
+            if (apiClient.url)
+                this.apiClient.url = apiClient.url;
+            if (apiClient.subscriptionClient)
+                this.apiClient.subscriptionClient = apiClient.subscriptionClient;
+            if (apiClient.wrapMessageHandling)
+                this.apiClient.wrapMessageHandling = apiClient.wrapMessageHandling;
+        }
+    }
+    /* @internal*/
+    liveQueryStorage;
+    subscriptionServer;
+    /* @internal*/
+    liveQueryPublisher = {
+        itemChanged: async () => { }
+    };
+    //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
+    /** Used to call a `backendMethod` using a specific `remult` object
+     * @example
+     * await remult.call(TasksController.setAll, undefined, true);
+     * @param backendMethod - the backend method to call
+     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
+     * @param args - the arguments to send to the backend method
+    */
+    call(backendMethod, classInstance, ...args) {
+        const z = (backendMethod[serverActionField]);
+        if (!z.doWork)
+            throw Error("The method received is not a valid backend method");
+        //@ts-ignore
+        return z.doWork(args, classInstance, this.apiClient.url, buildRestDataProvider(this.apiClient.httpClient));
+    }
+    /* @internal*/
+    liveQuerySubscriber = new LiveQueryClient(() => this.apiClient, () => this.user?.id);
+    /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
+    static onFind = (metadata, options) => { };
+    clearAllCache() {
+        this.repCache.clear();
+    }
+    /** A helper callback that is called whenever an entity is created. */
+    static entityRefInit;
+    /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
+    context = {};
+    /** The api client that will be used by `remult` to perform calls to the `api` */
+    apiClient = {
+        url: '/api',
+        subscriptionClient: new SseSubscriptionClient()
+    };
+    static run(callback, options) {
+        const remult = new Remult();
+        if (options.dataProvider)
+            remult.dataProvider = options.dataProvider;
+        let r;
+        RemultAsyncLocalStorage.instance.run(remult, () => {
+            r = callback();
+        });
+        return r;
+    }
+}
+RemultProxy.defaultRemult = new Remult();
+;
+export const allEntities = [];
+export const classHelpers = new Map();
+export class ClassHelper {
+    classes = new Map();
+}
+export function setControllerSettings(target, options) {
+    let r = target;
+    while (true) {
+        let helper = classHelpers.get(r);
+        if (!helper)
+            classHelpers.set(r, helper = new ClassHelper());
+        helper.classes.set(target, options);
+        let p = Object.getPrototypeOf(r.prototype);
+        if (p == null)
+            break;
+        r = p.constructor;
+    }
+}
+export class Allow {
+    static everyone = () => true;
+    static authenticated = (...args) => {
+        if (args.length > 1) {
+            return args[1].authenticated();
+        }
+        else if (args.length == 1) {
+            if (args[0].authenticated)
+                return args[0].authenticated();
+        }
+        return remult.authenticated();
+    };
+}
+export const queryConfig = {
+    defaultPageSize: 200
+};
+export class EventSource {
+    listeners = [];
+    async fire() {
+        for (const l of this.listeners) {
+            await l();
+        }
+    }
+    dispatcher = {
+        observe: async (what) => {
+            this.listeners.push(what);
+            await what();
+            return () => {
+                this.listeners = this.listeners.filter(x => x != what);
+            };
+        }
+    };
+}
+export async function doTransaction(remult, what) {
+    const trans = new transactionLiveQueryPublisher(remult.liveQueryPublisher);
+    let ok = true;
+    const result = await remult.dataProvider.transaction(async (ds) => {
+        remult.dataProvider = (ds);
+        remult.liveQueryPublisher = trans;
+        await what();
+        ok = true;
+    });
+    if (ok)
+        await trans.flush();
+}
+class transactionLiveQueryPublisher {
+    orig;
+    constructor(orig) {
+        this.orig = orig;
+    }
+    transactionItems = new Map();
+    async itemChanged(entityKey, changes) {
+        let items = this.transactionItems.get(entityKey);
+        if (!items) {
+            this.transactionItems.set(entityKey, items = []);
+        }
+        for (const c of changes) {
+            if (c.oldId !== undefined) {
+                const item = items.find(y => y.id === c.oldId);
+                if (item !== undefined) {
+                    if (c.deleted)
+                        item.deleted = true;
+                    if (c.id != item.id)
+                        item.id = c.id;
+                }
+                else
+                    items.push(c);
+            }
+            else
+                items.push(c);
+        }
+    }
+    async flush() {
+        for (const key of this.transactionItems.keys()) {
+            await this.orig.itemChanged(key, this.transactionItems.get(key));
+        }
+    }
+}

package/esm/core/src/data-api.d.ts

@@ -0,0 +1,39 @@
+import { Remult } from './context';
+import type { FindOptions, Repository } from './remult3';
+import type { ErrorInfo } from './data-interfaces';
+export declare class DataApi<T = any> {
+    private repository;
+    private remult;
+    constructor(repository: Repository<T>, remult: Remult);
+    httpGet(res: DataApiResponse, req: DataApiRequest, serializeContext: () => Promise<any>): Promise<void>;
+    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeContext: () => Promise<any>): Promise<void>;
+    static defaultGetLimit: number;
+    get(response: DataApiResponse, id: any): Promise<void>;
+    count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    getArrayImpl(response: DataApiResponse, request: DataApiRequest, filterBody: any): Promise<{
+        r: any[];
+        findOptions: FindOptions<T>;
+    }>;
+    getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
+    private buildWhere;
+    private doOnId;
+    put(response: DataApiResponse, id: any, body: any): Promise<void>;
+    delete(response: DataApiResponse, id: any): Promise<void>;
+    post(response: DataApiResponse, body: any): Promise<void>;
+}
+export interface DataApiResponse {
+    success(data: any): void;
+    deleted(): void;
+    created(data: any): void;
+    notFound(): void;
+    error(data: ErrorInfo): void;
+    forbidden(): void;
+    progress(progress: number): void;
+}
+export interface DataApiRequest {
+    get(key: string): any;
+}
+export declare function determineSort(sortUrlParm: string, dirUrlParam: string): any;
+export declare function serializeError(data: ErrorInfo): ErrorInfo<any>;
+export declare function getLiveQueryChannel(queryId: string, userId: string): string;

package/esm/core/src/data-api.js

@@ -0,0 +1,279 @@
+import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
+import { doTransaction } from './context';
+import { Filter } from './filter/filter-interfaces';
+import { ForbiddenError } from './server-action';
+import { findOptionsToJson, liveQueryAction } from './data-providers/rest-data-provider';
+export class DataApi {
+    repository;
+    remult;
+    constructor(repository, remult) {
+        this.repository = repository;
+        this.remult = remult;
+    }
+    httpGet(res, req, serializeContext) {
+        const action = req?.get("__action");
+        if (action?.startsWith(liveQueryAction))
+            return this.liveQuery(res, req, undefined, serializeContext, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
+        switch (action) {
+            case "get":
+            case "count":
+                return this.count(res, req, undefined);
+        }
+        return this.getArray(res, req, undefined);
+    }
+    async httpPost(res, req, body, serializeContext) {
+        const action = req?.get("__action");
+        if (action?.startsWith(liveQueryAction))
+            return this.liveQuery(res, req, undefined, serializeContext, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
+        switch (action) {
+            case "get":
+                return this.getArray(res, req, body);
+            case "count":
+                return this.count(res, req, body);
+            case "endLiveQuery":
+                await this.remult.liveQueryStorage.remove(getLiveQueryChannel(body.id, this.remult.user?.id));
+                res.success("ok");
+                return;
+            default:
+                return this.post(res, body);
+        }
+    }
+    static defaultGetLimit = 0;
+    async get(response, id) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        await this.doOnId(response, id, async (row) => response.success(this.repository.getEntityRef(row).toApiJson()));
+    }
+    async count(response, request, filterBody) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            response.success({ count: +await this.repository.count(await this.buildWhere(request, filterBody)) });
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+    async getArrayImpl(response, request, filterBody) {
+        let findOptions = { load: () => [] };
+        findOptions.where = await this.buildWhere(request, filterBody);
+        if (request) {
+            let sort = request.get("_sort");
+            if (sort != undefined) {
+                let dir = request.get('_order');
+                findOptions.orderBy = determineSort(sort, dir);
+            }
+            let limit = +request.get("_limit");
+            if (!limit && DataApi.defaultGetLimit)
+                limit = DataApi.defaultGetLimit;
+            findOptions.limit = limit;
+            findOptions.page = +request.get("_page");
+        }
+        if (this.remult.isAllowed(this.repository.metadata.options.apiRequireId)) {
+            let hasId = false;
+            let w = await Filter.fromEntityFilter(this.repository.metadata, findOptions.where);
+            if (w) {
+                w.__applyToConsumer({
+                    containsCaseInsensitive: () => { },
+                    isDifferentFrom: () => { },
+                    isEqualTo: (col, val) => {
+                        if (this.repository.metadata.idMetadata.isIdField(col))
+                            hasId = true;
+                    },
+                    custom: () => { },
+                    databaseCustom: () => { },
+                    isGreaterOrEqualTo: () => { },
+                    isGreaterThan: () => { },
+                    isIn: () => { },
+                    isLessOrEqualTo: () => { },
+                    isLessThan: () => { },
+                    isNotNull: () => { },
+                    isNull: () => { },
+                    or: () => { }
+                });
+            }
+            if (!hasId) {
+                response.forbidden();
+                throw new ForbiddenError();
+            }
+        }
+        const r = await this.repository.find(findOptions)
+            .then(async (r) => {
+            return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
+        });
+        return { r, findOptions };
+    }
+    async getArray(response, request, filterBody) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            const { r } = await this.getArrayImpl(response, request, filterBody);
+            response.success(r);
+        }
+        catch (err) {
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
+        }
+    }
+    async liveQuery(response, request, filterBody, serializeContext, queryChannel) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            const r = await this.getArrayImpl(response, request, filterBody);
+            const data = {
+                requestJson: await serializeContext(),
+                findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
+                lastIds: r.r.map(y => this.repository.metadata.idMetadata.getId(y))
+            };
+            await this.remult.liveQueryStorage.add({
+                entityKey: this.repository.metadata.key,
+                id: queryChannel,
+                data
+            });
+            response.success(r.r);
+        }
+        catch (err) {
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
+        }
+    }
+    async buildWhere(request, filterBody) {
+        var where = [];
+        if (this.repository.metadata.options.apiPrefilter) {
+            if (typeof this.repository.metadata.options.apiPrefilter === "function")
+                where.push(await this.repository.metadata.options.apiPrefilter());
+            else
+                where.push(this.repository.metadata.options.apiPrefilter);
+        }
+        if (request) {
+            where.push(buildFilterFromRequestParameters(this.repository.metadata, {
+                get: key => {
+                    let result = request.get(key);
+                    if (key.startsWith(customUrlToken) && result)
+                        return JSON.parse(result);
+                    return result;
+                }
+            }));
+        }
+        if (filterBody)
+            where.push(Filter.entityFilterFromJson(this.repository.metadata, filterBody));
+        return { $and: where };
+    }
+    async doOnId(response, id, what) {
+        try {
+            var where = [this.repository.metadata.idMetadata.getIdFilter(id)];
+            if (this.repository.metadata.options.apiPrefilter) {
+                if (typeof this.repository.metadata.options.apiPrefilter === "function")
+                    where.push(await this.repository.metadata.options.apiPrefilter());
+                else
+                    where.push(this.repository.metadata.options.apiPrefilter);
+            }
+            await this.repository.find({
+                where: { $and: where }
+            })
+                .then(async (r) => {
+                if (r.length == 0)
+                    response.notFound();
+                else if (r.length > 1)
+                    response.error({ message: "id is not unique" });
+                else
+                    await what(r[0]);
+            });
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+    async put(response, id, body) {
+        await this.doOnId(response, id, async (row) => {
+            let ref = this.repository.getEntityRef(row);
+            await ref._updateEntityBasedOnApi(body);
+            if (!ref.apiUpdateAllowed) {
+                response.forbidden();
+                return;
+            }
+            await ref.save();
+            response.success(ref.toApiJson());
+        });
+    }
+    async delete(response, id) {
+        await this.doOnId(response, id, async (row) => {
+            if (!this.repository.getEntityRef(row).apiDeleteAllowed) {
+                response.forbidden();
+                return;
+            }
+            await this.repository.getEntityRef(row).delete();
+            response.deleted();
+        });
+    }
+    async post(response, body) {
+        try {
+            const insert = async (what) => {
+                let newr = this.repository.create();
+                await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
+                if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                    throw new ForbiddenError();
+                }
+                await this.repository.getEntityRef(newr).save();
+                return this.repository.getEntityRef(newr).toApiJson();
+            };
+            if (Array.isArray(body)) {
+                const result = [];
+                await doTransaction(this.remult, async () => {
+                    for (const item of body) {
+                        result.push(await insert(item));
+                    }
+                });
+                response.created(result);
+            }
+            else
+                response.created(await insert(body));
+        }
+        catch (err) {
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
+        }
+    }
+}
+export function determineSort(sortUrlParm, dirUrlParam) {
+    let dirItems = [];
+    if (dirUrlParam)
+        dirItems = dirUrlParam.split(',');
+    let result = {};
+    sortUrlParm.split(',').map((name, i) => {
+        let key = name.trim();
+        if (i < dirItems.length && dirItems[i].toLowerCase().trim().startsWith("d"))
+            return result[key] = "desc";
+        else
+            return result[key] = "asc";
+    });
+    return result;
+}
+export function serializeError(data) {
+    if (data instanceof TypeError) {
+        data = { message: data.message, stack: data.stack };
+    }
+    let x = JSON.parse(JSON.stringify(data));
+    if (!x.message && !x.modelState)
+        data = { message: data.message, stack: data.stack };
+    if (typeof x === 'string')
+        data = { message: x };
+    return data;
+}
+export function getLiveQueryChannel(queryId, userId) {
+    return `users:${userId}:queries:${queryId}`;
+}

package/esm/core/src/data-interfaces.d.ts

@@ -0,0 +1,41 @@
+import { Sort } from './sort';
+import { Filter } from './filter/filter-interfaces';
+import { EntityMetadata, OmitEB } from './remult3';
+export interface DataProvider {
+    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
+    isProxy?: boolean;
+}
+export interface Storage {
+    ensureSchema(): Promise<void>;
+}
+export interface EntityDataProvider {
+    count(where: Filter): Promise<number>;
+    find(options?: EntityDataProviderFindOptions): Promise<Array<any>>;
+    update(id: any, data: any): Promise<any>;
+    delete(id: any): Promise<void>;
+    insert(data: any): Promise<any>;
+}
+export interface EntityDataProviderFindOptions {
+    where?: Filter;
+    limit?: number;
+    page?: number;
+    orderBy?: Sort;
+}
+export interface RestDataProviderHttpProvider {
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function extractSort(sort: any): Sort;
+export interface ErrorInfo<entityType = any> {
+    message?: string;
+    modelState?: {
+        [Properties in keyof Partial<OmitEB<entityType>>]?: string;
+    };
+    stack?: string;
+    exception?: any;
+    httpStatusCode?: number;
+}

package/esm/core/src/data-interfaces.js

@@ -0,0 +1,12 @@
+import { Sort } from './sort';
+export function extractSort(sort) {
+    if (sort instanceof Sort)
+        return sort;
+    if (sort instanceof Array) {
+        let r = new Sort();
+        sort.forEach(i => {
+            r.Segments.push(i);
+        });
+        return r;
+    }
+}

package/esm/core/src/data-providers/array-entity-data-provider.d.ts

@@ -0,0 +1,22 @@
+import { EntityDataProvider, EntityDataProviderFindOptions } from '../data-interfaces';
+import { Filter } from '../filter/filter-interfaces';
+import { EntityMetadata, EntityFilter } from '../remult3';
+export declare class ArrayEntityDataProvider implements EntityDataProvider {
+    private entity;
+    private rows?;
+    static rawFilter(filter: CustomArrayFilter): EntityFilter<any>;
+    constructor(entity: EntityMetadata, rows?: any[] | undefined);
+    private verifyThatRowHasAllNotNullColumns;
+    count(where?: Filter): Promise<number>;
+    find(options?: EntityDataProviderFindOptions): Promise<any[]>;
+    translateFromJson(row: any): {};
+    translateToJson(row: any): {};
+    private idMatches;
+    update(id: any, data: any): Promise<any>;
+    delete(id: any): Promise<void>;
+    insert(data: any): Promise<any>;
+}
+export type CustomArrayFilter = (item: any) => boolean;
+export interface CustomArrayFilterObject {
+    arrayFilter: CustomArrayFilter;
+}