prisma-arktype 2.1.0 → 2.3.0

package/README.md

@@ -86,16 +86,18 @@ generator prisma-arktype {
 
 For each model, the generator creates multiple schema types:
 
-- **`ModelPlain`** - Fields without relationships
-- **`ModelRelations`** - Relationship definitions only
-- **`Model`** - Complete composite schema (Plain & Relations)
-- **`ModelWhere`** - Where clause schema
-- **`ModelWhereUnique`** - Unique where clause schema
-- **`ModelCreate`** - Create input schema
-- **`ModelUpdate`** - Update input schema
-- **`ModelSelect`** - Select schema
-- **`ModelInclude`** - Include schema
-- **`ModelOrderBy`** - OrderBy schema
+- **`ModelPlain`** - Scalar fields only (strings, numbers, dates, enums) - no relations
+- **`ModelRelations`** - Relationship fields only, referencing related model Plain types
+- **`Model`** - Complete composite schema combining Plain & Relations
+- **`ModelWhere`** - Where clause schema for filtering
+- **`ModelWhereUnique`** - Unique where clause schema for finding specific records
+- **`ModelCreate`** - Input schema for creating records
+- **`ModelUpdate`** - Input schema for updating records
+- **`ModelSelect`** - Schema for selecting specific fields
+- **`ModelInclude`** - Schema for including relations
+- **`ModelOrderBy`** - Schema for ordering results
+
+**Enums** are generated as separate reusable types that are imported and referenced by models that use them.
 
 ### Using Generated Schemas
 
@@ -130,6 +132,101 @@ const whereResult = UserWhere(whereClause);
 // ...
 ```
 
+### Generated Code Examples
+
+#### Enum Generation
+
+For a Prisma enum like:
+```prisma
+enum Currency {
+  USD
+  EUR
+  GBP
+}
+```
+
+The generator creates a separate reusable type:
+```typescript
+// Currency.ts
+import { type } from "arktype";
+
+export const Currency = type("'USD' | 'EUR' | 'GBP'");
+```
+
+Which is then imported and used in models:
+```typescript
+// PaymentPlain.ts
+import { type } from "arktype";
+import { Currency } from "./Currency";
+
+export const PaymentPlain = type({
+  "id": "string",
+  "amount": "number",
+  "currency": Currency,        // Required enum
+  "status?": Currency.or("null") // Optional enum
+});
+```
+
+#### Relation Generation
+
+For Prisma models with relations like:
+```prisma
+model User {
+  id    String  @id
+  email String
+  posts Post[]
+}
+
+model Post {
+  id       String @id
+  title    String
+  author   User   @relation(fields: [authorId], references: [id])
+  authorId String
+}
+```
+
+The generator creates Plain types (without relations):
+```typescript
+// UserPlain.ts
+export const UserPlain = type({
+  "id": "string",
+  "email": "string"
+});
+
+// PostPlain.ts
+export const PostPlain = type({
+  "id": "string",
+  "title": "string",
+  "authorId": "string"
+});
+```
+
+And Relations types that reference the Plain types:
+```typescript
+// UserRelations.ts
+import { PostPlain } from "./PostPlain";
+
+export const UserRelations = type({
+  "posts": PostPlain.array() // Array of Post objects
+});
+
+// PostRelations.ts
+import { UserPlain } from "./UserPlain";
+
+export const PostRelations = type({
+  "author": UserPlain // Single User object
+});
+```
+
+The combined model merges both:
+```typescript
+// User.ts
+import { UserPlain } from "./UserPlain";
+import { UserRelations } from "./UserRelations";
+
+export const User = type(() => UserPlain.and(UserRelations));
+```
+
 ## Annotations
 
 Control schema generation using annotations in your Prisma schema. All annotations are added as documentation comments (`///`).
@@ -219,15 +316,16 @@ Prisma types are mapped to ArkType as follows:
 | `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 |
+| Enums | Reference to enum type | `Currency` (imported from `./Currency`) |
+| Relations | Reference to related Plain type | `PostPlain` or `PostPlain.array()` |
 
 ### 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()`
+- **Arrays**: Use `.array()` syntax for lists (`type("string").array()` or `Currency.array()`)
+- **Enums**: Generated as separate reusable type definitions and imported where used
+- **Relations**: Reference the Plain type of the related model, imported automatically
 
 ## Differences from prismabox
 

package/dist/index.js

@@ -181,17 +181,17 @@ function stringifyEnum(enumData) {
 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 { hidden } = extractAnnotations(
@@ -201,6 +201,7 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     return;
   }
   const fields = [];
+  const enumDependencies = [];
   for (const field of model.fields) {
     const {
       annotations: fieldAnnotations,
@@ -227,17 +228,28 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     } 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 = `"${wrapPrimitiveWithArray(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) {
@@ -247,9 +259,12 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     }
     fields.push(`"${fieldName}": ${fieldType}`);
   }
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}`;
+}`,
+    enumDependencies
+  };
 }
 function stringifyPlainInputCreate(model) {
   return stringifyPlain(model, true, false);
@@ -263,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
       });
     }
   }
@@ -348,11 +364,12 @@ const processedRelationsCreate = [];
 const processedRelationsUpdate = [];
 function processRelations(models) {
   for (const model of models) {
-    const stringified = stringifyRelations(model);
-    if (stringified) {
+    const result = stringifyRelations(model);
+    if (result) {
       processedRelations.push({
         name: model.name,
-        stringified
+        stringified: result.stringified,
+        modelDependencies: result.modelDependencies
       });
     }
   }
@@ -366,26 +383,34 @@ function stringifyRelations(model) {
     return;
   }
   const fields = [];
+  const modelDependencies = [];
   for (const field of model.fields) {
     const { hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
     if (field.kind !== "object") continue;
+    const relatedModelPlain = `${field.type}Plain`;
+    if (!modelDependencies.includes(field.type)) {
+      modelDependencies.push(field.type);
+    }
     let fieldType;
     if (field.isList) {
-      fieldType = `type("unknown").array()`;
+      fieldType = `${relatedModelPlain}.array()`;
     } else if (!field.isRequired) {
-      fieldType = `"unknown | null"`;
+      fieldType = `${relatedModelPlain}.or("null")`;
     } else {
-      fieldType = `"unknown"`;
+      fieldType = relatedModelPlain;
     }
     fields.push(`"${field.name}": ${fieldType}`);
   }
   if (fields.length === 0) {
     return;
   }
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}`;
+}`,
+    modelDependencies
+  };
 }
 function processRelationsCreate(models) {
   for (const model of models) {
@@ -530,11 +555,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
       });
     }
   }
@@ -545,25 +571,26 @@ 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 { hidden } = extractAnnotations(
     model.documentation
@@ -572,6 +599,7 @@ function stringifyWhere(model) {
     return;
   }
   const fields = [];
+  const enumDependencies = [];
   for (const field of model.fields) {
     const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
@@ -585,20 +613,30 @@ function stringifyWhere(model) {
     } 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 = `"${wrapPrimitiveWithArray(inner)}"`;
+      if (isEnumType) {
+        fieldType = `${fieldType}.array()`;
+      } else {
+        const inner = fieldType.slice(1, -1);
+        fieldType = `"${wrapPrimitiveWithArray(inner)}"`;
+      }
     }
     fields.push(`"${field.name}?": ${fieldType}`);
   }
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}`;
+}`,
+    enumDependencies
+  };
 }
 function stringifyWhereUnique(model) {
   const { hidden } = extractAnnotations(
@@ -608,6 +646,7 @@ function stringifyWhereUnique(model) {
     return;
   }
   const fields = [];
+  const enumDependencies = [];
   for (const field of model.fields) {
     const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
@@ -622,8 +661,10 @@ function stringifyWhereUnique(model) {
     } 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;
     }
@@ -632,14 +673,33 @@ function stringifyWhereUnique(model) {
   if (fields.length === 0) {
     return;
   }
-  return `{
+  return {
+    stringified: `{
   ${fields.join(",\n  ")}
-}`;
+}`,
+    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 generateModelImports(modelDependencies) {
+  if (!modelDependencies || modelDependencies.length === 0) {
+    return "";
+  }
+  return `${modelDependencies.map(
+    (modelName) => `import { ${modelName}Plain } from "./${modelName}Plain";`
+  ).join("\n")}
+`;
+}
 function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations, processedWhere, processedWhereUnique, processedCreate, processedUpdate, processedRelationsCreate, processedRelationsUpdate, processedSelect, processedInclude, processedOrderBy) {
   const config = getConfig();
   const modelMap = /* @__PURE__ */ new Map();
@@ -652,12 +712,14 @@ 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);
   }
   for (const model of processedRelations) {
-    const content = `${arktypeImport}export const ${model.name}Relations = type(${model.stringified});
+    const modelImports = generateModelImports(model.modelDependencies);
+    const content = `${arktypeImport}${modelImports}export const ${model.name}Relations = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Relations`, content);
   }
@@ -679,22 +741,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);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-arktype",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Generate ArkType schemas from your Prisma schema",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,7 +41,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.11",
-    "@changesets/cli": "^2.29.7",
+    "@changesets/cli": "2.29.8",
     "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
     "@prisma/client": "^6.18.0",