remult 0.21.1 → 0.22.0

package/esm/core/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -0,0 +1,50 @@
+import { SqlCommandWithParameters } from "../sql-command";
+import { Filter, FilterConsumer } from './filter-interfaces';
+import { FieldMetadata } from "../column-interfaces";
+import { EntityFilter, OmitEB } from "../remult3/remult3";
+import { EntityMetadataOverloads, RepositoryOverloads } from "../remult3";
+export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
+    private r;
+    private nameProvider;
+    private where;
+    _addWhere: boolean;
+    promises: Promise<void>[];
+    resolveWhere(): Promise<string>;
+    constructor(r: SqlCommandWithParameters, nameProvider: EntityDbNamesBase);
+    custom(key: string, customItem: 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;
+    private add;
+    private addToWhere;
+    databaseCustom(databaseCustom: CustomSqlFilterObject): void;
+}
+export type CustomSqlFilterBuilderFunction = (builder: CustomSqlFilterBuilder) => void | Promise<any>;
+export interface CustomSqlFilterObject {
+    buildSql: CustomSqlFilterBuilderFunction;
+}
+export declare class CustomSqlFilterBuilder {
+    private r;
+    constructor(r: SqlCommandWithParameters);
+    sql: string;
+    addParameterAndReturnSqlToken<valueType>(val: valueType, field?: FieldMetadata<valueType>): string;
+    filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<string>;
+}
+export declare function isDbReadonly<entityType>(field: FieldMetadata, dbNames: EntityDbNames<entityType>): boolean;
+export declare type EntityDbNamesBase = {
+    $entityName: string;
+    $dbNameOf(field: FieldMetadata<any> | string): string;
+    toString(): string;
+};
+export declare type EntityDbNames<entityType> = {
+    [Properties in keyof Required<OmitEB<entityType>>]: string;
+} & EntityDbNamesBase;
+export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>): Promise<EntityDbNames<entityType>>;

package/esm/core/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -0,0 +1,150 @@
+import { getEntityMetadata } from "../remult3";
+import { SqlDatabase } from "../data-providers/sql-database";
+export class FilterConsumerBridgeToSqlRequest {
+    r;
+    nameProvider;
+    where = "";
+    _addWhere = true;
+    promises = [];
+    async resolveWhere() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            for (const pr of p) {
+                await pr;
+            }
+        }
+        return this.where;
+    }
+    constructor(r, nameProvider) {
+        this.r = r;
+        this.nameProvider = nameProvider;
+    }
+    custom(key, customItem) {
+        throw new Error("Custom filter should be translated before it gets here");
+    }
+    or(orElements) {
+        let statement = '';
+        this.promises.push((async () => {
+            for (const element of orElements) {
+                let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider);
+                f._addWhere = false;
+                element.__applyToConsumer(f);
+                let where = await f.resolveWhere();
+                if (!where)
+                    return; //since if any member of or is empty, then the entire or is irrelevant
+                if (where.length > 0) {
+                    if (statement.length > 0) {
+                        statement += " or ";
+                    }
+                    if (orElements.length > 1) {
+                        statement += "(" + where + ")";
+                    }
+                    else
+                        statement += where;
+                }
+            }
+            this.addToWhere("(" + statement + ")");
+        })());
+    }
+    isNull(col) {
+        this.promises.push((async () => this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is null'))());
+    }
+    isNotNull(col) {
+        this.promises.push((async () => this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is not null'))());
+    }
+    isIn(col, val) {
+        this.promises.push((async () => {
+            if (val && val.length > 0)
+                this.addToWhere(this.nameProvider.$dbNameOf(col) + " in (" + val.map(x => this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x))).join(",") + ")");
+            else
+                this.addToWhere('1 = 0 /*isIn with no values*/');
+        })());
+    }
+    isEqualTo(col, val) {
+        this.add(col, val, "=");
+    }
+    isDifferentFrom(col, val) {
+        this.add(col, val, "<>");
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.add(col, val, ">=");
+    }
+    isGreaterThan(col, val) {
+        this.add(col, val, ">");
+    }
+    isLessOrEqualTo(col, val) {
+        this.add(col, val, "<=");
+    }
+    isLessThan(col, val) {
+        this.add(col, val, "<");
+    }
+    containsCaseInsensitive(col, val) {
+        this.promises.push((async () => {
+            this.addToWhere('lower (' + this.nameProvider.$dbNameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')");
+        })());
+    }
+    add(col, val, operator) {
+        this.promises.push((async () => {
+            let x = this.nameProvider.$dbNameOf(col) + ' ' + operator + ' ' + this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
+            this.addToWhere(x);
+        })());
+    }
+    addToWhere(x) {
+        if (this.where.length == 0) {
+            if (this._addWhere)
+                this.where += ' where ';
+        }
+        else
+            this.where += ' and ';
+        this.where += x;
+    }
+    databaseCustom(databaseCustom) {
+        this.promises.push((async () => {
+            if (databaseCustom?.buildSql) {
+                let item = new CustomSqlFilterBuilder(this.r);
+                await databaseCustom.buildSql(item);
+                if (item.sql) {
+                    this.addToWhere("(" + item.sql + ")");
+                }
+            }
+        })());
+    }
+}
+export class CustomSqlFilterBuilder {
+    r;
+    constructor(r) {
+        this.r = r;
+    }
+    sql = '';
+    addParameterAndReturnSqlToken(val, field) {
+        if (field)
+            val = field.valueConverter.toDb(val);
+        return this.r.addParameterAndReturnSqlToken(val);
+    }
+    async filterToRaw(repo, condition) {
+        return SqlDatabase.filterToRaw(repo, condition, this);
+    }
+}
+export function isDbReadonly(field, dbNames) {
+    return (field.dbReadOnly || field.isServerExpression || dbNames.$dbNameOf(field) != field.options.dbName);
+}
+export async function dbNamesOf(repo) {
+    var meta = getEntityMetadata(repo);
+    const result = {
+        $entityName: await meta.getDbName(),
+        toString: () => result.$entityName,
+        $dbNameOf: (field) => {
+            var key;
+            if (typeof field === "string")
+                key = field;
+            else
+                key = field.key;
+            return result[key];
+        }
+    };
+    for (const field of meta.fields) {
+        result[field.key] = await field.getDbName();
+    }
+    return result;
+}

package/esm/core/src/filter/filter-consumer-bridge-to-url-builder.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/core/src/filter/filter-consumer-bridge-to-url-builder.js

@@ -0,0 +1 @@
+export {};

package/esm/core/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) | undefined);
+    __applyToConsumer(add: FilterConsumer): void;
+    static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
+    static createCustom<entityType>(rawFilterTranslator: (unused: never, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & rawFilterInfo<entityType>;
+    static createCustom<entityType, argsType>(rawFilterTranslator: (args: argsType, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): ((y: argsType) => EntityFilter<entityType>) & rawFilterInfo<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 rawFilterInfo<entityType> {
+    rawFilterInfo: {
+        key: string;
+        rawFilterTranslator: (args: any, r: Remult) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+    };
+}