remult 0.21.1 → 0.22.0

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

@@ -1,10 +1,10 @@
-import { getEntityMetadata } from "../remult3";
-import { SqlDatabase } from "../data-providers/sql-database";
+import { getEntityMetadata, } from '../remult3';
+import { SqlDatabase } from '../data-providers/sql-database';
 export class FilterConsumerBridgeToSqlRequest {
     constructor(r, nameProvider) {
         this.r = r;
         this.nameProvider = nameProvider;
-        this.where = "";
+        this.where = '';
         this._addWhere = true;
         this.promises = [];
     }
@@ -19,7 +19,7 @@ export class FilterConsumerBridgeToSqlRequest {
         return this.where;
     }
     custom(key, customItem) {
-        throw new Error("Custom filter should be translated before it gets here");
+        throw new Error('Custom filter should be translated before it gets here');
     }
     or(orElements) {
         let statement = '';
@@ -33,16 +33,16 @@ export class FilterConsumerBridgeToSqlRequest {
                     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 ";
+                        statement += ' or ';
                     }
                     if (orElements.length > 1) {
-                        statement += "(" + where + ")";
+                        statement += '(' + where + ')';
                     }
                     else
                         statement += where;
                 }
             }
-            this.addToWhere("(" + statement + ")");
+            this.addToWhere('(' + statement + ')');
         })());
     }
     isNull(col) {
@@ -54,37 +54,50 @@ export class FilterConsumerBridgeToSqlRequest {
     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(",") + ")");
+                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, "=");
+        this.add(col, val, '=');
     }
     isDifferentFrom(col, val) {
-        this.add(col, val, "<>");
+        this.add(col, val, '<>');
     }
     isGreaterOrEqualTo(col, val) {
-        this.add(col, val, ">=");
+        this.add(col, val, '>=');
     }
     isGreaterThan(col, val) {
-        this.add(col, val, ">");
+        this.add(col, val, '>');
     }
     isLessOrEqualTo(col, val) {
-        this.add(col, val, "<=");
+        this.add(col, val, '<=');
     }
     isLessThan(col, val) {
-        this.add(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, '\'\'') + "%')");
+            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));
+            let x = this.nameProvider.$dbNameOf(col) +
+                ' ' +
+                operator +
+                ' ' +
+                this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
             this.addToWhere(x);
         })());
     }
@@ -103,7 +116,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 let item = new CustomSqlFilterBuilder(this.r);
                 await databaseCustom.buildSql(item);
                 if (item.sql) {
-                    this.addToWhere("(" + item.sql + ")");
+                    this.addToWhere('(' + item.sql + ')');
                 }
             }
         })());
@@ -124,7 +137,9 @@ export class CustomSqlFilterBuilder {
     }
 }
 export function isDbReadonly(field, dbNames) {
-    return (field.dbReadOnly || field.isServerExpression || dbNames.$dbNameOf(field) != field.options.dbName);
+    return (field.dbReadOnly ||
+        field.isServerExpression ||
+        dbNames.$dbNameOf(field) != field.options.dbName);
 }
 export async function dbNamesOf(repo) {
     var meta = getEntityMetadata(repo);
@@ -133,12 +148,12 @@ export async function dbNamesOf(repo) {
         toString: () => result.$entityName,
         $dbNameOf: (field) => {
             var key;
-            if (typeof field === "string")
+            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();

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

@@ -1,13 +1,13 @@
-import { FieldMetadata } from "../column-interfaces";
-import { Remult } from "../context";
-import { EntityMetadata, EntityFilter } from "../remult3";
+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>(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 createCustom<entityType>(rawFilterTranslator: (unused: never, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & customFilterInfo<entityType>;
+    static createCustom<entityType, argsType>(rawFilterTranslator: (args: argsType, r: Remult) => 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;
@@ -77,9 +77,9 @@ export declare function entityFilterToJson<T>(entityDefs: EntityMetadata<T>, whe
 export declare function buildFilterFromRequestParameters(entity: EntityMetadata, filterInfo: {
     get: (key: string) => any;
 }): EntityFilter<any>;
-export interface rawFilterInfo<entityType> {
+export interface customFilterInfo<entityType> {
     rawFilterInfo: {
         key: string;
-        rawFilterTranslator: (args: any, r: Remult) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+        rawFilterTranslator: (args: any, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>;
     };
 }

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

@@ -1,4 +1,4 @@
-import { getEntityRef, getEntitySettings } from "../remult3";
+import { getEntityRef, getEntitySettings, } from '../remult3';
 export class Filter {
     constructor(apply) {
         this.apply = apply;
@@ -10,7 +10,7 @@ export class Filter {
         this.apply(add);
     }
     static async resolve(filter) {
-        if (typeof filter === "function")
+        if (typeof filter === 'function')
             return await filter();
         return filter;
     }
@@ -21,9 +21,9 @@ export class Filter {
             if (x == undefined)
                 x = {};
             if (!rawFilterInfo.key)
-                throw "Usage of custom filter before a key was assigned to it";
+                throw 'Usage of custom filter before a key was assigned to it';
             return {
-                [customUrlToken + rawFilterInfo.key]: x
+                [customUrlToken + rawFilterInfo.key]: x,
             };
         }, { rawFilterInfo });
     }
@@ -33,19 +33,19 @@ export class Filter {
             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))));
+                    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 == '$and') {
+                        result.push(new AndFilter(...fieldToFilter.map((x) => Filter.fromEntityFilter(entity, x))));
                     }
                     else if (key.startsWith(customUrlToken)) {
-                        result.push(new Filter(x => {
+                        result.push(new Filter((x) => {
                             x.custom(key.substring(customUrlToken.length), fieldToFilter);
                         }));
                     }
                     else if (key == customDatabaseFilterToken) {
-                        result.push(new Filter(x => x.databaseCustom(fieldToFilter)));
+                        result.push(new Filter((x) => x.databaseCustom(fieldToFilter)));
                     }
                     else {
                         let fh = new filterHelper(entity.fields[key]);
@@ -57,29 +57,29 @@ export class Filter {
                                 if (Object.prototype.hasOwnProperty.call(fieldToFilter, key)) {
                                     const element = fieldToFilter[key];
                                     switch (key) {
-                                        case "$gte":
-                                        case ">=":
+                                        case '$gte':
+                                        case '>=':
                                             result.push(fh.isGreaterOrEqualTo(element));
                                             found = true;
                                             break;
-                                        case "$gt":
-                                        case ">":
+                                        case '$gt':
+                                        case '>':
                                             result.push(fh.isGreaterThan(element));
                                             found = true;
                                             break;
-                                        case "$lte":
-                                        case "<=":
+                                        case '$lte':
+                                        case '<=':
                                             result.push(fh.isLessOrEqualTo(element));
                                             found = true;
                                             break;
-                                        case "$lt":
-                                        case "<":
+                                        case '$lt':
+                                        case '<':
                                             result.push(fh.isLessThan(element));
                                             found = true;
                                             break;
-                                        case "$ne":
-                                        case "!=":
-                                        case "$nin":
+                                        case '$ne':
+                                        case '!=':
+                                        case '$nin':
                                             found = true;
                                             if (Array.isArray(element)) {
                                                 result.push(fh.isNotIn(element));
@@ -87,11 +87,11 @@ export class Filter {
                                             else
                                                 result.push(fh.isDifferentFrom(element));
                                             break;
-                                        case "$in":
+                                        case '$in':
                                             found = true;
                                             result.push(fh.isIn(element));
                                             break;
-                                        case "$contains":
+                                        case '$contains':
                                             found = true;
                                             result.push(fh.contains(element));
                                             break;
@@ -121,14 +121,18 @@ export class Filter {
         return Filter.fromEntityFilter(entityDefs, where).toJson();
     }
     static entityFilterFromJson(entityDefs, packed) {
-        return buildFilterFromRequestParameters(entityDefs, { get: (key) => packed[key] });
+        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.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
+                if (element &&
+                    element.rawFilterInfo &&
+                    element.rawFilterInfo.rawFilterTranslator) {
                     if (element.rawFilterInfo.key == filterKey) {
                         r.push(await Filter.fromEntityFilter(entity, await element.rawFilterInfo.rawFilterTranslator(custom, remult)));
                     }
@@ -138,7 +142,7 @@ export class Filter {
         });
         r.__applyToConsumer(f);
         await f.resolve();
-        r = new Filter(x => f.applyTo(x));
+        r = new Filter((x) => f.applyTo(x));
         return r;
     }
 }
@@ -151,25 +155,25 @@ export class filterHelper {
         if (ei) {
             if (!val)
                 return null;
-            if (typeof val === "string" || typeof val === "number")
+            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));
+        return new Filter((add) => add.containsCaseInsensitive(this.metadata, val));
     }
     isLessThan(val) {
         val = this.processVal(val);
-        return new Filter(add => add.isLessThan(this.metadata, 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));
+        return new Filter((add) => add.isGreaterOrEqualTo(this.metadata, val));
     }
     isNotIn(values) {
-        return new Filter(add => {
+        return new Filter((add) => {
             for (const v of values) {
                 add.isDifferentFrom(this.metadata, this.processVal(v));
             }
@@ -178,31 +182,31 @@ export class filterHelper {
     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));
+            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));
+        return new Filter((add) => add.isLessOrEqualTo(this.metadata, val));
     }
     isGreaterThan(val) {
         val = this.processVal(val);
-        return new Filter(add => add.isGreaterThan(this.metadata, 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));
+            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));
+        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 => {
+        super((add) => {
             for (const iterator of this.filters) {
                 if (iterator)
                     iterator.__applyToConsumer(add);
@@ -216,8 +220,8 @@ export class AndFilter extends Filter {
 }
 export class OrFilter extends Filter {
     constructor(...filters) {
-        super(add => {
-            let f = this.filters.filter(x => x !== undefined);
+        super((add) => {
+            let f = this.filters.filter((x) => x !== undefined);
             if (f.length > 1) {
                 add.or(f);
             }
@@ -227,17 +231,20 @@ export class OrFilter extends Filter {
         this.filters = filters;
     }
 }
-export const customUrlToken = "$custom$";
-export const customDatabaseFilterToken = "$db$";
+export const customUrlToken = '$custom$';
+export const customDatabaseFilterToken = '$db$';
+const customArrayToken = '$an array';
 export class FilterSerializer {
     constructor() {
         this.result = {};
         this.hasUndefined = false;
     }
     databaseCustom(databaseCustom) {
-        throw new Error("database custom is not allowed with api calls.");
+        throw new Error('database custom is not allowed with api calls.');
     }
     custom(key, customItem) {
+        if (Array.isArray(customItem))
+            customItem = { [customArrayToken]: customItem };
         this.add(customUrlToken + key, customItem);
     }
     add(key, val) {
@@ -257,20 +264,20 @@ export class FilterSerializer {
         r[key] = v;
     }
     or(orElements) {
-        this.add("OR", orElements.map(x => {
+        this.add('OR', orElements.map((x) => {
             let f = new FilterSerializer();
             x.__applyToConsumer(f);
             return f.result;
         }));
     }
     isNull(col) {
-        this.add(col.key + ".null", true);
+        this.add(col.key + '.null', true);
     }
     isNotNull(col) {
-        this.add(col.key + ".null", false);
+        this.add(col.key + '.null', false);
     }
     isIn(col, val) {
-        this.add(col.key + ".in", val.map(x => col.valueConverter.toJson(x)));
+        this.add(col.key + '.in', val.map((x) => col.valueConverter.toJson(x)));
     }
     isEqualTo(col, val) {
         this.add(col.key, col.valueConverter.toJson(val));
@@ -291,17 +298,17 @@ export class FilterSerializer {
         this.add(col.key + '.lt', col.valueConverter.toJson(val));
     }
     containsCaseInsensitive(col, val) {
-        this.add(col.key + ".contains", val);
+        this.add(col.key + '.contains', val);
     }
 }
 export function entityFilterToJson(entityDefs, where) {
     if (!where)
         return {};
-    return (Filter.fromEntityFilter(entityDefs, where)).toJson();
+    return Filter.fromEntityFilter(entityDefs, where).toJson();
 }
 export function buildFilterFromRequestParameters(entity, filterInfo) {
     let where = [];
-    [...entity.fields].forEach(col => {
+    [...entity.fields].forEach((col) => {
         function addFilter(operation, theFilter, jsonArray = false, asString = false) {
             let val = filterInfo.get(col.key + operation);
             if (val !== undefined) {
@@ -313,7 +320,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                             arr = JSON.parse(val);
                         else
                             arr = val;
-                        theVal = arr.map(x => asString ? x : col.valueConverter.fromJson(x));
+                        theVal = arr.map((x) => asString ? x : col.valueConverter.fromJson(x));
                     }
                     else {
                         theVal = asString ? theVal : col.valueConverter.fromJson(theVal);
@@ -324,7 +331,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                     }
                 };
                 if (!jsonArray && val instanceof Array) {
-                    val.forEach(v => {
+                    val.forEach((v) => {
                         addFilter(v);
                     });
                 }
@@ -341,44 +348,57 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
             }
         }
         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");
+        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":
+                case 'y':
+                case 'true':
+                case 'yes':
                     where.push({ [col.key]: null });
                     break;
                 default:
-                    where.push({ [col.key]: { "$ne": null } });
+                    where.push({ [col.key]: { $ne: null } });
                     break;
             }
         }
-        addFilter('.contains', val => ({ $contains: val }), false, true);
+        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] }))
-            }))
+            $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.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
+        if (element &&
+            element.rawFilterInfo &&
+            element.rawFilterInfo.rawFilterTranslator) {
             let custom = filterInfo.get(customUrlToken + key);
             if (custom !== undefined) {
-                where.push({ [customUrlToken + key]: custom });
+                const addItem = (item) => {
+                    if (item[customArrayToken] != undefined)
+                        item = item[customArrayToken];
+                    where.push({ [customUrlToken + key]: item });
+                };
+                if (Array.isArray(custom)) {
+                    custom.forEach((item) => addItem(item));
+                }
+                else
+                    addItem(custom);
             }
         }
     }
@@ -405,7 +425,7 @@ class customTranslator {
         this.promises = [];
     }
     applyTo(x) {
-        this.commands.forEach(y => y(x));
+        this.commands.forEach((y) => y(x));
     }
     or(orElements) {
         let newOrElements;
@@ -413,54 +433,54 @@ class customTranslator {
             let c = new customTranslator(this.translateCustom);
             element.__applyToConsumer(c);
             await c.resolve();
-            return new Filter(x => c.applyTo(x));
-        })).then(x => {
+            return new Filter((x) => c.applyTo(x));
+        })).then((x) => {
             newOrElements = x;
         }));
-        this.commands.push(x => x.or(newOrElements));
+        this.commands.push((x) => x.or(newOrElements));
     }
     isEqualTo(col, val) {
-        this.commands.push(x => x.isEqualTo(col, val));
+        this.commands.push((x) => x.isEqualTo(col, val));
     }
     isDifferentFrom(col, val) {
-        this.commands.push(x => x.isDifferentFrom(col, val));
+        this.commands.push((x) => x.isDifferentFrom(col, val));
     }
     isNull(col) {
-        this.commands.push(x => x.isNull(col));
+        this.commands.push((x) => x.isNull(col));
     }
     isNotNull(col) {
-        this.commands.push(x => x.isNotNull(col));
+        this.commands.push((x) => x.isNotNull(col));
     }
     isGreaterOrEqualTo(col, val) {
-        this.commands.push(x => x.isGreaterOrEqualTo(col, val));
+        this.commands.push((x) => x.isGreaterOrEqualTo(col, val));
     }
     isGreaterThan(col, val) {
-        this.commands.push(x => x.isGreaterThan(col, val));
+        this.commands.push((x) => x.isGreaterThan(col, val));
     }
     isLessOrEqualTo(col, val) {
-        this.commands.push(x => x.isLessOrEqualTo(col, val));
+        this.commands.push((x) => x.isLessOrEqualTo(col, val));
     }
     isLessThan(col, val) {
-        this.commands.push(x => x.isLessThan(col, val));
+        this.commands.push((x) => x.isLessThan(col, val));
     }
     containsCaseInsensitive(col, val) {
-        this.commands.push(x => x.containsCaseInsensitive(col, val));
+        this.commands.push((x) => x.containsCaseInsensitive(col, val));
     }
     isIn(col, val) {
-        this.commands.push(x => x.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));
+                    r.forEach((x) => x.__applyToConsumer(this));
                 else
                     r.__applyToConsumer(this);
         })());
     }
     databaseCustom(custom) {
-        this.commands.push(x => x.databaseCustom(custom));
+        this.commands.push((x) => x.databaseCustom(custom));
     }
     async resolve() {
         while (this.promises.length > 0) {