remult 0.17.3 → 0.18.0

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

@@ -13,6 +13,15 @@ var WebSqlDataProvider = /** @class */ (function () {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
+    // return instance of websql.Database class - see @types/websql
+    WebSqlDataProvider.getDb = function (remult) {
+        var sql = sql_database_1.SqlDatabase.getDb(remult);
+        var me = sql._getSourceSql();
+        if (!me.db) {
+            throw "the data provider is not a WebSqlDataProvider";
+        }
+        return me.db;
+    };
     WebSqlDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     };
@@ -28,17 +37,53 @@ var WebSqlDataProvider = /** @class */ (function () {
             });
         });
     };
+    WebSqlDataProvider.prototype.ensureSchema = function (entities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var entities_1, entities_1_1, entity, e_1_1;
+            var e_1, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 5, 6, 7]);
+                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
+                        _b.label = 1;
+                    case 1:
+                        if (!!entities_1_1.done) return [3 /*break*/, 4];
+                        entity = entities_1_1.value;
+                        return [4 /*yield*/, this.createTable(entity)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        entities_1_1 = entities_1.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     WebSqlDataProvider.prototype.dropTable = function (entity) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var e, sql;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
                     case 1:
                         e = _a.sent();
-                        sql = 'drop  table if exists ' + e.entityName;
+                        sql = 'drop  table if exists ' + e.$entityName;
                         if (sql_database_1.SqlDatabase.LogToConsole)
-                            console.log(sql);
+                            console.info(sql);
                         return [4 /*yield*/, this.createCommand().execute(sql)];
                     case 2:
                         _a.sent();
@@ -50,28 +95,28 @@ var WebSqlDataProvider = /** @class */ (function () {
     WebSqlDataProvider.prototype.createTable = function (entity) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var result, e, _a, _b, x, sql;
-            var e_1, _c;
+            var e_2, _c;
             return tslib_1.__generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         result = '';
-                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
                     case 1:
                         e = _d.sent();
                         try {
                             for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
                                 x = _b.value;
-                                if (!e.isDbReadonly(x) || remult3_1.isAutoIncrement(x)) {
+                                if (!filter_consumer_bridge_to_sql_request_1.isDbReadonly(x, e) || remult3_1.isAutoIncrement(x)) {
                                     if (result.length != 0)
                                         result += ',';
                                     result += '\r\n  ';
                                     if (remult3_1.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';
                                         }
@@ -79,14 +124,14 @@ var WebSqlDataProvider = /** @class */ (function () {
                                 }
                             }
                         }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
                         finally {
                             try {
                                 if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                             }
-                            finally { if (e_1) throw e_1.error; }
+                            finally { if (e_2) throw e_2.error; }
                         }
-                        sql = 'create table if not exists ' + e.entityName + ' (' + result + '\r\n)';
+                        sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
                         if (sql_database_1.SqlDatabase.LogToConsole)
                             console.log(sql);
                         return [4 /*yield*/, this.createCommand().execute(sql)];

package/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/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/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dbNameProviderImpl = exports.getDbNameProvider = exports.CustomSqlFilterBuilder = exports.FilterConsumerBridgeToSqlRequest = void 0;
+exports.dbNamesOf = exports.isDbReadonly = exports.CustomSqlFilterBuilder = exports.FilterConsumerBridgeToSqlRequest = void 0;
 var tslib_1 = require("tslib");
+var remult3_1 = require("../remult3");
+var sql_database_1 = require("../data-providers/sql-database");
 var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
     function FilterConsumerBridgeToSqlRequest(r, nameProvider) {
         this.r = r;
@@ -113,13 +115,13 @@ var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
     FilterConsumerBridgeToSqlRequest.prototype.isNull = function (col) {
         var _this = this;
         this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, this.addToWhere(this.nameProvider.nameOf(col) + ' is null')];
+            return [2 /*return*/, this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is null')];
         }); }); })());
     };
     FilterConsumerBridgeToSqlRequest.prototype.isNotNull = function (col) {
         var _this = this;
         this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, this.addToWhere(this.nameProvider.nameOf(col) + ' is not null')];
+            return [2 /*return*/, this.addToWhere(this.nameProvider.$dbNameOf(col) + ' is not null')];
         }); }); })());
     };
     FilterConsumerBridgeToSqlRequest.prototype.isIn = function (col, val) {
@@ -128,7 +130,7 @@ var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 if (val && val.length > 0)
-                    this.addToWhere(this.nameProvider.nameOf(col) + " in (" + val.map(function (x) { return _this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x)); }).join(",") + ")");
+                    this.addToWhere(this.nameProvider.$dbNameOf(col) + " in (" + val.map(function (x) { return _this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x)); }).join(",") + ")");
                 else
                     this.addToWhere('1 = 0 /*isIn with no values*/');
                 return [2 /*return*/];
@@ -157,7 +159,7 @@ var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
         var _this = this;
         this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
-                this.addToWhere('lower (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')");
+                this.addToWhere('lower (' + this.nameProvider.$dbNameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')");
                 return [2 /*return*/];
             });
         }); })());
@@ -167,7 +169,7 @@ var FilterConsumerBridgeToSqlRequest = /** @class */ (function () {
         this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var x;
             return tslib_1.__generator(this, function (_a) {
-                x = this.nameProvider.nameOf(col) + ' ' + operator + ' ' + this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
+                x = this.nameProvider.$dbNameOf(col) + ' ' + operator + ' ' + this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
                 this.addToWhere(x);
                 return [2 /*return*/];
             });
@@ -216,66 +218,73 @@ var CustomSqlFilterBuilder = /** @class */ (function () {
             val = field.valueConverter.toDb(val);
         return this.r.addParameterAndReturnSqlToken(val);
     };
+    CustomSqlFilterBuilder.prototype.filterToRaw = function (repo, condition) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, sql_database_1.SqlDatabase.filterToRaw(repo, condition, this)];
+            });
+        });
+    };
     return CustomSqlFilterBuilder;
 }());
 exports.CustomSqlFilterBuilder = CustomSqlFilterBuilder;
-function getDbNameProvider(meta) {
+function isDbReadonly(field, dbNames) {
+    return (field.dbReadOnly || field.isServerExpression || dbNames.$dbNameOf(field) != field.options.dbName);
+}
+exports.isDbReadonly = isDbReadonly;
+function dbNamesOf(repo) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var result, _a, _b, f, _c, _d, _e, e_3_1, _f;
-        var e_3, _g;
-        return tslib_1.__generator(this, function (_h) {
-            switch (_h.label) {
+        var meta, result, _a, _b, field, _c, _d, e_3_1;
+        var _e, e_3, _f;
+        return tslib_1.__generator(this, function (_g) {
+            switch (_g.label) {
                 case 0:
-                    result = new dbNameProviderImpl();
-                    _h.label = 1;
+                    meta = remult3_1.getEntityMetadata(repo);
+                    _e = {};
+                    return [4 /*yield*/, meta.getDbName()];
                 case 1:
-                    _h.trys.push([1, 6, 7, 8]);
-                    _a = tslib_1.__values(meta.fields), _b = _a.next();
-                    _h.label = 2;
+                    result = (_e.$entityName = _g.sent(),
+                        _e.toString = function () { return result.$entityName; },
+                        _e.$dbNameOf = function (field) {
+                            var key;
+                            if (typeof field === "string")
+                                key = field;
+                            else
+                                key = field.key;
+                            return result[key];
+                        },
+                        _e);
+                    _g.label = 2;
                 case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    f = _b.value;
-                    _d = (_c = result.map).set;
-                    _e = [f.key];
-                    return [4 /*yield*/, f.getDbName()];
+                    _g.trys.push([2, 7, 8, 9]);
+                    _a = tslib_1.__values(meta.fields), _b = _a.next();
+                    _g.label = 3;
                 case 3:
-                    _d.apply(_c, _e.concat([_h.sent()]));
-                    _h.label = 4;
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    field = _b.value;
+                    _c = result;
+                    _d = field.key;
+                    return [4 /*yield*/, field.getDbName()];
                 case 4:
+                    _c[_d] = _g.sent();
+                    _g.label = 5;
+                case 5:
                     _b = _a.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_3_1 = _h.sent();
-                    e_3 = { error: e_3_1 };
-                    return [3 /*break*/, 8];
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
                 case 7:
+                    e_3_1 = _g.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 9];
+                case 8:
                     try {
-                        if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
                     }
                     finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
-                case 8:
-                    _f = result;
-                    return [4 /*yield*/, meta.getDbName()];
-                case 9:
-                    _f.entityName = _h.sent();
-                    return [2 /*return*/, result];
+                case 9: return [2 /*return*/, result];
             }
         });
     });
 }
-exports.getDbNameProvider = getDbNameProvider;
-var dbNameProviderImpl = /** @class */ (function () {
-    function dbNameProviderImpl() {
-        this.map = new Map();
-    }
-    dbNameProviderImpl.prototype.nameOf = function (field) {
-        return this.map.get(field.key);
-    };
-    dbNameProviderImpl.prototype.isDbReadonly = function (x) {
-        return (x.dbReadOnly || x.isServerExpression || this.nameOf(x) != x.options.dbName);
-    };
-    return dbNameProviderImpl;
-}());
-exports.dbNameProviderImpl = dbNameProviderImpl;
+exports.dbNamesOf = dbNamesOf;

package/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>>);
     };
 }

package/src/filter/filter-interfaces.js

@@ -26,20 +26,20 @@ var Filter = /** @class */ (function () {
             });
         });
     };
-    Filter.createCustom = function (customFilterTranslator, key) {
+    Filter.createCustom = function (rawFilterTranslator, key) {
         if (key === void 0) { key = ''; }
-        var customFilterInfo = { key: key, customFilterTranslator: customFilterTranslator };
+        var rawFilterInfo = { key: key, rawFilterTranslator: rawFilterTranslator };
         return Object.assign(function (x) {
             var _a;
             var z = {};
             if (x == undefined)
                 x = {};
-            if (!customFilterInfo.key)
+            if (!rawFilterInfo.key)
                 throw "Usage of custom filter before a key was assigned to it";
             return _a = {},
-                _a[exports.customUrlToken + customFilterInfo.key] = x,
+                _a[exports.customUrlToken + rawFilterInfo.key] = x,
                 _a;
-        }, { customFilterInfo: customFilterInfo });
+        }, { rawFilterInfo: rawFilterInfo });
     };
     Filter.fromEntityFilter = function (entity, whereItem) {
         var result = [];
@@ -93,6 +93,7 @@ var Filter = /** @class */ (function () {
                                             break;
                                         case "$ne":
                                         case "!=":
+                                        case "$nin":
                                             found = true;
                                             if (Array.isArray(element)) {
                                                 result.push(fh.isNotIn(element));
@@ -100,6 +101,10 @@ var Filter = /** @class */ (function () {
                                             else
                                                 result.push(fh.isDifferentFrom(element));
                                             break;
+                                        case "$in":
+                                            found = true;
+                                            result.push(fh.isIn(element));
+                                            break;
                                         case "$contains":
                                             found = true;
                                             result.push(fh.contains(element));
@@ -157,12 +162,12 @@ var Filter = /** @class */ (function () {
                                         if (!(_i < _a.length)) return [3 /*break*/, 5];
                                         key = _a[_i];
                                         element = entity.entityType[key];
-                                        if (!(element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator)) return [3 /*break*/, 4];
-                                        if (!(element.customFilterInfo.key == filterKey)) return [3 /*break*/, 4];
+                                        if (!(element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator)) return [3 /*break*/, 4];
+                                        if (!(element.rawFilterInfo.key == filterKey)) return [3 /*break*/, 4];
                                         _d = (_c = r).push;
                                         _f = (_e = Filter).fromEntityFilter;
                                         _g = [entity];
-                                        return [4 /*yield*/, element.customFilterInfo.customFilterTranslator(remult, custom)];
+                                        return [4 /*yield*/, element.rawFilterInfo.rawFilterTranslator(custom, remult)];
                                     case 2: return [4 /*yield*/, _f.apply(_e, _g.concat([_h.sent()]))];
                                     case 3:
                                         _d.apply(_c, [_h.sent()]);
@@ -358,34 +363,34 @@ var FilterSerializer = /** @class */ (function () {
         }));
     };
     FilterSerializer.prototype.isNull = function (col) {
-        this.add(col.key + "_null", true);
+        this.add(col.key + ".null", true);
     };
     FilterSerializer.prototype.isNotNull = function (col) {
-        this.add(col.key + "_null", false);
+        this.add(col.key + ".null", false);
     };
     FilterSerializer.prototype.isIn = function (col, val) {
-        this.add(col.key + "_in", val.map(function (x) { return col.valueConverter.toJson(x); }));
+        this.add(col.key + ".in", val.map(function (x) { return col.valueConverter.toJson(x); }));
     };
     FilterSerializer.prototype.isEqualTo = function (col, val) {
         this.add(col.key, col.valueConverter.toJson(val));
     };
     FilterSerializer.prototype.isDifferentFrom = function (col, val) {
-        this.add(col.key + '_ne', col.valueConverter.toJson(val));
+        this.add(col.key + '.ne', col.valueConverter.toJson(val));
     };
     FilterSerializer.prototype.isGreaterOrEqualTo = function (col, val) {
-        this.add(col.key + '_gte', col.valueConverter.toJson(val));
+        this.add(col.key + '.gte', col.valueConverter.toJson(val));
     };
     FilterSerializer.prototype.isGreaterThan = function (col, val) {
-        this.add(col.key + '_gt', col.valueConverter.toJson(val));
+        this.add(col.key + '.gt', col.valueConverter.toJson(val));
     };
     FilterSerializer.prototype.isLessOrEqualTo = function (col, val) {
-        this.add(col.key + '_lte', col.valueConverter.toJson(val));
+        this.add(col.key + '.lte', col.valueConverter.toJson(val));
     };
     FilterSerializer.prototype.isLessThan = function (col, val) {
-        this.add(col.key + '_lt', col.valueConverter.toJson(val));
+        this.add(col.key + '.lt', col.valueConverter.toJson(val));
     };
     FilterSerializer.prototype.containsCaseInsensitive = function (col, val) {
-        this.add(col.key + "_contains", val);
+        this.add(col.key + ".contains", val);
     };
     return FilterSerializer;
 }());
@@ -455,13 +460,13 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
         }
         var c = new filterHelper(col);
         addFilter('', function (val) { return val; });
-        addFilter('_gt', function (val) { return ({ "$gt": val }); });
-        addFilter('_gte', function (val) { return ({ "$gte": val }); });
-        addFilter('_lt', function (val) { return ({ "$lt": val }); });
-        addFilter('_lte', function (val) { return ({ "$lte": val }); });
-        addFilter('_ne', function (val) { return ({ "$ne": val }); });
-        addFilter('_in', function (val) { return val; }, true);
-        var nullFilter = filterInfo.get(col.key + "_null");
+        addFilter('.gt', function (val) { return ({ "$gt": val }); });
+        addFilter('.gte', function (val) { return ({ "$gte": val }); });
+        addFilter('.lt', function (val) { return ({ "$lt": val }); });
+        addFilter('.lte', function (val) { return ({ "$lte": val }); });
+        addFilter('.ne', function (val) { return ({ "$ne": val }); });
+        addFilter('.in', function (val) { return val; }, true);
+        var nullFilter = filterInfo.get(col.key + ".null");
         if (nullFilter) {
             nullFilter = nullFilter.toString().trim().toLowerCase();
             switch (nullFilter) {
@@ -475,7 +480,7 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                     break;
             }
         }
-        addFilter('_contains', function (val) { return ({ $contains: val }); }, false, true);
+        addFilter('.contains', function (val) { return ({ $contains: val }); }, false, true);
     });
     var val = filterInfo.get('OR');
     if (val) {
@@ -490,7 +495,7 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
     }
     for (var key in entity.entityType) {
         var element = entity.entityType[key];
-        if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+        if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
             var custom = filterInfo.get(exports.customUrlToken + key);
             if (custom !== undefined) {
                 where.push((_a = {}, _a[exports.customUrlToken + key] = custom, _a));

package/src/live-query/LiveQueryClient.d.ts

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