@promakeai/orm 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -47,5 +47,6 @@ export type { TranslationQueryOptions, TranslationQueryResult, } from "./utils/t
 export { resolvePopulate, getPopulatableFields, validatePopulate, } from "./utils/populateResolver";
 export type { PopulateAdapter } from "./utils/populateResolver";
 export { parseJSONSchema } from "./utils/jsonConverter";
+export { isJsonType } from "./types";
 export { deserializeRow, serializeRow } from "./utils/deserializer";
-export type { FieldType, FieldDefinition, FieldReference, FieldBuilderLike, TableDefinition, LanguageConfig, SchemaDefinition, SchemaInput, JSONFieldDefinition, JSONTableDefinition, JSONSchemaDefinition, WhereCondition, OrderByOption, PopulateOption, PopulateNested, QueryOptions, PaginatedResult, ORMConfig, } from "./types";
+export type { FieldType, FieldDefinition, FieldReference, FieldBuilderLike, TableDefinition, LanguageConfig, SchemaDefinition, SchemaInput, JSONFieldType, JSONFieldDefinition, JSONTableDefinition, JSONSchemaDefinition, WhereCondition, OrderByOption, PopulateOption, PopulateNested, QueryOptions, PaginatedResult, ORMConfig, } from "./types";

package/dist/index.js

@@ -1,3 +1,8 @@
+// src/types.ts
+function isJsonType(type) {
+  return type === "json" || type === "string[]" || type === "number[]" || type === "boolean[]" || type === "object" || type === "object[]";
+}
+
 // src/utils/populateResolver.ts
 function getRefInfo(fieldName, field) {
   if (!field.ref)
@@ -9,7 +14,7 @@ function getRefInfo(fieldName, field) {
     field: isString ? "id" : ref.field || "id",
     localField: fieldName,
     targetField: isString ? "id" : ref.field || "id",
-    isArray: Array.isArray(field.default) || fieldName.endsWith("Ids")
+    isArray: isJsonType(field.type) || Array.isArray(field.default) || fieldName.endsWith("Ids")
   };
 }
 function toPopulatedName(fieldName) {
@@ -164,7 +169,10 @@ class ORM {
     const { populate, ...queryOpts } = opts;
     let records = await this.adapter.list(table, queryOpts);
     if (populate && this.schema) {
-      records = await this.resolvePopulateForRecords(records, table, populate);
+      records = await this.resolvePopulateForRecords(records, table, populate, {
+        lang: opts.lang,
+        fallbackLang: opts.fallbackLang
+      });
     }
     return records;
   }
@@ -173,7 +181,7 @@ class ORM {
     const { populate, ...queryOpts } = opts;
     const record = await this.adapter.get(table, id, queryOpts);
     if (record && populate && this.schema) {
-      const [populated] = await this.resolvePopulateForRecords([record], table, populate);
+      const [populated] = await this.resolvePopulateForRecords([record], table, populate, { lang: opts.lang, fallbackLang: opts.fallbackLang });
       return populated;
     }
     return record;
@@ -257,7 +265,7 @@ class ORM {
       throw new Error(`Table "${table}" not found in schema`);
     }
   }
-  async resolvePopulateForRecords(records, table, populate) {
+  async resolvePopulateForRecords(records, table, populate, queryOptions) {
     if (!this.schema)
       return records;
     const validation = validatePopulate(populate, table, this.schema);
@@ -266,7 +274,11 @@ class ORM {
     }
     const adapterWrapper = {
       findMany: (t, opts) => {
-        return this.adapter.list(t, opts);
+        return this.adapter.list(t, {
+          ...opts,
+          lang: queryOptions?.lang,
+          fallbackLang: queryOptions?.fallbackLang
+        });
       }
     };
     return resolvePopulate(records, table, populate, this.schema, adapterWrapper);
@@ -299,7 +311,7 @@ function getPrimaryKeyField(table) {
   return entry ? entry[0] : null;
 }
 function getReferenceFields(table) {
-  return Object.entries(table.fields).filter(([_, field]) => field.ref).map(([name, field]) => {
+  return Object.entries(table.fields).filter(([_, field]) => field.ref && !isJsonType(field.type)).map(([name, field]) => {
     const ref = field.ref;
     if (typeof ref === "string") {
       return [name, { table: ref, field: "id" }];
@@ -536,7 +548,20 @@ var f = {
   decimal: () => new FieldBuilder("decimal"),
   bool: () => new FieldBuilder("bool"),
   timestamp: () => new FieldBuilder("timestamp"),
-  json: () => new FieldBuilder("json")
+  json: () => new FieldBuilder("json"),
+  stringArray: () => new FieldBuilder("string[]"),
+  numberArray: () => new FieldBuilder("number[]"),
+  boolArray: () => new FieldBuilder("boolean[]"),
+  object: (properties) => {
+    const builder = new FieldBuilder("object");
+    builder["definition"].properties = properties;
+    return builder;
+  },
+  objectArray: (properties) => {
+    const builder = new FieldBuilder("object[]");
+    builder["definition"].properties = properties;
+    return builder;
+  }
 };
 
 // src/schema/defineSchema.ts
@@ -740,6 +765,20 @@ function processFieldOperators(field, operators) {
       params.push(value[0], value[1]);
     } else if (op === "$isNull") {
       parts.push(value ? `${field} IS NULL` : `${field} IS NOT NULL`);
+    } else if (op === "$contains") {
+      parts.push(`EXISTS (SELECT 1 FROM json_each(${field}) WHERE value = ?)`);
+      params.push(value);
+    } else if (op === "$containsAny") {
+      if (!Array.isArray(value)) {
+        throw new Error("$containsAny operator requires an array value");
+      }
+      if (value.length === 0) {
+        parts.push("0 = 1");
+      } else {
+        const placeholders = value.map(() => "?").join(", ");
+        parts.push(`EXISTS (SELECT 1 FROM json_each(${field}) WHERE value IN (${placeholders}))`);
+        params.push(...value);
+      }
     } else if (op === "$not") {
       if (typeof value !== "object" || value === null || Array.isArray(value)) {
         throw new Error("$not operator requires an object with operators");
@@ -984,6 +1023,22 @@ function parseJSONSchema(json) {
     tables
   };
 }
+function normalizeJsonType(type) {
+  if (Array.isArray(type)) {
+    const first = type[0];
+    if (typeof first === "string") {
+      const arrayType = `${first}[]`;
+      return { type: arrayType };
+    }
+    if (typeof first === "object" && first !== null) {
+      return { type: "object[]", properties: first };
+    }
+  }
+  if (typeof type === "object" && type !== null && !Array.isArray(type)) {
+    return { type: "object", properties: type };
+  }
+  return { type };
+}
 function convertJSONField(jsonField) {
   let ref;
   if (jsonField.ref) {
@@ -998,13 +1053,15 @@ function convertJSONField(jsonField) {
       };
     }
   }
+  const { type, properties } = normalizeJsonType(jsonField.type);
   return {
-    type: jsonField.type,
+    type,
     nullable: jsonField.nullable ?? !jsonField.required,
     unique: jsonField.unique ?? false,
     primary: jsonField.primary ?? false,
     default: jsonField.default,
     translatable: jsonField.translatable ?? false,
+    properties,
     ref
   };
 }
@@ -1015,7 +1072,7 @@ function deserializeValue(value, fieldType) {
   if (fieldType === "bool") {
     return value === 1 || value === true;
   }
-  if (fieldType === "json" && typeof value === "string") {
+  if (isJsonType(fieldType) && typeof value === "string") {
     try {
       return JSON.parse(value);
     } catch {
@@ -1039,7 +1096,7 @@ function serializeValue(value, fieldType) {
   if (fieldType === "bool") {
     return value ? 1 : 0;
   }
-  if (fieldType === "json" && typeof value !== "string") {
+  if (isJsonType(fieldType) && typeof value !== "string") {
     return JSON.stringify(value);
   }
   return value;
@@ -1073,6 +1130,7 @@ export {
   mergeSchemas,
   isValidSchema,
   isRequiredField,
+  isJsonType,
   hasTranslatableFields,
   getTranslationTableFields,
   getTranslatableFields,

package/dist/schema/fieldBuilder.d.ts

@@ -146,7 +146,43 @@ export declare const f: {
      */
     timestamp: () => FieldBuilder;
     /**
-     * JSON field (TEXT with JSON serialization)
+     * JSON field (TEXT with JSON serialization) — untyped, generates Record<string, unknown>
      */
     json: () => FieldBuilder;
+    /**
+     * String array field — stored as JSON TEXT, generates string[]
+     */
+    stringArray: () => FieldBuilder;
+    /**
+     * Number array field — stored as JSON TEXT, generates number[]
+     */
+    numberArray: () => FieldBuilder;
+    /**
+     * Boolean array field — stored as JSON TEXT, generates boolean[]
+     */
+    boolArray: () => FieldBuilder;
+    /**
+     * Typed object field — stored as JSON TEXT, generates typed interface
+     * @param properties - Property definitions. Keys ending with "?" are optional.
+     *   Values: "string" | "number" | "boolean"
+     *
+     * @example
+     * ```typescript
+     * f.object({ key: "string", value: "number" })
+     * // Generates: { key: string; value: number }
+     * ```
+     */
+    object: (properties: Record<string, string>) => FieldBuilder;
+    /**
+     * Typed object array field — stored as JSON TEXT, generates Array<{...}>
+     * @param properties - Property definitions. Keys ending with "?" are optional.
+     *   Values: "string" | "number" | "boolean"
+     *
+     * @example
+     * ```typescript
+     * f.objectArray({ id: "number", slug: "string", "name?": "string" })
+     * // Generates: Array<{ id: number; slug: string; name?: string }>
+     * ```
+     */
+    objectArray: (properties: Record<string, string>) => FieldBuilder;
 };

package/dist/types.d.ts

@@ -5,8 +5,16 @@
  */
 /**
  * Supported field types
+ *
+ * Primitive types map directly to SQL column types.
+ * Typed JSON types (string[], object[], etc.) store as TEXT in SQL
+ * but generate accurate TypeScript types.
+ */
+export type FieldType = "id" | "string" | "text" | "int" | "decimal" | "bool" | "timestamp" | "json" | "string[]" | "number[]" | "boolean[]" | "object" | "object[]";
+/**
+ * Check if a field type is JSON-like (stored as TEXT in SQL, serialized as JSON)
  */
-export type FieldType = "id" | "string" | "text" | "int" | "decimal" | "bool" | "timestamp" | "json";
+export declare function isJsonType(type: FieldType): boolean;
 /**
  * Foreign key reference definition (MongoDB-style)
  */
@@ -26,6 +34,7 @@ export interface FieldDefinition {
     primary: boolean;
     default?: unknown;
     translatable: boolean;
+    properties?: Record<string, string>;
     ref?: string | FieldReference;
     required?: boolean;
     trim?: boolean;
@@ -74,11 +83,21 @@ export interface SchemaInput {
     languages: string[] | LanguageConfig;
     tables: Record<string, Record<string, FieldBuilderLike>>;
 }
+/**
+ * JSON-native type syntax for schema.json
+ *
+ * Accepts:
+ * - string: primitive type ("string", "int", "json", etc.)
+ * - ["string"]: primitive array
+ * - [{ id: "number", name: "string" }]: typed object array
+ * - { key: "string", value: "number" }: typed object
+ */
+export type JSONFieldType = FieldType | [string] | [Record<string, string>] | Record<string, string>;
 /**
  * JSON Schema Field Definition
  */
 export interface JSONFieldDefinition {
-    type: FieldType;
+    type: JSONFieldType;
     translatable?: boolean;
     required?: boolean;
     unique?: boolean;
@@ -136,6 +155,8 @@ export interface WhereCondition {
     $notLike?: string;
     $between?: [unknown, unknown];
     $isNull?: boolean;
+    $contains?: unknown;
+    $containsAny?: unknown[];
     $not?: WhereCondition;
     $and?: WhereCondition[];
     $or?: WhereCondition[];

package/dist/utils/whereBuilder.d.ts

@@ -12,6 +12,7 @@
  * - Null: $isNull
  * - Negation: $not (field-level)
  * - Logical: $and, $or, $nor
+ * - JSON Array: $contains, $containsAny (for JSON array fields stored as TEXT)
  */
 export interface WhereResult {
     sql: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promakeai/orm",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Database-agnostic ORM core - works in browser and Node.js",
   "type": "module",
   "main": "./dist/index.js",

package/src/ORM.ts

@@ -100,7 +100,10 @@ export class ORM {
 
     // Resolve populate if schema is available
     if (populate && this.schema) {
-      records = await this.resolvePopulateForRecords(records, table, populate);
+      records = await this.resolvePopulateForRecords(records, table, populate, {
+        lang: opts.lang,
+        fallbackLang: opts.fallbackLang,
+      });
     }
 
     return records;
@@ -132,7 +135,8 @@ export class ORM {
       const [populated] = await this.resolvePopulateForRecords(
         [record],
         table,
-        populate
+        populate,
+        { lang: opts.lang, fallbackLang: opts.fallbackLang }
       );
       return populated;
     }
@@ -346,7 +350,8 @@ export class ORM {
   private async resolvePopulateForRecords<T>(
     records: T[],
     table: string,
-    populate: QueryOptions["populate"]
+    populate: QueryOptions["populate"],
+    queryOptions?: { lang?: string; fallbackLang?: string }
   ): Promise<T[]> {
     if (!this.schema) return records;
 
@@ -356,13 +361,17 @@ export class ORM {
       console.warn("Populate validation warnings:", validation.errors);
     }
 
-    // Create adapter wrapper for populate resolver
+    // Create adapter wrapper for populate resolver (passes lang for translations)
     const adapterWrapper = {
       findMany: <R = unknown>(
         t: string,
         opts?: { where?: Record<string, unknown> }
       ): Promise<R[]> => {
-        return this.adapter.list<R>(t, opts);
+        return this.adapter.list<R>(t, {
+          ...opts,
+          lang: queryOptions?.lang,
+          fallbackLang: queryOptions?.fallbackLang,
+        });
       },
     };
 

package/src/index.ts

@@ -116,6 +116,9 @@ export type { PopulateAdapter } from "./utils/populateResolver";
 // JSON Schema Converter
 export { parseJSONSchema } from "./utils/jsonConverter";
 
+// Type Helpers
+export { isJsonType } from "./types";
+
 // Row Serializer/Deserializer
 export { deserializeRow, serializeRow } from "./utils/deserializer";
 
@@ -134,6 +137,7 @@ export type {
   SchemaInput,
 
   // JSON Schema types (AI-friendly)
+  JSONFieldType,
   JSONFieldDefinition,
   JSONTableDefinition,
   JSONSchemaDefinition,

package/src/schema/fieldBuilder.ts

@@ -237,8 +237,57 @@ export const f = {
   timestamp: (): FieldBuilder => new FieldBuilder("timestamp"),
 
   /**
-   * JSON field (TEXT with JSON serialization)
+   * JSON field (TEXT with JSON serialization) — untyped, generates Record<string, unknown>
    */
   json: (): FieldBuilder => new FieldBuilder("json"),
+
+  /**
+   * String array field — stored as JSON TEXT, generates string[]
+   */
+  stringArray: (): FieldBuilder => new FieldBuilder("string[]"),
+
+  /**
+   * Number array field — stored as JSON TEXT, generates number[]
+   */
+  numberArray: (): FieldBuilder => new FieldBuilder("number[]"),
+
+  /**
+   * Boolean array field — stored as JSON TEXT, generates boolean[]
+   */
+  boolArray: (): FieldBuilder => new FieldBuilder("boolean[]"),
+
+  /**
+   * Typed object field — stored as JSON TEXT, generates typed interface
+   * @param properties - Property definitions. Keys ending with "?" are optional.
+   *   Values: "string" | "number" | "boolean"
+   *
+   * @example
+   * ```typescript
+   * f.object({ key: "string", value: "number" })
+   * // Generates: { key: string; value: number }
+   * ```
+   */
+  object: (properties: Record<string, string>): FieldBuilder => {
+    const builder = new FieldBuilder("object");
+    builder["definition"].properties = properties;
+    return builder;
+  },
+
+  /**
+   * Typed object array field — stored as JSON TEXT, generates Array<{...}>
+   * @param properties - Property definitions. Keys ending with "?" are optional.
+   *   Values: "string" | "number" | "boolean"
+   *
+   * @example
+   * ```typescript
+   * f.objectArray({ id: "number", slug: "string", "name?": "string" })
+   * // Generates: Array<{ id: number; slug: string; name?: string }>
+   * ```
+   */
+  objectArray: (properties: Record<string, string>): FieldBuilder => {
+    const builder = new FieldBuilder("object[]");
+    builder["definition"].properties = properties;
+    return builder;
+  },
 };
 

package/src/schema/schemaHelpers.ts

@@ -5,6 +5,7 @@
  */
 
 import type { TableDefinition, FieldDefinition, FieldReference } from "../types";
+import { isJsonType } from "../types";
 
 /**
  * Get names of translatable fields in a table
@@ -55,7 +56,7 @@ export function getReferenceFields(
   table: TableDefinition
 ): [string, FieldReference][] {
   return Object.entries(table.fields)
-    .filter(([_, field]) => field.ref)
+    .filter(([_, field]) => field.ref && !isJsonType(field.type))
     .map(([name, field]) => {
       const ref = field.ref!;
       // Normalize string to FieldReference

package/src/types.ts

@@ -8,6 +8,10 @@
 
 /**
  * Supported field types
+ *
+ * Primitive types map directly to SQL column types.
+ * Typed JSON types (string[], object[], etc.) store as TEXT in SQL
+ * but generate accurate TypeScript types.
  */
 export type FieldType =
   | "id"
@@ -17,7 +21,19 @@ export type FieldType =
   | "decimal"
   | "bool"
   | "timestamp"
-  | "json";
+  | "json"
+  | "string[]"
+  | "number[]"
+  | "boolean[]"
+  | "object"
+  | "object[]";
+
+/**
+ * Check if a field type is JSON-like (stored as TEXT in SQL, serialized as JSON)
+ */
+export function isJsonType(type: FieldType): boolean {
+  return type === "json" || type === "string[]" || type === "number[]" || type === "boolean[]" || type === "object" || type === "object[]";
+}
 
 /**
  * Foreign key reference definition (MongoDB-style)
@@ -40,6 +56,10 @@ export interface FieldDefinition {
   default?: unknown;
   translatable: boolean;
 
+  // Typed JSON properties (for "object" and "object[]" types)
+  // Keys ending with "?" are optional. Values: "string" | "number" | "boolean"
+  properties?: Record<string, string>;
+
   // Reference (MongoDB-style)
   ref?: string | FieldReference;
 
@@ -101,11 +121,26 @@ export interface SchemaInput {
 
 // ==================== JSON Schema Types (AI Agent Friendly) ====================
 
+/**
+ * JSON-native type syntax for schema.json
+ *
+ * Accepts:
+ * - string: primitive type ("string", "int", "json", etc.)
+ * - ["string"]: primitive array
+ * - [{ id: "number", name: "string" }]: typed object array
+ * - { key: "string", value: "number" }: typed object
+ */
+export type JSONFieldType =
+  | FieldType
+  | [string]
+  | [Record<string, string>]
+  | Record<string, string>;
+
 /**
  * JSON Schema Field Definition
  */
 export interface JSONFieldDefinition {
-  type: FieldType;
+  type: JSONFieldType;
   translatable?: boolean;
   required?: boolean;
   unique?: boolean;
@@ -176,6 +211,8 @@ export interface WhereCondition {
   $notLike?: string;
   $between?: [unknown, unknown];
   $isNull?: boolean;
+  $contains?: unknown;
+  $containsAny?: unknown[];
   $not?: WhereCondition;
   $and?: WhereCondition[];
   $or?: WhereCondition[];

package/src/utils/deserializer.ts

@@ -7,6 +7,7 @@
  */
 
 import type { FieldType, FieldDefinition } from "../types";
+import { isJsonType } from "../types";
 
 /**
  * Deserialize a single value from DB storage type to application type
@@ -18,7 +19,7 @@ function deserializeValue(value: unknown, fieldType: FieldType): unknown {
     return value === 1 || value === true;
   }
 
-  if (fieldType === "json" && typeof value === "string") {
+  if (isJsonType(fieldType) && typeof value === "string") {
     try {
       return JSON.parse(value);
     } catch {
@@ -61,7 +62,7 @@ function serializeValue(value: unknown, fieldType: FieldType): unknown {
     return value ? 1 : 0;
   }
 
-  if (fieldType === "json" && typeof value !== "string") {
+  if (isJsonType(fieldType) && typeof value !== "string") {
     return JSON.stringify(value);
   }
 

package/src/utils/jsonConverter.ts

@@ -8,8 +8,10 @@
 import type {
   JSONSchemaDefinition,
   JSONFieldDefinition,
+  JSONFieldType,
   SchemaDefinition,
   FieldDefinition,
+  FieldType,
   TableDefinition,
   LanguageConfig,
 } from "../types";
@@ -63,6 +65,40 @@ export function parseJSONSchema(json: JSONSchemaDefinition): SchemaDefinition {
   };
 }
 
+/**
+ * Normalize JSON-native type syntax to internal FieldType + properties
+ *
+ * - ["string"]              → type: "string[]"
+ * - ["number"]              → type: "number[]"
+ * - ["boolean"]             → type: "boolean[]"
+ * - [{ id: "number", ... }] → type: "object[]", properties: { id: "number", ... }
+ * - { key: "string", ... }  → type: "object", properties: { key: "string", ... }
+ * - "string" / "json" / ... → pass through as-is
+ */
+function normalizeJsonType(type: JSONFieldType): { type: FieldType; properties?: Record<string, string> } {
+  // Array syntax: ["string"] or [{ ... }]
+  if (Array.isArray(type)) {
+    const first = type[0];
+    if (typeof first === "string") {
+      // Primitive array: ["string"] → "string[]"
+      const arrayType = `${first}[]` as FieldType;
+      return { type: arrayType };
+    }
+    if (typeof first === "object" && first !== null) {
+      // Object array: [{ id: "number", ... }] → "object[]" + properties
+      return { type: "object[]", properties: first as Record<string, string> };
+    }
+  }
+
+  // Object syntax: { key: "string", ... } → "object" + properties
+  if (typeof type === "object" && type !== null && !Array.isArray(type)) {
+    return { type: "object", properties: type as Record<string, string> };
+  }
+
+  // String: pass through as-is
+  return { type: type as FieldType };
+}
+
 /**
  * Convert single JSON field to internal FieldDefinition
  */
@@ -82,13 +118,16 @@ function convertJSONField(jsonField: JSONFieldDefinition): FieldDefinition {
     }
   }
 
+  const { type, properties } = normalizeJsonType(jsonField.type);
+
   return {
-    type: jsonField.type,
+    type,
     nullable: jsonField.nullable ?? !jsonField.required,
     unique: jsonField.unique ?? false,
     primary: jsonField.primary ?? false,
     default: jsonField.default,
     translatable: jsonField.translatable ?? false,
+    properties,
     ref,
   };
 }

package/src/utils/populateResolver.ts

@@ -31,6 +31,7 @@ import type {
   PopulateOption,
   PopulateNested,
 } from "../types";
+import { isJsonType } from "../types";
 
 /**
  * Adapter interface for fetching records
@@ -79,7 +80,7 @@ function getRefInfo(
     field: isString ? "id" : ref.field || "id",
     localField: fieldName,
     targetField: isString ? "id" : ref.field || "id",
-    isArray: Array.isArray(field.default) || fieldName.endsWith("Ids"),
+    isArray: isJsonType(field.type) || Array.isArray(field.default) || fieldName.endsWith("Ids"),
   };
 }
 

package/src/utils/whereBuilder.ts

@@ -12,6 +12,7 @@
  * - Null: $isNull
  * - Negation: $not (field-level)
  * - Logical: $and, $or, $nor
+ * - JSON Array: $contains, $containsAny (for JSON array fields stored as TEXT)
  */
 
 export interface WhereResult {
@@ -68,6 +69,22 @@ function processFieldOperators(
       params.push(value[0], value[1]);
     } else if (op === "$isNull") {
       parts.push(value ? `${field} IS NULL` : `${field} IS NOT NULL`);
+    } else if (op === "$contains") {
+      // JSON array contains a single value: EXISTS (SELECT 1 FROM json_each(field) WHERE value = ?)
+      parts.push(`EXISTS (SELECT 1 FROM json_each(${field}) WHERE value = ?)`);
+      params.push(value);
+    } else if (op === "$containsAny") {
+      // JSON array contains any of the values: EXISTS (SELECT 1 FROM json_each(field) WHERE value IN (?, ?))
+      if (!Array.isArray(value)) {
+        throw new Error("$containsAny operator requires an array value");
+      }
+      if (value.length === 0) {
+        parts.push("0 = 1");
+      } else {
+        const placeholders = value.map(() => "?").join(", ");
+        parts.push(`EXISTS (SELECT 1 FROM json_each(${field}) WHERE value IN (${placeholders}))`);
+        params.push(...value);
+      }
     } else if (op === "$not") {
       if (typeof value !== "object" || value === null || Array.isArray(value)) {
         throw new Error("$not operator requires an object with operators");