prisma-effect-kysely 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.2] - 2025-10-03
+
+### Note
+**Temporary release due to npm 24-hour republish restriction.**
+This version will be unpublished and superseded by v1.0.0 within 24 hours.
+
+### Fixed
+- Export configuration to allow importing runtime helpers from main package entry point
+- Clean dependency tree with minimal deprecation warnings
+
+## [1.0.0] - 2025-10-02
+
+### Added
+
+- Initial release of Prisma Effect Schema Generator
+- Type-safe generation of Effect Schema types from Prisma models
+- Intelligent UUID detection with 4-tier strategy:
+  - Native type detection via `@db.Uuid`
+  - Documentation-based detection
+  - Default value pattern matching
+  - Field name pattern matching
+- Complete Prisma type mappings to Effect Schema equivalents
+- Support for Prisma enums with `@map` annotations
+- Deterministic output with alphabetical sorting
+- Zero type coercion with exact DMMF types
+- Automated file generation (enums.ts, types.ts, index.ts)
+- Comprehensive test suite with 100% coverage paths
+- TypeScript strict mode compliance
+- Prettier code formatting
+
+### Features
+
+- ✅ All Prisma scalar types supported (String, Int, Float, BigInt, Decimal, Boolean, DateTime, Json, Bytes)
+- ✅ Array and optional field support
+- ✅ Relation field exclusion (only scalar and enum fields included)
+- ✅ Internal model filtering (models starting with `_`)
+- ✅ DBSchema interface generation for type-safe database operations
+
+[1.0.0]: https://github.com/samuelho-dev/prisma-effect-kysely/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Samuel Ho
+
+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,219 @@
+# Prisma Effect Generator
+
+A Prisma generator that creates Effect Schema types from Prisma schema definitions with exact type safety and intelligent UUID detection.
+
+## Features
+
+- ✅ **Type-Safe Generation**: Zero type coercion, complete type safety
+- ✅ **Intelligent UUID Detection**: Via `@db.Uuid`, `nativeType`, or field name patterns
+- ✅ **Enum Support**: Effect Schema enums with `@map` annotation support
+- ✅ **Deterministic Output**: Alphabetically sorted for consistent results
+- ✅ **Complete Type Mappings**: All Prisma types mapped to Effect Schema equivalents
+
+## Installation
+
+```bash
+npm install prisma-effect-kysely
+# or
+pnpm add prisma-effect-kysely
+# or
+yarn add prisma-effect-kysely
+```
+
+## Usage
+
+### 1. Add to schema.prisma
+
+```prisma
+generator effect_schemas {
+  provider = "prisma-effect-kysely"
+  output   = "./generated/effect"
+}
+```
+
+### 2. Generate Effect Schemas
+
+```bash
+npx prisma generate
+```
+
+## Output
+
+Generates three files in the configured output directory:
+
+### enums.ts
+
+Effect Schema enums from Prisma enums with exact literal types:
+
+```typescript
+export const UserRole = Schema.Literal('admin', 'user', 'guest');
+export type UserRole = Schema.Schema.Type<typeof UserRole>;
+```
+
+### types.ts
+
+Effect Schema structs from Prisma models:
+
+```typescript
+export const User = Schema.Struct({
+  id: Schema.UUID,
+  email: Schema.String,
+  name: Schema.optional(Schema.String),
+  role: UserRole,
+  createdAt: Schema.Date,
+});
+export type User = Schema.Schema.Type<typeof User>;
+```
+
+### index.ts
+
+Re-exports all generated types for easy importing
+
+## Type Mappings
+
+| Prisma Type | Effect Schema Type  | Notes                            |
+| ----------- | ------------------- | -------------------------------- |
+| String      | `Schema.String`     | `Schema.UUID` for id fields      |
+| Int / Float | `Schema.Number`     | With `Schema.int()` for integers |
+| BigInt      | `Schema.BigInt`     | Exact bigint type                |
+| Decimal     | `Schema.String`     | String for precision             |
+| Boolean     | `Schema.Boolean`    | -                                |
+| DateTime    | `Schema.Date`       | -                                |
+| Json        | `Schema.Unknown`    | Safe unknown type                |
+| Bytes       | `Schema.Uint8Array` | -                                |
+| Enum        | Enum Schema         | With `Schema.Literal` values     |
+
+## UUID Detection
+
+The generator intelligently detects UUID fields through multiple strategies (in order):
+
+1. **Native Type**: `@db.Uuid` attribute (most reliable)
+2. **Documentation**: `@db.Uuid` in field comments
+3. **Default Value**: `dbgenerated("gen_random_uuid()")` or similar
+4. **Field Name Patterns**: `id`, `*_id`, `*_uuid`, `uuid`
+
+Example:
+
+```prisma
+model User {
+  id        String @id @db.Uuid @default(dbgenerated("gen_random_uuid()"))
+  userId    String @db.Uuid  // Detected via native type
+  productId String           // Detected via field name pattern
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+
+# Type check
+npm run typecheck
+
+# Build
+npm run build
+```
+
+## Architecture
+
+### Type Safety
+
+This generator uses **EXACT DMMF types** from Prisma and implements **zero type coercion**:
+
+- Uses `FieldDefault` type matching Prisma's exact structure
+- Type-safe validation with structural typing
+- No `as` assertions or unsafe casts
+- Complete TypeScript strict mode compliance
+
+### Generated Code Quality
+
+- **Alphabetically sorted** fields and models for consistency
+- **Branded types** for UUIDs via `Schema.UUID`
+- **Exact type inference** - no widening to `any` or `unknown`
+- **Auto-generated headers** with timestamps and edit warnings
+
+## Custom Type Overrides
+
+Use `@customType` annotations to override Effect Schema types for **Prisma-supported fields**:
+
+```prisma
+model User {
+  /// @customType(Schema.String.pipe(Schema.email()))
+  email String @unique
+
+  /// @customType(Schema.Number.pipe(Schema.positive()))
+  age Int
+
+  /// @customType(Schema.String.pipe(Schema.brand('UserId')))
+  userId String
+}
+```
+
+**Supported for**: All Prisma scalar types (String, Int, Float, Boolean, DateTime, BigInt, Decimal, Json, Bytes)
+
+**Use cases**:
+- Email/URL validation
+- Number constraints (positive, range, etc.)
+- Custom branded types
+- Refined string patterns
+
+**Examples**:
+```typescript
+// Generated from Prisma schema with @customType annotations
+export const _User = Schema.Struct({
+  email: Schema.String.pipe(Schema.email()),
+  age: Schema.Number.pipe(Schema.positive()),
+  userId: Schema.String.pipe(Schema.brand('UserId')),
+});
+```
+
+## Troubleshooting
+
+### Generator Not Found
+
+If you're developing the generator locally, make sure to build it first:
+
+```bash
+npm run build
+```
+
+Then reference it in your schema.prisma:
+
+```prisma
+generator effect_schemas {
+  provider = "node ./path/to/dist/generator.js"
+  output   = "./generated/effect"
+}
+```
+
+### Wrong Types Generated
+
+Check the generator output in console:
+
+```
+[Effect Generator] Starting generation...
+[Effect Generator] Processing 15 models, 3 enums
+[Effect Generator] ✓ Generated to ../../libs/types/storage/src/lib/effect
+```
+
+### UUID Not Detected
+
+Add explicit `@db.Uuid` attribute:
+
+```prisma
+userId String @db.Uuid
+```
+
+## License
+
+MIT

package/dist/effect/enum.d.ts

@@ -0,0 +1,10 @@
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * Generate Effect Schema Literal enum code
+ */
+export declare function generateEnumSchema(enumDef: DMMF.DatamodelEnum): string;
+/**
+ * Generate all enum schemas as a single file content
+ */
+export declare function generateEnumsFile(enums: readonly DMMF.DatamodelEnum[]): string;
+//# sourceMappingURL=enum.d.ts.map

package/dist/effect/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/effect/enum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAGrD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,UAa7D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,IAAI,CAAC,aAAa,EAAE,UAWrE"}

package/dist/effect/enum.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnumSchema = generateEnumSchema;
+exports.generateEnumsFile = generateEnumsFile;
+const enum_1 = require("../prisma/enum");
+/**
+ * Generate Effect Schema Literal enum code
+ */
+function generateEnumSchema(enumDef) {
+    const enumValues = enumDef.values
+        .map((v) => {
+        const value = (0, enum_1.getEnumValueDbName)(v);
+        return `"${value}"`;
+    })
+        .join(', ');
+    const enumName = enumDef.name;
+    return `export const ${enumName} = Schema.Literal(${enumValues});
+
+export type ${enumName} = Schema.Schema.Type<typeof ${enumName}>;`;
+}
+/**
+ * Generate all enum schemas as a single file content
+ */
+function generateEnumsFile(enums) {
+    const header = `/**
+ * Generated: ${new Date().toISOString()}
+ * DO NOT EDIT MANUALLY
+ */`;
+    const imports = `import { Schema } from "effect";`;
+    const enumSchemas = Array.from(enums).map(generateEnumSchema).join('\n\n');
+    return `${header}\n\n${imports}\n\n${enumSchemas}`;
+}
+//# sourceMappingURL=enum.js.map

package/dist/effect/enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/effect/enum.ts"],"names":[],"mappings":";;AAMA,gDAaC;AAKD,8CAWC;AAlCD,yCAAoD;AAEpD;;GAEG;AACH,SAAgB,kBAAkB,CAAC,OAA2B;IAC5D,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM;SAC9B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,KAAK,GAAG,IAAA,yBAAkB,EAAC,CAAC,CAAC,CAAC;QACpC,OAAO,IAAI,KAAK,GAAG,CAAC;IACtB,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAE9B,OAAO,gBAAgB,QAAQ,qBAAqB,UAAU;;cAElD,QAAQ,gCAAgC,QAAQ,IAAI,CAAC;AACnE,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB,CAAC,KAAoC;IACpE,MAAM,MAAM,GAAG;gBACD,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;;IAEpC,CAAC;IAEH,MAAM,OAAO,GAAG,kCAAkC,CAAC;IAEnD,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAE3E,OAAO,GAAG,MAAM,OAAO,OAAO,OAAO,WAAW,EAAE,CAAC;AACrD,CAAC"}

package/dist/effect/generator.d.ts

@@ -0,0 +1,33 @@
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * Effect domain generator - orchestrates Effect Schema generation
+ */
+export declare class EffectGenerator {
+    private readonly dmmf;
+    constructor(dmmf: DMMF.Document);
+    /**
+     * Generate enums.ts file content
+     */
+    generateEnums(enums: readonly DMMF.DatamodelEnum[]): string;
+    /**
+     * Generate base schema for a model (_ModelName)
+     */
+    generateBaseSchema(model: DMMF.Model, fields: readonly DMMF.Field[]): string;
+    /**
+     * Generate operational schemas (ModelName.Selectable, etc.)
+     */
+    generateOperationalSchemas(model: DMMF.Model): string;
+    /**
+     * Generate TypeScript type exports
+     */
+    generateTypeExports(model: DMMF.Model): string;
+    /**
+     * Generate complete model schema (base + operational + types)
+     */
+    generateModelSchema(model: DMMF.Model, fields: DMMF.Field[]): string;
+    /**
+     * Generate types.ts file header
+     */
+    generateTypesHeader(hasEnums: boolean): string;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/effect/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/effect/generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAKrD;;GAEG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,IAAI,CAAC,QAAQ;IAEhD;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,SAAS,IAAI,CAAC,aAAa,EAAE;IAIlD;;OAEG;IACH,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,IAAI,CAAC,KAAK,EAAE;IAgBnE;;OAEG;IACH,0BAA0B,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK;IAO5C;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK;IAOrC;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE;IAQ3D;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,OAAO;CAkBtC"}

package/dist/effect/generator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectGenerator = void 0;
+const enum_1 = require("./enum");
+const type_1 = require("./type");
+/**
+ * Effect domain generator - orchestrates Effect Schema generation
+ */
+class EffectGenerator {
+    constructor(dmmf) {
+        this.dmmf = dmmf;
+    }
+    /**
+     * Generate enums.ts file content
+     */
+    generateEnums(enums) {
+        return (0, enum_1.generateEnumsFile)(enums);
+    }
+    /**
+     * Generate base schema for a model (_ModelName)
+     */
+    generateBaseSchema(model, fields) {
+        const fieldDefinitions = Array.from(fields)
+            .map((field) => {
+            const fieldType = (0, type_1.buildFieldType)(field, this.dmmf);
+            return `  ${field.name}: ${fieldType}`;
+        })
+            .join(',\n');
+        const baseSchemaName = `_${model.name}`;
+        return `// ${model.name} Base Schema
+export const ${baseSchemaName} = Schema.Struct({
+${fieldDefinitions}
+});`;
+    }
+    /**
+     * Generate operational schemas (ModelName.Selectable, etc.)
+     */
+    generateOperationalSchemas(model) {
+        const baseSchemaName = `_${model.name}`;
+        const operationalSchemaName = model.name;
+        return `export const ${operationalSchemaName} = getSchemas(${baseSchemaName});`;
+    }
+    /**
+     * Generate TypeScript type exports
+     */
+    generateTypeExports(model) {
+        const name = model.name;
+        return `export type ${name}Select = Schema.Schema.Type<typeof ${name}.Selectable>;
+export type ${name}Insert = Schema.Schema.Type<typeof ${name}.Insertable>;
+export type ${name}Update = Schema.Schema.Type<typeof ${name}.Updateable>;`;
+    }
+    /**
+     * Generate complete model schema (base + operational + types)
+     */
+    generateModelSchema(model, fields) {
+        const baseSchema = this.generateBaseSchema(model, fields);
+        const operationalSchema = this.generateOperationalSchemas(model);
+        const typeExports = this.generateTypeExports(model);
+        return `${baseSchema}\n\n${operationalSchema}\n\n${typeExports}`;
+    }
+    /**
+     * Generate types.ts file header
+     */
+    generateTypesHeader(hasEnums) {
+        const header = `/**
+ * Generated: ${new Date().toISOString()}
+ * DO NOT EDIT MANUALLY
+ */`;
+        const imports = [
+            `import { Schema } from "effect";`,
+            `import { columnType, generated, getSchemas } from "prisma-effect-kysely";`,
+        ];
+        if (hasEnums) {
+            const enumNames = this.dmmf.datamodel.enums.map((e) => e.name).join(', ');
+            imports.push(`import { ${enumNames} } from "./enums";`);
+        }
+        return `${header}\n\n${imports.join('\n')}`;
+    }
+}
+exports.EffectGenerator = EffectGenerator;
+//# sourceMappingURL=generator.js.map

package/dist/effect/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../src/effect/generator.ts"],"names":[],"mappings":";;;AACA,iCAA2C;AAC3C,iCAAwC;AAGxC;;GAEG;AACH,MAAa,eAAe;IAC1B,YAA6B,IAAmB;QAAnB,SAAI,GAAJ,IAAI,CAAe;IAAG,CAAC;IAEpD;;OAEG;IACH,aAAa,CAAC,KAAoC;QAChD,OAAO,IAAA,wBAAiB,EAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,KAAiB,EAAE,MAA6B;QACjE,MAAM,gBAAgB,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;aACxC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACb,MAAM,SAAS,GAAG,IAAA,qBAAc,EAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACnD,OAAO,KAAK,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QACzC,CAAC,CAAC;aACD,IAAI,CAAC,KAAK,CAAC,CAAC;QAEf,MAAM,cAAc,GAAG,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QAExC,OAAO,MAAM,KAAK,CAAC,IAAI;eACZ,cAAc;EAC3B,gBAAgB;IACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,0BAA0B,CAAC,KAAiB;QAC1C,MAAM,cAAc,GAAG,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QACxC,MAAM,qBAAqB,GAAG,KAAK,CAAC,IAAI,CAAC;QAEzC,OAAO,gBAAgB,qBAAqB,iBAAiB,cAAc,IAAI,CAAC;IAClF,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,KAAiB;QACnC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QACxB,OAAO,eAAe,IAAI,sCAAsC,IAAI;cAC1D,IAAI,sCAAsC,IAAI;cAC9C,IAAI,sCAAsC,IAAI,eAAe,CAAC;IAC1E,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,KAAiB,EAAE,MAAoB;QACzD,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC1D,MAAM,iBAAiB,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAC;QACjE,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAEpD,OAAO,GAAG,UAAU,OAAO,iBAAiB,OAAO,WAAW,EAAE,CAAC;IACnE,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,QAAiB;QACnC,MAAM,MAAM,GAAG;gBACH,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;;IAEpC,CAAC;QAED,MAAM,OAAO,GAAG;YACd,kCAAkC;YAClC,2EAA2E;SAC5E,CAAC;QAEF,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1E,OAAO,CAAC,IAAI,CAAC,YAAY,SAAS,oBAAoB,CAAC,CAAC;QAC1D,CAAC;QAED,OAAO,GAAG,MAAM,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,CAAC;CACF;AAjFD,0CAiFC"}

package/dist/effect/type.d.ts

@@ -0,0 +1,11 @@
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * Map Prisma field type to Effect Schema type
+ * Priority order: annotation → UUID → scalar → enum → unknown fallback
+ */
+export declare function mapFieldToEffectType(field: DMMF.Field, dmmf: DMMF.Document): string;
+/**
+ * Build complete field type with array and optional wrapping
+ */
+export declare function buildFieldType(field: DMMF.Field, dmmf: DMMF.Document): string;
+//# sourceMappingURL=type.d.ts.map

package/dist/effect/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../src/effect/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAyBrD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,UA2B1E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,UAcpE"}

package/dist/effect/type.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapFieldToEffectType = mapFieldToEffectType;
+exports.buildFieldType = buildFieldType;
+const type_1 = require("../prisma/type");
+const annotations_1 = require("../utils/annotations");
+/**
+ * Prisma scalar type mapping to Effect Schema types
+ * Uses const assertion to avoid type guards
+ */
+const PRISMA_SCALAR_MAP = {
+    String: 'Schema.String',
+    Int: 'Schema.Number',
+    Float: 'Schema.Number',
+    BigInt: 'Schema.BigInt',
+    Decimal: 'Schema.String', // For precision
+    Boolean: 'Schema.Boolean',
+    DateTime: 'Schema.Date',
+    Json: 'Schema.Unknown', // Safe unknown type
+    Bytes: 'Schema.Uint8Array',
+};
+/**
+ * Map Prisma field type to Effect Schema type
+ * Priority order: annotation → UUID → scalar → enum → unknown fallback
+ */
+function mapFieldToEffectType(field, dmmf) {
+    // PRIORITY 1: Check for @customType annotation
+    const typeOverride = (0, annotations_1.extractEffectTypeOverride)(field);
+    if (typeOverride) {
+        return typeOverride;
+    }
+    // PRIORITY 2: Handle String type with UUID detection
+    if (field.type === 'String' && (0, type_1.isUuidField)(field)) {
+        return 'Schema.UUID';
+    }
+    // PRIORITY 3: Handle scalar types with const assertion lookup
+    const scalarType = PRISMA_SCALAR_MAP[field.type];
+    if (scalarType) {
+        return scalarType;
+    }
+    // PRIORITY 4: Check if it's an enum
+    const enumDef = dmmf.datamodel.enums.find((e) => e.name === field.type);
+    if (enumDef) {
+        return field.type; // Use enum name directly
+    }
+    // PRIORITY 5: Fallback to Unknown
+    return 'Schema.Unknown';
+}
+/**
+ * Build complete field type with array and optional wrapping
+ */
+function buildFieldType(field, dmmf) {
+    let baseType = mapFieldToEffectType(field, dmmf);
+    // Handle arrays
+    if ((0, type_1.isListField)(field)) {
+        baseType = `Schema.Array(${baseType})`;
+    }
+    // Handle optional fields (only if NOT already has @default)
+    if (!(0, type_1.isRequiredField)(field) && !(0, type_1.hasDefaultValue)(field)) {
+        baseType = `Schema.UndefinedOr(${baseType})`;
+    }
+    return baseType;
+}
+//# sourceMappingURL=type.js.map

package/dist/effect/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../src/effect/type.ts"],"names":[],"mappings":";;AA6BA,oDA2BC;AAKD,wCAcC;AA1ED,yCAKwB;AACxB,sDAAiE;AAEjE;;;GAGG;AACH,MAAM,iBAAiB,GAAG;IACxB,MAAM,EAAE,eAAe;IACvB,GAAG,EAAE,eAAe;IACpB,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,OAAO,EAAE,eAAe,EAAE,gBAAgB;IAC1C,OAAO,EAAE,gBAAgB;IACzB,QAAQ,EAAE,aAAa;IACvB,IAAI,EAAE,gBAAgB,EAAE,oBAAoB;IAC5C,KAAK,EAAE,mBAAmB;CAClB,CAAC;AAEX;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,KAAiB,EAAE,IAAmB;IACzE,+CAA+C;IAC/C,MAAM,YAAY,GAAG,IAAA,uCAAyB,EAAC,KAAK,CAAC,CAAC;IACtD,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,qDAAqD;IACrD,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAA,kBAAW,EAAC,KAAK,CAAC,EAAE,CAAC;QAClD,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,8DAA8D;IAC9D,MAAM,UAAU,GACd,iBAAiB,CAAC,KAAK,CAAC,IAAsC,CAAC,CAAC;IAClE,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,oCAAoC;IACpC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC;IACxE,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,yBAAyB;IAC9C,CAAC;IAED,kCAAkC;IAClC,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,KAAiB,EAAE,IAAmB;IACnE,IAAI,QAAQ,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAEjD,gBAAgB;IAChB,IAAI,IAAA,kBAAW,EAAC,KAAK,CAAC,EAAE,CAAC;QACvB,QAAQ,GAAG,gBAAgB,QAAQ,GAAG,CAAC;IACzC,CAAC;IAED,4DAA4D;IAC5D,IAAI,CAAC,IAAA,sBAAe,EAAC,KAAK,CAAC,IAAI,CAAC,IAAA,sBAAe,EAAC,KAAK,CAAC,EAAE,CAAC;QACvD,QAAQ,GAAG,sBAAsB,QAAQ,GAAG,CAAC;IAC/C,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/generator/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export * from '../kysely/helpers';
+export declare const generator: void;
+//# sourceMappingURL=index.d.ts.map

package/dist/generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":";AAMA,cAAc,mBAAmB,CAAC;AAElC,eAAO,MAAM,SAAS,MAUpB,CAAC"}

package/dist/generator/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = void 0;
+const generator_helper_1 = require("@prisma/generator-helper");
+const orchestrator_1 = require("./orchestrator");
+// Re-export kysely helpers for generated code
+__exportStar(require("../kysely/helpers"), exports);
+exports.generator = (0, generator_helper_1.generatorHandler)({
+    onManifest: () => ({
+        version: '1.0.0',
+        defaultOutput: './generated',
+        prettyName: 'Prisma Effect Kysely Generator',
+    }),
+    onGenerate: async (options) => {
+        const orchestrator = new orchestrator_1.GeneratorOrchestrator(options);
+        await orchestrator.generate(options);
+    },
+});
+//# sourceMappingURL=index.js.map

package/dist/generator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAEA,+DAA4D;AAC5D,iDAAuD;AAEvD,8CAA8C;AAC9C,oDAAkC;AAErB,QAAA,SAAS,GAAG,IAAA,mCAAgB,EAAC;IACxC,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;QACjB,OAAO,EAAE,OAAO;QAChB,aAAa,EAAE,aAAa;QAC5B,UAAU,EAAE,gCAAgC;KAC7C,CAAC;IACF,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QAC5B,MAAM,YAAY,GAAG,IAAI,oCAAqB,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;CACF,CAAC,CAAC"}

package/dist/generator/orchestrator.d.ts

@@ -0,0 +1,42 @@
+import type { GeneratorOptions } from '@prisma/generator-helper';
+/**
+ * Orchestrates the generation of Effect Schema types from Prisma schema
+ * Uses domain-driven generators: Prisma → Effect → Kysely
+ */
+export declare class GeneratorOrchestrator {
+    private readonly fileManager;
+    private readonly prismaGen;
+    private readonly effectGen;
+    private readonly kyselyGen;
+    constructor(options: GeneratorOptions);
+    /**
+     * Validate and extract output path from generator options
+     */
+    private validateOutputPath;
+    /**
+     * Main generation entry point
+     * Orchestrates all generation steps
+     */
+    generate(options: GeneratorOptions): Promise<void>;
+    /**
+     * Generate enums.ts file
+     */
+    private generateEnums;
+    /**
+     * Generate types.ts file
+     */
+    private generateTypes;
+    /**
+     * Generate index.ts file
+     */
+    private generateIndex;
+    /**
+     * Log generation start with stats
+     */
+    private logStart;
+    /**
+     * Log generation completion
+     */
+    private logComplete;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/generator/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/generator/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAMjE;;;GAGG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;gBAEhC,OAAO,EAAE,gBAAgB;IASrC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;;OAGG;IACG,QAAQ,CAAC,OAAO,EAAE,gBAAgB;IAgBxC;;OAEG;YACW,aAAa;IAM3B;;OAEG;YACW,aAAa;IAoC3B;;OAEG;YACW,aAAa;IAK3B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAYhB;;OAEG;IACH,OAAO,CAAC,WAAW;CAKpB"}