@ruiapp/rapid-core 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @ruiapp/rapid-core
+
+## 0.2.4
+
+### Patch Changes
+
+- 146a99d: add between filterMode, range is deprecated

package/dist/dataAccess/dataAccessTypes.d.ts

@@ -2,12 +2,13 @@ export type DataAccessPgColumnTypes = "int4" | "int8" | "float4" | "float8" | "d
 export type RowFilterRelationalOperators = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | "notContains" | "containsCS" | "notContainsCS" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith";
 export type RowFilterArrayOperators = "arrayContains" | "arrayOverlap";
 export type RowFilterSetOperators = "in" | "notIn";
+export type RowFilterRangeOperators = "between";
 export type RowFilterLogicalOperators = "or" | "and";
 export type RowFilterUnaryOperators = "null" | "notNull";
 export type RowFilterExistenceOperators = "exists" | "notExists";
-export type RowFilterOperators = RowFilterRelationalOperators | RowFilterArrayOperators | RowFilterSetOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
-export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowArrayFilterOptions | FindRowSetFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
-export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowArrayFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
+export type RowFilterOperators = RowFilterRelationalOperators | RowFilterArrayOperators | RowFilterSetOperators | RowFilterRangeOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
+export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowArrayFilterOptions | FindRowSetFilterOptions | FindRowRangeFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
+export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowArrayFilterOptions | FindRowSetFilterOptions | FindRowRangeFilterOptions | FindRowUnaryFilterOptions;
 export type ColumnSelectOptions = string | ColumnNameWithTableName;
 export type ColumnNameWithTableName = {
     name: string;
@@ -38,6 +39,12 @@ export interface FindRowSetFilterOptions {
     value: any[];
     itemType?: string;
 }
+export interface FindRowRangeFilterOptions {
+    field: ColumnSelectOptions;
+    operator: RowFilterRangeOperators;
+    value: any[];
+    itemType?: string;
+}
 export interface FindRowLogicalFilterOptions {
     operator: RowFilterLogicalOperators;
     filters: RowFilterOptions[];

package/dist/helpers/filterHelper.d.ts

@@ -1,2 +1,5 @@
-import { EntityFilterOptions } from "../types";
+import { EntityFilterOptions, RpdDataModel, RpdDataModelIndexOptions } from "../types";
+import { RowFilterOptions } from "../dataAccess/dataAccessTypes";
 export declare function removeFiltersWithNullValue(filters?: EntityFilterOptions[]): EntityFilterOptions[];
+export declare function convertModelIndexConditionsToRowFilterOptions(model: RpdDataModel, filters: RpdDataModelIndexOptions[]): RowFilterOptions[];
+export declare function replaceModelIndexConditionEntityPropertyWithTableColumn(model: RpdDataModel, filter: RpdDataModelIndexOptions): RowFilterOptions;

package/dist/helpers/metaHelper.d.ts

@@ -7,4 +7,6 @@ export declare function getEntityProperties(server: IRpdServer, model: RpdDataMo
 export declare function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel): RpdDataModelProperty[];
 export declare function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined;
 export declare function getEntityProperty(server: IRpdServer, model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined;
+export declare function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined;
+export declare function getEntityOwnProperty(model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined;
 export declare function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty | undefined;

package/dist/index.js

@@ -202,8 +202,8 @@ const pgPropertyTypeColumnMap = {
     "image[]": "jsonb",
 };
 
-const objLeftQuoteChar = '"';
-const objRightQuoteChar = '"';
+const objLeftQuoteChar = "\"";
+const objRightQuoteChar = "\"";
 const relationalOperatorsMap = new Map([
     ["eq", "="],
     ["ne", "<>"],
@@ -369,7 +369,7 @@ class QueryBuilder {
             paramToLiteral: false,
         };
         let { filters } = options;
-        let command = 'SELECT COUNT(*)::int as "count" FROM ';
+        let command = "SELECT COUNT(*)::int as \"count\" FROM ";
         command += this.quoteTable(model);
         if (filters && filters.length) {
             command += " WHERE ";
@@ -389,7 +389,7 @@ class QueryBuilder {
             paramToLiteral: false,
         };
         let { filters } = options;
-        let command = 'SELECT COUNT(*)::int as "count" FROM ';
+        let command = "SELECT COUNT(*)::int as \"count\" FROM ";
         command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(baseModel.tableName)}.id`;
         if (filters && filters.length) {
             command += " WHERE ";
@@ -535,6 +535,9 @@ function buildFilterQuery(level, ctx, filter) {
     else if (operator === "in" || operator === "notIn") {
         return buildInFilterQuery(ctx, filter);
     }
+    else if (operator === "between") {
+        return buildRangeFilterQuery(ctx, filter);
+    }
     else if (operator === "contains") {
         return buildContainsFilterQuery(ctx, filter);
     }
@@ -607,6 +610,24 @@ function buildInFilterQuery(ctx, filter) {
     }
     return command;
 }
+function buildRangeFilterQuery(ctx, filter) {
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
+    if (filter.operator === "between") {
+        if (filter.value.length != 2) {
+            throw new Error(`Filter operator '${filter.operator}' need two values.`);
+        }
+        command += " BETWEEN ";
+        ctx.params.push(filter.value[0]);
+        command += `$${ctx.params.length}`;
+        command += " AND ";
+        ctx.params.push(filter.value[1]);
+        command += `$${ctx.params.length}`;
+    }
+    else {
+        throw new Error(`Filter operator '${filter.operator}' is not supported.`);
+    }
+    return command;
+}
 function buildContainsFilterQuery(ctx, filter) {
     let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
     command += " LIKE ";
@@ -2064,6 +2085,13 @@ function getEntityProperty(server, model, predicate) {
     }
     return property;
 }
+function getEntityOwnPropertyByCode(model, propertyCode) {
+    return getEntityOwnProperty(model, (e) => e.code === propertyCode);
+}
+function getEntityOwnProperty(model, predicate) {
+    let property = model.properties.find(predicate);
+    return property;
+}
 function getEntityPropertyByFieldName(server, model, fieldName) {
     let property = getEntityPropertyByCode(server, model, fieldName);
     if (!property) {
@@ -4150,6 +4178,120 @@ var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   handler: handler$r
 });
 
+function removeFiltersWithNullValue(filters) {
+    const result = [];
+    if (!filters) {
+        return result;
+    }
+    for (const filter of filters) {
+        const { operator } = filter;
+        switch (operator) {
+            case "null":
+            case "notNull":
+                result.push(filter);
+                break;
+            case "exists":
+            case "notExists":
+            case "and":
+            case "or":
+                const transformedFilter = transformFilterWithSubFilters(filter);
+                if (transformedFilter !== null) {
+                    result.push(transformedFilter);
+                }
+                break;
+            default:
+                if (!isNullOrUndefined(filter.value)) {
+                    result.push(filter);
+                }
+        }
+    }
+    return result;
+}
+function transformFilterWithSubFilters(filter) {
+    const subFilters = removeFiltersWithNullValue(filter.filters);
+    if (!subFilters.length) {
+        return null;
+    }
+    filter.filters = subFilters;
+    return filter;
+}
+function convertModelIndexConditionsToRowFilterOptions(model, filters) {
+    if (!filters || !filters.length) {
+        return [];
+    }
+    const replacedFilters = [];
+    for (const filter of filters) {
+        const { operator } = filter;
+        if (operator === "and" || operator === "or") {
+            replacedFilters.push({
+                operator: operator,
+                filters: convertModelIndexConditionsToRowFilterOptions(model, filter.filters),
+            });
+        }
+        else {
+            replacedFilters.push(replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter));
+        }
+    }
+    return replacedFilters;
+}
+function replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter) {
+    const { operator } = filter;
+    const filterField = filter.field;
+    let property = getEntityOwnPropertyByCode(model, filterField);
+    let filterValue = filter.value;
+    let columnName = "";
+    if (property) {
+        if (isOneRelationProperty(property)) {
+            columnName = property.targetIdColumnName;
+            if (lodash.isPlainObject(filterValue)) {
+                filterValue = filterValue.id;
+            }
+        }
+        else if (isManyRelationProperty(property)) {
+            throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+        }
+        else {
+            columnName = property.columnName || property.code;
+        }
+    }
+    else if (operator === "exists" || operator === "notExists") {
+        throw new Error(`"exists" and "notExists" operators are not supported in index conditions.`);
+    }
+    else {
+        property = getEntityOwnProperty(model, (property) => {
+            return property.columnName === filterField;
+        });
+        if (property) {
+            columnName = property.columnName;
+        }
+        else {
+            // may be relation property.
+            property = getEntityOwnProperty(model, (property) => {
+                return property.targetIdColumnName === filterField;
+            });
+            if (property) {
+                if (isManyRelationProperty(property)) {
+                    throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+                }
+                columnName = property.targetIdColumnName;
+                if (lodash.isPlainObject(filterValue)) {
+                    filterValue = filterValue.id;
+                }
+            }
+            else {
+                throw new Error(`Unknown field "${filterField}" in index conditions.`);
+            }
+        }
+    }
+    // TODO: do not use `any` here
+    return {
+        operator: filter.operator,
+        field: columnName,
+        value: filterValue,
+        itemType: filter.itemType,
+    };
+}
+
 /**
  * Meta manager plugin
  */
@@ -4431,6 +4573,7 @@ async function syncDatabaseSchema(server, applicationConfig) {
         if (!model.indexes || !model.indexes.length) {
             continue;
         }
+        logger.debug(`Creating indexes of table ${queryBuilder.quoteTable(model)}`);
         for (const index of model.indexes) {
             const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
             await server.tryQueryDatabaseObject(sqlCreateIndex, []);
@@ -4508,7 +4651,8 @@ function generateTableIndexDDL(queryBuilder, server, model, index) {
         tableName: model.tableName,
     })} (${indexColumns.join(", ")})`;
     if (index.conditions) {
-        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, index.conditions)}`;
+        const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(model, index.conditions);
+        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
     }
     return ddl;
 }
@@ -4537,44 +4681,6 @@ async function runCollectionEntityActionHandler(ctx, options, code, handleEntity
     }
 }
 
-function removeFiltersWithNullValue(filters) {
-    const result = [];
-    if (!filters) {
-        return result;
-    }
-    for (const filter of filters) {
-        const { operator } = filter;
-        switch (operator) {
-            case "null":
-            case "notNull":
-                result.push(filter);
-                break;
-            case "exists":
-            case "notExists":
-            case "and":
-            case "or":
-                const transformedFilter = transformFilterWithSubFilters(filter);
-                if (transformedFilter !== null) {
-                    result.push(transformedFilter);
-                }
-                break;
-            default:
-                if (!isNullOrUndefined(filter.value)) {
-                    result.push(filter);
-                }
-        }
-    }
-    return result;
-}
-function transformFilterWithSubFilters(filter) {
-    const subFilters = removeFiltersWithNullValue(filter.filters);
-    if (!subFilters.length) {
-        return null;
-    }
-    filter.filters = subFilters;
-    return filter;
-}
-
 const code$q = "findCollectionEntities";
 async function handler$q(plugin, ctx, options) {
     await runCollectionEntityActionHandler(ctx, options, code$q, async (entityManager, input) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/dataAccess/dataAccessTypes.ts

@@ -32,6 +32,8 @@ export type RowFilterArrayOperators = "arrayContains" | "arrayOverlap";
 
 export type RowFilterSetOperators = "in" | "notIn";
 
+export type RowFilterRangeOperators = "between";
+
 export type RowFilterLogicalOperators = "or" | "and";
 
 export type RowFilterUnaryOperators = "null" | "notNull";
@@ -42,6 +44,7 @@ export type RowFilterOperators =
   | RowFilterRelationalOperators
   | RowFilterArrayOperators
   | RowFilterSetOperators
+  | RowFilterRangeOperators
   | RowFilterLogicalOperators
   | RowFilterUnaryOperators
   | RowFilterExistenceOperators;
@@ -50,6 +53,7 @@ export type RowFilterOptions =
   | FindRowRelationalFilterOptions
   | FindRowArrayFilterOptions
   | FindRowSetFilterOptions
+  | FindRowRangeFilterOptions
   | FindRowLogicalFilterOptions
   | FindRowUnaryFilterOptions
   | FindRowExistenceFilterOptions;
@@ -58,6 +62,7 @@ export type RowNonRelationPropertyFilterOptions =
   | FindRowRelationalFilterOptions
   | FindRowArrayFilterOptions
   | FindRowSetFilterOptions
+  | FindRowRangeFilterOptions
   | FindRowUnaryFilterOptions;
 
 export type ColumnSelectOptions = string | ColumnNameWithTableName;
@@ -98,6 +103,13 @@ export interface FindRowSetFilterOptions {
   itemType?: string;
 }
 
+export interface FindRowRangeFilterOptions {
+  field: ColumnSelectOptions;
+  operator: RowFilterRangeOperators;
+  value: any[];
+  itemType?: string;
+}
+
 export interface FindRowLogicalFilterOptions {
   operator: RowFilterLogicalOperators;
   filters: RowFilterOptions[];

package/src/helpers/filterHelper.ts

@@ -1,5 +1,17 @@
-import { EntityFilterOptions, FindEntityExistenceFilterOptions, FindEntityLogicalFilterOptions } from "~/types";
+import {
+  EntityFilterOptions,
+  EntityNonRelationPropertyFilterOptions,
+  FindEntityExistenceFilterOptions,
+  FindEntityLogicalFilterOptions,
+  RpdDataModel,
+  RpdDataModelIndexOptions,
+  RpdDataModelProperty,
+} from "~/types";
 import { isNullOrUndefined } from "~/utilities/typeUtility";
+import { getEntityOwnProperty, getEntityOwnPropertyByCode, isManyRelationProperty, isOneRelationProperty } from "./metaHelper";
+import { IRpdServer } from "~/core/server";
+import { isPlainObject } from "lodash";
+import { RowFilterOptions } from "~/dataAccess/dataAccessTypes";
 
 export function removeFiltersWithNullValue(filters?: EntityFilterOptions[]) {
   const result: EntityFilterOptions[] = [];
@@ -45,3 +57,79 @@ function transformFilterWithSubFilters(
   filter.filters = subFilters;
   return filter;
 }
+
+export function convertModelIndexConditionsToRowFilterOptions(model: RpdDataModel, filters: RpdDataModelIndexOptions[]) {
+  if (!filters || !filters.length) {
+    return [];
+  }
+
+  const replacedFilters: RowFilterOptions[] = [];
+  for (const filter of filters) {
+    const { operator } = filter;
+    if (operator === "and" || operator === "or") {
+      replacedFilters.push({
+        operator: operator,
+        filters: convertModelIndexConditionsToRowFilterOptions(model, filter.filters),
+      });
+    } else {
+      replacedFilters.push(replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter));
+    }
+  }
+  return replacedFilters;
+}
+export function replaceModelIndexConditionEntityPropertyWithTableColumn(model: RpdDataModel, filter: RpdDataModelIndexOptions): RowFilterOptions {
+  const { operator } = filter;
+  const filterField = (filter as EntityNonRelationPropertyFilterOptions).field;
+  let property: RpdDataModelProperty = getEntityOwnPropertyByCode(model, filterField);
+
+  let filterValue = (filter as any).value;
+
+  let columnName = "";
+  if (property) {
+    if (isOneRelationProperty(property)) {
+      columnName = property.targetIdColumnName;
+      if (isPlainObject(filterValue)) {
+        filterValue = filterValue.id;
+      }
+    } else if (isManyRelationProperty(property)) {
+      throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+    } else {
+      columnName = property.columnName || property.code;
+    }
+  } else if ((operator as any) === "exists" || (operator as any) === "notExists") {
+    throw new Error(`"exists" and "notExists" operators are not supported in index conditions.`);
+  } else {
+    property = getEntityOwnProperty(model, (property) => {
+      return property.columnName === filterField;
+    });
+
+    if (property) {
+      columnName = property.columnName;
+    } else {
+      // may be relation property.
+      property = getEntityOwnProperty(model, (property) => {
+        return property.targetIdColumnName === filterField;
+      });
+
+      if (property) {
+        if (isManyRelationProperty(property)) {
+          throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+        }
+        columnName = property.targetIdColumnName;
+        if (isPlainObject(filterValue)) {
+          filterValue = filterValue.id;
+        }
+      } else {
+        throw new Error(`Unknown field "${filterField}" in index conditions.`);
+      }
+    }
+  }
+
+  // TODO: do not use `any` here
+  return {
+    operator: filter.operator,
+    field: columnName,
+    value: filterValue,
+    itemType: (filter as any).itemType,
+  } as RowFilterOptions;
+}

package/src/helpers/metaHelper.ts

@@ -66,6 +66,15 @@ export function getEntityProperty(
   return property;
 }
 
+export function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
+  return getEntityOwnProperty(model, (e) => e.code === propertyCode);
+}
+
+export function getEntityOwnProperty(model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined {
+  let property = model.properties.find(predicate);
+  return property;
+}
+
 export function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty | undefined {
   let property = getEntityPropertyByCode(server, model, fieldName);
   if (!property) {

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -30,6 +30,7 @@ import { find, isString, map } from "lodash";
 import { getEntityPropertiesIncludingBase, getEntityPropertyByCode, isOneRelationProperty, isRelationProperty } from "~/helpers/metaHelper";
 import { DataAccessPgColumnTypes } from "~/dataAccess/dataAccessTypes";
 import { pgPropertyTypeColumnMap } from "~/dataAccess/columnTypeMapper";
+import { convertModelIndexConditionsToRowFilterOptions } from "~/helpers/filterHelper";
 
 class MetaManager implements RapidPlugin {
   get code(): string {
@@ -388,6 +389,7 @@ async function syncDatabaseSchema(server: IRpdServer, applicationConfig: RpdAppl
       continue;
     }
 
+    logger.debug(`Creating indexes of table ${queryBuilder.quoteTable(model)}`);
     for (const index of model.indexes) {
       const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
       await server.tryQueryDatabaseObject(sqlCreateIndex, []);
@@ -493,7 +495,8 @@ function generateTableIndexDDL(queryBuilder: IQueryBuilder, server: IRpdServer,
   })} (${indexColumns.join(", ")})`;
 
   if (index.conditions) {
-    ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, index.conditions)}`;
+    const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(model, index.conditions);
+    ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
   }
 
   return ddl;

package/src/queryBuilder/queryBuilder.ts

@@ -15,11 +15,12 @@ import {
   ColumnNameWithTableName,
   DataAccessPgColumnTypes,
   FindRowArrayFilterOptions,
+  FindRowRangeFilterOptions,
 } from "~/dataAccess/dataAccessTypes";
 import { pgPropertyTypeColumnMap } from "~/dataAccess/columnTypeMapper";
 
-const objLeftQuoteChar = '"';
-const objRightQuoteChar = '"';
+const objLeftQuoteChar = "\"";
+const objRightQuoteChar = "\"";
 
 const relationalOperatorsMap = new Map<RowFilterRelationalOperators, string>([
   ["eq", "="],
@@ -222,7 +223,7 @@ export default class QueryBuilder {
       paramToLiteral: false,
     };
     let { filters } = options;
-    let command = 'SELECT COUNT(*)::int as "count" FROM ';
+    let command = "SELECT COUNT(*)::int as \"count\" FROM ";
 
     command += this.quoteTable(model);
 
@@ -246,7 +247,7 @@ export default class QueryBuilder {
       paramToLiteral: false,
     };
     let { filters } = options;
-    let command = 'SELECT COUNT(*)::int as "count" FROM ';
+    let command = "SELECT COUNT(*)::int as \"count\" FROM ";
 
     command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(
       baseModel.tableName,
@@ -413,6 +414,8 @@ function buildFilterQuery(level: number, ctx: BuildQueryContext, filter: RowFilt
     return buildUnaryFilterQuery(ctx, filter);
   } else if (operator === "in" || operator === "notIn") {
     return buildInFilterQuery(ctx, filter);
+  } else if (operator === "between") {
+    return buildRangeFilterQuery(ctx, filter);
   } else if (operator === "contains") {
     return buildContainsFilterQuery(ctx, filter);
   } else if (operator === "notContains") {
@@ -482,6 +485,31 @@ function buildInFilterQuery(ctx: BuildQueryContext, filter: FindRowSetFilterOpti
   return command;
 }
 
+function buildRangeFilterQuery(ctx: BuildQueryContext, filter: FindRowRangeFilterOptions) {
+  let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
+
+  if (filter.operator === "between") {
+    if (filter.value.length != 2) {
+      throw new Error(`Filter operator '${filter.operator}' need two values.`);
+    }
+
+    command += " BETWEEN ";
+
+    ctx.params.push(filter.value[0]);
+    command += `$${ctx.params.length}`;
+
+    command += " AND "
+
+    ctx.params.push(filter.value[1]);
+    command += `$${ctx.params.length}`;
+
+  } else {
+    throw new Error(`Filter operator '${filter.operator}' is not supported.`);
+  }
+
+  return command;
+}
+
 function buildContainsFilterQuery(ctx: BuildQueryContext, filter: FindRowRelationalFilterOptions) {
   let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);