prisma-arktype 2.0.0 → 2.2.0

package/README.md

@@ -132,75 +132,102 @@ const whereResult = UserWhere(whereClause);
 
 ## Annotations
 
-Control schema generation using annotations in your Prisma schema:
+Control schema generation using annotations in your Prisma schema. All annotations are added as documentation comments (`///`).
+
+### Available Annotations
+
+| Annotation | Scope | Description |
+|------------|-------|-------------|
+| `@prisma-arktype.hide` | Model or Field | Completely hide from all generated schemas |
+| `@prisma-arktype.input.hide` | Field | Hide from Create and Update input schemas |
+| `@prisma-arktype.create.input.hide` | Field | Hide from Create input schema only |
+| `@prisma-arktype.update.input.hide` | Field | Hide from Update input schema only |
+| `@prisma-arktype.typeOverwrite="<type>"` | Field | Override the generated ArkType type |
 
 ### Hide Fields/Models
 
+Completely exclude models or fields from all generated schemas:
+
 ```prisma
 /// @prisma-arktype.hide
 model InternalModel {
   id String @id
+  secret String
 }
 
 model User {
   id String @id
+  email String
   /// @prisma-arktype.hide
-  internalField String
+  passwordHash String
 }
 ```
 
 ### Hide from Input Models
 
+Control which fields appear in Create and Update schemas:
+
 ```prisma
 model User {
   id String @id
+  email String
+
   /// @prisma-arktype.input.hide
+  /// Hidden from both Create and Update
   computedField String
+
   /// @prisma-arktype.create.input.hide
-  onlyInUpdates String
+  /// Only appears in Update schema
+  lastModified DateTime
+
   /// @prisma-arktype.update.input.hide
-  onlyInCreates String
+  /// Only appears in Create schema
+  initialStatus String
 }
 ```
 
 ### Type Override
 
+Override the default type mapping with custom ArkType type strings:
+
 ```prisma
 model User {
   id String @id
   /// @prisma-arktype.typeOverwrite="string.email"
   email String
+  /// @prisma-arktype.typeOverwrite="string.url"
+  website String
   /// @prisma-arktype.typeOverwrite="string.numeric"
   phone String
 }
 ```
 
-### Custom Options
-
-```prisma
-model User {
-  id String @id
-  /// @prisma-arktype.options{minLength: 3, maxLength: 50}
-  username String
-}
-```
+This allows you to use any ArkType type definition, including built-in refinements like `string.email`, `string.url`, `number.integer`, etc.
 
 ## Type Mapping
 
 Prisma types are mapped to ArkType as follows:
 
-| Prisma Type | ArkType Type |
-|-------------|--------------|
-| `String` | `"string"` |
-| `Int` | `"integer"` |
-| `BigInt` | `"integer"` |
-| `Float` | `"number"` |
-| `Decimal` | `"number"` |
-| `Boolean` | `"boolean"` |
-| `DateTime` | `"Date"` |
-| `Json` | `"unknown"` |
-| `Bytes` | `"instanceof Buffer"` |
-| Enums | Union of literal values |
+| Prisma Type | ArkType Type | Example Output |
+|-------------|--------------|----------------|
+| `String` | `"string"` | `"string"` |
+| `Int` | `"number.integer"` | `"number.integer"` |
+| `BigInt` | `"number.integer"` | `"number.integer"` |
+| `Float` | `"number"` | `"number"` |
+| `Decimal` | `"number"` | `"number"` |
+| `Boolean` | `"boolean"` | `"boolean"` |
+| `DateTime` | `"Date"` | `"Date"` |
+| `Json` | `"unknown"` | `"unknown"` |
+| `Bytes` | `"instanceof Buffer"` | `"instanceof Buffer"` |
+| Enums | Union of literal values | `type("'USD' \| 'EUR' \| 'GBP'")` |
+| Relations | `"unknown"` | `type("unknown").array()` for lists |
+
+### Special Handling
+
+- **Optional fields**: Use `?` on the key name (`"name?": "string"`)
+- **Nullable fields**: Add `| null` to the type (`"string | null"`)
+- **Arrays**: Use `.array()` syntax for lists (`type("string").array()`)
+- **Enums**: Generated as string literal unions wrapped in `type()`
 
 ## Differences from prismabox
 
@@ -239,6 +266,57 @@ pnpm lint
 pnpm lint:fix
 ```
 
+### Testing
+
+This library has a **completely schema-independent test suite** using self-contained test models in `prisma/schema/test-models.prisma`.
+
+#### Running Tests
+
+```bash
+# Run all tests
+pnpm test:e2e
+
+# Run tests in watch mode
+pnpm test:watch
+```
+
+#### Test Architecture
+
+The test suite is designed to be **100% independent** of production schemas:
+
+- **Self-Contained Schema** - `prisma/schema/test-models.prisma` contains all models needed for testing
+- **No Production Dependencies** - Tests work even if production schemas don't exist
+- **Comprehensive Coverage** - Test models cover all Prisma types, relations, and generator features
+- **Portable** - Can be used across different projects or extracted as a standalone test suite
+
+#### Test Model Categories
+
+The test schema includes specialized models for testing:
+
+1. **Basic CRUD** - `TestUser`, `TestPost`, `TestProfile`
+2. **All Prisma Types** - `TestAllTypes` (String, Int, BigInt, Float, Decimal, Boolean, DateTime, Json, Bytes)
+3. **Relations** - One-to-one, one-to-many, many-to-many, composite keys
+4. **Annotations** - `@prisma-arktype.hide`, `@prisma-arktype.input.hide`, `@prisma-arktype.typeOverwrite`
+5. **Query Operations** - Select, Include, OrderBy schemas
+6. **Enums** - `TestCurrency`, `TestStatus`
+
+#### Adding New Tests
+
+1. **Add test models** to `prisma/schema/test-models.prisma` if needed
+2. **Update mapping** in `__tests__/config/model-mapping.ts` to reference your models
+3. **Write tests** using helper functions from `__tests__/utils/test-helpers.ts`
+4. **Run tests** - `pnpm test`
+
+See existing test files for examples.
+
+#### Why Schema-Independent?
+
+- ✅ Tests never break due to production schema changes
+- ✅ Contributors can run tests without setting up production databases
+- ✅ Tests can be run in isolation (CI/CD, local development)
+- ✅ Clear, documented examples of generator usage
+- ✅ Easy to test new features by adding new test models
+
 ### Publishing
 
 This project uses [Changesets](https://github.com/changesets/changesets) for version management and publishing.

package/dist/index.js

@@ -40,9 +40,6 @@ function isHiddenInputCreate(annotation) {
 function isHiddenInputUpdate(annotation) {
   return annotation.type === "HIDDEN_INPUT_UPDATE";
 }
-function isOptions(annotation) {
-  return annotation.type === "OPTIONS";
-}
 function isTypeOverwrite(annotation) {
   return annotation.type === "TYPE_OVERWRITE";
 }
@@ -69,10 +66,8 @@ const annotationKeys = [
     ],
     type: "HIDDEN_INPUT_UPDATE"
   },
-  { keys: ["@prisma-arktype.options"], type: "OPTIONS" },
   { keys: ["@prisma-arktype.typeOverwrite"], type: "TYPE_OVERWRITE" }
 ];
-const prismaArktypeOptionsRegex = /@prisma-arktype\.options\{(.+)\}/;
 const prismaArktypeTypeOverwriteRegex = /@prisma-arktype\.typeOverwrite=(.+)/;
 function extractAnnotations(documentation) {
   const annotations = [];
@@ -84,14 +79,7 @@ function extractAnnotations(documentation) {
         for (const key of keys) {
           if (line.includes(key)) {
             isAnnotation = true;
-            if (type === "OPTIONS") {
-              const match = line.match(prismaArktypeOptionsRegex);
-              if (match && match[1]) {
-                annotations.push({ type: "OPTIONS", value: match[1] });
-              } else {
-                throw new Error(`Invalid OPTIONS annotation: ${line}`);
-              }
-            } else if (type === "TYPE_OVERWRITE") {
+            if (type === "TYPE_OVERWRITE") {
               const match = line.match(prismaArktypeTypeOverwriteRegex);
               if (match && match[1]) {
                 annotations.push({
@@ -123,13 +111,6 @@ function extractAnnotations(documentation) {
     hiddenInputUpdate: annotations.some(isHiddenInputUpdate)
   };
 }
-function generateArktypeOptions(annotations) {
-  const optionsAnnotations = annotations.filter(isOptions);
-  if (optionsAnnotations.length === 0) {
-    return "";
-  }
-  return `.pipe(${optionsAnnotations.map((a) => a.value).join(", ")})`;
-}
 
 const primitiveTypes = [
   "Int",
@@ -146,30 +127,29 @@ function isPrimitivePrismaFieldType(type) {
   return primitiveTypes.includes(type);
 }
 function stringifyPrimitiveType(type, annotations) {
-  const options = generateArktypeOptions(annotations);
   switch (type) {
     case "Int":
     case "BigInt":
-      return `"number.integer"${options}`;
+      return `"number.integer"`;
     case "Float":
     case "Decimal":
-      return `"number"${options}`;
+      return `"number"`;
     case "String":
-      return `"string"${options}`;
+      return `"string"`;
     case "DateTime":
-      return `"Date"${options}`;
+      return `"Date"`;
     case "Json":
-      return `"unknown"${options}`;
+      return `"unknown"`;
     case "Boolean":
-      return `"boolean"${options}`;
+      return `"boolean"`;
     case "Bytes":
-      return `"instanceof Buffer"${options}`;
+      return `"instanceof Buffer"`;
     default:
       throw new Error(`Unsupported primitive type: ${type}`);
   }
 }
 
-function wrapWithArray(input) {
+function wrapPrimitiveWithArray(input) {
   return `${input}[]`;
 }
 function makeUnion(inputModels) {
@@ -190,38 +170,38 @@ function processEnums(enums) {
   Object.freeze(processedEnums);
 }
 function stringifyEnum(enumData) {
-  const { annotations, hidden } = extractAnnotations(enumData.documentation);
+  const { hidden } = extractAnnotations(enumData.documentation);
   if (hidden) {
     return;
   }
   const values = enumData.values.map((v) => `'${v.name}'`);
-  const options = generateArktypeOptions(annotations);
-  return `type("${makeUnion(values)}")${options}`;
+  return `type("${makeUnion(values)}")`;
 }
 
 const processedPlain = [];
 function processPlain(models) {
   for (const model of models) {
-    const stringified = stringifyPlain(model);
-    if (stringified) {
+    const result = stringifyPlain(model);
+    if (result) {
       processedPlain.push({
         name: model.name,
-        stringified
+        stringified: result.stringified,
+        enumDependencies: result.enumDependencies
       });
     }
   }
   Object.freeze(processedPlain);
 }
-const enumMatch$1 = /type\("(.+)"\)/;
 function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
   const config = getConfig();
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
     return;
   }
   const fields = [];
+  const enumDependencies = [];
   for (const field of model.fields) {
     const {
       annotations: fieldAnnotations,
@@ -244,21 +224,32 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     if (typeOverwrite) {
       fieldType = typeOverwrite.value;
     } else if (isPrimitivePrismaFieldType(field.type)) {
-      fieldType = stringifyPrimitiveType(field.type, fieldAnnotations);
+      fieldType = stringifyPrimitiveType(field.type);
     } else if (field.kind === "enum") {
       const enumDef = processedEnums.find((e) => e.name === field.type);
       if (!enumDef) continue;
-      const match = enumDef.stringified.match(enumMatch$1);
-      fieldType = match ? `"${match[1]}"` : `"'${field.type}'"`;
+      if (!enumDependencies.includes(field.type)) {
+        enumDependencies.push(field.type);
+      }
+      fieldType = field.type;
     } else {
       continue;
     }
+    const isEnumType = field.kind === "enum" && !typeOverwrite;
     if (field.isList) {
-      fieldType = `"${wrapWithArray(fieldType.slice(1, -1))}"`;
+      if (isEnumType) {
+        fieldType = `${fieldType}.array()`;
+      } else {
+        fieldType = `"${wrapPrimitiveWithArray(fieldType.slice(1, -1))}"`;
+      }
     }
     if (!field.isRequired) {
-      const inner = fieldType.slice(1, -1);
-      fieldType = `"${inner} | null"`;
+      if (isEnumType) {
+        fieldType = `${fieldType}.or("null")`;
+      } else {
+        const inner = fieldType.slice(1, -1);
+        fieldType = `"${inner} | null"`;
+      }
       fieldName += "?";
     }
     if (field.hasDefaultValue || isInputUpdate) {
@@ -268,10 +259,12 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     }
     fields.push(`"${fieldName}": ${fieldType}`);
   }
-  const options = generateArktypeOptions(modelAnnotations);
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`,
+    enumDependencies
+  };
 }
 function stringifyPlainInputCreate(model) {
   return stringifyPlain(model, true, false);
@@ -285,11 +278,12 @@ function processCreate(models) {
   for (const model of models) {
     const { hidden } = extractAnnotations(model.documentation);
     if (hidden) continue;
-    const stringified = stringifyPlainInputCreate(model);
-    if (stringified) {
+    const result = stringifyPlainInputCreate(model);
+    if (result) {
       processedCreate.push({
         name: model.name,
-        stringified
+        stringified: result.stringified,
+        enumDependencies: result.enumDependencies
       });
     }
   }
@@ -310,7 +304,7 @@ function processInclude(models) {
   Object.freeze(processedInclude);
 }
 function stringifyInclude(model) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
@@ -327,10 +321,9 @@ function stringifyInclude(model) {
   if (fields.length <= 1) {
     return;
   }
-  const options = generateArktypeOptions(modelAnnotations);
   return `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`;
 }
 
 const processedOrderBy = [];
@@ -347,7 +340,7 @@ function processOrderBy(models) {
   Object.freeze(processedOrderBy);
 }
 function stringifyOrderBy(model) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
@@ -361,10 +354,9 @@ function stringifyOrderBy(model) {
     if (field.kind === "object") continue;
     fields.push(`"${field.name}?": ${sortOrder}`);
   }
-  const options = generateArktypeOptions(modelAnnotations);
   return `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`;
 }
 
 const processedRelations = [];
@@ -383,7 +375,7 @@ function processRelations(models) {
   Object.freeze(processedRelations);
 }
 function stringifyRelations(model) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
@@ -394,22 +386,22 @@ function stringifyRelations(model) {
     const { hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
     if (field.kind !== "object") continue;
-    let fieldType = `"unknown"`;
+    let fieldType;
     if (field.isList) {
-      fieldType = `"unknown[]"`;
-    }
-    if (!field.isRequired) {
+      fieldType = `type("unknown").array()`;
+    } else if (!field.isRequired) {
       fieldType = `"unknown | null"`;
+    } else {
+      fieldType = `"unknown"`;
     }
     fields.push(`"${field.name}": ${fieldType}`);
   }
   if (fields.length === 0) {
     return;
   }
-  const options = generateArktypeOptions(modelAnnotations);
   return `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`;
 }
 function processRelationsCreate(models) {
   for (const model of models) {
@@ -424,7 +416,7 @@ function processRelationsCreate(models) {
   Object.freeze(processedRelationsCreate);
 }
 function stringifyRelationsInputCreate(model, allModels) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
@@ -454,10 +446,9 @@ function stringifyRelationsInputCreate(model, allModels) {
   if (fields.length === 0) {
     return;
   }
-  const options = generateArktypeOptions(modelAnnotations);
   return `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`;
 }
 function processRelationsUpdate(models) {
   for (const model of models) {
@@ -472,7 +463,7 @@ function processRelationsUpdate(models) {
   Object.freeze(processedRelationsUpdate);
 }
 function stringifyRelationsInputUpdate(model, allModels) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
@@ -498,12 +489,14 @@ function stringifyRelationsInputUpdate(model, allModels) {
     }
     let fieldType;
     if (field.isList) {
-      fieldType = `{ "connect"?: { "id": ${idType} }[], "disconnect"?: { "id": ${idType} }[] }`;
+      const connectType = `type({ "id": ${idType} }).array()`;
+      const disconnectType = `type({ "id": ${idType} }).array()`;
+      fieldType = `{ "connect?": ${connectType}, "disconnect?": ${disconnectType} }`;
     } else {
       if (field.isRequired) {
         fieldType = `{ "connect": { "id": ${idType} } }`;
       } else {
-        fieldType = `{ "connect"?: { "id": ${idType} }, "disconnect"?: "boolean" }`;
+        fieldType = `{ "connect?": { "id": ${idType} }, "disconnect?": "boolean" }`;
       }
     }
     fields.push(`"${field.name}?": ${fieldType}`);
@@ -511,10 +504,9 @@ function stringifyRelationsInputUpdate(model, allModels) {
   if (fields.length === 0) {
     return;
   }
-  const options = generateArktypeOptions(modelAnnotations);
   return `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`;
 }
 
 const processedSelect = [];
@@ -531,7 +523,7 @@ function processSelect(models) {
   Object.freeze(processedSelect);
 }
 function stringifySelect(model) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
@@ -544,10 +536,9 @@ function stringifySelect(model) {
     fields.push(`"${field.name}?": "boolean"`);
   }
   fields.push(`"_count?": "boolean"`);
-  const options = generateArktypeOptions(modelAnnotations);
   return `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`;
 }
 
 const processedUpdate = [];
@@ -555,11 +546,12 @@ function processUpdate(models) {
   for (const model of models) {
     const { hidden } = extractAnnotations(model.documentation);
     if (hidden) continue;
-    const stringified = stringifyPlainInputUpdate(model);
-    if (stringified) {
+    const result = stringifyPlainInputUpdate(model);
+    if (result) {
       processedUpdate.push({
         name: model.name,
-        stringified
+        stringified: result.stringified,
+        enumDependencies: result.enumDependencies
       });
     }
   }
@@ -570,33 +562,35 @@ const processedWhere = [];
 const processedWhereUnique = [];
 function processWhere(models) {
   for (const model of models) {
-    const stringified = stringifyWhere(model);
-    if (stringified) {
+    const result = stringifyWhere(model);
+    if (result) {
       processedWhere.push({
         name: model.name,
-        stringified
+        stringified: result.stringified,
+        enumDependencies: result.enumDependencies
       });
     }
-    const stringifiedUnique = stringifyWhereUnique(model);
-    if (stringifiedUnique) {
+    const uniqueResult = stringifyWhereUnique(model);
+    if (uniqueResult) {
       processedWhereUnique.push({
         name: model.name,
-        stringified: stringifiedUnique
+        stringified: uniqueResult.stringified,
+        enumDependencies: uniqueResult.enumDependencies
       });
     }
   }
   Object.freeze(processedWhere);
   Object.freeze(processedWhereUnique);
 }
-const enumMatch = /type\("(.+)"\)/;
 function stringifyWhere(model) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
     return;
   }
   const fields = [];
+  const enumDependencies = [];
   for (const field of model.fields) {
     const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
@@ -604,36 +598,46 @@ function stringifyWhere(model) {
     const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
     let fieldType;
     if (typeOverwrite) {
-      fieldType = `"${typeOverwrite.value}"`;
+      fieldType = typeOverwrite.value;
     } else if (isPrimitivePrismaFieldType(field.type)) {
-      fieldType = stringifyPrimitiveType(field.type, fieldAnnotations);
+      fieldType = stringifyPrimitiveType(field.type);
     } else if (field.kind === "enum") {
       const enumDef = processedEnums.find((e) => e.name === field.type);
       if (!enumDef) continue;
-      const match = enumDef.stringified.match(enumMatch);
-      fieldType = match ? `"${match[1]}"` : `"'${field.type}'"`;
+      if (!enumDependencies.includes(field.type)) {
+        enumDependencies.push(field.type);
+      }
+      fieldType = field.type;
     } else {
       continue;
     }
+    const isEnumType = field.kind === "enum" && !typeOverwrite;
     if (field.isList) {
-      const inner = fieldType.slice(1, -1);
-      fieldType = `"${wrapWithArray(inner)}"`;
+      if (isEnumType) {
+        fieldType = `${fieldType}.array()`;
+      } else {
+        const inner = fieldType.slice(1, -1);
+        fieldType = `"${wrapPrimitiveWithArray(inner)}"`;
+      }
     }
     fields.push(`"${field.name}?": ${fieldType}`);
   }
-  const options = generateArktypeOptions(modelAnnotations);
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`,
+    enumDependencies
+  };
 }
 function stringifyWhereUnique(model) {
-  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+  const { hidden } = extractAnnotations(
     model.documentation
   );
   if (hidden) {
     return;
   }
   const fields = [];
+  const enumDependencies = [];
   for (const field of model.fields) {
     const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
@@ -642,14 +646,16 @@ function stringifyWhereUnique(model) {
     const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
     let fieldType;
     if (typeOverwrite) {
-      fieldType = `"${typeOverwrite.value}"`;
+      fieldType = typeOverwrite.value;
     } else if (isPrimitivePrismaFieldType(field.type)) {
-      fieldType = stringifyPrimitiveType(field.type, fieldAnnotations);
+      fieldType = stringifyPrimitiveType(field.type);
     } else if (field.kind === "enum") {
       const enumDef = processedEnums.find((e) => e.name === field.type);
       if (!enumDef) continue;
-      const match = enumDef.stringified.match(enumMatch);
-      fieldType = match ? `"${match[1]}"` : `"'${field.type}'"`;
+      if (!enumDependencies.includes(field.type)) {
+        enumDependencies.push(field.type);
+      }
+      fieldType = field.type;
     } else {
       continue;
     }
@@ -658,15 +664,24 @@ function stringifyWhereUnique(model) {
   if (fields.length === 0) {
     return;
   }
-  const options = generateArktypeOptions(modelAnnotations);
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}${options}`;
+}`,
+    enumDependencies
+  };
 }
 
 async function format(input) {
   return input;
 }
+function generateEnumImports(enumDependencies) {
+  if (!enumDependencies || enumDependencies.length === 0) {
+    return "";
+  }
+  return `${enumDependencies.map((enumName) => `import { ${enumName} } from "./${enumName}";`).join("\n")}
+`;
+}
 function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations, processedWhere, processedWhereUnique, processedCreate, processedUpdate, processedRelationsCreate, processedRelationsUpdate, processedSelect, processedInclude, processedOrderBy) {
   const config = getConfig();
   const modelMap = /* @__PURE__ */ new Map();
@@ -679,7 +694,8 @@ function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations
     modelMap.set(model.name, content);
   }
   for (const model of processedPlain) {
-    const content = `${arktypeImport}export const ${model.name}Plain = type(${model.stringified});
+    const enumImports = generateEnumImports(model.enumDependencies);
+    const content = `${arktypeImport}${enumImports}export const ${model.name}Plain = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Plain`, content);
   }
@@ -706,22 +722,26 @@ export const ${plain.name} = ${plain.name}Plain;
     }
   }
   for (const model of processedWhere) {
-    const content = `${arktypeImport}export const ${model.name}Where = type(${model.stringified});
+    const enumImports = generateEnumImports(model.enumDependencies);
+    const content = `${arktypeImport}${enumImports}export const ${model.name}Where = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Where`, content);
   }
   for (const model of processedWhereUnique) {
-    const content = `${arktypeImport}export const ${model.name}WhereUnique = type(${model.stringified});
+    const enumImports = generateEnumImports(model.enumDependencies);
+    const content = `${arktypeImport}${enumImports}export const ${model.name}WhereUnique = type(${model.stringified});
 `;
     modelMap.set(`${model.name}WhereUnique`, content);
   }
   for (const model of processedCreate) {
-    const content = `${arktypeImport}export const ${model.name}Create = type(${model.stringified});
+    const enumImports = generateEnumImports(model.enumDependencies);
+    const content = `${arktypeImport}${enumImports}export const ${model.name}Create = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Create`, content);
   }
   for (const model of processedUpdate) {
-    const content = `${arktypeImport}export const ${model.name}Update = type(${model.stringified});
+    const enumImports = generateEnumImports(model.enumDependencies);
+    const content = `${arktypeImport}${enumImports}export const ${model.name}Update = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Update`, content);
   }
@@ -773,10 +793,6 @@ async function write(processedEnums, processedPlain, processedRelations, process
     const filePath = join(config.output, `${name}.ts`);
     writePromises.push(writeFile(filePath, await format(content)));
   }
-  const barrelExports = Array.from(modelMap.keys()).map((name) => `export * from "./${name}";`).join("\n");
-  writePromises.push(
-    writeFile(join(config.output, "index.ts"), await format(barrelExports))
-  );
   await Promise.all(writePromises);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-arktype",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Generate ArkType schemas from your Prisma schema",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,19 +40,19 @@
     "arktype": "^2.1.25"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.3",
-    "@changesets/cli": "^2.29.7",
+    "@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",
-    "@tilli-pro/biome": "^0.8.0",
+    "@tilli-pro/biome": "0.9.0",
     "@types/node": "^24.10.0",
     "lefthook": "^2.0.2",
     "pkgroll": "^2.20.1",
-    "prisma": "^6.18.0",
-    "tsx": "^4.20.6",
+    "prisma": "7.2.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^2.1.9"
+    "vitest": "^4.0.16"
   },
   "scripts": {
     "build": "pkgroll",