remult 0.14.7 → 0.14.10

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

@@ -0,0 +1,85 @@
+import { FieldMetadata } from "../column-interfaces";
+import { Remult } from "../context";
+import { EntityMetadata, EntityFilter } from "../remult3";
+export declare class Filter {
+    private apply?;
+    constructor(apply?: (add: FilterConsumer) => void);
+    __applyToConsumer(add: FilterConsumer): void;
+    static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
+    static createCustom<entityType>(customFilterTranslator: (r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & customFilterInfo<entityType>;
+    static createCustom<entityType, argsType>(customFilterTranslator: (r: Remult, args: argsType) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): ((y: argsType) => EntityFilter<entityType>) & customFilterInfo<entityType>;
+    static fromEntityFilter<T>(entity: EntityMetadata<T>, whereItem: EntityFilter<T>): Filter;
+    toJson(): any;
+    static entityFilterToJson<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>): any;
+    static entityFilterFromJson<T>(entityDefs: EntityMetadata<T>, packed: any): EntityFilter<T>;
+    static translateCustomWhere<T>(r: Filter, entity: EntityMetadata<T>, remult: Remult): Promise<Filter>;
+}
+export declare class filterHelper {
+    metadata: FieldMetadata;
+    constructor(metadata: FieldMetadata);
+    processVal(val: any): any;
+    contains(val: string): Filter;
+    isLessThan(val: any): Filter;
+    isGreaterOrEqualTo(val: any): Filter;
+    isNotIn(values: any[]): Filter;
+    isDifferentFrom(val: any): Filter;
+    isLessOrEqualTo(val: any): Filter;
+    isGreaterThan(val: any): Filter;
+    isEqualTo(val: any): Filter;
+    isIn(val: any[]): Filter;
+}
+export interface FilterConsumer {
+    or(orElements: Filter[]): any;
+    isEqualTo(col: FieldMetadata, val: any): void;
+    isDifferentFrom(col: FieldMetadata, val: any): void;
+    isNull(col: FieldMetadata): void;
+    isNotNull(col: FieldMetadata): void;
+    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
+    isGreaterThan(col: FieldMetadata, val: any): void;
+    isLessOrEqualTo(col: FieldMetadata, val: any): void;
+    isLessThan(col: FieldMetadata, val: any): void;
+    containsCaseInsensitive(col: FieldMetadata, val: any): void;
+    isIn(col: FieldMetadata, val: any[]): void;
+    custom(key: string, customItem: any): void;
+    databaseCustom(databaseCustom: any): void;
+}
+export declare class AndFilter extends Filter {
+    readonly filters: Filter[];
+    constructor(...filters: Filter[]);
+    add(filter: Filter): void;
+}
+export declare class OrFilter extends Filter {
+    readonly filters: Filter[];
+    constructor(...filters: Filter[]);
+}
+export declare const customUrlToken = "$custom$";
+export declare const customDatabaseFilterToken = "$db$";
+export declare class FilterSerializer implements FilterConsumer {
+    result: any;
+    constructor();
+    databaseCustom(databaseCustom: any): void;
+    custom(key: any, customItem: any): void;
+    hasUndefined: boolean;
+    add(key: string, val: any): void;
+    or(orElements: Filter[]): void;
+    isNull(col: FieldMetadata): void;
+    isNotNull(col: FieldMetadata): void;
+    isIn(col: FieldMetadata, val: any[]): void;
+    isEqualTo(col: FieldMetadata, val: any): void;
+    isDifferentFrom(col: FieldMetadata, val: any): void;
+    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
+    isGreaterThan(col: FieldMetadata, val: any): void;
+    isLessOrEqualTo(col: FieldMetadata, val: any): void;
+    isLessThan(col: FieldMetadata, val: any): void;
+    containsCaseInsensitive(col: FieldMetadata, val: any): void;
+}
+export declare function entityFilterToJson<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>): any;
+export declare function buildFilterFromRequestParameters(entity: EntityMetadata, filterInfo: {
+    get: (key: string) => any;
+}): EntityFilter<any>;
+export interface customFilterInfo<entityType> {
+    customFilterInfo: {
+        key: string;
+        customFilterTranslator: (r: Remult, args: any) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+    };
+}

package/esm/src/filter/filter-interfaces.js

@@ -0,0 +1,467 @@
+import { getEntityRef, getEntitySettings } from "../remult3";
+export class Filter {
+    constructor(apply) {
+        this.apply = apply;
+        if (!this.apply) {
+            this.apply = () => { };
+        }
+    }
+    __applyToConsumer(add) {
+        this.apply(add);
+    }
+    static async resolve(filter) {
+        if (typeof filter === "function")
+            return await filter();
+        return filter;
+    }
+    static createCustom(customFilterTranslator, key = '') {
+        let customFilterInfo = { key: key, customFilterTranslator };
+        return Object.assign((x) => {
+            let z = {};
+            if (x == undefined)
+                x = {};
+            if (!customFilterInfo.key)
+                throw "Usage of custom filter before a key was assigned to it";
+            return {
+                [customUrlToken + customFilterInfo.key]: x
+            };
+        }, { customFilterInfo });
+    }
+    static fromEntityFilter(entity, whereItem) {
+        let result = [];
+        for (const key in whereItem) {
+            if (Object.prototype.hasOwnProperty.call(whereItem, key)) {
+                let fieldToFilter = whereItem[key];
+                {
+                    if (key == "$or") {
+                        result.push(new OrFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
+                    }
+                    else if (key == "$and") {
+                        result.push(new AndFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
+                    }
+                    else if (key.startsWith(customUrlToken)) {
+                        result.push(new Filter(x => {
+                            x.custom(key.substring(customUrlToken.length), fieldToFilter);
+                        }));
+                    }
+                    else if (key == customDatabaseFilterToken) {
+                        result.push(new Filter(x => x.databaseCustom(fieldToFilter)));
+                    }
+                    else {
+                        let fh = new filterHelper(entity.fields[key]);
+                        let found = false;
+                        if (fieldToFilter !== undefined && fieldToFilter != null) {
+                            if (fieldToFilter.$id)
+                                fieldToFilter = fieldToFilter.$id;
+                            for (const key in fieldToFilter) {
+                                if (Object.prototype.hasOwnProperty.call(fieldToFilter, key)) {
+                                    const element = fieldToFilter[key];
+                                    switch (key) {
+                                        case "$gte":
+                                        case ">=":
+                                            result.push(fh.isGreaterOrEqualTo(element));
+                                            found = true;
+                                            break;
+                                        case "$gt":
+                                        case ">":
+                                            result.push(fh.isGreaterThan(element));
+                                            found = true;
+                                            break;
+                                        case "$lte":
+                                        case "<=":
+                                            result.push(fh.isLessOrEqualTo(element));
+                                            found = true;
+                                            break;
+                                        case "$lt":
+                                        case "<":
+                                            result.push(fh.isLessThan(element));
+                                            found = true;
+                                            break;
+                                        case "$ne":
+                                        case "!=":
+                                            found = true;
+                                            if (Array.isArray(element)) {
+                                                result.push(fh.isNotIn(element));
+                                            }
+                                            else
+                                                result.push(fh.isDifferentFrom(element));
+                                            break;
+                                        case "$contains":
+                                            found = true;
+                                            result.push(fh.contains(element));
+                                            break;
+                                    }
+                                }
+                            }
+                            if (Array.isArray(fieldToFilter)) {
+                                found = true;
+                                result.push(fh.isIn(fieldToFilter));
+                            }
+                        }
+                        if (!found && fieldToFilter !== undefined) {
+                            result.push(fh.isEqualTo(fieldToFilter));
+                        }
+                    }
+                }
+            }
+        }
+        return new AndFilter(...result);
+    }
+    toJson() {
+        let r = new FilterSerializer();
+        this.__applyToConsumer(r);
+        return r.result;
+    }
+    static entityFilterToJson(entityDefs, where) {
+        return Filter.fromEntityFilter(entityDefs, where).toJson();
+    }
+    static entityFilterFromJson(entityDefs, packed) {
+        return buildFilterFromRequestParameters(entityDefs, { get: (key) => packed[key] });
+    }
+    static async translateCustomWhere(r, entity, remult) {
+        let f = new customTranslator(async (filterKey, custom) => {
+            let r = [];
+            for (const key in entity.entityType) {
+                const element = entity.entityType[key];
+                if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+                    if (element.customFilterInfo.key == filterKey) {
+                        r.push(await Filter.fromEntityFilter(entity, await element.customFilterInfo.customFilterTranslator(remult, custom)));
+                    }
+                }
+            }
+            return r;
+        });
+        r.__applyToConsumer(f);
+        await f.resolve();
+        r = new Filter(x => f.applyTo(x));
+        return r;
+    }
+}
+export class filterHelper {
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    processVal(val) {
+        let ei = getEntitySettings(this.metadata.valueType, false);
+        if (ei) {
+            if (!val)
+                return null;
+            if (typeof val === "string" || typeof val === "number")
+                return val;
+            return getEntityRef(val).getId();
+        }
+        return val;
+    }
+    contains(val) {
+        return new Filter(add => add.containsCaseInsensitive(this.metadata, val));
+    }
+    isLessThan(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isLessThan(this.metadata, val));
+    }
+    isGreaterOrEqualTo(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isGreaterOrEqualTo(this.metadata, val));
+    }
+    isNotIn(values) {
+        return new Filter(add => {
+            for (const v of values) {
+                add.isDifferentFrom(this.metadata, this.processVal(v));
+            }
+        });
+    }
+    isDifferentFrom(val) {
+        val = this.processVal(val);
+        if ((val === null || val === undefined) && this.metadata.allowNull)
+            return new Filter(add => add.isNotNull(this.metadata));
+        return new Filter(add => add.isDifferentFrom(this.metadata, val));
+    }
+    isLessOrEqualTo(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isLessOrEqualTo(this.metadata, val));
+    }
+    isGreaterThan(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isGreaterThan(this.metadata, val));
+    }
+    isEqualTo(val) {
+        val = this.processVal(val);
+        if ((val === null || val === undefined) && this.metadata.allowNull)
+            return new Filter(add => add.isNull(this.metadata));
+        return new Filter(add => add.isEqualTo(this.metadata, val));
+    }
+    isIn(val) {
+        val = val.map(x => this.processVal(x));
+        return new Filter(add => add.isIn(this.metadata, val));
+    }
+}
+export class AndFilter extends Filter {
+    constructor(...filters) {
+        super(add => {
+            for (const iterator of this.filters) {
+                if (iterator)
+                    iterator.__applyToConsumer(add);
+            }
+        });
+        this.filters = filters;
+    }
+    add(filter) {
+        this.filters.push(filter);
+    }
+}
+export class OrFilter extends Filter {
+    constructor(...filters) {
+        super(add => {
+            let f = this.filters.filter(x => x !== undefined);
+            if (f.length > 1) {
+                add.or(f);
+            }
+            else if (f.length == 1)
+                f[0].__applyToConsumer(add);
+        });
+        this.filters = filters;
+    }
+}
+export const customUrlToken = "$custom$";
+export const customDatabaseFilterToken = "$db$";
+export class FilterSerializer {
+    constructor() {
+        this.result = {};
+        this.hasUndefined = false;
+    }
+    databaseCustom(databaseCustom) {
+        throw new Error("database custom is not allowed with api calls.");
+    }
+    custom(key, customItem) {
+        this.add(customUrlToken + key, customItem);
+    }
+    add(key, val) {
+        if (val === undefined)
+            this.hasUndefined = true;
+        let r = this.result;
+        if (!r[key]) {
+            r[key] = val;
+            return;
+        }
+        let v = r[key];
+        if (v instanceof Array) {
+            v.push(val);
+        }
+        else
+            v = [v, val];
+        r[key] = v;
+    }
+    or(orElements) {
+        this.add("OR", orElements.map(x => {
+            let f = new FilterSerializer();
+            x.__applyToConsumer(f);
+            return f.result;
+        }));
+    }
+    isNull(col) {
+        this.add(col.key + "_null", true);
+    }
+    isNotNull(col) {
+        this.add(col.key + "_null", false);
+    }
+    isIn(col, val) {
+        this.add(col.key + "_in", val.map(x => col.valueConverter.toJson(x)));
+    }
+    isEqualTo(col, val) {
+        this.add(col.key, col.valueConverter.toJson(val));
+    }
+    isDifferentFrom(col, val) {
+        this.add(col.key + '_ne', col.valueConverter.toJson(val));
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.add(col.key + '_gte', col.valueConverter.toJson(val));
+    }
+    isGreaterThan(col, val) {
+        this.add(col.key + '_gt', col.valueConverter.toJson(val));
+    }
+    isLessOrEqualTo(col, val) {
+        this.add(col.key + '_lte', col.valueConverter.toJson(val));
+    }
+    isLessThan(col, val) {
+        this.add(col.key + '_lt', col.valueConverter.toJson(val));
+    }
+    containsCaseInsensitive(col, val) {
+        this.add(col.key + "_contains", val);
+    }
+}
+export function entityFilterToJson(entityDefs, where) {
+    if (!where)
+        return {};
+    return (Filter.fromEntityFilter(entityDefs, where)).toJson();
+}
+export function buildFilterFromRequestParameters(entity, filterInfo) {
+    let where = [];
+    [...entity.fields].forEach(col => {
+        function addFilter(operation, theFilter, jsonArray = false, asString = false) {
+            let val = filterInfo.get(col.key + operation);
+            if (val !== undefined) {
+                let addFilter = (val) => {
+                    let theVal = val;
+                    if (jsonArray) {
+                        let arr;
+                        if (typeof val === 'string')
+                            arr = JSON.parse(val);
+                        else
+                            arr = val;
+                        theVal = arr.map(x => asString ? x : col.valueConverter.fromJson(x));
+                    }
+                    else {
+                        theVal = asString ? theVal : col.valueConverter.fromJson(theVal);
+                    }
+                    let f = theFilter(theVal);
+                    if (f !== undefined) {
+                        where.push({ [col.key]: f });
+                    }
+                };
+                if (!jsonArray && val instanceof Array) {
+                    val.forEach(v => {
+                        addFilter(v);
+                    });
+                }
+                else {
+                    if (jsonArray) {
+                        if (typeof val === 'string')
+                            val = JSON.parse(val);
+                    }
+                    const array = separateArrayFromInnerArray(val);
+                    for (const x of array) {
+                        addFilter(x);
+                    }
+                }
+            }
+        }
+        let c = new filterHelper(col);
+        addFilter('', val => val);
+        addFilter('_gt', val => ({ "$gt": val }));
+        addFilter('_gte', val => ({ "$gte": val }));
+        addFilter('_lt', val => ({ "$lt": val }));
+        addFilter('_lte', val => ({ "$lte": val }));
+        addFilter('_ne', val => ({ "$ne": val }));
+        addFilter('_in', val => val, true);
+        var nullFilter = filterInfo.get(col.key + "_null");
+        if (nullFilter) {
+            nullFilter = nullFilter.toString().trim().toLowerCase();
+            switch (nullFilter) {
+                case "y":
+                case "true":
+                case "yes":
+                    where.push({ [col.key]: null });
+                    break;
+                default:
+                    where.push({ [col.key]: { "$ne": null } });
+                    break;
+            }
+        }
+        addFilter('_contains', val => ({ $contains: val }), false, true);
+    });
+    let val = filterInfo.get('OR');
+    if (val) {
+        const array = separateArrayFromInnerArray(val);
+        where.push({
+            $and: array.map(v => ({
+                $or: v.map(x => buildFilterFromRequestParameters(entity, { get: (key) => x[key] }))
+            }))
+        });
+    }
+    for (const key in entity.entityType) {
+        const element = entity.entityType[key];
+        if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+            let custom = filterInfo.get(customUrlToken + key);
+            if (custom !== undefined) {
+                where.push({ [customUrlToken + key]: custom });
+            }
+        }
+    }
+    return { $and: where };
+    function separateArrayFromInnerArray(val) {
+        if (!Array.isArray(val))
+            return [val];
+        const nonArray = [], array = [];
+        for (const v of val) {
+            if (Array.isArray(v)) {
+                array.push(v);
+            }
+            else
+                nonArray.push(v);
+        }
+        array.push(nonArray);
+        return array;
+    }
+}
+class customTranslator {
+    constructor(translateCustom) {
+        this.translateCustom = translateCustom;
+        this.commands = [];
+        this.promises = [];
+    }
+    applyTo(x) {
+        this.commands.forEach(y => y(x));
+    }
+    or(orElements) {
+        let newOrElements;
+        this.promises.push(Promise.all(orElements.map(async (element) => {
+            let c = new customTranslator(this.translateCustom);
+            element.__applyToConsumer(c);
+            await c.resolve();
+            return new Filter(x => c.applyTo(x));
+        })).then(x => {
+            newOrElements = x;
+        }));
+        this.commands.push(x => x.or(newOrElements));
+    }
+    isEqualTo(col, val) {
+        this.commands.push(x => x.isEqualTo(col, val));
+    }
+    isDifferentFrom(col, val) {
+        this.commands.push(x => x.isDifferentFrom(col, val));
+    }
+    isNull(col) {
+        this.commands.push(x => x.isNull(col));
+    }
+    isNotNull(col) {
+        this.commands.push(x => x.isNotNull(col));
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.commands.push(x => x.isGreaterOrEqualTo(col, val));
+    }
+    isGreaterThan(col, val) {
+        this.commands.push(x => x.isGreaterThan(col, val));
+    }
+    isLessOrEqualTo(col, val) {
+        this.commands.push(x => x.isLessOrEqualTo(col, val));
+    }
+    isLessThan(col, val) {
+        this.commands.push(x => x.isLessThan(col, val));
+    }
+    containsCaseInsensitive(col, val) {
+        this.commands.push(x => x.containsCaseInsensitive(col, val));
+    }
+    isIn(col, val) {
+        this.commands.push(x => x.isIn(col, val));
+    }
+    custom(key, customItem) {
+        this.promises.push((async () => {
+            let r = await this.translateCustom(key, customItem);
+            if (r)
+                if (Array.isArray(r))
+                    r.forEach(x => x.__applyToConsumer(this));
+                else
+                    r.__applyToConsumer(this);
+        })());
+    }
+    databaseCustom(custom) {
+        this.commands.push(x => x.databaseCustom(custom));
+    }
+    async resolve() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            await Promise.all(p);
+        }
+    }
+}

package/esm/src/id-entity.d.ts

@@ -0,0 +1,4 @@
+import { EntityBase } from './remult3';
+export declare class IdEntity extends EntityBase {
+    id: string;
+}

package/esm/src/id-entity.js

@@ -0,0 +1,8 @@
+import { __decorate, __metadata } from "tslib";
+import { EntityBase, Fields } from './remult3';
+export class IdEntity extends EntityBase {
+}
+__decorate([
+    Fields.uuid(),
+    __metadata("design:type", String)
+], IdEntity.prototype, "id", void 0);