remult 0.22.2 → 0.22.3

package/esm/core/src/context.js

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

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

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

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

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

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