zodipus 0.1.0

package/README.md

@@ -0,0 +1,424 @@
+# Zodipus
+
+> **Zodipus: solves your schema tragedies.**
+
+A powerful Prisma generator that automatically creates:
+1. **Clean Zod model schemas** (without relations) from your Prisma schema
+2. **Enum schemas** with TypeScript types
+3. **Relation metadata** for query engines and GraphQL resolvers
+4. **Custom schema support** for complex JSON fields
+5. **Query Engine** for composable, runtime-validated Prisma queries
+
+## The Problem: Prisma Types vs. Zod Types
+
+Prisma and Zod generate **incompatible types**, especially for JSON fields and enums:
+
+```typescript
+import { z } from 'zod';
+
+const user = await prisma.user.findFirst();
+// Prisma type: { settings: JsonValue, role: $Enums.UserRole, ... }
+
+function processUser(data: z.infer<typeof UserSchema>) {
+  // Zod type: { settings: { theme: 'light' | 'dark', ... }, role: 'USER' | 'ADMIN', ... }
+}
+
+// ❌ TypeScript ERROR:
+// Type 'JsonValue' is not assignable to type '{ theme?: "light" | "dark" | ... }'
+// Type '$Enums.UserRole' is not assignable to type '"USER" | "ADMIN" | "MODERATOR"'
+processUser(user);
+```
+
+**Why types are incompatible:**
+- **JSON fields**: Prisma uses generic `JsonValue`, but Zod schemas (via `@zodSchema`) define specific structures
+- **Enums**: Prisma generates `$Enums.UserRole`, while Zod uses literal unions `"USER" | "ADMIN"`
+- **Runtime validation**: Even if types matched, Prisma data is not validated — malformed JSON or invalid values can slip through
+
+## The Solution: Query Engine
+
+Zodipus's **Query Engine** creates composable Prisma queries that automatically validate results:
+
+```typescript
+import { createRegistry } from 'zodipus/queryEngine';
+import { models, modelRelations } from './generated/generated-index';
+
+const registry = createRegistry({ models, relations: modelRelations });
+const userQuery = registry.createQuery('user');
+
+// Build a type-safe query with relations
+const query = userQuery({
+  select: { id: true, email: true, name: true },
+  posts: { select: { title: true, published: true } },
+});
+
+// Execute with Prisma
+const users = await prisma.user.findMany(query.query);
+
+// ✅ Validate and get properly typed results
+const validatedUsers = query.array().parse(users);
+// Type: { id: string, email: string, name: string | null, posts: { title: string, published: boolean }[] }[]
+
+// Now safely pass to functions expecting validated data
+processUsers(validatedUsers); // ✅ Guaranteed valid!
+```
+
+
+
+## Installation
+
+```bash
+# Using npm
+npm install -D zodipus
+
+# Using yarn
+yarn add -D zodipus
+
+# Using pnpm
+pnpm add -D zodipus
+```
+
+## Quick Start
+
+### 1. Add generator to your Prisma schema
+
+```prisma
+generator zodipus {
+  provider      = "zodipus"
+  output        = "./generated"
+  relationDepth = "5"
+}
+
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  name      String?
+  role      Role
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+enum Role {
+  USER
+  ADMIN
+}
+
+model Post {
+  id        String   @id @default(uuid())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  String
+  
+  /// @zodSchema PostMetadataSchema
+  metadata  Json?
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+### 2. Run Prisma generate
+
+```bash
+pnpm prisma generate
+```
+
+### 3. Use generated schemas
+
+```typescript
+import { UserSchema, RoleSchema, PostSchema } from './generated';
+
+// Parse and validate data
+const user = UserSchema.parse({
+  id: '123',
+  email: 'user@example.com',
+  role: 'ADMIN',
+  createdAt: new Date(),
+  updatedAt: new Date()
+});
+
+// Use enums
+const role = RoleSchema.parse('ADMIN');
+```
+
+## Features
+
+### Clean Zod Schemas
+
+Generate schemas containing only scalar fields - no relation clutter:
+
+```typescript
+export const UserSchema = z.object({
+  id: z.string(),
+  email: z.string(),
+  name: z.string().optional().nullable(),
+  role: RoleSchema,
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date()
+});
+```
+
+### Custom JSON Field Schemas
+
+Add type-safe validation for JSON fields using `@zodSchema` annotations:
+
+```prisma
+model Post {
+  /// @zodSchema PostMetadataSchema
+  metadata Json?
+}
+```
+
+Then define in `generated/custom-schemas.ts`:
+
+```typescript
+export const PostMetadataSchema = z.object({
+  tags: z.array(z.string()),
+  views: z.number(),
+  featured: z.boolean().optional(),
+});
+```
+
+### Relation Metadata
+
+Extracted automatically for building query engines:
+
+```typescript
+const relations = {
+  user: {
+    posts: {
+      type: "post" as const,
+      isArray: true,
+      relations: { /* nested */ }
+    }
+  }
+} as const;
+```
+
+## Query Engine Integration
+
+Zodipus includes a powerful Query Engine that works seamlessly with your generated schemas:
+
+```typescript
+import { createRegistry } from 'zodipus/queryEngine';
+import { models, modelRelations } from './generated/generated-index';
+
+// Create registry
+const registry = createRegistry({
+  models,
+  relations: modelRelations,
+});
+
+// Create query builders
+export const userQuery = registry.createQuery('user');
+export const postQuery = registry.createQuery('post');
+
+// Use with Prisma
+const query = userQuery({
+  select: { id: true, email: true, name: true },
+  posts: {
+    select: { title: true, published: true },
+  },
+});
+
+// Execute and validate
+const users = await prisma.user.findMany(query.query);
+const validated = query.array().parse(users);
+```
+
+**Features:**
+- ✅ Complete compile-time type safety
+- ✅ Runtime validation with Zod
+- ✅ Automatic relation handling
+- ✅ Nested query support
+- ✅ Selective validation for performance
+
+See [Query Engine Documentation](./queryEngine.md) for complete API reference and examples.
+
+## Configuration
+
+Add options to your Prisma generator configuration:
+
+```prisma
+generator zodipus {
+  provider           = "zodipus"
+  output             = "./generated"
+  relationDepth      = "5"
+  dateFormat         = "coerce"    // or "string"
+  passthroughEnabled = "false"     // or "true"
+  debug              = "false"     // or "true"
+}
+```
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `provider` | string | Required | Set to `"zodipus"` |
+| `output` | string | Required | Output directory for generated files |
+| `relationDepth` | string | `"5"` | Maximum depth for nested relations |
+| `dateFormat` | string | `"coerce"` | DateTime handling: `"coerce"` uses `z.coerce.date()`, `"string"` uses `z.string().datetime()` |
+| `passthroughEnabled` | string | `"false"` | When `"true"`, objects allow extra keys (passthrough mode). When `"false"` (default), unknown keys are stripped. |
+| `debug` | string | `"false"` | Enable debug logging during generation |
+
+### DateTime Format
+
+Choose how DateTime fields are validated:
+
+- **`coerce` (default)**: Uses `z.coerce.date()` - accepts Date objects, ISO strings, and timestamps
+- **`string`**: Uses `z.string().datetime()` - only accepts ISO 8601 datetime strings
+
+```prisma
+// dateFormat = "coerce" (default)
+generator zodipus {
+  dateFormat = "coerce"
+}
+// Generates: createdAt: z.coerce.date()
+
+// dateFormat = "string"
+generator zodipus {
+  dateFormat = "string"
+}
+// Generates: createdAt: z.string().datetime()
+```
+
+### Passthrough Mode
+
+Control how objects handle extra properties:
+
+- **`false` (default)**: Strict mode - unknown keys are stripped during parsing
+- **`true`**: Passthrough mode - unknown keys are preserved
+
+```prisma
+// passthroughEnabled = "false" (default)
+generator zodipus {
+  passthroughEnabled = "false"
+}
+// Generates: z.object({ ... })
+
+// passthroughEnabled = "true"
+generator zodipus {
+  passthroughEnabled = "true"
+}
+// Generates: z.object({ ... }).passthrough()
+```
+
+## Generated Files
+
+```
+generated/
+├── enums.ts              # Prisma enums as Zod schemas
+├── models.ts             # Clean model schemas
+├── custom-schemas.ts     # Custom JSON field schemas
+├── generated-relations.ts # Relation metadata
+└── generated-index.ts    # Exports
+```
+
+## Examples
+
+### API Validation
+
+```typescript
+import { UserSchema } from './generated';
+
+app.post('/users', (req, res) => {
+  const user = UserSchema.parse(req.body);
+  await db.user.create({ data: user });
+});
+```
+
+### Partial Updates
+
+```typescript
+const UpdateUserSchema = UserSchema.partial();
+const updates = UpdateUserSchema.parse(req.body);
+```
+
+## API Reference
+
+### Main Exports (`zodipus`)
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `createRegistry` | Function | Creates a query registry for type-safe Prisma queries |
+
+### Query Engine (`zodipus/queryEngine`)
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `createRegistry(config)` | Function | Creates query registry with models and relations |
+| `ModelRegistry` | Type | Generic type for model schema map |
+| `ModelRelations` | Type | Generic type for relation metadata |
+| `RelationConfig` | Type | Configuration for a single relation |
+| `QueryExecutor` | Type | Return type of query builders |
+| `SafeParseResult<T>` | Type | Result of `.safeParse()` operations |
+
+#### `createRegistry(config)`
+
+```typescript
+function createRegistry<TModels, TRelations>(config: {
+  models: TModels;
+  relations: TRelations;
+}): {
+  createQuery: (model: keyof TModels) => QueryBuilder;
+};
+```
+
+#### `QueryExecutor`
+
+```typescript
+interface QueryExecutor<T> {
+  query: { select: ... } | { include: ... };  // Pass to Prisma
+  parse(data: unknown): T;                     // Throws on invalid
+  safeParse(data: unknown): SafeParseResult<T>; // Returns {success, data/error}
+  array(): {
+    parse(data: unknown[]): T[];
+    safeParse(data: unknown[]): SafeParseResult<T[]>;
+  };
+}
+```
+
+### Errors (`zodipus/errors`)
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `ZodipusError` | Class | Base error class |
+| `ZodipusValidationError` | Class | Thrown when validation fails |
+| `ZodipusGeneratorError` | Class | Thrown during schema generation |
+| `ValidationErrorContext` | Type | Context included in validation errors |
+
+#### `ZodipusValidationError`
+
+```typescript
+class ZodipusValidationError extends ZodipusError {
+  context: {
+    model: string;      // Model being validated
+    field?: string;     // Field that failed
+    expected?: string;  // Expected type/value
+    received?: string;  // Received type/value
+    path?: (string | number)[];  // Path to field
+  };
+}
+```
+
+### Generated Files
+
+| File | Exports |
+|------|---------|
+| `models.ts` | `UserSchema`, `PostSchema`, etc. (Zod schemas for each model) |
+| `enums.ts` | `RoleSchema`, `StatusSchema`, etc. (Zod schemas for enums) |
+| `generated-relations.ts` | `modelRelations` (relation metadata for Query Engine) |
+| `generated-index.ts` | Re-exports all above + `models` namespace |
+| `custom-schemas.ts` | Your custom JSON field schemas (created once, not overwritten) |
+
+### CLI
+
+```bash
+# Inspect schema structure
+zodipus inspect <schema.prisma> [--models] [--enums] [--relations] [--json]
+
+# Generate with dry-run
+zodipus generate <schema.prisma> [--dry-run]
+```

package/dist/cli.cjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+'use strict';
+
+var child_process = require('child_process');
+var path = require('path');
+var commander = require('commander');
+
+var program = new commander.Command();
+program.name("zodipus").description("Zodipus: solves your schema tragedies").version("0.1.0");
+function runPrismaGenerate(schemaPath, env) {
+  return new Promise((resolvePromise, reject) => {
+    const resolvedPath = path.resolve(process.cwd(), schemaPath);
+    console.log("\n\u{1F680} Running Zodipus via Prisma Generator...");
+    console.log(`\u{1F4C4} Schema: ${resolvedPath}
+`);
+    const child = child_process.spawn(
+      "pnpm dlx",
+      [
+        "prisma",
+        "generate",
+        "--schema",
+        resolvedPath,
+        "--generator",
+        "zodipus"
+        // Only run our generator
+      ],
+      {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          ...env
+        },
+        shell: true
+      }
+    );
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolvePromise();
+      } else {
+        reject(new Error(`Prisma generate failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+program.command("inspect").description("Inspect a Prisma schema and show its structure").argument("<schema>", "Path to the Prisma schema file").option("-m, --models", "Show only models").option("-e, --enums", "Show only enums").option("-r, --relations", "Show only relations").option("--json", "Output as JSON").action(async (schemaPath, options) => {
+  const flags = [];
+  if (options.models) flags.push("models");
+  if (options.enums) flags.push("enums");
+  if (options.relations) flags.push("relations");
+  try {
+    await runPrismaGenerate(schemaPath, {
+      ZODIPUS_CMD: "inspect",
+      ZODIPUS_INSPECT_FLAGS: flags.join(","),
+      ZODIPUS_INSPECT_JSON: options.json ? "true" : "false"
+    });
+  } catch (error) {
+    console.error("\n\u274C Inspect failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("generate").description("Generate Zod schemas from a Prisma schema").argument("<schema>", "Path to the Prisma schema file").option("-o, --output <dir>", "Output directory (defaults to schema config)").option("--dry-run", "Preview output without writing files").action(async (schemaPath, options) => {
+  try {
+    if (options.output) {
+      console.warn(
+        "\u26A0\uFE0F Note: --output flag is currently ignored by the wrapper. Configure output in your schema.prisma file."
+      );
+    }
+    await runPrismaGenerate(schemaPath, {
+      ZODIPUS_CMD: "generate",
+      ZODIPUS_DRY_RUN: options.dryRun ? "true" : "false"
+    });
+  } catch (error) {
+    console.error("\n\u274C Generation failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map

package/dist/cli.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts"],"names":["Command","resolve","spawn"],"mappings":"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","file":"cli.cjs","sourcesContent":["#!/usr/bin/env node\n/**\n * Zodipus CLI\n *\n * Command-line interface for schema inspection and generation.\n * Wraps `prisma generate` with special environment variables to trigger\n * inspection or dry-run modes within the native generator execution.\n */\n\nimport { spawn } from 'node:child_process';\nimport { resolve } from 'node:path';\nimport { Command } from 'commander';\n\nconst program = new Command();\n\nprogram.name('zodipus').description('Zodipus: solves your schema tragedies').version('0.1.0');\n\n/**\n * Execute prisma generate with custom env vars\n */\nfunction runPrismaGenerate(schemaPath: string, env: Record<string, string>): Promise<void> {\n  return new Promise((resolvePromise, reject) => {\n    const resolvedPath = resolve(process.cwd(), schemaPath);\n    console.log('\\n🚀 Running Zodipus via Prisma Generator...');\n    console.log(`📄 Schema: ${resolvedPath}\\n`);\n\n    const child = spawn(\n      'pnpm dlx',\n      [\n        'prisma',\n        'generate',\n        '--schema',\n        resolvedPath,\n        '--generator',\n        'zodipus', // Only run our generator\n      ],\n      {\n        stdio: 'inherit',\n        env: {\n          ...process.env,\n          ...env,\n        },\n        shell: true,\n      }\n    );\n\n    child.on('close', (code) => {\n      if (code === 0) {\n        resolvePromise();\n      } else {\n        reject(new Error(`Prisma generate failed with exit code ${code}`));\n      }\n    });\n\n    child.on('error', (err) => {\n      reject(err);\n    });\n  });\n}\n\n/**\n * Inspect command - shows models, enums, and relations from a Prisma schema\n */\nprogram\n  .command('inspect')\n  .description('Inspect a Prisma schema and show its structure')\n  .argument('<schema>', 'Path to the Prisma schema file')\n  .option('-m, --models', 'Show only models')\n  .option('-e, --enums', 'Show only enums')\n  .option('-r, --relations', 'Show only relations')\n  .option('--json', 'Output as JSON')\n  .action(async (schemaPath: string, options) => {\n    const flags: string[] = [];\n    if (options.models) flags.push('models');\n    if (options.enums) flags.push('enums');\n    if (options.relations) flags.push('relations');\n\n    try {\n      await runPrismaGenerate(schemaPath, {\n        ZODIPUS_CMD: 'inspect',\n        ZODIPUS_INSPECT_FLAGS: flags.join(','),\n        ZODIPUS_INSPECT_JSON: options.json ? 'true' : 'false',\n      });\n    } catch (error) {\n      console.error('\\n❌ Inspect failed:', error instanceof Error ? error.message : error);\n      process.exit(1);\n    }\n  });\n\n/**\n * Generate command with --dry-run support\n */\nprogram\n  .command('generate')\n  .description('Generate Zod schemas from a Prisma schema')\n  .argument('<schema>', 'Path to the Prisma schema file')\n  .option('-o, --output <dir>', 'Output directory (defaults to schema config)')\n  .option('--dry-run', 'Preview output without writing files')\n  .action(async (schemaPath: string, options) => {\n    try {\n      if (options.output) {\n        console.warn(\n          '⚠️ Note: --output flag is currently ignored by the wrapper. Configure output in your schema.prisma file.'\n        );\n      }\n\n      await runPrismaGenerate(schemaPath, {\n        ZODIPUS_CMD: 'generate',\n        ZODIPUS_DRY_RUN: options.dryRun ? 'true' : 'false',\n      });\n    } catch (error) {\n      console.error('\\n❌ Generation failed:', error instanceof Error ? error.message : error);\n      process.exit(1);\n    }\n  });\n\nprogram.parse();\n"]}

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/errors.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+// src/errors.ts
+var ZodipusError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZodipusError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var ZodipusValidationError = class extends ZodipusError {
+  context;
+  constructor(message, context) {
+    const contextInfo = [
+      `Model: ${context.model}`,
+      context.field ? `Field: ${context.field}` : null,
+      context.expected ? `Expected: ${context.expected}` : null,
+      context.received ? `Received: ${context.received}` : null,
+      context.path?.length ? `Path: ${context.path.join(".")}` : null
+    ].filter(Boolean).join(", ");
+    super(`${message} (${contextInfo})`);
+    this.name = "ZodipusValidationError";
+    this.context = context;
+  }
+};
+var ZodipusGeneratorError = class extends ZodipusError {
+  schemaPath;
+  modelName;
+  constructor(message, options) {
+    const contextParts = [
+      options?.schemaPath ? `Schema: ${options.schemaPath}` : null,
+      options?.modelName ? `Model: ${options.modelName}` : null
+    ].filter(Boolean);
+    const fullMessage = contextParts.length ? `${message} (${contextParts.join(", ")})` : message;
+    super(fullMessage);
+    this.name = "ZodipusGeneratorError";
+    this.schemaPath = options?.schemaPath;
+    this.modelName = options?.modelName;
+  }
+};
+
+exports.ZodipusError = ZodipusError;
+exports.ZodipusGeneratorError = ZodipusGeneratorError;
+exports.ZodipusValidationError = ZodipusValidationError;
+//# sourceMappingURL=errors.cjs.map
+//# sourceMappingURL=errors.cjs.map

package/dist/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"names":[],"mappings":";;;AAUO,IAAM,YAAA,GAAN,cAA2B,KAAA,CAAM;AAAA,EACtC,YAAY,OAAA,EAAiB;AAC3B,IAAA,KAAA,CAAM,OAAO,CAAA;AACb,IAAA,IAAA,CAAK,IAAA,GAAO,cAAA;AAEZ,IAAA,IAAI,MAAM,iBAAA,EAAmB;AAC3B,MAAA,KAAA,CAAM,iBAAA,CAAkB,IAAA,EAAM,IAAA,CAAK,WAAW,CAAA;AAAA,IAChD;AAAA,EACF;AACF;AAgCO,IAAM,sBAAA,GAAN,cAAqC,YAAA,CAAa;AAAA,EAC9C,OAAA;AAAA,EAET,WAAA,CAAY,SAAiB,OAAA,EAAiC;AAC5D,IAAA,MAAM,WAAA,GAAc;AAAA,MAClB,CAAA,OAAA,EAAU,QAAQ,KAAK,CAAA,CAAA;AAAA,MACvB,OAAA,CAAQ,KAAA,GAAQ,CAAA,OAAA,EAAU,OAAA,CAAQ,KAAK,CAAA,CAAA,GAAK,IAAA;AAAA,MAC5C,OAAA,CAAQ,QAAA,GAAW,CAAA,UAAA,EAAa,OAAA,CAAQ,QAAQ,CAAA,CAAA,GAAK,IAAA;AAAA,MACrD,OAAA,CAAQ,QAAA,GAAW,CAAA,UAAA,EAAa,OAAA,CAAQ,QAAQ,CAAA,CAAA,GAAK,IAAA;AAAA,MACrD,OAAA,CAAQ,MAAM,MAAA,GAAS,CAAA,MAAA,EAAS,QAAQ,IAAA,CAAK,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,GAAK;AAAA,KAC7D,CACG,MAAA,CAAO,OAAO,CAAA,CACd,KAAK,IAAI,CAAA;AAEZ,IAAA,KAAA,CAAM,CAAA,EAAG,OAAO,CAAA,EAAA,EAAK,WAAW,CAAA,CAAA,CAAG,CAAA;AACnC,IAAA,IAAA,CAAK,IAAA,GAAO,wBAAA;AACZ,IAAA,IAAA,CAAK,OAAA,GAAU,OAAA;AAAA,EACjB;AACF;AAKO,IAAM,qBAAA,GAAN,cAAoC,YAAA,CAAa;AAAA,EAC7C,UAAA;AAAA,EACA,SAAA;AAAA,EAET,WAAA,CAAY,SAAiB,OAAA,EAAuD;AAClF,IAAA,MAAM,YAAA,GAAe;AAAA,MACnB,OAAA,EAAS,UAAA,GAAa,CAAA,QAAA,EAAW,OAAA,CAAQ,UAAU,CAAA,CAAA,GAAK,IAAA;AAAA,MACxD,OAAA,EAAS,SAAA,GAAY,CAAA,OAAA,EAAU,OAAA,CAAQ,SAAS,CAAA,CAAA,GAAK;AAAA,KACvD,CAAE,OAAO,OAAO,CAAA;AAEhB,IAAA,MAAM,WAAA,GAAc,YAAA,CAAa,MAAA,GAAS,CAAA,EAAG,OAAO,KAAK,YAAA,CAAa,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA,CAAA,GAAM,OAAA;AAEtF,IAAA,KAAA,CAAM,WAAW,CAAA;AACjB,IAAA,IAAA,CAAK,IAAA,GAAO,uBAAA;AACZ,IAAA,IAAA,CAAK,aAAa,OAAA,EAAS,UAAA;AAC3B,IAAA,IAAA,CAAK,YAAY,OAAA,EAAS,SAAA;AAAA,EAC5B;AACF","file":"errors.cjs","sourcesContent":["/**\n * Custom error classes for Zodipus\n *\n * These errors provide better context for debugging validation\n * and generation issues.\n */\n\n/**\n * Base error class for all Zodipus errors\n */\nexport class ZodipusError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ZodipusError';\n    // Maintains proper stack trace for where error was thrown (V8 engines)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Context for validation errors\n */\nexport interface ValidationErrorContext {\n  /** The model being validated */\n  model: string;\n  /** The field that failed validation (if applicable) */\n  field?: string;\n  /** The expected type or value */\n  expected?: string;\n  /** The received type or value */\n  received?: string;\n  /** The path to the field in nested objects */\n  path?: (string | number)[];\n}\n\n/**\n * Error thrown when data validation fails\n *\n * @example\n * ```typescript\n * throw new ZodipusValidationError('Invalid data type', {\n *   model: 'User',\n *   field: 'email',\n *   expected: 'string',\n *   received: 'number',\n *   path: ['user', 'email'],\n * });\n * ```\n */\nexport class ZodipusValidationError extends ZodipusError {\n  readonly context: ValidationErrorContext;\n\n  constructor(message: string, context: ValidationErrorContext) {\n    const contextInfo = [\n      `Model: ${context.model}`,\n      context.field ? `Field: ${context.field}` : null,\n      context.expected ? `Expected: ${context.expected}` : null,\n      context.received ? `Received: ${context.received}` : null,\n      context.path?.length ? `Path: ${context.path.join('.')}` : null,\n    ]\n      .filter(Boolean)\n      .join(', ');\n\n    super(`${message} (${contextInfo})`);\n    this.name = 'ZodipusValidationError';\n    this.context = context;\n  }\n}\n\n/**\n * Error thrown during schema generation\n */\nexport class ZodipusGeneratorError extends ZodipusError {\n  readonly schemaPath?: string;\n  readonly modelName?: string;\n\n  constructor(message: string, options?: { schemaPath?: string; modelName?: string }) {\n    const contextParts = [\n      options?.schemaPath ? `Schema: ${options.schemaPath}` : null,\n      options?.modelName ? `Model: ${options.modelName}` : null,\n    ].filter(Boolean);\n\n    const fullMessage = contextParts.length ? `${message} (${contextParts.join(', ')})` : message;\n\n    super(fullMessage);\n    this.name = 'ZodipusGeneratorError';\n    this.schemaPath = options?.schemaPath;\n    this.modelName = options?.modelName;\n  }\n}\n"]}

package/dist/errors.d.cts

@@ -0,0 +1,58 @@
+/**
+ * Custom error classes for Zodipus
+ *
+ * These errors provide better context for debugging validation
+ * and generation issues.
+ */
+/**
+ * Base error class for all Zodipus errors
+ */
+declare class ZodipusError extends Error {
+    constructor(message: string);
+}
+/**
+ * Context for validation errors
+ */
+interface ValidationErrorContext {
+    /** The model being validated */
+    model: string;
+    /** The field that failed validation (if applicable) */
+    field?: string;
+    /** The expected type or value */
+    expected?: string;
+    /** The received type or value */
+    received?: string;
+    /** The path to the field in nested objects */
+    path?: (string | number)[];
+}
+/**
+ * Error thrown when data validation fails
+ *
+ * @example
+ * ```typescript
+ * throw new ZodipusValidationError('Invalid data type', {
+ *   model: 'User',
+ *   field: 'email',
+ *   expected: 'string',
+ *   received: 'number',
+ *   path: ['user', 'email'],
+ * });
+ * ```
+ */
+declare class ZodipusValidationError extends ZodipusError {
+    readonly context: ValidationErrorContext;
+    constructor(message: string, context: ValidationErrorContext);
+}
+/**
+ * Error thrown during schema generation
+ */
+declare class ZodipusGeneratorError extends ZodipusError {
+    readonly schemaPath?: string;
+    readonly modelName?: string;
+    constructor(message: string, options?: {
+        schemaPath?: string;
+        modelName?: string;
+    });
+}
+
+export { type ValidationErrorContext, ZodipusError, ZodipusGeneratorError, ZodipusValidationError };