prisma-arktype 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ibrahim Saberi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,345 @@
+# prisma-arktype
+
+Generate [ArkType](https://arktype.io) validation schemas from your [Prisma](https://www.prisma.io) schema.
+
+This package is heavily inspired by and based on the structure of [prismabox](https://github.com/m1212e/prismabox), which generates TypeBox schemas from Prisma schemas.
+
+## Features
+
+- 🎯 **Type-safe validation** - Generate ArkType schemas that match your Prisma models
+- 🔄 **Automatic generation** - Schemas are generated automatically when you run `prisma generate`
+- 📦 **Comprehensive coverage** - Generates schemas for models, relations, where clauses, select, include, orderBy, and more
+- 🎨 **Customizable** - Control schema generation with annotations
+- 🚀 **Zero config** - Works out of the box with sensible defaults
+
+## Installation
+
+```bash
+npm install prisma-arktype arktype
+# or
+pnpm add prisma-arktype arktype
+# or
+yarn add prisma-arktype arktype
+```
+
+## Usage
+
+### Basic Setup
+
+Add the generator to your `schema.prisma` file:
+
+```prisma
+generator prisma-arktype {
+  provider = "prisma-arktype"
+  output   = "./generated/validators"
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model Post {
+  id        String   @id @default(cuid())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+Then run:
+
+```bash
+npx prisma generate
+```
+
+### Configuration Options
+
+Configure the generator in your `schema.prisma`:
+
+```prisma
+generator prisma-arktype {
+  provider                     = "prisma-arktype"
+  output                       = "./generated/validators"
+  arktypeImportDependencyName  = "arktype"
+  ignoredKeysOnInputModels     = ["id", "createdAt", "updatedAt"]
+}
+```
+
+#### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `output` | `string` | `"./prisma/generated/validators"` | Output directory for generated schemas |
+| `arktypeImportDependencyName` | `string` | `"arktype"` | The package name to import from |
+| `ignoredKeysOnInputModels` | `string[]` | `["id", "createdAt", "updatedAt"]` | Fields to exclude from input models |
+
+### Generated Schemas
+
+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
+
+### Using Generated Schemas
+
+```typescript
+import { type } from "arktype";
+import { User, UserCreate, UserWhere } from "./generated/validators";
+
+// Validate a user object
+const userResult = User(someUserData);
+if (userResult instanceof type.errors) {
+  console.error(userResult.summary);
+} else {
+  // userResult is validated user data
+  console.log(userResult);
+}
+
+// Validate create input
+const createData = {
+  email: "user@example.com",
+  name: "John Doe"
+};
+
+const createResult = UserCreate(createData);
+// ...
+
+// Validate where clauses
+const whereClause = {
+  email: "user@example.com"
+};
+
+const whereResult = UserWhere(whereClause);
+// ...
+```
+
+## Annotations
+
+Control schema generation using annotations in your Prisma schema:
+
+### Hide Fields/Models
+
+```prisma
+/// @prisma-arktype.hide
+model InternalModel {
+  id String @id
+}
+
+model User {
+  id String @id
+  /// @prisma-arktype.hide
+  internalField String
+}
+```
+
+### Hide from Input Models
+
+```prisma
+model User {
+  id String @id
+  /// @prisma-arktype.input.hide
+  computedField String
+  /// @prisma-arktype.create.input.hide
+  onlyInUpdates String
+  /// @prisma-arktype.update.input.hide
+  onlyInCreates String
+}
+```
+
+### Type Override
+
+```prisma
+model User {
+  id String @id
+  /// @prisma-arktype.typeOverwrite="string.email"
+  email 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
+}
+```
+
+## 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 |
+
+## Differences from prismabox
+
+While this package is inspired by prismabox, there are some key differences:
+
+1. **ArkType vs TypeBox**: Uses ArkType's syntax and type system instead of TypeBox
+2. **Simpler type definitions**: ArkType's string-based syntax makes schemas more readable
+3. **No nullable wrapper**: ArkType handles nullable types directly with union syntax
+4. **Different validation API**: Uses ArkType's validation approach
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/prisma-arktype.git
+cd prisma-arktype
+
+# Install dependencies
+pnpm install
+
+# Build the project
+pnpm build
+
+# Run tests
+pnpm test
+
+# Run tests in watch mode
+pnpm test:watch
+
+# Run linter
+pnpm lint
+
+# Fix linting issues
+pnpm lint:fix
+```
+
+### Publishing
+
+This project uses [Changesets](https://github.com/changesets/changesets) for version management and publishing.
+
+#### Creating a changeset
+
+When you make changes that should be included in the next release:
+
+```bash
+pnpm changeset
+```
+
+This will prompt you to:
+1. Select the type of change (major, minor, patch)
+2. Provide a description of the changes
+
+Commit the generated changeset file along with your changes.
+
+#### Publishing workflow
+
+1. **Create a changeset** for your changes
+2. **Open a PR** with your changes and the changeset
+3. **Merge the PR** - The GitHub Action will automatically create a "Version Packages" PR
+4. **Review and merge** the Version Packages PR - This will:
+   - Update the version in package.json
+   - Update the CHANGELOG.md
+   - Publish the package to npm
+   - Create a GitHub release
+
+#### Manual publishing (maintainers only)
+
+```bash
+# Build and publish
+pnpm release
+```
+
+**Prerequisites:**
+- Set up `NPM_TOKEN` secret in GitHub repository settings
+- Ensure you have publish access to the npm package
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Create a changeset (`pnpm changeset`)
+5. Commit your changes following the commit message format (see below)
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+### Commit Message Format
+
+This project uses [Conventional Commits](https://www.conventionalcommits.org/). Commit messages are automatically linted using commitlint and lefthook.
+
+Format: `<type>(<scope>): <subject>`
+
+**Types:**
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, etc.)
+- `refactor`: Code refactoring
+- `perf`: Performance improvements
+- `test`: Adding or updating tests
+- `build`: Build system changes
+- `ci`: CI/CD changes
+- `chore`: Other changes
+
+**Examples:**
+```bash
+git commit -m "feat: add support for custom type validators"
+git commit -m "fix: resolve issue with nullable DateTime fields"
+git commit -m "docs: update installation instructions"
+git commit -m "refactor: simplify where clause generation"
+```
+
+### Git Hooks
+
+This project uses [lefthook](https://github.com/evilmartians/lefthook) to manage git hooks:
+
+- **commit-msg**: Validates commit message format
+- **pre-commit**: Runs linter and checks for debug statements
+- **pre-push**: Runs tests before pushing
+
+To skip hooks (use sparingly):
+```bash
+git commit --no-verify -m "your message"
+```
+
+## License
+
+MIT
+
+## Credits
+
+This package is heavily based on [prismabox](https://github.com/m1212e/prismabox) by m1212e. Many thanks for the excellent foundation and architecture!
+
+## Related Projects
+
+- [ArkType](https://arktype.io) - TypeScript's 1:1 validator
+- [Prisma](https://www.prisma.io) - Next-generation ORM for Node.js & TypeScript
+- [prismabox](https://github.com/m1212e/prismabox) - Generate TypeBox schemas from Prisma (inspiration for this project)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/index.js

@@ -0,0 +1,829 @@
+#!/usr/bin/env node
+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';
+
+const configSchema = type({
+  output: "string = './prisma/generated/validators'",
+  arktypeImportDependencyName: "string = 'arktype'",
+  ignoredKeysOnInputModels: "string[]"
+});
+let config = {
+  output: "./prisma/generated/validators",
+  arktypeImportDependencyName: "arktype",
+  ignoredKeysOnInputModels: ["id", "createdAt", "updatedAt"]
+};
+const configPartialSchema = configSchema.partial();
+function setConfig(newConfig) {
+  const out = configPartialSchema(newConfig);
+  if (out instanceof ArkErrors) {
+    throw new Error(`Invalid generator config:
+${out.toString()}`);
+  }
+  config = { ...config, ...out };
+  Object.freeze(config);
+}
+function getConfig() {
+  return config;
+}
+
+function isHidden(annotation) {
+  return annotation.type === "HIDDEN";
+}
+function isHiddenInput(annotation) {
+  return annotation.type === "HIDDEN_INPUT";
+}
+function isHiddenInputCreate(annotation) {
+  return annotation.type === "HIDDEN_INPUT_CREATE";
+}
+function isHiddenInputUpdate(annotation) {
+  return annotation.type === "HIDDEN_INPUT_UPDATE";
+}
+function isOptions(annotation) {
+  return annotation.type === "OPTIONS";
+}
+function isTypeOverwrite(annotation) {
+  return annotation.type === "TYPE_OVERWRITE";
+}
+const annotationKeys = [
+  {
+    keys: ["@prisma-arktype.hide", "@prisma-arktype.hidden"],
+    type: "HIDDEN"
+  },
+  {
+    keys: ["@prisma-arktype.input.hide", "@prisma-arktype.input.hidden"],
+    type: "HIDDEN_INPUT"
+  },
+  {
+    keys: [
+      "@prisma-arktype.create.input.hide",
+      "@prisma-arktype.create.input.hidden"
+    ],
+    type: "HIDDEN_INPUT_CREATE"
+  },
+  {
+    keys: [
+      "@prisma-arktype.update.input.hide",
+      "@prisma-arktype.update.input.hidden"
+    ],
+    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 = [];
+  const descriptionLines = [];
+  if (documentation) {
+    for (const line of documentation.split("\n")) {
+      let isAnnotation = false;
+      for (const { keys, type } of annotationKeys) {
+        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") {
+              const match = line.match(prismaArktypeTypeOverwriteRegex);
+              if (match && match[1]) {
+                annotations.push({
+                  type: "TYPE_OVERWRITE",
+                  value: match[1].trim()
+                });
+              } else {
+                throw new Error(`Invalid TYPE_OVERWRITE annotation: ${line}`);
+              }
+            } else {
+              annotations.push({ type });
+            }
+            break;
+          }
+        }
+        if (isAnnotation) break;
+      }
+      if (!isAnnotation) {
+        descriptionLines.push(line);
+      }
+    }
+  }
+  return {
+    annotations,
+    description: descriptionLines.join("\n").trim(),
+    hidden: annotations.some(isHidden),
+    hiddenInput: annotations.some(isHiddenInput),
+    hiddenInputCreate: annotations.some(isHiddenInputCreate),
+    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",
+  "BigInt",
+  "Float",
+  "Decimal",
+  "String",
+  "DateTime",
+  "Json",
+  "Boolean",
+  "Bytes"
+];
+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}`;
+    case "Float":
+    case "Decimal":
+      return `"number"${options}`;
+    case "String":
+      return `"string"${options}`;
+    case "DateTime":
+      return `"Date"${options}`;
+    case "Json":
+      return `"unknown"${options}`;
+    case "Boolean":
+      return `"boolean"${options}`;
+    case "Bytes":
+      return `"instanceof Buffer"${options}`;
+    default:
+      throw new Error(`Unsupported primitive type: ${type}`);
+  }
+}
+
+function wrapWithArray(input) {
+  return `${input}[]`;
+}
+function makeUnion(inputModels) {
+  return inputModels.join(" | ");
+}
+
+const processedEnums = [];
+function processEnums(enums) {
+  for (const enumData of enums) {
+    const stringified = stringifyEnum(enumData);
+    if (stringified) {
+      processedEnums.push({
+        name: enumData.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedEnums);
+}
+function stringifyEnum(enumData) {
+  const { annotations, hidden } = extractAnnotations(enumData.documentation);
+  if (hidden) {
+    return;
+  }
+  const values = enumData.values.map((v) => `'${v.name}'`);
+  const options = generateArktypeOptions(annotations);
+  return `type("${makeUnion(values)}")${options}`;
+}
+
+const processedPlain = [];
+function processPlain(models) {
+  for (const model of models) {
+    const stringified = stringifyPlain(model);
+    if (stringified) {
+      processedPlain.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedPlain);
+}
+const enumMatch$1 = /type\("(.+)"\)/;
+function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
+  const config = getConfig();
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const {
+      annotations: fieldAnnotations,
+      hidden: fieldHidden,
+      hiddenInput,
+      hiddenInputCreate,
+      hiddenInputUpdate
+    } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    if (isInputCreate && (hiddenInput || hiddenInputCreate)) continue;
+    if (isInputUpdate && (hiddenInput || hiddenInputUpdate)) continue;
+    if (field.kind === "object") continue;
+    if (isInputCreate || isInputUpdate) {
+      if (config.ignoredKeysOnInputModels.includes(field.name)) continue;
+      if (field.name.endsWith("Id") && field.relationName) continue;
+    }
+    const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
+    let fieldType;
+    let fieldName = field.name;
+    if (typeOverwrite) {
+      fieldType = typeOverwrite.value;
+    } else if (isPrimitivePrismaFieldType(field.type)) {
+      fieldType = stringifyPrimitiveType(field.type, fieldAnnotations);
+    } 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}'"`;
+    } else {
+      continue;
+    }
+    if (field.isList) {
+      fieldType = `"${wrapWithArray(fieldType.slice(1, -1))}"`;
+    }
+    if (!field.isRequired) {
+      const inner = fieldType.slice(1, -1);
+      fieldType = `"${inner} | null"`;
+      fieldName += "?";
+    }
+    if (field.hasDefaultValue || isInputUpdate) {
+      if (!fieldName.endsWith("?")) {
+        fieldName += "?";
+      }
+    }
+    fields.push(`"${fieldName}": ${fieldType}`);
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+function stringifyPlainInputCreate(model) {
+  return stringifyPlain(model, true, false);
+}
+function stringifyPlainInputUpdate(model) {
+  return stringifyPlain(model, false, true);
+}
+
+const processedCreate = [];
+function processCreate(models) {
+  for (const model of models) {
+    const { hidden } = extractAnnotations(model.documentation);
+    if (hidden) continue;
+    const stringified = stringifyPlainInputCreate(model);
+    if (stringified) {
+      processedCreate.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedCreate);
+}
+
+const processedInclude = [];
+function processInclude(models) {
+  for (const model of models) {
+    const stringified = stringifyInclude(model);
+    if (stringified) {
+      processedInclude.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedInclude);
+}
+function stringifyInclude(model) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const { hidden: fieldHidden } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    if (field.kind !== "object") continue;
+    fields.push(`"${field.name}?": "boolean"`);
+  }
+  fields.push(`"_count?": "boolean"`);
+  if (fields.length <= 1) {
+    return;
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+
+const processedOrderBy = [];
+function processOrderBy(models) {
+  for (const model of models) {
+    const stringified = stringifyOrderBy(model);
+    if (stringified) {
+      processedOrderBy.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedOrderBy);
+}
+function stringifyOrderBy(model) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  const sortOrder = `"'asc' | 'desc'"`;
+  for (const field of model.fields) {
+    const { hidden: fieldHidden } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    if (field.kind === "object") continue;
+    fields.push(`"${field.name}?": ${sortOrder}`);
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+
+const processedRelations = [];
+const processedRelationsCreate = [];
+const processedRelationsUpdate = [];
+function processRelations(models) {
+  for (const model of models) {
+    const stringified = stringifyRelations(model);
+    if (stringified) {
+      processedRelations.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedRelations);
+}
+function stringifyRelations(model) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const { hidden: fieldHidden } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    if (field.kind !== "object") continue;
+    let fieldType = `"unknown"`;
+    if (field.isList) {
+      fieldType = `"unknown[]"`;
+    }
+    if (!field.isRequired) {
+      fieldType = `"unknown | null"`;
+    }
+    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) {
+    const stringified = stringifyRelationsInputCreate(model, models);
+    if (stringified) {
+      processedRelationsCreate.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedRelationsCreate);
+}
+function stringifyRelationsInputCreate(model, allModels) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const {
+      hidden: fieldHidden,
+      hiddenInput,
+      hiddenInputCreate
+    } = extractAnnotations(field.documentation);
+    if (fieldHidden || hiddenInput || hiddenInputCreate) continue;
+    if (field.kind !== "object") continue;
+    const relatedModel = allModels.find((m) => m.name === field.type);
+    if (!relatedModel) continue;
+    const idField = relatedModel.fields.find((f) => f.isId);
+    let idType = '"string"';
+    if (idField) {
+      if (idField.type === "Int" || idField.type === "BigInt") {
+        idType = '"integer"';
+      }
+    }
+    const connectType = `{ "connect": { "id": ${idType} } }`;
+    fields.push(`"${field.name}?": ${connectType}`);
+  }
+  if (fields.length === 0) {
+    return;
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+function processRelationsUpdate(models) {
+  for (const model of models) {
+    const stringified = stringifyRelationsInputUpdate(model, models);
+    if (stringified) {
+      processedRelationsUpdate.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedRelationsUpdate);
+}
+function stringifyRelationsInputUpdate(model, allModels) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const {
+      hidden: fieldHidden,
+      hiddenInput,
+      hiddenInputUpdate
+    } = extractAnnotations(field.documentation);
+    if (fieldHidden || hiddenInput || hiddenInputUpdate) continue;
+    if (field.kind !== "object") continue;
+    const relatedModel = allModels.find((m) => m.name === field.type);
+    if (!relatedModel) continue;
+    const idField = relatedModel.fields.find((f) => f.isId);
+    let idType = '"string"';
+    if (idField) {
+      if (idField.type === "Int" || idField.type === "BigInt") {
+        idType = '"integer"';
+      }
+    }
+    let fieldType;
+    if (field.isList) {
+      fieldType = `{ "connect"?: { "id": ${idType} }[], "disconnect"?: { "id": ${idType} }[] }`;
+    } else {
+      if (field.isRequired) {
+        fieldType = `{ "connect": { "id": ${idType} } }`;
+      } else {
+        fieldType = `{ "connect"?: { "id": ${idType} }, "disconnect"?: "boolean" }`;
+      }
+    }
+    fields.push(`"${field.name}?": ${fieldType}`);
+  }
+  if (fields.length === 0) {
+    return;
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+
+const processedSelect = [];
+function processSelect(models) {
+  for (const model of models) {
+    const stringified = stringifySelect(model);
+    if (stringified) {
+      processedSelect.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedSelect);
+}
+function stringifySelect(model) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const { hidden: fieldHidden } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    fields.push(`"${field.name}?": "boolean"`);
+  }
+  fields.push(`"_count?": "boolean"`);
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+
+const processedUpdate = [];
+function processUpdate(models) {
+  for (const model of models) {
+    const { hidden } = extractAnnotations(model.documentation);
+    if (hidden) continue;
+    const stringified = stringifyPlainInputUpdate(model);
+    if (stringified) {
+      processedUpdate.push({
+        name: model.name,
+        stringified
+      });
+    }
+  }
+  Object.freeze(processedUpdate);
+}
+
+const processedWhere = [];
+const processedWhereUnique = [];
+function processWhere(models) {
+  for (const model of models) {
+    const stringified = stringifyWhere(model);
+    if (stringified) {
+      processedWhere.push({
+        name: model.name,
+        stringified
+      });
+    }
+    const stringifiedUnique = stringifyWhereUnique(model);
+    if (stringifiedUnique) {
+      processedWhereUnique.push({
+        name: model.name,
+        stringified: stringifiedUnique
+      });
+    }
+  }
+  Object.freeze(processedWhere);
+  Object.freeze(processedWhereUnique);
+}
+const enumMatch = /type\("(.+)"\)/;
+function stringifyWhere(model) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    if (field.kind === "object") continue;
+    const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
+    let fieldType;
+    if (typeOverwrite) {
+      fieldType = `"${typeOverwrite.value}"`;
+    } else if (isPrimitivePrismaFieldType(field.type)) {
+      fieldType = stringifyPrimitiveType(field.type, fieldAnnotations);
+    } 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}'"`;
+    } else {
+      continue;
+    }
+    if (field.isList) {
+      const inner = fieldType.slice(1, -1);
+      fieldType = `"${wrapWithArray(inner)}"`;
+    }
+    fields.push(`"${field.name}?": ${fieldType}`);
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+function stringifyWhereUnique(model) {
+  const { annotations: modelAnnotations, hidden } = extractAnnotations(
+    model.documentation
+  );
+  if (hidden) {
+    return;
+  }
+  const fields = [];
+  for (const field of model.fields) {
+    const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
+    if (fieldHidden) continue;
+    if (field.kind === "object") continue;
+    if (!(field.isId || field.isUnique)) continue;
+    const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
+    let fieldType;
+    if (typeOverwrite) {
+      fieldType = `"${typeOverwrite.value}"`;
+    } else if (isPrimitivePrismaFieldType(field.type)) {
+      fieldType = stringifyPrimitiveType(field.type, fieldAnnotations);
+    } 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}'"`;
+    } else {
+      continue;
+    }
+    fields.push(`"${field.name}?": ${fieldType}`);
+  }
+  if (fields.length === 0) {
+    return;
+  }
+  const options = generateArktypeOptions(modelAnnotations);
+  return `{
+  ${fields.join(",\n  ")}
+}${options}`;
+}
+
+async function format(input) {
+  return input;
+}
+function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations, processedWhere, processedWhereUnique, processedCreate, processedUpdate, processedRelationsCreate, processedRelationsUpdate, processedSelect, processedInclude, processedOrderBy) {
+  const config = getConfig();
+  const modelMap = /* @__PURE__ */ new Map();
+  const arktypeImport = `import { type } from "${config.arktypeImportDependencyName}";
+
+`;
+  for (const model of processedEnums) {
+    const content = `${arktypeImport}export const ${model.name} = ${model.stringified};
+`;
+    modelMap.set(model.name, content);
+  }
+  for (const model of processedPlain) {
+    const content = `${arktypeImport}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});
+`;
+    modelMap.set(`${model.name}Relations`, content);
+  }
+  for (const plain of processedPlain) {
+    const hasRelations = processedRelations.some((r) => r.name === plain.name);
+    if (hasRelations) {
+      const content = `${arktypeImport}import { ${plain.name}Plain } from "./${plain.name}Plain";
+import { ${plain.name}Relations } from "./${plain.name}Relations";
+
+export const ${plain.name} = type(() => ${plain.name}Plain.and(${plain.name}Relations));
+`;
+      modelMap.set(plain.name, content);
+    } else {
+      const content = `${arktypeImport}import { ${plain.name}Plain } from "./${plain.name}Plain";
+
+export const ${plain.name} = ${plain.name}Plain;
+`;
+      modelMap.set(plain.name, content);
+    }
+  }
+  for (const model of processedWhere) {
+    const content = `${arktypeImport}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});
+`;
+    modelMap.set(`${model.name}WhereUnique`, content);
+  }
+  for (const model of processedCreate) {
+    const content = `${arktypeImport}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});
+`;
+    modelMap.set(`${model.name}Update`, content);
+  }
+  for (const model of processedRelationsCreate) {
+    const content = `${arktypeImport}export const ${model.name}RelationsCreate = type(${model.stringified});
+`;
+    modelMap.set(`${model.name}RelationsCreate`, content);
+  }
+  for (const model of processedRelationsUpdate) {
+    const content = `${arktypeImport}export const ${model.name}RelationsUpdate = type(${model.stringified});
+`;
+    modelMap.set(`${model.name}RelationsUpdate`, content);
+  }
+  for (const model of processedSelect) {
+    const content = `${arktypeImport}export const ${model.name}Select = type(${model.stringified});
+`;
+    modelMap.set(`${model.name}Select`, content);
+  }
+  for (const model of processedInclude) {
+    const content = `${arktypeImport}export const ${model.name}Include = type(${model.stringified});
+`;
+    modelMap.set(`${model.name}Include`, content);
+  }
+  for (const model of processedOrderBy) {
+    const content = `${arktypeImport}export const ${model.name}OrderBy = type(${model.stringified});
+`;
+    modelMap.set(`${model.name}OrderBy`, content);
+  }
+  return modelMap;
+}
+async function write(processedEnums, processedPlain, processedRelations, processedWhere, processedWhereUnique, processedCreate, processedUpdate, processedRelationsCreate, processedRelationsUpdate, processedSelect, processedInclude, processedOrderBy) {
+  const config = getConfig();
+  const modelMap = mapAllModelsForWrite(
+    processedEnums,
+    processedPlain,
+    processedRelations,
+    processedWhere,
+    processedWhereUnique,
+    processedCreate,
+    processedUpdate,
+    processedRelationsCreate,
+    processedRelationsUpdate,
+    processedSelect,
+    processedInclude,
+    processedOrderBy
+  );
+  const writePromises = [];
+  for (const [name, content] of modelMap.entries()) {
+    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);
+}
+
+const { generatorHandler } = generatorHelperPkg;
+generatorHandler({
+  onManifest() {
+    return {
+      defaultOutput: "./prisma/generated/validators",
+      prettyName: "prisma-arktype"
+    };
+  },
+  async onGenerate(options) {
+    setConfig({
+      ...options.generator.config,
+      output: options.generator.output?.value
+    });
+    try {
+      await access(getConfig().output);
+      await rm(getConfig().output, { recursive: true });
+    } catch {
+    }
+    await mkdir(getConfig().output, { recursive: true });
+    processEnums(options.dmmf.datamodel.enums);
+    processPlain(options.dmmf.datamodel.models);
+    processWhere(options.dmmf.datamodel.models);
+    processCreate(options.dmmf.datamodel.models);
+    processUpdate(options.dmmf.datamodel.models);
+    processSelect(options.dmmf.datamodel.models);
+    processInclude(options.dmmf.datamodel.models);
+    processOrderBy(options.dmmf.datamodel.models);
+    processRelations(options.dmmf.datamodel.models);
+    processRelationsCreate(options.dmmf.datamodel.models);
+    processRelationsUpdate(options.dmmf.datamodel.models);
+    await write(
+      processedEnums,
+      processedPlain,
+      processedRelations,
+      processedWhere,
+      processedWhereUnique,
+      processedCreate,
+      processedUpdate,
+      processedRelationsCreate,
+      processedRelationsUpdate,
+      processedSelect,
+      processedInclude,
+      processedOrderBy
+    );
+    console.info("\u2705 prisma-arktype: Generated ArkType schemas successfully!");
+  }
+});

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "prisma-arktype",
+  "version": "2.0.0",
+  "description": "Generate ArkType schemas from your Prisma schema",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "prisma-arktype": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "prisma",
+    "arktype",
+    "validation",
+    "schema",
+    "generator",
+    "typesafe"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GeorgeIpsum/prisma-arktype.git"
+  },
+  "homepage": "https://github.com/GeorgeIpsum/prisma-arktype#readme",
+  "bugs": {
+    "url": "https://github.com/GeorgeIpsum/prisma-arktype/issues"
+  },
+  "dependencies": {
+    "@prisma/generator-helper": "^6.18.0",
+    "arktype": "^2.1.25"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.3",
+    "@changesets/cli": "^2.29.7",
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@prisma/client": "^6.18.0",
+    "@tilli-pro/biome": "^0.8.0",
+    "@types/node": "^24.10.0",
+    "lefthook": "^2.0.2",
+    "pkgroll": "^2.20.1",
+    "prisma": "^6.18.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.9"
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "dev": "pkgroll --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "pnpm build && prisma generate && vitest run",
+    "pretest": "pnpm build",
+    "postinstall": "lefthook install",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm build && changeset publish"
+  }
+}