remult 0.14.7 → 0.14.8

package/esm/src/context.js

@@ -0,0 +1,285 @@
+import { Action, actionInfo } from './server-action';
+import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
+export class HttpProviderBridgeToRestDataProviderHttpProvider {
+    constructor(http) {
+        this.http = http;
+    }
+    async post(url, data) {
+        return await retry(() => toPromise(this.http.post(url, data)));
+    }
+    delete(url) {
+        return toPromise(this.http.delete(url));
+    }
+    put(url, data) {
+        return toPromise(this.http.put(url, data));
+    }
+    async get(url) {
+        return await retry(() => toPromise(this.http.get(url)));
+    }
+}
+export async function retry(what) {
+    while (true) {
+        try {
+            return await what();
+        }
+        catch (err) {
+            if (err.message?.startsWith("Error occurred while trying to proxy") ||
+                err.message?.startsWith("Error occured while trying to proxy") ||
+                err.message?.includes("http proxy error") ||
+                err.message?.startsWith("Gateway Timeout")) {
+                await new Promise((res, req) => {
+                    setTimeout(() => {
+                        res({});
+                    }, 250);
+                });
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+export function toPromise(p) {
+    let r;
+    if (p["toPromise"] !== undefined) {
+        r = p["toPromise"]();
+    }
+    //@ts-ignore
+    else
+        r = p;
+    return r.then((x) => {
+        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
+            return x.data;
+        return x;
+    }).catch(async (ex) => {
+        throw await processHttpException(ex);
+    });
+}
+export async function processHttpException(ex) {
+    let z = await ex;
+    var error;
+    if (z.error)
+        error = z.error;
+    else if (z.isAxiosError) {
+        if (typeof z.response?.data === "string")
+            error = z.response.data;
+        else
+            error = z?.response?.data;
+    }
+    if (!error)
+        error = z.message;
+    if (z.status == 0 && z.error.isTrusted)
+        error = "Network Error";
+    if (typeof error === 'string') {
+        error = {
+            message: error,
+        };
+    }
+    let httpStatusCode = z.status;
+    if (httpStatusCode === undefined)
+        httpStatusCode = z.response?.status;
+    if (httpStatusCode !== undefined && httpStatusCode !== null) {
+        error.httpStatusCode = httpStatusCode;
+    }
+    var result = Object.assign(error, {
+    //     exception: ex disabled for now because JSON.stringify crashed with this
+    });
+    return result;
+}
+export function isBackend() {
+    return actionInfo.runningOnServer;
+}
+export class Remult {
+    /** Creates a new instance of the `remult` object.
+     *
+     * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
+     *
+     * If no provider is specified, `fetch` will be used as an http provider
+     */
+    constructor(provider) {
+        this._userChangeEvent = new EventSource();
+        this.repCache = new Map();
+        if (provider && provider.getEntityDataProvider) {
+            this._dataSource = provider;
+            return;
+        }
+        let http = provider;
+        let dataProvider;
+        if (http) {
+            dataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
+        }
+        if (!dataProvider) {
+            dataProvider = new RestDataProviderHttpProviderUsingFetch();
+        }
+        this._dataSource = new RestDataProvider(Remult.apiBaseUrl, dataProvider);
+        if (!Action.provider)
+            Action.provider = dataProvider;
+    }
+    /**Return's a `Repository` of the specific entity type
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * @see [Repository](https://remult.dev/docs/ref_repository.html)
+     *
+     */
+    repo(entity, dataProvider) {
+        if (dataProvider === undefined)
+            dataProvider = this._dataSource;
+        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 */
+    get user() {
+        if (this._user === undefined) {
+            return {
+                id: undefined,
+                name: '',
+                roles: []
+            };
+        }
+        return this._user;
+    }
+    /** Set's the current user info */
+    async setUser(info) {
+        this._user = info;
+        let auth = info;
+        if (auth) {
+            if (!this._user.id && auth.sub)
+                this._user.id = auth.sub;
+            if (!this._user.roles && auth.permissions) {
+                this._user.roles = auth.permissions;
+            }
+            if (!this._user.name)
+                this._user.name = auth.username;
+        }
+        if (this._user && !this._user.roles)
+            this._user.roles = [];
+        await this._userChangeEvent.fire();
+    }
+    /** 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(this, instance);
+        }
+        else
+            return this.isAllowed(allowed);
+    }
+    /** returns a dispatcher object that fires once a user has changed*/
+    get userChange() {
+        return this._userChangeEvent.dispatcher;
+    }
+    /** sets the current data provider */
+    setDataProvider(dataProvider) {
+        this._dataSource = dataProvider;
+    }
+    clearAllCache() {
+        this.repCache.clear();
+    }
+}
+/** The api Base Url to be used in all remult calls. by default it's set to `/api`.
+ *
+ * Set this property in case you want to determine a non relative api url
+ */
+Remult.apiBaseUrl = '/api';
+/** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
+Remult.onFind = (metadata, options) => { };
+export const allEntities = [];
+export const classHelpers = new Map();
+export class ClassHelper {
+    constructor() {
+        this.methods = [];
+    }
+}
+export class MethodHelper {
+    constructor() {
+        this.classes = new Map();
+    }
+}
+export function setControllerSettings(target, options) {
+    let r = target;
+    while (true) {
+        let helper = classHelpers.get(r);
+        if (helper) {
+            for (const m of helper.methods) {
+                m.classes.set(target, options);
+            }
+        }
+        let p = Object.getPrototypeOf(r.prototype);
+        if (p == null)
+            break;
+        r = p.constructor;
+    }
+}
+export class Allow {
+}
+Allow.everyone = () => true;
+Allow.authenticated = (remult) => remult.authenticated();
+export const queryConfig = {
+    defaultPageSize: 200
+};
+export class EventSource {
+    constructor() {
+        this.listeners = [];
+        this.dispatcher = {
+            observe: async (what) => {
+                this.listeners.push(what);
+                await what();
+                return () => {
+                    this.listeners = this.listeners.filter(x => x != what);
+                };
+            }
+        };
+    }
+    async fire() {
+        for (const l of this.listeners) {
+            await l();
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import { Remult } from './context';
+import { Repository } from './remult3';
+import { 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): Promise<void>;
+    httpPost(res: DataApiResponse, req: DataApiRequest, body: any): Promise<void>;
+    static defaultGetLimit: number;
+    get(response: DataApiResponse, id: any): Promise<void>;
+    count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): 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>;

package/esm/src/data-api.js

@@ -0,0 +1,204 @@
+import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
+import { Filter } from './filter/filter-interfaces';
+export class DataApi {
+    constructor(repository, remult) {
+        this.repository = repository;
+        this.remult = remult;
+    }
+    httpGet(res, req) {
+        if (req.get("__action") == "count") {
+            return this.count(res, req);
+        }
+        else
+            return this.getArray(res, req);
+    }
+    httpPost(res, req, body) {
+        switch (req.get("__action")) {
+            case "get":
+                return this.getArray(res, req, body);
+            case "count":
+                return this.count(res, req, body);
+            default:
+                return this.post(res, body);
+        }
+    }
+    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 getArray(response, request, filterBody) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            let findOptions = { load: () => [] };
+            findOptions.where = await this.buildWhere(request, filterBody);
+            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();
+                    return;
+                }
+            }
+            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");
+            }
+            await this.repository.find(findOptions)
+                .then(async (r) => {
+                response.success(await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson())));
+            });
+        }
+        catch (err) {
+            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 {
+            await this.repository.find({
+                where: { $and: [this.repository.metadata.options.apiPrefilter, this.repository.metadata.idMetadata.getIdFilter(id)] }
+            })
+                .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 this.repository.getEntityRef(row).save();
+            response.success(this.repository.getEntityRef(row).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 {
+            let newr = this.repository.create();
+            await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(body);
+            if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                response.forbidden();
+                return;
+            }
+            await this.repository.getEntityRef(newr).save();
+            response.created(this.repository.getEntityRef(newr).toApiJson());
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+}
+DataApi.defaultGetLimit = 0;
+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;
+}

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

@@ -0,0 +1,37 @@
+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>;
+    supportsCustomFilter?: boolean;
+}
+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/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/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 customFilter(filter: CustomArrayFilter): EntityFilter<any>;
+    constructor(entity: EntityMetadata, rows?: any[]);
+    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 declare type CustomArrayFilter = (item: any) => boolean;
+export interface CustomArrayFilterObject {
+    arrayFilter: CustomArrayFilter;
+}