@effectify/prisma 1.0.0 → 1.1.0

package/dist/src/runtime/index.d.ts

@@ -0,0 +1,303 @@
+import { Schema } from "effect";
+import type { ColumnType as KyselyColumnType, Generated as KyselyGenerated, Insertable as KyselyInsertable, Selectable as KyselySelectable, Updateable as KyselyUpdateable } from "kysely";
+/**
+ * Runtime helpers for Kysely schema integration
+ * These are imported by generated code
+ *
+ * ## Type Extraction Patterns
+ *
+ * For Effect Schemas (recommended - full type safety):
+ * ```typescript
+ * import { Selectable, Insertable, Updateable } from '@effectify/prisma';
+ * import { User } from './generated/types';
+ *
+ * type UserSelect = Selectable<User>;
+ * type UserInsert = Insertable<User>;
+ * type UserUpdate = Updateable<User>;
+ * ```
+ *
+ * Note: This package exports branded versions of ColumnType and Generated that
+ * are compatible with Effect Schema's type inference. These extend the base
+ * select type (S) while carrying phantom insert/update type information.
+ */
+export type { KyselyColumnType, KyselyGenerated, KyselyInsertable, KyselySelectable, KyselyUpdateable };
+export declare const ColumnTypeId: unique symbol;
+export declare const GeneratedId: unique symbol;
+/**
+ * Symbol for VariantMarker - used in mapped type pattern that survives declaration emit.
+ */
+export declare const VariantTypeId: unique symbol;
+export type VariantTypeId = typeof VariantTypeId;
+/**
+ * Variant marker using mapped type pattern from Effect's Brand.
+ *
+ * TypeScript cannot simplify mapped types that depend on generic parameters.
+ * This ensures the variant information survives declaration emit (.d.ts generation).
+ *
+ * Pattern derived from Effect's Brand<K>:
+ * ```typescript
+ * readonly [BrandTypeId]: { readonly [k in K]: K }  // Mapped type - cannot be simplified!
+ * ```
+ *
+ * Our pattern uses a conditional type within the mapped type to encode both I and U:
+ * ```typescript
+ * readonly [VariantTypeId]: { readonly [K in "insert" | "update"]: K extends "insert" ? I : U }
+ * ```
+ */
+export interface VariantMarker<in out I, in out U> {
+    readonly [VariantTypeId]: {
+        readonly [K in "insert" | "update"]: K extends "insert" ? I : U;
+    };
+}
+/**
+ * Branded ColumnType that extends S while carrying phantom insert/update type information.
+ *
+ * This replaces Kysely's ColumnType because:
+ * 1. Kysely's ColumnType<S,I,U> = { __select__: S, __insert__: I, __update__: U } is NOT a subtype of S
+ * 2. Schema.make<KyselyColumnType<...>>(ast) doesn't work because AST represents S, not the struct
+ * 3. Our ColumnType<S,I,U> = S & Brand IS a subtype of S, so Schema.make works correctly
+ *
+ * Includes Kysely's phantom properties (__select__, __insert__, __update__) so that:
+ * 1. Kysely recognizes this as a ColumnType for INSERT/UPDATE operations
+ * 2. WHERE clauses work with plain S values (not branded)
+ *
+ * Uses VariantMarker with mapped types to survive TypeScript declaration emit.
+ *
+ * Usage is identical to Kysely's ColumnType:
+ * ```typescript
+ * type IdField = ColumnType<string, never, never>;  // Read-only ID
+ * type CreatedAt = ColumnType<Date, Date | undefined, Date>;  // Optional on insert
+ * ```
+ */
+export type ColumnType<S, I = S, U = S> = S & VariantMarker<I, U> & {
+    /** Kysely extracts this type for SELECT and WHERE */
+    readonly __select__: S;
+    /** Kysely uses this for INSERT */
+    readonly __insert__: I;
+    /** Kysely uses this for UPDATE */
+    readonly __update__: U;
+};
+/**
+ * Base Generated brand without Kysely phantom properties.
+ * Used as the __select__ return type to preserve branding on SELECT.
+ *
+ * Uses VariantMarker<T | undefined, T> so that Generated fields are:
+ * - Optional on insert (T | undefined) - can be provided or omitted
+ * - Required on update (T) - must provide value if updating
+ *
+ * This differs from ColumnType<S, never, never> which completely excludes
+ * the field from insert (used for auto-generated IDs).
+ */
+type GeneratedBrand<T> = T & VariantMarker<T | undefined, T> & {
+    readonly [GeneratedId]: true;
+};
+/**
+ * Branded Generated type for database-generated fields.
+ *
+ * Follows @effect/sql Model.Generated pattern - the field is:
+ * - Required on select (T) - Kysely returns the base type
+ * - Optional on insert (T | undefined) - Kysely recognizes this
+ * - Allowed on update (T)
+ *
+ * Includes Kysely's phantom properties (__select__, __insert__, __update__) so that:
+ * 1. Kysely recognizes this as a ColumnType and makes it optional on INSERT
+ * 2. WHERE clauses work with plain T values (not branded)
+ *
+ * The Selectable<T> type utility preserves the full Generated<T> type for schema alignment.
+ * Kysely operations work with the underlying T type.
+ *
+ * Uses VariantMarker with mapped types to survive TypeScript declaration emit.
+ */
+export type Generated<T> = GeneratedBrand<T> & {
+    /** Kysely extracts this type for SELECT and WHERE - base type for compatibility */
+    readonly __select__: T;
+    /** Kysely uses this for INSERT - optional */
+    readonly __insert__: T | undefined;
+    /** Kysely uses this for UPDATE */
+    readonly __update__: T;
+};
+/**
+ * Interface for ColumnType schema - preserves type parameters in declaration emit.
+ *
+ * Named interfaces with type parameters are preserved by TypeScript in declaration files,
+ * unlike anonymous intersection types which may be simplified.
+ *
+ * This follows the Schema.brand pattern from Effect which returns a named interface.
+ */
+export interface ColumnTypeSchema<S extends Schema.Schema.All, IType, UType> extends Schema.Schema<ColumnType<Schema.Schema.Type<S>, IType, UType>, ColumnType<Schema.Schema.Encoded<S>, IType, UType>, Schema.Schema.Context<S>> {
+    /** The original select schema */
+    readonly selectSchema: S;
+}
+/**
+ * Mark a field as having different types for select/insert/update
+ * Used for ID fields with @default (read-only)
+ *
+ * The insert/update schemas are stored in annotations and used at runtime
+ * to determine which fields to include in Insertable/Updateable schemas.
+ *
+ * Returns a ColumnTypeSchema which:
+ * 1. Is a named interface (preserved in declaration emit)
+ * 2. Contains the ColumnType<S, I, U> brand with Kysely phantom properties
+ * 3. Includes the original schema via `selectSchema` property
+ *
+ * This enables Kysely to recognize fields with `__insert__: never` and omit them from INSERT.
+ */
+export declare const columnType: <SType, SEncoded, SR, IType, IEncoded, IR, UType, UEncoded, UR>(selectSchema: Schema.Schema<SType, SEncoded, SR>, insertSchema: Schema.Schema<IType, IEncoded, IR>, updateSchema: Schema.Schema<UType, UEncoded, UR>) => ColumnTypeSchema<Schema.Schema<SType, SEncoded, SR>, IType, UType>;
+/**
+ * Interface for Generated schema - preserves type parameter in declaration emit.
+ *
+ * Named interfaces with type parameters are preserved by TypeScript in declaration files,
+ * unlike anonymous intersection types which may be simplified.
+ *
+ * This follows the Schema.brand pattern from Effect which returns a named interface.
+ */
+export interface GeneratedSchema<S extends Schema.Schema.All> extends Schema.Schema<Generated<Schema.Schema.Type<S>>, Generated<Schema.Schema.Encoded<S>>, Schema.Schema.Context<S>> {
+    /** The original schema before Generated wrapper */
+    readonly from: S;
+}
+/**
+ * Mark a field as database-generated (omitted from insert)
+ * Used for fields with @default
+ *
+ * Follows @effect/sql Model.Generated pattern:
+ * - Present in select and update schemas
+ * - OMITTED from insert schema (not optional, completely absent)
+ *
+ * Returns a GeneratedSchema<S> which:
+ * 1. Is a named interface (preserved in declaration emit)
+ * 2. Contains the Generated<T> brand using VariantMarker (mapped types survive emit)
+ * 3. Includes the original schema via `from` property
+ *
+ * This enables CustomInsertable to filter out generated fields at compile time.
+ */
+export declare const generated: <S extends Schema.Schema.All>(schema: S) => GeneratedSchema<S>;
+/**
+ * Extract the insert type from a field using the __insert__ phantom property:
+ * - ColumnType<S, I, U> -> I (via __insert__)
+ * - Generated<T> -> T | undefined (via __insert__)
+ * - Other types -> as-is
+ *
+ * Uses the __insert__ property which is always present on ColumnType and Generated.
+ * This approach is more reliable across module boundaries than using VariantMarker
+ * with unique symbols, which can cause type matching failures when TypeScript
+ * compiles from source files with different symbol references.
+ */
+type ExtractInsertType<T> = T extends {
+    readonly __insert__: infer I;
+} ? I : T extends {
+    [VariantTypeId]: {
+        insert: infer I;
+    };
+} ? I : T;
+/**
+ * Check if a type is nullable (includes null or undefined).
+ * Matches Kysely's IfNullable behavior:
+ *   type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
+ *
+ * A field is optional for insert if its InsertType can be null or undefined.
+ */
+type IsOptionalInsert<T> = undefined extends ExtractInsertType<T> ? true : null extends ExtractInsertType<T> ? true : false;
+/**
+ * Extract the base type without null/undefined for optional fields.
+ * Keeps the type as-is (including null) for the property type,
+ * since the optionality is expressed via `?` not the type itself.
+ */
+type ExtractInsertBaseType<T> = ExtractInsertType<T>;
+/**
+ * Extract the update type from a field using the __update__ phantom property:
+ * - ColumnType<S, I, U> -> U (via __update__)
+ * - Generated<T> -> T (via __update__)
+ * - Other types -> as-is
+ *
+ * Uses the __update__ property which is always present on ColumnType and Generated.
+ * This approach is more reliable across module boundaries than using VariantMarker
+ * with unique symbols, which can cause type matching failures when TypeScript
+ * compiles from source files with different symbol references.
+ */
+type ExtractUpdateType<T> = T extends {
+    readonly __update__: infer U;
+} ? U : T extends {
+    [VariantTypeId]: {
+        update: infer U;
+    };
+} ? U : T;
+/**
+ * Custom Insertable type that:
+ * - Omits fields with `never` insert type (read-only IDs)
+ * - Makes fields with `T | undefined` insert type optional with type T
+ * - Keeps other fields required
+ */
+type CustomInsertable<T> = {
+    [K in keyof T as ExtractInsertType<T[K]> extends never ? never : IsOptionalInsert<T[K]> extends true ? never : K]: ExtractInsertType<T[K]>;
+} & {
+    [K in keyof T as ExtractInsertType<T[K]> extends never ? never : IsOptionalInsert<T[K]> extends true ? K : never]?: ExtractInsertBaseType<T[K]>;
+};
+/**
+ * Custom Updateable type that properly omits fields with `never` update types.
+ */
+type CustomUpdateable<T> = {
+    [K in keyof T as ExtractUpdateType<T[K]> extends never ? never : K]?: ExtractUpdateType<T[K]>;
+};
+type MutableInsert<Type> = CustomInsertable<Type>;
+/**
+ * Strip Generated<T> wrapper, returning the underlying type T.
+ * For non-Generated types, returns as-is.
+ * Preserves branded foreign keys (UserId, ProductId, etc.).
+ */
+type StripGeneratedWrapper<T> = T extends GeneratedBrand<infer U> ? U : T;
+/**
+ * Strip ColumnType wrapper, extracting the select type S.
+ * Must check AFTER Generated because Generated<T> also has __select__.
+ * Uses __insert__ existence to differentiate ColumnType from other types.
+ */
+type StripColumnTypeWrapper<T> = T extends {
+    readonly __select__: infer S;
+    readonly __insert__: unknown;
+} ? S : T;
+/**
+ * Strip all Kysely wrappers (Generated, ColumnType) from a field type.
+ * Order matters: check Generated first, then ColumnType.
+ * Preserves branded foreign keys (UserId, ProductId, etc.).
+ */
+type StripKyselyWrapper<T> = StripColumnTypeWrapper<StripGeneratedWrapper<T>>;
+/**
+ * Strip Kysely wrappers from all fields in a type.
+ * Preserves branded foreign keys (UserId, ProductId, etc.).
+ */
+type StripKyselyWrappersFromObject<T> = {
+    readonly [K in keyof T]: StripKyselyWrapper<T[K]>;
+};
+export declare function Selectable<Type, Encoded>(schema: Schema.Schema<Type, Encoded>): Schema.Schema<StripKyselyWrappersFromObject<Type>, StripKyselyWrappersFromObject<Encoded>, never>;
+/**
+ * Create Insertable schema from base schema
+ * Generated fields (@default) are made optional, not excluded
+ */
+export declare function Insertable<Type, Encoded>(schema: Schema.Schema<Type, Encoded>): Schema.Schema<MutableInsert<Type>, MutableInsert<Encoded>, never>;
+/**
+ * Create Updateable schema from base schema
+ */
+export declare function Updateable<Type, Encoded>(schema: Schema.Schema<Type, Encoded>): Schema.Schema<CustomUpdateable<Type>, CustomUpdateable<Encoded>, never>;
+/**
+ * Extract SELECT type from schema.
+ * - Preserves branded foreign keys (UserId, ProductId, etc.)
+ * - Strips Generated<T> and ColumnType<S,I,U> wrappers to match what Kysely returns
+ *
+ * Kysely extracts __select__ for SELECT results.
+ * Generated<T>/ColumnType remain in the DB interface for INSERT recognition,
+ * but Selectable<T> gives you the clean type matching query results.
+ *
+ * @example type UserSelect = Selectable<User>;
+ */
+export type Selectable<T> = StripKyselyWrappersFromObject<T>;
+/**
+ * Extract INSERT type from schema.
+ * Omits fields with `never` insert type (read-only IDs, generated fields).
+ * @example type UserInsert = Insertable<User>;
+ */
+export type Insertable<T> = CustomInsertable<T>;
+/**
+ * Extract UPDATE type from schema.
+ * Omits fields with `never` update type, makes all fields optional.
+ * @example type UserUpdate = Updateable<User>;
+ */
+export type Updateable<T> = CustomUpdateable<T>;

package/dist/src/runtime/index.js

@@ -0,0 +1,216 @@
+import { Schema } from "effect";
+import * as AST from "effect/SchemaAST";
+export const ColumnTypeId = Symbol.for("/ColumnTypeId");
+export const GeneratedId = Symbol.for("/GeneratedId");
+/**
+ * Symbol for VariantMarker - used in mapped type pattern that survives declaration emit.
+ */
+export const VariantTypeId = Symbol.for("@effectify/prisma/VariantType");
+/**
+ * Mark a field as having different types for select/insert/update
+ * Used for ID fields with @default (read-only)
+ *
+ * The insert/update schemas are stored in annotations and used at runtime
+ * to determine which fields to include in Insertable/Updateable schemas.
+ *
+ * Returns a ColumnTypeSchema which:
+ * 1. Is a named interface (preserved in declaration emit)
+ * 2. Contains the ColumnType<S, I, U> brand with Kysely phantom properties
+ * 3. Includes the original schema via `selectSchema` property
+ *
+ * This enables Kysely to recognize fields with `__insert__: never` and omit them from INSERT.
+ */
+export const columnType = (selectSchema, insertSchema, updateSchema) => {
+    const schemas = {
+        selectSchema,
+        insertSchema,
+        updateSchema,
+    };
+    // Return annotated schema with ColumnType brand at type level
+    // The runtime annotation enables filtering in Insertable() function
+    // The type-level brand enables Kysely to recognize INSERT/UPDATE constraints
+    const annotated = selectSchema.annotations({ [ColumnTypeId]: schemas });
+    return Object.assign(annotated, { selectSchema });
+};
+/**
+ * Mark a field as database-generated (omitted from insert)
+ * Used for fields with @default
+ *
+ * Follows @effect/sql Model.Generated pattern:
+ * - Present in select and update schemas
+ * - OMITTED from insert schema (not optional, completely absent)
+ *
+ * Returns a GeneratedSchema<S> which:
+ * 1. Is a named interface (preserved in declaration emit)
+ * 2. Contains the Generated<T> brand using VariantMarker (mapped types survive emit)
+ * 3. Includes the original schema via `from` property
+ *
+ * This enables CustomInsertable to filter out generated fields at compile time.
+ */
+export const generated = (schema) => {
+    // Return annotated schema with Generated brand at type level
+    // The runtime annotation enables filtering in Insertable() function
+    // The type-level brand enables filtering in CustomInsertable type utility
+    const annotated = schema.annotations({ [GeneratedId]: true });
+    return Object.assign(annotated, { from: schema });
+};
+/**
+ * Schema for validating column type annotations structure
+ */
+const ColumnTypeSchemasValidator = Schema.Struct({
+    selectSchema: Schema.Any,
+    insertSchema: Schema.Any,
+    updateSchema: Schema.Any,
+});
+/**
+ * Extract and validate column type schemas from AST annotations
+ * Returns null if not a column type or validation fails
+ */
+function getColumnTypeSchemas(ast) {
+    if (!(ColumnTypeId in ast.annotations)) {
+        return null;
+    }
+    const annotation = ast.annotations[ColumnTypeId];
+    const decoded = Schema.decodeUnknownOption(ColumnTypeSchemasValidator)(annotation);
+    if (decoded._tag === "None") {
+        return null;
+    }
+    // The decoded value has the correct structure, and the annotation
+    // was created by columnType() which ensures proper Schema types
+    return annotation;
+}
+const isGeneratedType = (ast) => GeneratedId in ast.annotations;
+const isOptionalType = (ast) => {
+    // Check for Union(T, Undefined) or Union(T, null) patterns
+    // These are optional on insert because omitting = NULL in DB
+    if (!AST.isUnion(ast)) {
+        return false;
+    }
+    return (ast.types.some((t) => AST.isUndefinedKeyword(t)) ||
+        ast.types.some((t) => isNullType(t)));
+};
+const isNullType = (ast) => AST.isLiteral(ast) &&
+    Object.entries(ast.annotations).find(([sym, value]) => sym === AST.IdentifierAnnotationId.toString() && value === "null");
+/**
+ * Strip null from a union type for Insertable fields.
+ * For INSERT operations, omitting a field = null in DB, so we don't need explicit null.
+ * Returns the non-null type if it's a union with null, otherwise returns the original type.
+ */
+const stripNullFromUnion = (ast) => {
+    if (!AST.isUnion(ast)) {
+        return ast;
+    }
+    // Filter out null types from the union
+    const nonNullTypes = ast.types.filter((t) => !isNullType(t));
+    // If only one type remains, return it directly (unwrap single-element union)
+    if (nonNullTypes.length === 1) {
+        return nonNullTypes[0];
+    }
+    // If multiple types remain, create a new union without null
+    if (nonNullTypes.length > 1) {
+        return AST.Union.make(nonNullTypes);
+    }
+    // Edge case: all types were null (shouldn't happen in practice)
+    return ast;
+};
+const extractParametersFromTypeLiteral = (ast, schemaType) => {
+    return ast.propertySignatures
+        .map((prop) => {
+        const columnSchemas = getColumnTypeSchemas(prop.type);
+        if (columnSchemas !== null) {
+            const targetSchema = columnSchemas[schemaType];
+            // Check for Schema.Never BEFORE mutable transformation
+            // Schema.mutable() wraps in Transformation node, changing _tag
+            if (AST.isNeverKeyword(targetSchema.ast)) {
+                return null; // Will be filtered out
+            }
+            // Use Schema.mutable() for insert/update schema to make arrays mutable
+            // Kysely expects mutable T[] for insert/update operations
+            const shouldBeMutable = schemaType === "updateSchema" || schemaType === "insertSchema";
+            return new AST.PropertySignature(prop.name, shouldBeMutable ? Schema.mutable(targetSchema).ast : targetSchema.ast, prop.isOptional, prop.isReadonly, prop.annotations);
+        }
+        // Handle Generated fields for Selectable - need to unwrap the base type
+        // Generated<T> annotates the schema but we want plain T for select
+        if (schemaType === "selectSchema" && isGeneratedType(prop.type)) {
+            // Generated fields have the base schema stored in annotations
+            // The AST is the annotated version of the base schema, so just strip annotations
+            // Get the underlying type by removing the Generated annotation
+            const baseAst = AST.annotations(prop.type, {
+                ...prop.type.annotations,
+                [GeneratedId]: undefined,
+                [ColumnTypeId]: undefined,
+            });
+            return new AST.PropertySignature(prop.name, baseAst, prop.isOptional, prop.isReadonly, prop.annotations);
+        }
+        // Apply Schema.mutable() to regular fields for insert/updateSchema to make arrays mutable
+        // Safe for all types - no-op for non-arrays
+        if (schemaType === "updateSchema" || schemaType === "insertSchema") {
+            return new AST.PropertySignature(prop.name, Schema.mutable(Schema.asSchema(Schema.make(prop.type))).ast, prop.isOptional, prop.isReadonly, prop.annotations);
+        }
+        // Regular fields - return as-is
+        return prop;
+    })
+        .filter((prop) => prop !== null);
+};
+// ============================================================================
+// Schema Functions
+// ============================================================================
+export function Selectable(schema) {
+    // Strip Generated/ColumnType wrappers to match what Kysely returns from queries
+    // Branded foreign keys (UserId, ProductId) are preserved
+    const { ast } = schema;
+    if (!AST.isTypeLiteral(ast)) {
+        // Non-struct schemas: use as identity
+        // Internal cast needed because Schema.make(ast) returns unknown types
+        // The return type annotation is what TypeScript uses for declaration emit
+        return Schema.asSchema(Schema.make(ast));
+    }
+    // Extract select schemas from annotated fields (strips wrappers at runtime)
+    return Schema.asSchema(Schema.make(new AST.TypeLiteral(extractParametersFromTypeLiteral(ast, "selectSchema"), ast.indexSignatures, ast.annotations)));
+}
+/**
+ * Create Insertable schema from base schema
+ * Generated fields (@default) are made optional, not excluded
+ */
+export function Insertable(schema) {
+    const { ast } = schema;
+    if (!AST.isTypeLiteral(ast)) {
+        // Internal cast - return type annotation is what TypeScript uses for declaration emit
+        return Schema.asSchema(Schema.make(ast));
+    }
+    const extracted = extractParametersFromTypeLiteral(ast, "insertSchema");
+    const fields = extracted.map((prop) => {
+        // Check if this is a Generated field - make it optional
+        const isGenerated = isGeneratedType(prop.type);
+        // Make Union(T, null) fields optional and strip null from the type
+        // For INSERT, omitting a field = null in DB, so explicit null is unnecessary
+        const isOptional = isOptionalType(prop.type) || isGenerated;
+        // For generated fields, unwrap the base type from the Generated annotation
+        let fieldType = prop.type;
+        if (isGenerated) {
+            // Strip the Generated annotation to get the base type
+            fieldType = AST.annotations(prop.type, {
+                ...prop.type.annotations,
+                [GeneratedId]: undefined,
+            });
+        }
+        else if (isOptionalType(prop.type)) {
+            fieldType = stripNullFromUnion(prop.type);
+        }
+        return new AST.PropertySignature(prop.name, fieldType, isOptional, prop.isReadonly, prop.annotations);
+    });
+    return Schema.asSchema(Schema.make(new AST.TypeLiteral(fields, ast.indexSignatures, ast.annotations)));
+}
+/**
+ * Create Updateable schema from base schema
+ */
+export function Updateable(schema) {
+    const { ast } = schema;
+    if (!AST.isTypeLiteral(ast)) {
+        // Internal cast - return type annotation is what TypeScript uses for declaration emit
+        return Schema.asSchema(Schema.make(ast));
+    }
+    const extracted = extractParametersFromTypeLiteral(ast, "updateSchema");
+    const res = new AST.TypeLiteral(extracted.map((prop) => new AST.PropertySignature(prop.name, AST.Union.make([prop.type, new AST.UndefinedKeyword()]), true, prop.isReadonly, prop.annotations)), ast.indexSignatures, ast.annotations);
+    return Schema.asSchema(Schema.make(res));
+}

package/dist/src/schema-generator/effect/enum.d.ts

@@ -0,0 +1,12 @@
+import type { DMMF } from "@prisma/generator-helper";
+export declare function prepareEnumData(enumDef: DMMF.DatamodelEnum): {
+    name: string;
+    values: string;
+};
+export declare function prepareEnumsData(enums: readonly DMMF.DatamodelEnum[]): {
+    header: string;
+    enums: {
+        name: string;
+        values: string;
+    }[];
+} | null;

package/dist/src/schema-generator/effect/enum.js

@@ -0,0 +1,18 @@
+import { getEnumValueDbName } from "../prisma/enum.js";
+import { generateFileHeader } from "../utils/codegen.js";
+import { toPascalCase } from "../utils/naming.js";
+export function prepareEnumData(enumDef) {
+    const schemaName = toPascalCase(enumDef.name);
+    const values = enumDef.values
+        .map((v) => `"${getEnumValueDbName(v)}"`)
+        .join(", ");
+    return { name: schemaName, values };
+}
+export function prepareEnumsData(enums) {
+    if (enums.length === 0) {
+        return null;
+    }
+    const header = generateFileHeader();
+    const enumItems = enums.map(prepareEnumData);
+    return { header, enums: enumItems };
+}

package/dist/src/schema-generator/effect/generator.d.ts

@@ -0,0 +1,16 @@
+import type { DMMF } from "@prisma/generator-helper";
+export declare const prepareBrandedIdSchemaData: (model: DMMF.Model, fields: readonly DMMF.Field[]) => {
+    name: string;
+    baseType: string;
+} | null;
+export declare const prepareModelSchemaData: (dmmf: DMMF.Document, model: DMMF.Model, fields: readonly DMMF.Field[]) => {
+    name: string;
+    fields: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const prepareTypesHeaderData: (dmmf: DMMF.Document, hasEnums: boolean) => {
+    header: string;
+    enumImports: string | null;
+};

package/dist/src/schema-generator/effect/generator.js

@@ -0,0 +1,42 @@
+import { buildKyselyFieldType } from "../kysely/type.js";
+import { buildForeignKeyMap } from "../prisma/relation.js";
+import { isUuidField } from "../prisma/type.js";
+import { generateFileHeader } from "../utils/codegen.js";
+import { toPascalCase } from "../utils/naming.js";
+import { buildFieldType } from "./type.js";
+export const prepareBrandedIdSchemaData = (model, fields) => {
+    const idField = fields.find((f) => f.isId);
+    if (!idField) {
+        return null;
+    }
+    const name = toPascalCase(model.name);
+    const isUuid = isUuidField(idField);
+    let baseType;
+    if (isUuid) {
+        baseType = "Schema.UUID";
+    }
+    else if (idField.type === "Int") {
+        baseType = "Schema.Number.pipe(Schema.positive())";
+    }
+    else {
+        baseType = "Schema.String";
+    }
+    return { name, baseType };
+};
+export const prepareModelSchemaData = (dmmf, model, fields) => {
+    const fkMap = buildForeignKeyMap(model, dmmf.datamodel.models);
+    const name = toPascalCase(model.name);
+    const fieldDefinitions = fields.map((field) => {
+        const baseType = buildFieldType(field, dmmf, fkMap);
+        const fieldType = buildKyselyFieldType(baseType, field, dmmf, model.name);
+        return { name: field.name, type: fieldType };
+    });
+    return { name, fields: fieldDefinitions };
+};
+export const prepareTypesHeaderData = (dmmf, hasEnums) => {
+    const header = generateFileHeader();
+    const enumImports = hasEnums
+        ? dmmf.datamodel.enums.map((e) => toPascalCase(e.name)).join(", ")
+        : null;
+    return { header, enumImports };
+};

package/dist/src/schema-generator/effect/join-table.d.ts

@@ -0,0 +1,12 @@
+import type { DMMF } from "@prisma/generator-helper";
+import type { JoinTableInfo } from "../prisma/relation.js";
+export declare function prepareJoinTableData(joinTable: JoinTableInfo, dmmf: DMMF.Document): {
+    tableName: string;
+    modelA: string;
+    modelB: string;
+    columnAFieldName: string;
+    columnBFieldName: string;
+    name: string;
+    columnAField: string;
+    columnBField: string;
+};

package/dist/src/schema-generator/effect/join-table.js

@@ -0,0 +1,28 @@
+import { isUuidField } from "../prisma/type.js";
+import { toPascalCase, toSnakeCase } from "../utils/naming.js";
+export function prepareJoinTableData(joinTable, dmmf) {
+    const { tableName, relationName, modelA, modelB } = joinTable;
+    const columnAFieldName = `${toSnakeCase(modelA)}_id`;
+    const columnBFieldName = `${toSnakeCase(modelB)}_id`;
+    const modelADef = dmmf.datamodel.models.find((m) => m.name === modelA);
+    const modelBDef = dmmf.datamodel.models.find((m) => m.name === modelB);
+    const modelAIdField = modelADef?.fields.find((f) => f.isId);
+    const modelBIdField = modelBDef?.fields.find((f) => f.isId);
+    const modelABaseType = modelAIdField && isUuidField(modelAIdField) ? "Schema.UUID" : "Schema.String";
+    const modelBBaseType = modelBIdField && isUuidField(modelBIdField) ? "Schema.UUID" : "Schema.String";
+    const modelASchemaType = modelAIdField?.type === "Int" ? "Schema.Number" : modelABaseType;
+    const modelBSchemaType = modelBIdField?.type === "Int" ? "Schema.Number" : modelBBaseType;
+    const columnAField = `  ${columnAFieldName}: Schema.propertySignature(columnType(${modelASchemaType}, Schema.Never, Schema.Never)).pipe(Schema.fromKey("A"))`;
+    const columnBField = `  ${columnBFieldName}: Schema.propertySignature(columnType(${modelBSchemaType}, Schema.Never, Schema.Never)).pipe(Schema.fromKey("B"))`;
+    const pascalName = toPascalCase(relationName);
+    return {
+        tableName,
+        modelA,
+        modelB,
+        columnAFieldName,
+        columnBFieldName,
+        name: pascalName,
+        columnAField,
+        columnBField,
+    };
+}

package/dist/src/schema-generator/effect/type.d.ts

@@ -0,0 +1,18 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * Map Prisma field type to Effect Schema type
+ * Priority order: annotation → FK branded → UUID → scalar → enum → unknown fallback
+ *
+ * @param field - The Prisma field to map
+ * @param dmmf - The full DMMF document for enum lookups
+ * @param fkMap - Optional FK field → target model mapping for branded FK types
+ */
+export declare function mapFieldToEffectType(field: DMMF.Field, dmmf: DMMF.Document, fkMap?: Map<string, string>): string;
+/**
+ * Build complete field type with array and optional wrapping
+ *
+ * @param field - The Prisma field to build type for
+ * @param dmmf - The full DMMF document for enum lookups
+ * @param fkMap - Optional FK field → target model mapping for branded FK types
+ */
+export declare function buildFieldType(field: DMMF.Field, dmmf: DMMF.Document, fkMap?: Map<string, string>): string;