@ruiapp/rapid-core 0.1.74 → 0.1.76

package/dist/dataAccess/columnTypeMapper.d.ts

@@ -0,0 +1,3 @@
+import { RpdDataPropertyTypes } from "../types";
+import { DataAccessPgColumnTypes } from "./dataAccessTypes";
+export declare const pgPropertyTypeColumnMap: Record<Exclude<RpdDataPropertyTypes, "relation" | "relation[]">, DataAccessPgColumnTypes>;

package/dist/dataAccess/dataAccessTypes.d.ts

@@ -1,11 +1,13 @@
+export type DataAccessPgColumnTypes = "int4" | "int8" | "float4" | "float8" | "decimal" | "text" | "text[]" | "bool" | "date" | "time" | "timestamptz" | "jsonb";
 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 RowFilterLogicalOperators = "or" | "and";
 export type RowFilterUnaryOperators = "null" | "notNull";
 export type RowFilterExistenceOperators = "exists" | "notExists";
-export type RowFilterOperators = RowFilterRelationalOperators | RowFilterSetOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
-export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
-export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
+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 ColumnSelectOptions = string | ColumnNameWithTableName;
 export type ColumnNameWithTableName = {
     name: string;
@@ -24,6 +26,12 @@ export interface FindRowRelationalFilterOptions {
     operator: RowFilterRelationalOperators;
     value: any;
 }
+export interface FindRowArrayFilterOptions {
+    field: ColumnSelectOptions;
+    operator: RowFilterArrayOperators;
+    value: any[];
+    itemType?: string;
+}
 export interface FindRowSetFilterOptions {
     field: ColumnSelectOptions;
     operator: RowFilterSetOperators;

package/dist/index.js

@@ -182,6 +182,26 @@ class DataAccessor {
     }
 }
 
+const pgPropertyTypeColumnMap = {
+    integer: "int4",
+    long: "int8",
+    float: "float4",
+    double: "float8",
+    decimal: "decimal",
+    text: "text",
+    boolean: "bool",
+    date: "date",
+    time: "time",
+    datetime: "timestamptz",
+    json: "jsonb",
+    option: "text",
+    "option[]": "text[]",
+    file: "jsonb",
+    "file[]": "jsonb",
+    image: "jsonb",
+    "image[]": "jsonb",
+};
+
 const objLeftQuoteChar = '"';
 const objRightQuoteChar = '"';
 const relationalOperatorsMap = new Map([
@@ -392,26 +412,27 @@ class QueryBuilder {
         const { entity } = options;
         let command = "INSERT INTO ";
         command += this.quoteTable(model);
-        const propertyNames = Object.keys(entity);
+        const columnNames = Object.keys(entity);
         let values = "";
-        propertyNames.forEach((propertyName, index) => {
+        columnNames.forEach((columnName, index) => {
             if (index) {
                 values += ", ";
             }
             let property = null;
             if (model) {
-                property = lodash.find(model.properties, (e) => e.code === propertyName);
+                property = lodash.find(model.properties, (e) => (e.columnName || e.code) === columnName);
             }
-            if (property && property.type === "json") {
-                params.push(JSON.stringify(entity[propertyName]));
+            const columnType = property ? pgPropertyTypeColumnMap[property.type] : null;
+            if (columnType === "jsonb") {
+                params.push(JSON.stringify(entity[columnName]));
                 values += `$${params.length}::jsonb`;
             }
             else {
-                params.push(entity[propertyName]);
+                params.push(entity[columnName]);
                 values += `$${params.length}`;
             }
         });
-        command += ` (${propertyNames.map(this.quoteObject).join(", ")})`;
+        command += ` (${columnNames.map(this.quoteObject).join(", ")})`;
         command += ` VALUES (${values}) RETURNING *`;
         return {
             command,
@@ -431,22 +452,24 @@ class QueryBuilder {
         let command = "UPDATE ";
         command += this.quoteTable(model);
         command += " SET ";
-        const propertyNames = Object.keys(entity);
-        propertyNames.forEach((propertyName, index) => {
+        const columnNames = Object.keys(entity);
+        columnNames.forEach((columnName, index) => {
             if (index) {
                 command += ", ";
             }
+            command += `${this.quoteObject(columnName)}=`;
             let property = null;
             if (model) {
-                property = lodash.find(model.properties, (e) => (e.columnName || e.code) === propertyName);
+                property = lodash.find(model.properties, (e) => (e.columnName || e.code) === columnName);
             }
-            if (property && property.type === "json") {
-                params.push(JSON.stringify(entity[propertyName]));
-                command += `${this.quoteObject(propertyName)}=$${params.length}::jsonb`;
+            const columnType = property ? pgPropertyTypeColumnMap[property.type] : null;
+            if (columnType === "jsonb") {
+                params.push(JSON.stringify(entity[columnName]));
+                command += `$${params.length}::jsonb`;
             }
             else {
-                params.push(entity[propertyName]);
-                command += `${this.quoteObject(propertyName)}=$${params.length}`;
+                params.push(entity[columnName]);
+                command += `$${params.length}`;
             }
         });
         if (filters && filters.length) {
@@ -530,6 +553,12 @@ function buildFilterQuery(level, ctx, filter) {
     else if (operator === "notEndsWith") {
         return buildNotEndsWithFilterQuery(ctx, filter);
     }
+    else if (operator === "arrayContains") {
+        return buildArrayContainsFilterQuery(ctx, filter);
+    }
+    else if (operator === "arrayOverlap") {
+        return buildArrayOverlapFilterQuery(ctx, filter);
+    }
     else {
         throw new Error(`Filter operator '${operator}' is not supported.`);
     }
@@ -645,6 +674,26 @@ function buildRelationalFilterQuery(ctx, filter) {
     }
     return command;
 }
+function buildArrayContainsFilterQuery(ctx, filter) {
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
+    command += " @> ";
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(filter.value);
+        command += "$" + ctx.params.length;
+    }
+    return command;
+}
+function buildArrayOverlapFilterQuery(ctx, filter) {
+    let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
+    command += " && ";
+    if (ctx.paramToLiteral) ;
+    else {
+        ctx.params.push(filter.value);
+        command += "$" + ctx.params.length;
+    }
+    return command;
+}
 function formatValueToSqlLiteral(value) {
     if (lodash.isNull(value) || lodash.isUndefined(value)) {
         return "null";
@@ -2618,12 +2667,18 @@ async function convertEntityFiltersToRowFilters(server, model, baseModel, filter
         }
         else {
             const filterField = filter.field;
-            let property = getEntityProperty(server, model, (property) => {
-                return property.code === filterField;
-            });
+            let property = getEntityPropertyByCode(server, model, filterField);
             let columnName = "";
             if (property) {
-                columnName = property.columnName || property.code;
+                if (isOneRelationProperty(property)) {
+                    columnName = property.targetIdColumnName;
+                }
+                else if (isManyRelationProperty(property)) {
+                    throw new Error(`Operator "${operator}" is not supported on many-relation property "${property.code}"`);
+                }
+                else {
+                    columnName = property.columnName || property.code;
+                }
             }
             else {
                 property = getEntityProperty(server, model, (property) => {
@@ -4336,21 +4391,7 @@ function generateTableIndexDDL(queryBuilder, server, model, index) {
         ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, index.conditions)}`;
     }
     return ddl;
-}
-const pgPropertyTypeColumnMap = {
-    integer: "int4",
-    long: "int8",
-    float: "float4",
-    double: "float8",
-    decimal: "decimal",
-    text: "text",
-    boolean: "bool",
-    date: "date",
-    time: "time",
-    datetime: "timestamptz",
-    json: "jsonb",
-    option: "text",
-};
+}
 
 function mergeInput(defaultInput, input, fixedInput) {
     return lodash.mergeWith({}, defaultInput, input, fixedInput, doNotMergeArray);

package/dist/types.d.ts

@@ -271,7 +271,7 @@ export interface RpdDataModelProperty {
      */
     linkSchema?: string;
 }
-export type RpdDataPropertyTypes = "integer" | "long" | "float" | "double" | "decimal" | "text" | "boolean" | "date" | "time" | "datetime" | "json" | "relation" | "relation[]" | "option";
+export type RpdDataPropertyTypes = "integer" | "long" | "float" | "double" | "decimal" | "text" | "boolean" | "date" | "time" | "datetime" | "json" | "relation" | "relation[]" | "option" | "option[]" | "file" | "file[]" | "image" | "image[]";
 /**
  * 数据字典
  */
@@ -359,13 +359,14 @@ export interface IRpdDataAccessor<T = any> {
     deleteById(id: any): Promise<void>;
 }
 export type EntityFilterRelationalOperators = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | "notContains" | "containsCS" | "notContainsCS" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith";
+export type EntityFilterArrayOperators = "arrayContains" | "arrayOverlap";
 export type EntityFilterSetOperators = "in" | "notIn";
 export type EntityFilterLogicalOperators = "or" | "and";
 export type EntityFilterUnaryOperators = "null" | "notNull";
 export type EntityFilterExistenceOperators = "exists" | "notExists";
-export type EntityFilterOperators = EntityFilterRelationalOperators | EntityFilterSetOperators | EntityFilterLogicalOperators | EntityFilterUnaryOperators | EntityFilterExistenceOperators;
-export type EntityFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityLogicalFilterOptions | FindEntityUnaryFilterOptions | FindEntityExistenceFilterOptions;
-export type EntityNonRelationPropertyFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityUnaryFilterOptions;
+export type EntityFilterOperators = EntityFilterRelationalOperators | EntityFilterArrayOperators | EntityFilterSetOperators | EntityFilterLogicalOperators | EntityFilterUnaryOperators | EntityFilterExistenceOperators;
+export type EntityFilterOptions = FindEntityRelationalFilterOptions | FindEntityArrayFilterOptions | FindEntitySetFilterOptions | FindEntityLogicalFilterOptions | FindEntityUnaryFilterOptions | FindEntityExistenceFilterOptions;
+export type EntityNonRelationPropertyFilterOptions = FindEntityRelationalFilterOptions | FindEntityArrayFilterOptions | FindEntitySetFilterOptions | FindEntityUnaryFilterOptions;
 export interface FindEntityOptions {
     routeContext?: RouteContext;
     filters?: EntityFilterOptions[];
@@ -388,6 +389,12 @@ export interface FindEntityRelationalFilterOptions {
     operator: EntityFilterRelationalOperators;
     value: any;
 }
+export interface FindEntityArrayFilterOptions {
+    field: string;
+    operator: EntityFilterArrayOperators;
+    value: any[];
+    itemType?: string;
+}
 export interface FindEntitySetFilterOptions {
     field: string;
     operator: EntityFilterSetOperators;

package/package.json

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

package/src/dataAccess/columnTypeMapper.ts

@@ -0,0 +1,22 @@
+import { RpdDataPropertyTypes } from "~/types";
+import { DataAccessPgColumnTypes } from "./dataAccessTypes";
+
+export const pgPropertyTypeColumnMap: Record<Exclude<RpdDataPropertyTypes, "relation" | "relation[]">, DataAccessPgColumnTypes> = {
+  integer: "int4",
+  long: "int8",
+  float: "float4",
+  double: "float8",
+  decimal: "decimal",
+  text: "text",
+  boolean: "bool",
+  date: "date",
+  time: "time",
+  datetime: "timestamptz",
+  json: "jsonb",
+  option: "text",
+  "option[]": "text[]",
+  file: "jsonb",
+  "file[]": "jsonb",
+  image: "jsonb",
+  "image[]": "jsonb",
+};

package/src/dataAccess/dataAccessTypes.ts

@@ -1,3 +1,17 @@
+export type DataAccessPgColumnTypes =
+  | "int4"
+  | "int8"
+  | "float4"
+  | "float8"
+  | "decimal"
+  | "text"
+  | "text[]"
+  | "bool"
+  | "date"
+  | "time"
+  | "timestamptz"
+  | "jsonb";
+
 export type RowFilterRelationalOperators =
   | "eq"
   | "ne"
@@ -14,6 +28,8 @@ export type RowFilterRelationalOperators =
   | "endsWith"
   | "notEndsWith";
 
+export type RowFilterArrayOperators = "arrayContains" | "arrayOverlap";
+
 export type RowFilterSetOperators = "in" | "notIn";
 
 export type RowFilterLogicalOperators = "or" | "and";
@@ -24,6 +40,7 @@ export type RowFilterExistenceOperators = "exists" | "notExists";
 
 export type RowFilterOperators =
   | RowFilterRelationalOperators
+  | RowFilterArrayOperators
   | RowFilterSetOperators
   | RowFilterLogicalOperators
   | RowFilterUnaryOperators
@@ -31,12 +48,17 @@ export type RowFilterOperators =
 
 export type RowFilterOptions =
   | FindRowRelationalFilterOptions
+  | FindRowArrayFilterOptions
   | FindRowSetFilterOptions
   | FindRowLogicalFilterOptions
   | FindRowUnaryFilterOptions
   | FindRowExistenceFilterOptions;
 
-export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
+export type RowNonRelationPropertyFilterOptions =
+  | FindRowRelationalFilterOptions
+  | FindRowArrayFilterOptions
+  | FindRowSetFilterOptions
+  | FindRowUnaryFilterOptions;
 
 export type ColumnSelectOptions = string | ColumnNameWithTableName;
 
@@ -62,6 +84,13 @@ export interface FindRowRelationalFilterOptions {
   value: any;
 }
 
+export interface FindRowArrayFilterOptions {
+  field: ColumnSelectOptions;
+  operator: RowFilterArrayOperators;
+  value: any[];
+  itemType?: string;
+}
+
 export interface FindRowSetFilterOptions {
   field: ColumnSelectOptions;
   operator: RowFilterSetOperators;

package/src/dataAccess/entityManager.ts

@@ -31,6 +31,7 @@ import {
   getEntityPropertyByCode,
   getEntityPropertyByFieldName,
   isManyRelationProperty,
+  isOneRelationProperty,
   isRelationProperty,
 } from "../helpers/metaHelper";
 import { ColumnSelectOptions, CountRowOptions, FindRowOptions, FindRowOrderByOptions, RowFilterOptions } from "./dataAccessTypes";
@@ -520,13 +521,17 @@ async function convertEntityFiltersToRowFilters(
       }
     } else {
       const filterField = (filter as EntityNonRelationPropertyFilterOptions).field;
-      let property: RpdDataModelProperty = getEntityProperty(server, model, (property) => {
-        return property.code === filterField;
-      });
+      let property: RpdDataModelProperty = getEntityPropertyByCode(server, model, filterField);
 
       let columnName = "";
       if (property) {
-        columnName = property.columnName || property.code;
+        if (isOneRelationProperty(property)) {
+          columnName = property.targetIdColumnName;
+        } else if (isManyRelationProperty(property)) {
+          throw new Error(`Operator "${operator}" is not supported on many-relation property "${property.code}"`);
+        } else {
+          columnName = property.columnName || property.code;
+        }
       } else {
         property = getEntityProperty(server, model, (property) => {
           return property.columnName === filterField;

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -27,6 +27,8 @@ import * as listMetaRoutes from "./actionHandlers/listMetaRoutes";
 import * as getMetaModelDetail from "./actionHandlers/getMetaModelDetail";
 import { find, isString, map } from "lodash";
 import { getEntityPropertiesIncludingBase, getEntityPropertyByCode, isOneRelationProperty, isRelationProperty } from "~/helpers/metaHelper";
+import { DataAccessPgColumnTypes } from "~/dataAccess/dataAccessTypes";
+import { pgPropertyTypeColumnMap } from "~/dataAccess/columnTypeMapper";
 
 class MetaManager implements RapidPlugin {
   get code(): string {
@@ -484,18 +486,3 @@ function generateTableIndexDDL(queryBuilder: IQueryBuilder, server: IRpdServer,
 
   return ddl;
 }
-
-const pgPropertyTypeColumnMap: Partial<Record<RpdDataPropertyTypes, string>> = {
-  integer: "int4",
-  long: "int8",
-  float: "float4",
-  double: "float8",
-  decimal: "decimal",
-  text: "text",
-  boolean: "bool",
-  date: "date",
-  time: "time",
-  datetime: "timestamptz",
-  json: "jsonb",
-  option: "text",
-};

package/src/queryBuilder/queryBuilder.ts

@@ -13,7 +13,10 @@ import {
   UpdateRowOptions,
   ColumnSelectOptions,
   ColumnNameWithTableName,
+  DataAccessPgColumnTypes,
+  FindRowArrayFilterOptions,
 } from "~/dataAccess/dataAccessTypes";
+import { pgPropertyTypeColumnMap } from "~/dataAccess/columnTypeMapper";
 
 const objLeftQuoteChar = '"';
 const objRightQuoteChar = '"';
@@ -274,28 +277,28 @@ export default class QueryBuilder {
 
     command += this.quoteTable(model);
 
-    const propertyNames: string[] = Object.keys(entity);
+    const columnNames: string[] = Object.keys(entity);
     let values = "";
-    propertyNames.forEach((propertyName, index) => {
+    columnNames.forEach((columnName, index) => {
       if (index) {
         values += ", ";
       }
 
       let property: RpdDataModelProperty | null = null;
       if (model) {
-        property = find(model.properties, (e: RpdDataModelProperty) => e.code === propertyName);
+        property = find(model.properties, (e: RpdDataModelProperty) => (e.columnName || e.code) === columnName);
       }
-
-      if (property && property.type === "json") {
-        params.push(JSON.stringify(entity[propertyName]));
+      const columnType: DataAccessPgColumnTypes | null = property ? pgPropertyTypeColumnMap[property.type] : null;
+      if (columnType === "jsonb") {
+        params.push(JSON.stringify(entity[columnName]));
         values += `$${params.length}::jsonb`;
       } else {
-        params.push(entity[propertyName]);
+        params.push(entity[columnName]);
         values += `$${params.length}`;
       }
     });
 
-    command += ` (${propertyNames.map(this.quoteObject).join(", ")})`;
+    command += ` (${columnNames.map(this.quoteObject).join(", ")})`;
     command += ` VALUES (${values}) RETURNING *`;
 
     return {
@@ -319,23 +322,25 @@ export default class QueryBuilder {
     command += this.quoteTable(model);
 
     command += " SET ";
-    const propertyNames: string[] = Object.keys(entity);
-    propertyNames.forEach((propertyName, index) => {
+    const columnNames: string[] = Object.keys(entity);
+    columnNames.forEach((columnName, index) => {
       if (index) {
         command += ", ";
       }
 
+      command += `${this.quoteObject(columnName)}=`;
+
       let property: RpdDataModelProperty | null = null;
       if (model) {
-        property = find(model.properties, (e: RpdDataModelProperty) => (e.columnName || e.code) === propertyName);
+        property = find(model.properties, (e: RpdDataModelProperty) => (e.columnName || e.code) === columnName);
       }
-
-      if (property && property.type === "json") {
-        params.push(JSON.stringify(entity[propertyName]));
-        command += `${this.quoteObject(propertyName)}=$${params.length}::jsonb`;
+      const columnType: DataAccessPgColumnTypes | null = property ? pgPropertyTypeColumnMap[property.type] : null;
+      if (columnType === "jsonb") {
+        params.push(JSON.stringify(entity[columnName]));
+        command += `$${params.length}::jsonb`;
       } else {
-        params.push(entity[propertyName]);
-        command += `${this.quoteObject(propertyName)}=$${params.length}`;
+        params.push(entity[columnName]);
+        command += `$${params.length}`;
       }
     });
 
@@ -420,6 +425,10 @@ function buildFilterQuery(level: number, ctx: BuildQueryContext, filter: RowFilt
     return buildEndsWithFilterQuery(ctx, filter);
   } else if (operator === "notEndsWith") {
     return buildNotEndsWithFilterQuery(ctx, filter);
+  } else if (operator === "arrayContains") {
+    return buildArrayContainsFilterQuery(ctx, filter);
+  } else if (operator === "arrayOverlap") {
+    return buildArrayOverlapFilterQuery(ctx, filter);
   } else {
     throw new Error(`Filter operator '${operator}' is not supported.`);
   }
@@ -573,6 +582,36 @@ function buildRelationalFilterQuery(ctx: BuildQueryContext, filter: FindRowRelat
   return command;
 }
 
+function buildArrayContainsFilterQuery(ctx: BuildQueryContext, filter: FindRowArrayFilterOptions) {
+  let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
+
+  command += " @> ";
+
+  if (ctx.paramToLiteral) {
+    // TODO: implement it
+  } else {
+    ctx.params.push(filter.value);
+    command += "$" + ctx.params.length;
+  }
+
+  return command;
+}
+
+function buildArrayOverlapFilterQuery(ctx: BuildQueryContext, filter: FindRowArrayFilterOptions) {
+  let command = ctx.builder.quoteColumn(ctx.model, filter.field, ctx.emitTableAlias);
+
+  command += " && ";
+
+  if (ctx.paramToLiteral) {
+    // TODO: implement it
+  } else {
+    ctx.params.push(filter.value);
+    command += "$" + ctx.params.length;
+  }
+
+  return command;
+}
+
 function formatValueToSqlLiteral(value: any) {
   if (isNull(value) || isUndefined(value)) {
     return "null";

package/src/types.ts

@@ -316,7 +316,12 @@ export type RpdDataPropertyTypes =
   | "json"
   | "relation"
   | "relation[]"
-  | "option";
+  | "option"
+  | "option[]"
+  | "file"
+  | "file[]"
+  | "image"
+  | "image[]";
 
 /**
  * 数据字典
@@ -444,6 +449,8 @@ export type EntityFilterRelationalOperators =
   | "endsWith"
   | "notEndsWith";
 
+export type EntityFilterArrayOperators = "arrayContains" | "arrayOverlap";
+
 export type EntityFilterSetOperators = "in" | "notIn";
 
 export type EntityFilterLogicalOperators = "or" | "and";
@@ -454,6 +461,7 @@ export type EntityFilterExistenceOperators = "exists" | "notExists";
 
 export type EntityFilterOperators =
   | EntityFilterRelationalOperators
+  | EntityFilterArrayOperators
   | EntityFilterSetOperators
   | EntityFilterLogicalOperators
   | EntityFilterUnaryOperators
@@ -461,12 +469,17 @@ export type EntityFilterOperators =
 
 export type EntityFilterOptions =
   | FindEntityRelationalFilterOptions
+  | FindEntityArrayFilterOptions
   | FindEntitySetFilterOptions
   | FindEntityLogicalFilterOptions
   | FindEntityUnaryFilterOptions
   | FindEntityExistenceFilterOptions;
 
-export type EntityNonRelationPropertyFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityUnaryFilterOptions;
+export type EntityNonRelationPropertyFilterOptions =
+  | FindEntityRelationalFilterOptions
+  | FindEntityArrayFilterOptions
+  | FindEntitySetFilterOptions
+  | FindEntityUnaryFilterOptions;
 
 export interface FindEntityOptions {
   routeContext?: RouteContext;
@@ -493,6 +506,13 @@ export interface FindEntityRelationalFilterOptions {
   value: any;
 }
 
+export interface FindEntityArrayFilterOptions {
+  field: string;
+  operator: EntityFilterArrayOperators;
+  value: any[];
+  itemType?: string;
+}
+
 export interface FindEntitySetFilterOptions {
   field: string;
   operator: EntityFilterSetOperators;