prisma-arktype 2.4.0 → 2.5.1

package/README.md

@@ -132,6 +132,216 @@ const whereResult = UserWhere(whereClause);
 // ...
 ```
 
+## Where Clause Filters
+
+Where clauses support advanced filtering through dedicated filter types. Fields can accept either direct values or filter objects with comparison operators.
+
+### Filter Types
+
+#### String Filters
+
+String fields can use `StringFilter` for advanced text filtering:
+
+```typescript
+import { UserWhere } from "./generated/validators";
+
+// Direct value
+const result1 = UserWhere({ email: "user@example.com" });
+
+// Filter object
+const result2 = UserWhere({
+  email: {
+    contains: "example",      // Contains substring
+    startsWith: "user",       // Starts with prefix
+    endsWith: ".com",         // Ends with suffix
+    equals: "user@example.com", // Exact match
+    not: "admin@example.com", // Not equal to
+    in: ["user1@example.com", "user2@example.com"], // In array
+    notIn: ["banned@example.com"], // Not in array
+    gt: "a",                  // Greater than (lexicographic)
+    gte: "a",                 // Greater than or equal
+    lt: "z",                  // Less than
+    lte: "z"                  // Less than or equal
+  }
+});
+```
+
+**Available operations:** `contains`, `startsWith`, `endsWith`, `equals`, `not`, `in`, `notIn`, `gt`, `gte`, `lt`, `lte`
+
+#### Number Filters
+
+Integer fields (`Int`, `BigInt`) use `IntFilter`, while floating-point fields (`Float`, `Decimal`) use `NumberFilter`:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+// Direct value
+const result1 = PostWhere({ views: 100 });
+
+// Filter object for integers
+const result2 = PostWhere({
+  views: {
+    equals: 100,
+    gt: 50,                   // Greater than
+    gte: 50,                  // Greater than or equal
+    lt: 200,                  // Less than
+    lte: 200,                 // Less than or equal
+    in: [100, 200, 300],      // In array
+    notIn: [0],               // Not in array
+    not: 0                    // Not equal to
+  }
+});
+
+// Filter object for floats/decimals
+const result3 = PostWhere({
+  rating: {
+    gte: 4.5,
+    lte: 5.0
+  }
+});
+```
+
+**Available operations:** `equals`, `gt`, `gte`, `lt`, `lte`, `in`, `notIn`, `not`
+
+#### Boolean Filters
+
+Boolean fields use `BooleanFilter`:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+// Direct value
+const result1 = PostWhere({ published: true });
+
+// Filter object
+const result2 = PostWhere({
+  published: {
+    equals: true,
+    not: false
+  }
+});
+```
+
+**Available operations:** `equals`, `not`
+
+#### Enum Filters
+
+Enum fields use the generic `enumFilter`:
+
+```typescript
+import { PaymentWhere } from "./generated/validators";
+
+// Direct enum value
+const result1 = PaymentWhere({ currency: "USD" });
+
+// Filter object
+const result2 = PaymentWhere({
+  currency: {
+    equals: "USD",
+    in: ["USD", "EUR", "GBP"],
+    notIn: ["JPY"],
+    not: "CAD"
+  }
+});
+```
+
+**Available operations:** `equals`, `in`, `notIn`, `not`
+
+#### DateTime Filters
+
+DateTime fields use `DateTimeFilter`:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+// Direct Date value
+const result1 = PostWhere({ createdAt: new Date("2024-01-01") });
+
+// Filter object
+const result2 = PostWhere({
+  createdAt: {
+    equals: new Date("2024-01-01"),
+    gt: new Date("2024-01-01"),   // After
+    gte: new Date("2024-01-01"),  // On or after
+    lt: new Date("2024-12-31"),   // Before
+    lte: new Date("2024-12-31"),  // On or before
+    in: [new Date("2024-01-01"), new Date("2024-06-01")],
+    notIn: [new Date("2024-07-04")],
+    not: new Date("2024-01-01")
+  }
+});
+```
+
+**Available operations:** `equals`, `gt`, `gte`, `lt`, `lte`, `in`, `notIn`, `not`
+
+#### Array Filters
+
+Array fields use specialized array filters with operations for list matching:
+
+```typescript
+import { TagWhere } from "./generated/validators";
+
+// String arrays
+const result1 = TagWhere({
+  labels: {
+    isEmpty: false,           // Array is empty
+    has: "important",         // Array contains value
+    hasEvery: ["tag1", "tag2"], // Array contains all values
+    hasSome: ["tag1", "tag2"],  // Array contains at least one value
+    equals: ["exact", "match"]  // Array exactly matches
+  }
+});
+
+// Number arrays
+const result2 = ScoresWhere({
+  values: {
+    isEmpty: false,
+    has: 100,
+    hasEvery: [90, 95, 100],
+    hasSome: [100, 200],
+    equals: [90, 95, 100]
+  }
+});
+
+// Enum arrays
+const result3 = PermissionsWhere({
+  roles: {
+    isEmpty: false,
+    has: "ADMIN",
+    hasEvery: ["USER", "ADMIN"],
+    hasSome: ["ADMIN", "MODERATOR"],
+    equals: ["USER"]
+  }
+});
+```
+
+**Available array filter types:**
+- `StringArrayFilter` - for `String[]` fields
+- `NumberArrayFilter` - for `Int[]`, `Float[]`, `Decimal[]` fields
+- `BigIntArrayFilter` - for `BigInt[]` fields
+- `arrayFilter(EnumType)` - for enum array fields
+
+**Available operations:** `isEmpty`, `has`, `hasEvery`, `hasSome`, `equals`
+
+### Combining Filters
+
+You can combine multiple filters in a single where clause:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+const complexQuery = PostWhere({
+  title: { contains: "TypeScript" },
+  views: { gte: 100 },
+  published: true,
+  rating: { gte: 4.0 },
+  createdAt: {
+    gte: new Date("2024-01-01"),
+    lt: new Date("2024-12-31")
+  }
+});
+```
+
 ### Generated Code Examples
 
 #### Enum Generation

package/dist/index.js

@@ -2,7 +2,9 @@
 import { writeFile, access, rm, mkdir } from 'node:fs/promises';
 import generatorHelperPkg from '@prisma/generator-helper';
 import { type, ArkErrors } from 'arktype';
-import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
 
 const configSchema = type({
   output: "string = './prisma/generated/validators'",
@@ -151,6 +153,21 @@ function extractAnnotations(documentation) {
   };
 }
 
+const require = createRequire(import.meta.url);
+function isPrismaV7OrHigher() {
+  try {
+    const prismaClientPath = require.resolve("@prisma/client");
+    const clientDir = dirname(prismaClientPath);
+    const packageJsonPath = join(clientDir, "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const version = packageJson.version;
+    const majorVersion = Number.parseInt(version.split(".")[0], 10);
+    return majorVersion >= 7;
+  } catch {
+    return false;
+  }
+}
+const IS_PRISMA_V7_OR_HIGHER = isPrismaV7OrHigher();
 const primitiveTypes = [
   "Int",
   "BigInt",
@@ -182,7 +199,10 @@ function stringifyPrimitiveType(type, annotations) {
     case "Boolean":
       return `"boolean"`;
     case "Bytes":
-      return `"instanceof Buffer"`;
+      if (IS_PRISMA_V7_OR_HIGHER) {
+        return "Uint8ArrayInstance";
+      }
+      return "BufferInstance";
     default:
       throw new Error(`Unsupported primitive type: ${type}`);
   }
@@ -218,6 +238,7 @@ function stringifyEnum(enumData) {
 }
 
 const processedPlain = [];
+const extRegex$1 = /\.(ts|js)$/;
 function processPlain(models) {
   for (const model of models) {
     const result = stringifyPlain(model);
@@ -226,7 +247,8 @@ function processPlain(models) {
         name: model.name,
         stringified: result.stringified,
         enumDependencies: result.enumDependencies,
-        externalSchemaDependencies: result.externalSchemaDependencies
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
   }
@@ -234,17 +256,16 @@ function processPlain(models) {
 }
 function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
   const config = getConfig();
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
   const fields = [];
   const enumDependencies = [];
   const externalSchemaDependencies = [];
+  const runtimeDependencies = [];
   function generateUniqueAlias(path, exportName, fieldName) {
-    const baseName = exportName || path.split("/").pop()?.replace(/\.(ts|js)$/, "") || "Schema";
+    const baseName = exportName || path.split("/").pop()?.replace(extRegex$1, "") || "Schema";
     const suffix = fieldName ? `_${fieldName}` : "";
     return `${baseName}${suffix}`;
   }
@@ -309,15 +330,22 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     }
     const isEnumType = field.kind === "enum" && !typeOverwrite && !schemaAnnotation;
     const isExternalSchema = schemaAnnotation?.isExternal === true;
+    const isBytesField = field.type === "Bytes" && !typeOverwrite && !schemaAnnotation;
+    if (isBytesField) {
+      const runtimeDep = fieldType;
+      if (!runtimeDependencies.includes(runtimeDep)) {
+        runtimeDependencies.push(runtimeDep);
+      }
+    }
     if (field.isList) {
-      if (isExternalSchema || isEnumType) {
+      if (isExternalSchema || isEnumType || isBytesField) {
         fieldType = `${fieldType}.array()`;
       } else {
         fieldType = `"${wrapPrimitiveWithArray(fieldType.slice(1, -1))}"`;
       }
     }
     if (!field.isRequired) {
-      if (isExternalSchema || isEnumType) {
+      if (isExternalSchema || isEnumType || isBytesField) {
         fieldType = `${fieldType}.or("null")`;
       } else {
         const inner = fieldType.slice(1, -1);
@@ -337,7 +365,8 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
   ${fields.join(",\n  ")}
 }`,
     enumDependencies,
-    externalSchemaDependencies
+    externalSchemaDependencies,
+    runtimeDependencies
   };
 }
 function stringifyPlainInputCreate(model) {
@@ -358,7 +387,8 @@ function processCreate(models) {
         name: model.name,
         stringified: result.stringified,
         enumDependencies: result.enumDependencies,
-        externalSchemaDependencies: result.externalSchemaDependencies
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
   }
@@ -379,9 +409,7 @@ function processInclude(models) {
   Object.freeze(processedInclude);
 }
 function stringifyInclude(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -415,9 +443,7 @@ function processOrderBy(models) {
   Object.freeze(processedOrderBy);
 }
 function stringifyOrderBy(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -451,9 +477,7 @@ function processRelations(models) {
   Object.freeze(processedRelations);
 }
 function stringifyRelations(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -500,9 +524,7 @@ function processRelationsCreate(models) {
   Object.freeze(processedRelationsCreate);
 }
 function stringifyRelationsInputCreate(model, allModels) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -547,9 +569,7 @@ function processRelationsUpdate(models) {
   Object.freeze(processedRelationsUpdate);
 }
 function stringifyRelationsInputUpdate(model, allModels) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -634,7 +654,8 @@ function processUpdate(models) {
         name: model.name,
         stringified: result.stringified,
         enumDependencies: result.enumDependencies,
-        externalSchemaDependencies: result.externalSchemaDependencies
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
   }
@@ -652,7 +673,8 @@ function processWhere(models) {
         name: model.name,
         stringified: result.stringified,
         enumDependencies: result.enumDependencies,
-        externalSchemaDependencies: result.externalSchemaDependencies
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
     const uniqueResult = stringifyWhereUnique(model);
@@ -661,7 +683,8 @@ function processWhere(models) {
         name: model.name,
         stringified: uniqueResult.stringified,
         enumDependencies: uniqueResult.enumDependencies,
-        externalSchemaDependencies: uniqueResult.externalSchemaDependencies
+        externalSchemaDependencies: uniqueResult.externalSchemaDependencies,
+        runtimeDependencies: uniqueResult.runtimeDependencies
       });
     }
   }
@@ -676,6 +699,7 @@ function stringifyWhere(model) {
   const fields = [];
   const enumDependencies = [];
   const externalSchemaDependencies = [];
+  const runtimeDependencies = [];
   function generateUniqueAlias(path, exportName, fieldName) {
     const baseName = exportName || path.split("/").pop()?.replace(extRegex, "") || "Schema";
     const suffix = fieldName ? `_${fieldName}` : "";
@@ -729,14 +753,82 @@ function stringifyWhere(model) {
     }
     const isEnumType = field.kind === "enum" && !typeOverwrite && !schemaAnnotation;
     const isExternalSchema = schemaAnnotation?.isExternal === true;
+    const isDateTimeField = field.type === "DateTime" && !typeOverwrite && !schemaAnnotation;
+    const isStringField = field.type === "String" && !typeOverwrite && !schemaAnnotation;
+    const isIntField = (field.type === "Int" || field.type === "BigInt") && !typeOverwrite && !schemaAnnotation;
+    const isFloatField = (field.type === "Float" || field.type === "Decimal") && !typeOverwrite && !schemaAnnotation;
+    const isBooleanField = field.type === "Boolean" && !typeOverwrite && !schemaAnnotation;
+    const isBytesField = field.type === "Bytes" && !typeOverwrite && !schemaAnnotation;
+    if (isBytesField) {
+      const runtimeDep = fieldType;
+      if (!runtimeDependencies.includes(runtimeDep)) {
+        runtimeDependencies.push(runtimeDep);
+      }
+    }
     if (field.isList) {
-      if (isExternalSchema || isEnumType) {
+      if (isEnumType) {
+        fieldType = `arrayFilter(${fieldType})`;
+        if (!runtimeDependencies.includes("arrayFilter")) {
+          runtimeDependencies.push("arrayFilter");
+        }
+      } else if (field.type === "String" && !typeOverwrite && !schemaAnnotation) {
+        fieldType = "StringArrayFilter";
+        if (!runtimeDependencies.includes("StringArrayFilter")) {
+          runtimeDependencies.push("StringArrayFilter");
+        }
+      } else if ((field.type === "Int" || field.type === "Float" || field.type === "Decimal") && !typeOverwrite && !schemaAnnotation) {
+        fieldType = "NumberArrayFilter";
+        if (!runtimeDependencies.includes("NumberArrayFilter")) {
+          runtimeDependencies.push("NumberArrayFilter");
+        }
+      } else if (field.type === "BigInt" && !typeOverwrite && !schemaAnnotation) {
+        fieldType = "BigIntArrayFilter";
+        if (!runtimeDependencies.includes("BigIntArrayFilter")) {
+          runtimeDependencies.push("BigIntArrayFilter");
+        }
+      } else if (isExternalSchema || isBytesField) {
         fieldType = `${fieldType}.array()`;
       } else {
         const inner = fieldType.slice(1, -1);
         fieldType = `"${wrapPrimitiveWithArray(inner)}"`;
       }
     }
+    if (isDateTimeField && !field.isList) {
+      fieldType = `type("Date").or(DateTimeFilter)`;
+      if (!runtimeDependencies.includes("DateTimeFilter")) {
+        runtimeDependencies.push("DateTimeFilter");
+      }
+    }
+    if (isStringField && !field.isList) {
+      fieldType = `type("string").or(StringFilter)`;
+      if (!runtimeDependencies.includes("StringFilter")) {
+        runtimeDependencies.push("StringFilter");
+      }
+    }
+    if (isIntField && !field.isList) {
+      fieldType = `type("number.integer").or(IntFilter)`;
+      if (!runtimeDependencies.includes("IntFilter")) {
+        runtimeDependencies.push("IntFilter");
+      }
+    }
+    if (isFloatField && !field.isList) {
+      fieldType = `type("number").or(NumberFilter)`;
+      if (!runtimeDependencies.includes("NumberFilter")) {
+        runtimeDependencies.push("NumberFilter");
+      }
+    }
+    if (isEnumType && !field.isList) {
+      fieldType = `type(${fieldType}).or(enumFilter(${fieldType}))`;
+      if (!runtimeDependencies.includes("enumFilter")) {
+        runtimeDependencies.push("enumFilter");
+      }
+    }
+    if (isBooleanField && !field.isList) {
+      fieldType = `type("boolean").or(BooleanFilter)`;
+      if (!runtimeDependencies.includes("BooleanFilter")) {
+        runtimeDependencies.push("BooleanFilter");
+      }
+    }
     fields.push(`"${field.name}?": ${fieldType}`);
   }
   return {
@@ -744,7 +836,8 @@ function stringifyWhere(model) {
   ${fields.join(",\n  ")}
 }`,
     enumDependencies,
-    externalSchemaDependencies
+    externalSchemaDependencies,
+    runtimeDependencies
   };
 }
 function stringifyWhereUnique(model) {
@@ -755,6 +848,7 @@ function stringifyWhereUnique(model) {
   const fields = [];
   const enumDependencies = [];
   const externalSchemaDependencies = [];
+  const runtimeDependencies = [];
   function generateUniqueAlias(path, exportName, fieldName) {
     const baseName = exportName || path.split("/").pop()?.replace(extRegex, "") || "Schema";
     const suffix = fieldName ? `_${fieldName}` : "";
@@ -807,6 +901,20 @@ function stringifyWhereUnique(model) {
     } else {
       continue;
     }
+    const isDateTimeField = field.type === "DateTime" && !typeOverwrite && !schemaAnnotation;
+    const isBytesField = field.type === "Bytes" && !typeOverwrite && !schemaAnnotation;
+    if (isBytesField) {
+      const runtimeDep = fieldType;
+      if (!runtimeDependencies.includes(runtimeDep)) {
+        runtimeDependencies.push(runtimeDep);
+      }
+    }
+    if (isDateTimeField) {
+      fieldType = `type("Date").or(DateTimeFilter)`;
+      if (!runtimeDependencies.includes("DateTimeFilter")) {
+        runtimeDependencies.push("DateTimeFilter");
+      }
+    }
     fields.push(`"${field.name}?": ${fieldType}`);
   }
   if (fields.length === 0) {
@@ -817,7 +925,8 @@ function stringifyWhereUnique(model) {
   ${fields.join(",\n  ")}
 }`,
     enumDependencies,
-    externalSchemaDependencies
+    externalSchemaDependencies,
+    runtimeDependencies
   };
 }
 
@@ -852,6 +961,38 @@ function generateExternalSchemaImports(externalSchemaDependencies) {
   }).join("\n")}
 `;
 }
+const RUNTIME_DEPENDENCY_IMPORTS = {
+  DateTimeFilter: `import { DateTimeFilter } from "prisma-arktype/runtime/filters";
+`,
+  StringFilter: `import { StringFilter } from "prisma-arktype/runtime/stringFilter";
+`,
+  NumberFilter: `import { NumberFilter } from "prisma-arktype/runtime/numberFilter";
+`,
+  IntFilter: `import { IntFilter } from "prisma-arktype/runtime/numberFilter";
+`,
+  BooleanFilter: `import { BooleanFilter } from "prisma-arktype/runtime/booleanFilter";
+`,
+  enumFilter: `import { enumFilter } from "prisma-arktype/runtime/enumFilter";
+`,
+  BufferInstance: `import { BufferInstance } from "prisma-arktype/runtime/buffer";
+`,
+  Uint8ArrayInstance: `import { Uint8ArrayInstance } from "prisma-arktype/runtime/uint8array";
+`,
+  arrayFilter: `import { arrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`,
+  StringArrayFilter: `import { StringArrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`,
+  NumberArrayFilter: `import { NumberArrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`,
+  BigIntArrayFilter: `import { BigIntArrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`
+};
+function generateRuntimeDependencyImports(runtimeDependencies) {
+  if (!runtimeDependencies || runtimeDependencies.length === 0) {
+    return "";
+  }
+  return runtimeDependencies.map((dep) => RUNTIME_DEPENDENCY_IMPORTS[dep]).join("");
+}
 function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations, processedWhere, processedWhereUnique, processedCreate, processedUpdate, processedRelationsCreate, processedRelationsUpdate, processedSelect, processedInclude, processedOrderBy) {
   const config = getConfig();
   const modelMap = /* @__PURE__ */ new Map();
@@ -868,7 +1009,10 @@ function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations
     const externalSchemaImports = generateExternalSchemaImports(
       model.externalSchemaDependencies
     );
-    const content = `${arktypeImport}${enumImports}${externalSchemaImports}export const ${model.name}Plain = type(${model.stringified});
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Plain = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Plain`, content);
   }
@@ -900,7 +1044,10 @@ export const ${plain.name} = ${plain.name}Plain;
     const externalSchemaImports = generateExternalSchemaImports(
       model.externalSchemaDependencies
     );
-    const content = `${arktypeImport}${enumImports}${externalSchemaImports}export const ${model.name}Where = type(${model.stringified});
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Where = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Where`, content);
   }
@@ -909,7 +1056,10 @@ export const ${plain.name} = ${plain.name}Plain;
     const externalSchemaImports = generateExternalSchemaImports(
       model.externalSchemaDependencies
     );
-    const content = `${arktypeImport}${enumImports}${externalSchemaImports}export const ${model.name}WhereUnique = type(${model.stringified});
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}WhereUnique = type(${model.stringified});
 `;
     modelMap.set(`${model.name}WhereUnique`, content);
   }
@@ -918,7 +1068,10 @@ export const ${plain.name} = ${plain.name}Plain;
     const externalSchemaImports = generateExternalSchemaImports(
       model.externalSchemaDependencies
     );
-    const content = `${arktypeImport}${enumImports}${externalSchemaImports}export const ${model.name}Create = type(${model.stringified});
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Create = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Create`, content);
   }
@@ -927,7 +1080,10 @@ export const ${plain.name} = ${plain.name}Plain;
     const externalSchemaImports = generateExternalSchemaImports(
       model.externalSchemaDependencies
     );
-    const content = `${arktypeImport}${enumImports}${externalSchemaImports}export const ${model.name}Update = type(${model.stringified});
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Update = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Update`, content);
   }

package/dist/runtime/arrayFilters.d.ts

@@ -0,0 +1,46 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import * as arktype from 'arktype';
+
+/**
+ * @description Generic array filter for Prisma where clauses
+ * Supports: isEmpty, has, hasEvery, hasSome, equals
+ */
+declare const arrayFilter: arktype.Generic<[["t", unknown]], {
+    readonly "isEmpty?": "boolean";
+    readonly "has?": "t";
+    readonly "hasEvery?": "t[]";
+    readonly "hasSome?": "t[]";
+    readonly "equals?": "t[]";
+}, {}, {}>;
+/**
+ * @description String array filter for Prisma where clauses
+ */
+declare const StringArrayFilter: arktype_internal_variants_object_ts.ObjectType<{
+    isEmpty?: boolean;
+    has?: string;
+    hasEvery?: string[];
+    hasSome?: string[];
+    equals?: string[];
+}, {}>;
+/**
+ * @description Number array filter for Prisma where clauses
+ */
+declare const NumberArrayFilter: arktype_internal_variants_object_ts.ObjectType<{
+    isEmpty?: boolean;
+    has?: number;
+    hasEvery?: number[];
+    hasSome?: number[];
+    equals?: number[];
+}, {}>;
+/**
+ * @description BigInt array filter for Prisma where clauses
+ */
+declare const BigIntArrayFilter: arktype_internal_variants_object_ts.ObjectType<{
+    isEmpty?: boolean;
+    has?: number;
+    hasEvery?: number[];
+    hasSome?: number[];
+    equals?: number[];
+}, {}>;
+
+export { BigIntArrayFilter, NumberArrayFilter, StringArrayFilter, arrayFilter };

package/dist/runtime/arrayFilters.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+
+const arrayFilter = type("<t>", {
+  "isEmpty?": "boolean",
+  "has?": "t",
+  "hasEvery?": "t[]",
+  "hasSome?": "t[]",
+  "equals?": "t[]"
+});
+const StringArrayFilter = arrayFilter("string");
+const NumberArrayFilter = arrayFilter("number");
+const BigIntArrayFilter = arrayFilter("number.integer");
+
+export { BigIntArrayFilter, NumberArrayFilter, StringArrayFilter, arrayFilter };

package/dist/runtime/booleanFilter.d.ts

@@ -0,0 +1,12 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Boolean filter for Prisma where clauses
+ * Supports: equals, not
+ */
+declare const BooleanFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: boolean;
+    not?: boolean;
+}, {}>;
+
+export { BooleanFilter };

package/dist/runtime/booleanFilter.js

@@ -0,0 +1,8 @@
+import { type } from 'arktype';
+
+const BooleanFilter = type({
+  "equals?": "boolean",
+  "not?": "boolean"
+});
+
+export { BooleanFilter };

package/dist/runtime/buffer.d.ts

@@ -0,0 +1,8 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Buffer instance type
+ */
+declare const BufferInstance: arktype_internal_variants_object_ts.ObjectType<Buffer<ArrayBufferLike>, {}>;
+
+export { BufferInstance };

package/dist/runtime/buffer.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+
+const BufferInstance = type("unknown").narrow(
+  (value, ctx) => {
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+      return true;
+    } else if (typeof Buffer === "undefined") {
+      ctx.errors.add(ctx.error("Buffer is not defined in this environment"));
+    }
+    return ctx.mustBe("an instance of Buffer");
+  }
+);
+
+export { BufferInstance };

package/dist/runtime/enumFilter.d.ts

@@ -0,0 +1,14 @@
+import * as arktype from 'arktype';
+
+/**
+ * @description Generic enum filter for Prisma where clauses
+ * Supports: equals, in, not, notIn
+ */
+declare const enumFilter: arktype.Generic<[["t", unknown]], {
+    readonly "equals?": "t";
+    readonly "in?": "t[]";
+    readonly "not?": "t";
+    readonly "notIn?": "t[]";
+}, {}, {}>;
+
+export { enumFilter };

package/dist/runtime/enumFilter.js

@@ -0,0 +1,10 @@
+import { type } from 'arktype';
+
+const enumFilter = type("<t>", {
+  "equals?": "t",
+  "in?": "t[]",
+  "not?": "t",
+  "notIn?": "t[]"
+});
+
+export { enumFilter };

package/dist/runtime/filters.d.ts

@@ -0,0 +1,19 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * DateTimeFilter allows querying DateTime fields with comparison operators.
+ * Can be used instead of a direct Date value in where clauses.
+ */
+declare const DateTimeFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: Date;
+    in?: Date[];
+    notIn?: Date[];
+    lt?: Date;
+    lte?: Date;
+    gt?: Date;
+    gte?: Date;
+    not?: Date;
+}, {}>;
+type DateTimeFilter = typeof DateTimeFilter.infer;
+
+export { DateTimeFilter };

package/dist/runtime/filters.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+
+const DateTimeFilter = type({
+  "equals?": "Date",
+  "in?": "Date[]",
+  "notIn?": "Date[]",
+  "lt?": "Date",
+  "lte?": "Date",
+  "gt?": "Date",
+  "gte?": "Date",
+  "not?": "Date"
+});
+
+export { DateTimeFilter };

package/dist/runtime/numberFilter.d.ts

@@ -0,0 +1,32 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Number filter for Prisma where clauses
+ * Supports: equals, gt, gte, in, lt, lte, not, notIn
+ */
+declare const NumberFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: number;
+    gt?: number;
+    gte?: number;
+    in?: number[];
+    lt?: number;
+    lte?: number;
+    not?: number;
+    notIn?: number[];
+}, {}>;
+/**
+ * @description Integer filter for Prisma where clauses (Int, BigInt)
+ * Supports: equals, gt, gte, in, lt, lte, not, notIn
+ */
+declare const IntFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: number;
+    gt?: number;
+    gte?: number;
+    in?: number[];
+    lt?: number;
+    lte?: number;
+    not?: number;
+    notIn?: number[];
+}, {}>;
+
+export { IntFilter, NumberFilter };

package/dist/runtime/numberFilter.js

@@ -0,0 +1,24 @@
+import { type } from 'arktype';
+
+const NumberFilter = type({
+  "equals?": "number",
+  "gt?": "number",
+  "gte?": "number",
+  "in?": "number[]",
+  "lt?": "number",
+  "lte?": "number",
+  "not?": "number",
+  "notIn?": "number[]"
+});
+const IntFilter = type({
+  "equals?": "number.integer",
+  "gt?": "number.integer",
+  "gte?": "number.integer",
+  "in?": "number.integer[]",
+  "lt?": "number.integer",
+  "lte?": "number.integer",
+  "not?": "number.integer",
+  "notIn?": "number.integer[]"
+});
+
+export { IntFilter, NumberFilter };

package/dist/runtime/stringFilter.d.ts

@@ -0,0 +1,21 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description String filter for Prisma where clauses
+ * Supports: contains, endsWith, equals, gt, gte, in, lt, lte, not, notIn, startsWith
+ */
+declare const StringFilter: arktype_internal_variants_object_ts.ObjectType<{
+    contains?: string;
+    endsWith?: string;
+    equals?: string;
+    gt?: string;
+    gte?: string;
+    in?: string[];
+    lt?: string;
+    lte?: string;
+    not?: string;
+    notIn?: string[];
+    startsWith?: string;
+}, {}>;
+
+export { StringFilter };

package/dist/runtime/stringFilter.js

@@ -0,0 +1,17 @@
+import { type } from 'arktype';
+
+const StringFilter = type({
+  "contains?": "string",
+  "endsWith?": "string",
+  "equals?": "string",
+  "gt?": "string",
+  "gte?": "string",
+  "in?": "string[]",
+  "lt?": "string",
+  "lte?": "string",
+  "not?": "string",
+  "notIn?": "string[]",
+  "startsWith?": "string"
+});
+
+export { StringFilter };

package/dist/runtime/uint8array.d.ts

@@ -0,0 +1,9 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Uint8Array instance type for Prisma v7+
+ * In Prisma v7+, Bytes fields return as Uint8Array instead of Buffer
+ */
+declare const Uint8ArrayInstance: arktype_internal_variants_object_ts.ObjectType<Uint8Array<ArrayBufferLike>, {}>;
+
+export { Uint8ArrayInstance };

package/dist/runtime/uint8array.js

@@ -0,0 +1,12 @@
+import { type } from 'arktype';
+
+const Uint8ArrayInstance = type("unknown").narrow(
+  (value, ctx) => {
+    if (value instanceof Uint8Array) {
+      return true;
+    }
+    return ctx.mustBe("an instance of Uint8Array");
+  }
+);
+
+export { Uint8ArrayInstance };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-arktype",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "Generate ArkType schemas from your Prisma schema",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,7 +8,48 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./runtime/filters": {
+      "import": "./dist/runtime/filters.js",
+      "types": "./dist/runtime/filters.d.ts",
+      "default": "./dist/runtime/filters.js"
+    },
+    "./runtime/buffer": {
+      "import": "./dist/runtime/buffer.js",
+      "types": "./dist/runtime/buffer.d.ts",
+      "default": "./dist/runtime/buffer.js"
+    },
+    "./runtime/uint8array": {
+      "import": "./dist/runtime/uint8array.js",
+      "types": "./dist/runtime/uint8array.d.ts",
+      "default": "./dist/runtime/uint8array.js"
+    },
+    "./runtime/arrayFilters": {
+      "import": "./dist/runtime/arrayFilters.js",
+      "types": "./dist/runtime/arrayFilters.d.ts",
+      "default": "./dist/runtime/arrayFilters.js"
+    },
+    "./runtime/stringFilter": {
+      "import": "./dist/runtime/stringFilter.js",
+      "types": "./dist/runtime/stringFilter.d.ts",
+      "default": "./dist/runtime/stringFilter.js"
+    },
+    "./runtime/numberFilter": {
+      "import": "./dist/runtime/numberFilter.js",
+      "types": "./dist/runtime/numberFilter.d.ts",
+      "default": "./dist/runtime/numberFilter.js"
+    },
+    "./runtime/enumFilter": {
+      "import": "./dist/runtime/enumFilter.js",
+      "types": "./dist/runtime/enumFilter.d.ts",
+      "default": "./dist/runtime/enumFilter.js"
+    },
+    "./runtime/booleanFilter": {
+      "import": "./dist/runtime/booleanFilter.js",
+      "types": "./dist/runtime/booleanFilter.d.ts",
+      "default": "./dist/runtime/booleanFilter.js"
     }
   },
   "bin": {
@@ -39,12 +80,16 @@
     "@prisma/generator-helper": "^6.18.0",
     "arktype": "^2.1.25"
   },
+  "peerDependencies": {
+    "@prisma/client": ">=6"
+  },
   "devDependencies": {
     "@biomejs/biome": "2.3.11",
     "@changesets/cli": "2.29.8",
     "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
-    "@prisma/client": "^6.18.0",
+    "@prisma/client": "7.2.0",
+    "@prisma/internals": "7.2.0",
     "@tilli-pro/biome": "0.9.0",
     "@types/node": "^24.10.0",
     "lefthook": "^2.0.2",
@@ -66,6 +111,16 @@
     "lint:fix": "biome check --write",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "pnpm build && changeset publish"
+    "release": "pnpm build && changeset publish",
+    "bench": "vitest bench --config vitest.bench.config.ts",
+    "bench:ui": "vitest bench --ui --config vitest.bench.config.ts",
+    "bench:generation": "vitest bench __benchmarks__/suites/generation.bench.ts --config vitest.bench.config.ts",
+    "bench:processors": "vitest bench __benchmarks__/suites/processors.bench.ts --config vitest.bench.config.ts",
+    "bench:annotations": "vitest bench __benchmarks__/suites/annotations.bench.ts --config vitest.bench.config.ts",
+    "bench:memory": "node --expose-gc node_modules/.bin/vitest bench __benchmarks__/suites/memory.bench.ts --config vitest.bench.config.ts",
+    "bench:compare": "tsx __benchmarks__/scripts/compare.ts",
+    "bench:update-baseline": "tsx __benchmarks__/scripts/update-baseline.ts",
+    "bench:profile": "node --cpu-prof --expose-gc node_modules/.bin/vitest bench --config vitest.bench.config.ts",
+    "bench:ci": "tsx __benchmarks__/scripts/run-and-save.ts"
   }
 }