remult 0.18.1-exp.2 → 0.18.1-exp.21

package/esm/src/data-providers/rest-data-provider.js

@@ -1,10 +1,11 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { customUrlToken, Filter } from '../filter/filter-interfaces';
 import { buildRestDataProvider, retry } from "../buildRestDataProvider";
+import { actionInfo } from '../server-action';
 export class RestDataProvider {
     constructor(apiProvider) {
         this.apiProvider = apiProvider;
-        this.supportsCustomFilter = true;
+        this.supportsrawFilter = true;
     }
     getEntityDataProvider(entity) {
         return new RestEntityDataProvider(() => {
@@ -20,6 +21,7 @@ export class RestDataProvider {
         throw new Error("Method not implemented.");
     }
 }
+//@internal
 export function findOptionsToJson(options, meta) {
     return {
         limit: options.limit,
@@ -28,6 +30,7 @@ export function findOptionsToJson(options, meta) {
         orderBy: options.orderBy
     };
 }
+//@internal
 export function findOptionsFromJson(json, meta) {
     let r = {};
     for (const key of ["limit", "page", "where", "orderBy"]) {
@@ -62,29 +65,14 @@ export class RestEntityDataProvider {
         return result;
     }
     async count(where) {
-        let url = new UrlBuilder(this.url());
-        url.add("__action", "count");
-        let filterObject;
-        if (where) {
-            filterObject = where.toJson();
-            if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
-                filterObject = undefined;
-        }
-        if (filterObject)
-            return this.http().post(url.url, filterObject).then(r => +(r.count));
-        else
-            return this.http().get(url.url).then(r => +(r.count));
+        const { run } = this.buildFindRequest({ where });
+        return run("count").then(r => +r.count);
     }
     find(options) {
-        let { filterObject, url } = this.buildFindRequest(options);
-        if (filterObject) {
-            url.add("__action", "get");
-            return this.http().post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
-        }
-        else
-            return this.http().get(url.url).then(x => x.map(y => this.translateFromJson(y)));
-        ;
+        let { run } = this.buildFindRequest(options);
+        return run().then(x => x.map(y => this.translateFromJson(y)));
     }
+    //@internal
     buildFindRequest(options) {
         let url = new UrlBuilder(this.url());
         let filterObject;
@@ -113,7 +101,34 @@ export class RestEntityDataProvider {
             if (options.page)
                 url.add('_page', options.page);
         }
-        return { filterObject, url };
+        const run = (action) => {
+            let u = new UrlBuilder(url.url);
+            if (!action && filterObject) {
+                action = "get";
+            }
+            if (action)
+                u.add("__action", action);
+            if (filterObject) {
+                return this.http().post(u.url, filterObject);
+            }
+            else
+                return this.http().get(u.url);
+        };
+        return {
+            createKey: () => JSON.stringify({ url, filterObject }),
+            run,
+            subscribe: async () => {
+                const result = await run("liveQuery");
+                return {
+                    ...result,
+                    unsubscribe: async () => {
+                        return actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + "?__action=endLiveQuery", {
+                            id: result.queryChannel
+                        }));
+                    }
+                };
+            }
+        };
     }
     update(id, data) {
         let result = {};
@@ -211,7 +226,7 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {
             const element = filter[key];
             if (Array.isArray(element)) {
-                if (key.endsWith("_in"))
+                if (key.endsWith(".in"))
                     url.add(key, JSON.stringify(element));
                 else
                     element.forEach(e => url.add(key, e));

package/esm/src/data-providers/sql-database.d.ts

@@ -1,14 +1,17 @@
 import { EntityDataProvider, DataProvider } from "../data-interfaces";
-import { SqlCommand, SqlImplementation, SqlResult } from "../sql-command";
+import { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from "../sql-command";
 import { CustomSqlFilterBuilderFunction } from "../filter/filter-consumer-bridge-to-sql-request";
-import { EntityMetadata, EntityFilter } from "../remult3";
+import { EntityMetadata, EntityFilter, RepositoryOverloads } from "../remult3";
+import { Remult } from "../context";
 export declare class SqlDatabase implements DataProvider {
     private sql;
+    static getDb(remult?: Remult): SqlDatabase;
     createCommand(): SqlCommand;
     execute(sql: string): Promise<SqlResult>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static customFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
+    static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
+    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters): Promise<string>;
     static LogToConsole: boolean;
     static durationThreshold: number;
     constructor(sql: SqlImplementation);

package/esm/src/data-providers/sql-database.js

@@ -1,23 +1,35 @@
 import { CompoundIdField } from "../column";
-import { FilterConsumerBridgeToSqlRequest, getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+import { dbNamesOf, FilterConsumerBridgeToSqlRequest, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
 import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
 import { Sort } from '../sort';
+import { getRepository } from "../remult3";
+import { RemultProxy } from "../remult-proxy";
 // @dynamic
 export class SqlDatabase {
     constructor(sql) {
         this.sql = sql;
         this.createdEntities = [];
     }
+    static getDb(remult) {
+        const r = (remult || RemultProxy.defaultRemult).dataProvider;
+        if (!r.createCommand)
+            throw "the data provider is not an SqlDatabase";
+        return r;
+    }
     createCommand() {
         return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
     }
     async execute(sql) {
         return await this.createCommand().execute(sql);
     }
+    /* @internal*/
+    _getSourceSql() {
+        return this.sql;
+    }
     getEntityDataProvider(entity) {
         return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
-            if (this.createdEntities.indexOf(dbName.entityName) < 0) {
-                this.createdEntities.push(dbName.entityName);
+            if (this.createdEntities.indexOf(dbName.$entityName) < 0) {
+                this.createdEntities.push(dbName.$entityName);
                 await this.sql.entityIsUsedForTheFirstTime(entity);
             }
         }, this.sql);
@@ -48,13 +60,25 @@ export class SqlDatabase {
             }
         });
     }
-    static customFilter(build) {
+    //TODO - change to "rawFilter" (in all databases and docs)
+    static rawFilter(build) {
         return {
             [customDatabaseFilterToken]: {
                 buildSql: build
             }
         };
     }
+    //TODO - filter to raw
+    static async filterToRaw(repo, condition, sqlCommand) {
+        if (!sqlCommand) {
+            sqlCommand = new myDummySQLCommand();
+        }
+        const r = getRepository(repo);
+        var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, await dbNamesOf(r.metadata));
+        b._addWhere = false;
+        await (await (r.translateWhereToFilter(condition))).__applyToConsumer(b);
+        return await b.resolveWhere();
+    }
 }
 SqlDatabase.LogToConsole = false;
 SqlDatabase.durationThreshold = 0;
@@ -95,13 +119,13 @@ class ActualSQLServerDataProvider {
         this.strategy = strategy;
     }
     async init() {
-        let dbNameProvider = await getDbNameProvider(this.entity);
+        let dbNameProvider = await dbNamesOf(this.entity);
         await this.iAmUsed(dbNameProvider);
         return dbNameProvider;
     }
     async count(where) {
         let e = await this.init();
-        let select = 'select count(*) count from ' + e.entityName;
+        let select = 'select count(*) count from ' + e.$entityName;
         let r = this.sql.createCommand();
         if (where) {
             let wc = new FilterConsumerBridgeToSqlRequest(r, e);
@@ -116,7 +140,7 @@ class ActualSQLServerDataProvider {
         let e = await this.init();
         let { colKeys, select } = this.buildSelect(e);
         select = 'select ' + select;
-        select += '\n from ' + e.entityName;
+        select += '\n from ' + e.$entityName;
         let r = this.sql.createCommand();
         if (options) {
             if (options.where) {
@@ -147,7 +171,7 @@ class ActualSQLServerDataProvider {
                     }
                     else
                         select += ', ';
-                    select += e.nameOf(c.field);
+                    select += e.$dbNameOf(c.field);
                     if (c.isDescending)
                         select += ' desc';
                 }
@@ -189,7 +213,7 @@ class ActualSQLServerDataProvider {
             else {
                 if (colKeys.length > 0)
                     select += ', ';
-                select += e.nameOf(x);
+                select += e.$dbNameOf(x);
                 colKeys.push(x);
             }
         }
@@ -200,12 +224,12 @@ class ActualSQLServerDataProvider {
         let r = this.sql.createCommand();
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let statement = 'update ' + e.entityName + ' set ';
+        let statement = 'update ' + e.$entityName + ' set ';
         let added = false;
         for (const x of this.entity.fields) {
             if (x instanceof CompoundIdField) {
             }
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else if (data[x.key] !== undefined) {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v !== undefined) {
@@ -213,7 +237,7 @@ class ActualSQLServerDataProvider {
                         added = true;
                     else
                         statement += ', ';
-                    statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                    statement += e.$dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
@@ -229,7 +253,7 @@ class ActualSQLServerDataProvider {
         let r = this.sql.createCommand();
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let statement = 'delete from ' + e.entityName;
+        let statement = 'delete from ' + e.$entityName;
         statement += await f.resolveWhere();
         return r.execute(statement).then(() => { });
     }
@@ -240,7 +264,7 @@ class ActualSQLServerDataProvider {
         let vals = '';
         let added = false;
         for (const x of this.entity.fields) {
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v != undefined) {
@@ -250,15 +274,32 @@ class ActualSQLServerDataProvider {
                         cols += ', ';
                         vals += ', ';
                     }
-                    cols += e.nameOf(x);
+                    cols += e.$dbNameOf(x);
                     vals += r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
-        let statement = `insert into ${e.entityName} (${cols}) values (${vals})`;
+        let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
         let { colKeys, select } = this.buildSelect(e);
         statement += ' returning ' + select;
         return await r.execute(statement).then(sql => this.buildResultRow(colKeys, sql.rows[0], sql));
     }
 }
 ActualSQLServerDataProvider.LogToConsole = false;
+class myDummySQLCommand {
+    execute(sql) {
+        throw new Error("Method not implemented.");
+    }
+    addParameterAndReturnSqlToken(val) {
+        if (val === null)
+            return "null";
+        if (val instanceof Date)
+            val = val.toISOString();
+        if (typeof (val) == "string") {
+            if (val == undefined)
+                val = '';
+            return '\'' + val.replace(/'/g, '\'\'') + '\'';
+        }
+        return val.toString();
+    }
+}

package/esm/src/data-providers/web-sql-data-provider.d.ts

@@ -1,12 +1,14 @@
 import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
 import { SqlCommand, SqlImplementation } from "../sql-command";
 import { EntityMetadata } from "../remult3";
+import { Remult } from "../context";
 export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
     private databaseName;
     rows: {
         [tableName: string]: any;
     };
     constructor(databaseName: string, databaseSize?: number);
+    static getDb(remult?: Remult): any;
     getLimitSqlSyntax(limit: number, offset: number): string;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     dropTable(entity: EntityMetadata): Promise<void>;

package/esm/src/data-providers/web-sql-data-provider.js

@@ -1,6 +1,6 @@
 import { isAutoIncrement } from "../remult3";
 import { SqlDatabase } from "./sql-database";
-import { getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+import { dbNamesOf, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
 //SqlDatabase.LogToConsole = true;
 export class WebSqlDataProvider {
     constructor(databaseName, databaseSize = 2 * 1024 * 1024) {
@@ -8,6 +8,15 @@ export class WebSqlDataProvider {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
+    // return instance of websql.Database class - see @types/websql
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.db) {
+            throw "the data provider is not a WebSqlDataProvider";
+        }
+        return me.db;
+    }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }
@@ -15,34 +24,34 @@ export class WebSqlDataProvider {
         await this.createTable(entity);
     }
     async dropTable(entity) {
-        let e = await getDbNameProvider(entity);
-        let sql = 'drop  table if exists ' + e.entityName;
+        let e = await dbNamesOf(entity);
+        let sql = 'drop  table if exists ' + e.$entityName;
         if (SqlDatabase.LogToConsole)
             console.info(sql);
         await this.createCommand().execute(sql);
     }
     async createTable(entity) {
         let result = '';
-        let e = await getDbNameProvider(entity);
+        let e = await dbNamesOf(entity);
         for (const x of entity.fields) {
-            if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
+            if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
                 if (result.length != 0)
                     result += ',';
                 result += '\r\n  ';
                 if (isAutoIncrement(x)) {
                     if (x.key != entity.idMetadata.field.key)
                         throw "in web sql, autoincrement is only allowed for primary key";
-                    result += e.nameOf(x) + ' integer primary key autoincrement';
+                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
                 }
                 else {
-                    result += this.addColumnSqlSyntax(x, e.nameOf(x));
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
                     if (x.key == entity.idMetadata.field.key) {
                         result += ' primary key';
                     }
                 }
             }
         }
-        let sql = 'create table if not exists ' + e.entityName + ' (' + result + '\r\n)';
+        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
         if (SqlDatabase.LogToConsole)
             console.log(sql);
         await this.createCommand().execute(sql);

package/esm/src/entity.d.ts

@@ -1,6 +1,6 @@
 import { Allowed, AllowedForInstance } from "./context";
 import { FieldMetadata as FieldMetadata } from './column-interfaces';
-import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef } from "./remult3";
+import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from "./remult3";
 export interface EntityOptions<entityType = any> {
     /**A human readable name for the entity */
     caption?: string;
@@ -67,7 +67,7 @@ export interface EntityOptions<entityType = any> {
    */
     dbName?: string;
     /** For entities that are based on SQL expressions instead of a physical table or view*/
-    sqlExpression?: string | ((entity: FieldsMetadata<entityType>) => string | Promise<string>);
+    sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
     /** An arrow function that identifies the `id` column to use for this entity
      * @example
      * //Single column id

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

@@ -1,7 +1,8 @@
-import { SqlCommand } from "../sql-command";
+import { SqlCommandWithParameters } from "../sql-command";
 import { Filter, FilterConsumer } from './filter-interfaces';
 import { FieldMetadata } from "../column-interfaces";
-import { EntityMetadata } from "../remult3/remult3";
+import { EntityFilter, OmitEB } from "../remult3/remult3";
+import { EntityMetadataOverloads, RepositoryOverloads } from "../remult3";
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
     private r;
     private nameProvider;
@@ -9,7 +10,7 @@ export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer
     _addWhere: boolean;
     promises: Promise<void>[];
     resolveWhere(): Promise<string>;
-    constructor(r: SqlCommand, nameProvider: dbNameProvider);
+    constructor(r: SqlCommandWithParameters, nameProvider: EntityDbNamesBase);
     custom(key: string, customItem: any): void;
     or(orElements: Filter[]): void;
     isNull(col: FieldMetadata): void;
@@ -32,19 +33,18 @@ export interface CustomSqlFilterObject {
 }
 export declare class CustomSqlFilterBuilder {
     private r;
-    constructor(r: SqlCommand);
+    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 getDbNameProvider(meta: EntityMetadata): Promise<dbNameProvider>;
-export declare class dbNameProviderImpl {
-    map: Map<string, string>;
-    nameOf(field: FieldMetadata<any>): string;
-    entityName: string;
-    isDbReadonly(x: FieldMetadata): boolean;
-}
-export interface dbNameProvider {
-    nameOf(field: FieldMetadata<any>): string;
-    entityName: string;
-    isDbReadonly(x: FieldMetadata): boolean;
-}
+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/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,3 +1,5 @@
+import { getEntityMetadata } from "../remult3";
+import { SqlDatabase } from "../data-providers/sql-database";
 export class FilterConsumerBridgeToSqlRequest {
     constructor(r, nameProvider) {
         this.r = r;
@@ -44,15 +46,15 @@ export class FilterConsumerBridgeToSqlRequest {
         })());
     }
     isNull(col) {
-        this.promises.push((async () => this.addToWhere(this.nameProvider.nameOf(col) + ' is null'))());
+        this.promises.push((async () => this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is null'))());
     }
     isNotNull(col) {
-        this.promises.push((async () => this.addToWhere(this.nameProvider.nameOf(col) + ' is not null'))());
+        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.nameOf(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*/');
         })());
@@ -77,12 +79,12 @@ export class FilterConsumerBridgeToSqlRequest {
     }
     containsCaseInsensitive(col, val) {
         this.promises.push((async () => {
-            this.addToWhere('lower (' + this.nameProvider.nameOf(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.nameOf(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);
         })());
     }
@@ -117,23 +119,29 @@ export class CustomSqlFilterBuilder {
             val = field.valueConverter.toDb(val);
         return this.r.addParameterAndReturnSqlToken(val);
     }
-}
-export async function getDbNameProvider(meta) {
-    var result = new dbNameProviderImpl();
-    for (const f of meta.fields) {
-        result.map.set(f.key, await f.getDbName());
+    async filterToRaw(repo, condition) {
+        return SqlDatabase.filterToRaw(repo, condition, this);
     }
-    result.entityName = await meta.getDbName();
-    return result;
 }
-export class dbNameProviderImpl {
-    constructor() {
-        this.map = new Map();
-    }
-    nameOf(field) {
-        return this.map.get(field.key);
-    }
-    isDbReadonly(x) {
-        return (x.dbReadOnly || x.isServerExpression || this.nameOf(x) != x.options.dbName);
+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/src/filter/filter-interfaces.d.ts

@@ -6,8 +6,8 @@ export declare class Filter {
     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 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;
@@ -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 customFilterInfo<entityType> {
-    customFilterInfo: {
+export interface rawFilterInfo<entityType> {
+    rawFilterInfo: {
         key: string;
-        customFilterTranslator: (r: Remult, args: any) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+        rawFilterTranslator: (args: any, r: Remult) => (EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
     };
 }