@effectify/prisma 0.1.1 → 1.0.0

package/dist/src/effect-prisma.js

@@ -1,1771 +0,0 @@
-#!/usr/bin/env -S pnpm dlx tsx
-/** biome-ignore-all lint/nursery/useMaxParams: <explanation> */
-/** biome-ignore-all lint/nursery/noShadow: <todo> */
-/** biome-ignore-all lint/complexity/noExcessiveCognitiveComplexity: <todo> */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import generatorHelper from '@prisma/generator-helper';
-const { generatorHandler } = generatorHelper;
-const header = '// This file was generated by prisma-effect-generator, do not edit manually.\n';
-// Utility function to convert PascalCase to camelCase
-const prismaSchemaContent = `/**
- * @since 1.0.0
- */
-import * as Cause from 'effect/Cause'
-import * as Effect from 'effect/Effect'
-import type * as Option from 'effect/Option'
-import type { ParseError } from 'effect/ParseResult'
-import * as Schema from 'effect/Schema'
-
-/**
- * Run a sql query with a request schema and a result schema.
- *
- * @since 1.0.0
- * @category constructor
- */
-export const findAll = <IR, II, IA, AR, AI, A, R, E>(options: {
-  readonly Request: Schema.Schema<IA, II, IR>
-  readonly Result: Schema.Schema<A, AI, AR>
-  readonly execute: (request: II) => Effect.Effect<ReadonlyArray<unknown>, E, R>
-}) => {
-  const encodeRequest = Schema.encode(options.Request)
-  const decode = Schema.decodeUnknown(Schema.Array(options.Result))
-  return (request: IA): Effect.Effect<ReadonlyArray<A>, E | ParseError, R | IR | AR> =>
-    Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode)
-}
-
-const void_ = <IR, II, IA, R, E>(options: {
-  readonly Request: Schema.Schema<IA, II, IR>
-  readonly execute: (request: II) => Effect.Effect<unknown, E, R>
-}) => {
-  const encode = Schema.encode(options.Request)
-  return (request: IA): Effect.Effect<void, E | ParseError, R | IR> =>
-    Effect.asVoid(Effect.flatMap(encode(request), options.execute))
-}
-export {
-  /**
-   * Run a sql query with a request schema and discard the result.
-   *
-   * @since 1.0.0
-   * @category constructor
-   */
-  void_ as void,
-}
-
-/**
- * Run a sql query with a request schema and a result schema and return the first result.
- *
- * @since 1.0.0
- * @category constructor
- */
-export const findOne = <IR, II, IA, AR, AI, A, R, E>(options: {
-  readonly Request: Schema.Schema<IA, II, IR>
-  readonly Result: Schema.Schema<A, AI, AR>
-  readonly execute: (request: II) => Effect.Effect<ReadonlyArray<unknown>, E, R>
-}) => {
-  const encodeRequest = Schema.encode(options.Request)
-  const decode = Schema.decodeUnknown(options.Result)
-  return (request: IA): Effect.Effect<Option.Option<A>, E | ParseError, R | IR | AR> =>
-    Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), (arr) =>
-      Array.isArray(arr) && arr.length > 0 ? Effect.asSome(decode(arr[0])) : Effect.succeedNone,
-    )
-}
-
-/**
- * Run a sql query with a request schema and a result schema and return the first result.
- *
- * @since 1.0.0
- * @category constructor
- */
-export const single = <IR, II, IA, AR, AI, A, R, E>(options: {
-  readonly Request: Schema.Schema<IA, II, IR>
-  readonly Result: Schema.Schema<A, AI, AR>
-  readonly execute: (request: II) => Effect.Effect<ReadonlyArray<unknown>, E, R>
-}) => {
-  const encodeRequest = Schema.encode(options.Request)
-  const decode = Schema.decodeUnknown(options.Result)
-  return (request: IA): Effect.Effect<A, E | ParseError | Cause.NoSuchElementException, R | IR | AR> =>
-    Effect.flatMap(
-      Effect.flatMap(encodeRequest(request), options.execute),
-      (arr): Effect.Effect<A, ParseError | Cause.NoSuchElementException, AR> =>
-        Array.isArray(arr) && arr.length > 0 ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementException()),
-    )
-}
-
-export const many = <IR, II, IA, AR, AI, A, R, E>(options: {
-  readonly Request: Schema.Schema<IA, II, IR>
-  readonly Result: Schema.Schema<A, AI, AR>
-  readonly execute: (request: II) => Effect.Effect<Array<unknown>, E, R>
-}) => {
-  const encodeRequest = Schema.encode(options.Request)
-  const decode = Schema.decodeUnknown(Schema.Array(options.Result))
-  return (request: IA): Effect.Effect<Array<A>, E | ParseError, R | IR | AR> =>
-    Effect.map(Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode), (arr) => [...arr])
-}
-`;
-const getPrismaModelContent = (clientImportPath) => `/** biome-ignore-all lint/suspicious/noExplicitAny: <todo> */
-/** biome-ignore-all lint/style/useDefaultSwitchClause: <todo> */
-
-import * as VariantSchema from '@effect/experimental/VariantSchema'
-import { type PrismaClient as BasePrismaClient, Prisma as PrismaNamespace } from '${clientImportPath}'
-import { PrismaClient } from './index.js'
-import * as Data from 'effect/Data'
-import * as Effect from 'effect/Effect'
-import type * as Option from 'effect/Option'
-import * as Schema from 'effect/Schema'
-import * as SqlSchema from './prisma-schema.js'
-
-export class PrismaUniqueConstraintError extends Data.TaggedError('PrismaUniqueConstraintError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaForeignKeyConstraintError extends Data.TaggedError('PrismaForeignKeyConstraintError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaRecordNotFoundError extends Data.TaggedError('PrismaRecordNotFoundError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaRelationViolationError extends Data.TaggedError('PrismaRelationViolationError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaRelatedRecordNotFoundError extends Data.TaggedError('PrismaRelatedRecordNotFoundError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaTransactionConflictError extends Data.TaggedError('PrismaTransactionConflictError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaValueTooLongError extends Data.TaggedError('PrismaValueTooLongError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaValueOutOfRangeError extends Data.TaggedError('PrismaValueOutOfRangeError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaDbConstraintError extends Data.TaggedError('PrismaDbConstraintError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaConnectionError extends Data.TaggedError('PrismaConnectionError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaMissingRequiredValueError extends Data.TaggedError('PrismaMissingRequiredValueError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaInputValidationError extends Data.TaggedError('PrismaInputValidationError')<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export type PrismaCreateError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaRelatedRecordNotFoundError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaTransactionConflictError
-
-export type PrismaUpdateError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaRelationViolationError
-  | PrismaRelatedRecordNotFoundError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-  | PrismaTransactionConflictError
-
-export type PrismaDeleteError =
-  | PrismaForeignKeyConstraintError
-  | PrismaRelationViolationError
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-  | PrismaTransactionConflictError
-
-export type PrismaFindOrThrowError =
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-
-export type PrismaFindError =
-  | PrismaConnectionError
-
-export type PrismaDeleteManyError =
-  | PrismaForeignKeyConstraintError
-  | PrismaRelationViolationError
-  | PrismaConnectionError
-  | PrismaTransactionConflictError
-
-export type PrismaUpdateManyError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaTransactionConflictError
-
-// Create, Upsert
-export const mapCreateError = (error: unknown, operation: string, model: string): PrismaCreateError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case 'P2000':
-        return new PrismaValueTooLongError({ cause: error, operation, model })
-      case 'P2002':
-        return new PrismaUniqueConstraintError({ cause: error, operation, model })
-      case 'P2003':
-        return new PrismaForeignKeyConstraintError({ cause: error, operation, model })
-      case 'P2004':
-        return new PrismaDbConstraintError({ cause: error, operation, model })
-      case 'P2005':
-      case 'P2006':
-      case 'P2019':
-        return new PrismaInputValidationError({ cause: error, operation, model })
-      case 'P2011':
-      case 'P2012':
-        return new PrismaMissingRequiredValueError({ cause: error, operation, model })
-      case 'P2015':
-      case 'P2018':
-        return new PrismaRelatedRecordNotFoundError({ cause: error, operation, model })
-      case 'P2020':
-        return new PrismaValueOutOfRangeError({ cause: error, operation, model })
-      case 'P2024':
-        return new PrismaConnectionError({ cause: error, operation, model })
-      case 'P2034':
-        return new PrismaTransactionConflictError({ cause: error, operation, model })
-    }
-  }
-  throw error
-}
-
-// Update
-export const mapUpdateError = (error: unknown, operation: string, model: string): PrismaUpdateError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2000":
-        return new PrismaValueTooLongError({ cause: error, operation, model });
-      case "P2002":
-        return new PrismaUniqueConstraintError({ cause: error, operation, model });
-      case "P2003":
-        return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
-      case "P2004":
-        return new PrismaDbConstraintError({ cause: error, operation, model });
-      case "P2005":
-      case "P2006":
-      case "P2019":
-        return new PrismaInputValidationError({ cause: error, operation, model });
-      case "P2011":
-      case "P2012":
-        return new PrismaMissingRequiredValueError({ cause: error, operation, model });
-      case "P2014":
-        return new PrismaRelationViolationError({ cause: error, operation, model });
-      case "P2015":
-      case "P2018":
-        return new PrismaRelatedRecordNotFoundError({ cause: error, operation, model });
-      case "P2020":
-        return new PrismaValueOutOfRangeError({ cause: error, operation, model });
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-      case "P2025":
-        return new PrismaRecordNotFoundError({ cause: error, operation, model });
-      case "P2034":
-        return new PrismaTransactionConflictError({ cause: error, operation, model });
-    }
-  }
-  throw error;
-}
-
-// Delete
-export const mapDeleteError = (error: unknown, operation: string, model: string): PrismaDeleteError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2003":
-        return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
-      case "P2014":
-        return new PrismaRelationViolationError({ cause: error, operation, model });
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-      case "P2025":
-        return new PrismaRecordNotFoundError({ cause: error, operation, model });
-      case "P2034":
-        return new PrismaTransactionConflictError({ cause: error, operation, model });
-    }
-  }
-  throw error;
-}
-
-// FindOrThrow
-export const mapFindOrThrowError = (error: unknown, operation: string, model: string): PrismaFindOrThrowError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-      case "P2025":
-        return new PrismaRecordNotFoundError({ cause: error, operation, model });
-    }
-  }
-  throw error;
-}
-
-// Find
-export const mapFindError = (error: unknown, operation: string, model: string): PrismaFindError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-    }
-  }
-  throw error;
-}
-
-// DeleteMany
-export const mapDeleteManyError = (error: unknown, operation: string, model: string): PrismaDeleteManyError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2003":
-        return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
-      case "P2014":
-        return new PrismaRelationViolationError({ cause: error, operation, model });
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-      case "P2034":
-        return new PrismaTransactionConflictError({ cause: error, operation, model });
-    }
-  }
-  throw error;
-}
-
-// UpdateMany
-export const mapUpdateManyError = (error: unknown, operation: string, model: string): PrismaUpdateManyError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2000":
-        return new PrismaValueTooLongError({ cause: error, operation, model });
-      case "P2002":
-        return new PrismaUniqueConstraintError({ cause: error, operation, model });
-      case "P2003":
-        return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
-      case "P2004":
-        return new PrismaDbConstraintError({ cause: error, operation, model });
-      case "P2005":
-      case "P2006":
-      case "P2019":
-        return new PrismaInputValidationError({ cause: error, operation, model });
-      case "P2011":
-      case "P2012":
-        return new PrismaMissingRequiredValueError({ cause: error, operation, model });
-      case "P2020":
-        return new PrismaValueOutOfRangeError({ cause: error, operation, model });
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-      case "P2034":
-        return new PrismaTransactionConflictError({ cause: error, operation, model });
-    }
-  }
-  throw error;
-}
-
-const { Class, Field, FieldExcept, FieldOnly, Struct, Union, extract, fieldEvolve, fieldFromKey } = VariantSchema.make({
-  variants: [
-    'findUnique',
-    'findUniqueOrThrow',
-    'findFirst',
-    'findFirstOrThrow',
-    'findMany',
-    'create',
-    'createMany',
-    'createManyAndReturn',
-    'update',
-    'json',
-    'jsonCreate',
-    'jsonUpdate',
-  ],
-  defaultVariant: 'findUnique',
-})
-
-/**
- * @since 1.0.0
- * @category models
- */
-export type Any = Schema.Schema.Any & {
-  readonly fields: Schema.Struct.Fields
-  readonly findUnique: Schema.Schema.Any
-  readonly findUniqueOrThrow: Schema.Schema.Any
-  readonly findFirst: Schema.Schema.Any
-  readonly findFirstOrThrow: Schema.Schema.Any
-  readonly findMany: Schema.Schema.Any
-  readonly create: Schema.Schema.Any
-  readonly createMany: Schema.Schema.Any
-  readonly createManyAndReturn: Schema.Schema.Any
-  readonly update: Schema.Schema.Any
-  readonly json: Schema.Schema.Any
-  readonly jsonCreate: Schema.Schema.Any
-  readonly jsonUpdate: Schema.Schema.Any
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export type AnyNoContext = Schema.Schema.AnyNoContext & {
-  readonly fields: Schema.Struct.Fields
-  readonly findUnique: Schema.Schema.AnyNoContext
-  readonly findUniqueOrThrow: Schema.Schema.AnyNoContext
-  readonly findFirst: Schema.Schema.AnyNoContext
-  readonly findFirstOrThrow: Schema.Schema.AnyNoContext
-  readonly findMany: Schema.Schema.AnyNoContext
-  readonly create: Schema.Schema.AnyNoContext
-  readonly createMany: Schema.Schema.AnyNoContext
-  readonly createManyAndReturn: Schema.Schema.AnyNoContext
-  readonly update: Schema.Schema.AnyNoContext
-  readonly json: Schema.Schema.AnyNoContext
-  readonly jsonCreate: Schema.Schema.AnyNoContext
-  readonly jsonUpdate: Schema.Schema.AnyNoContext
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export type VariantsDatabase =
-  | 'findUnique'
-  | 'findUniqueOrThrow'
-  | 'findFirst'
-  | 'findFirstOrThrow'
-  | 'findMany'
-  | 'create'
-  | 'createMany'
-  | 'createManyAndReturn'
-  | 'update'
-
-/**
- * @since 1.0.0
- * @category models
- */
-export type VariantsJson = 'json' | 'jsonCreate' | 'jsonUpdate'
-
-export {
-  /**
-   * A base class used for creating domain model schemas.
-   *
-   * It supports common variants for database and JSON apis.
-   *
-   * @since 1.0.0
-   * @category constructors
-   * @example
-   * \`\`\`ts
-   * import { Schema } from "effect"
-   * import { Model } from "@effect/sql"
-   *
-   * export const GroupId = Schema.Number.pipe(Schema.brand("GroupId"))
-   *
-   * export class Group extends Model.Class<Group>("Group")({
-   *   id: Model.Generated(GroupId),
-   *   name: Schema.NonEmptyTrimmedString,
-   *   createdAt: Model.DateTimeInsertFromDate,
-   *   updatedAt: Model.DateTimeUpdateFromDate
-   * }) {}
-   *
-   * // schema used for selects
-   * Group
-   *
-   * // schema used for inserts
-   * Group.insert
-   *
-   * // schema used for updates
-   * Group.update
-   *
-   * // schema used for json api
-   * Group.json
-   * Group.jsonCreate
-   * Group.jsonUpdate
-   *
-   * // you can also turn them into classes
-   * class GroupJson extends Schema.Class<GroupJson>("GroupJson")(Group.json) {
-   *   get upperName() {
-   *     return this.name.toUpperCase()
-   *   }
-   * }
-   * \`\`\`
-   */
-  Class,
-  /**
-   * @since 1.0.0
-   * @category extraction
-   */
-  extract,
-  /**
-   * @since 1.0.0
-   * @category fields
-   */
-  Field,
-  /**
-   * @since 1.0.0
-   * @category fields
-   */
-  fieldEvolve,
-  /**
-   * @since 1.0.0
-   * @category fields
-   */
-  FieldExcept,
-  /**
-   * @since 1.0.0
-   * @category fields
-   */
-  fieldFromKey,
-  /**
-   * @since 1.0.0
-   * @category fields
-   */
-  FieldOnly,
-  /**
-   * @since 1.0.0
-   * @category constructors
-   */
-  Struct,
-  /**
-   * @since 1.0.0
-   * @category constructors
-   */
-  Union,
-}
-
-/**
- * Create a simple CRUD repository from a model.
- *
- * @since 1.0.0
- * @category repository
- */
-export const make = <S extends Any, M extends keyof BasePrismaClient>(
-  Model: S,
-  options: {
-    readonly modelName: M extends string ? M : string
-    readonly spanPrefix: string
-    readonly uniqueKey?: string | ReadonlyArray<string>
-  },
-): Effect.Effect<
-  {
-    readonly findUnique: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>,
-    ) => Effect.Effect<Option.Option<S['Type']>, PrismaFindError, S['Context'] | S['findUnique']['Context']>
-
-    readonly findUniqueOrThrow: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>,
-    ) => Effect.Effect<S['Type'], PrismaFindOrThrowError, S['Context'] | S['findUniqueOrThrow']['Context']>
-
-    readonly findFirst: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findFirst'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findFirst'>>
-    ) => Effect.Effect<Option.Option<S['Type']>, PrismaFindError, S['Context'] | S['findFirst']['Context']>
-
-    readonly findFirstOrThrow: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findFirstOrThrow'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findFirstOrThrow'>>
-    ) => Effect.Effect<S['Type'], PrismaFindOrThrowError, S['Context'] | S['findFirstOrThrow']['Context']>
-
-    readonly findMany: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findMany'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findMany'>>
-    ) => Effect.Effect<Array<S['Type']>, PrismaFindError, S['Context'] | S['findMany']['Context']>
-
-    readonly create: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'create'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'create'>>,
-    ) => Effect.Effect<S['Type'], PrismaCreateError, S['Context'] | S['create']['Context']>
-
-    readonly createMany: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>,
-    ) => Effect.Effect<PrismaNamespace.BatchPayload, PrismaCreateError, S['Context'] | S['createMany']['Context']>
-
-    readonly createManyAndReturn: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>,
-    ) => Effect.Effect<Array<S['Type']>, PrismaCreateError, S['Context'] | S['createManyAndReturn']['Context']>
-
-    readonly update: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'update'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'update'>>
-    ) => Effect.Effect<S['Type'], PrismaUpdateError, S['Context'] | S['update']['Context']>
-
-    readonly updateMany: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>
-    ) => Effect.Effect<PrismaNamespace.BatchPayload, PrismaUpdateManyError, S['Context'] | S['update']['Context']>
-
-    readonly delete: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'delete'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'delete'>>
-    ) => Effect.Effect<S['Type'], PrismaDeleteError, S['Context']>
-
-    readonly deleteMany: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'deleteMany'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'deleteMany'>>
-    ) => Effect.Effect<PrismaNamespace.BatchPayload, PrismaDeleteManyError, S['Context']>
-
-    readonly upsert: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>
-    ) => Effect.Effect<S['Type'], PrismaCreateError, S['Context']>
-
-    readonly count: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'count'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'count'>>
-    ) => Effect.Effect<unknown, PrismaFindError, S['Context']>
-
-    readonly aggregate: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'aggregate'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'aggregate'>>
-    ) => Effect.Effect<unknown, PrismaFindError, S['Context']>
-
-    readonly groupBy: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'groupBy'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'groupBy'>>
-    ) => Effect.Effect<unknown, PrismaFindError, S['Context']>
-  },
-  never,
-  PrismaClient
-> =>
-  Effect.gen(function* () {
-    const prisma = yield* PrismaClient
-
-    // Construye el schema del where para findUnique usando uniqueKey en modo builder
-    let findUniqueRequestSchema: Schema.Schema<any, any, any> = Schema.Unknown
-    if (options.uniqueKey) {
-      const keys = Array.isArray(options.uniqueKey) ? options.uniqueKey : [options.uniqueKey]
-      const shape: Record<string, Schema.Schema.Any> = {}
-      let valid = true
-      for (const key of keys) {
-        const field = (Model as any).fields?.[key]
-        if (!field) {
-          valid = false
-          break
-        }
-        shape[key] = field
-      }
-      if (valid) {
-        findUniqueRequestSchema = Schema.Struct(shape as any)
-      }
-    }
-
-    const findUniqueSchema = SqlSchema.findOne({
-      Request: findUniqueRequestSchema,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).findUnique({ where: request }) as any,
-          catch: (error) => mapFindError(error, 'findUnique', options.modelName),
-        }).pipe(Effect.map((result) => (result ? [result] : []))),
-    })
-
-    const findUnique = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>,
-    ): Effect.Effect<Option.Option<S['Type']>, never, S['Context'] | S['findUnique']['Context']> =>
-      findUniqueSchema((args as any).where).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.findUnique\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any).where },
-        }),
-      ) as any
-
-    const findUniqueOrThrowSchema = SqlSchema.single({
-      Request: findUniqueRequestSchema,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).findUniqueOrThrow({
-              where: request,
-            }) as any,
-          catch: (error) => mapFindOrThrowError(error, 'findUniqueOrThrow', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const findUniqueOrThrow = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findUnique'>>,
-    ): Effect.Effect<S['Type'], never, S['Context'] | S['findUniqueOrThrow']['Context']> =>
-      findUniqueOrThrowSchema((args as any).where).pipe(
-        Effect.map((result) => result as S['Type']),
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.findUniqueOrThrow\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any).where },
-        }),
-      ) as any
-
-    const findFirstSchema = SqlSchema.findOne({
-      Request: Schema.Unknown,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).findFirst(request) as any,
-          catch: (error) => mapFindError(error, 'findFirst', options.modelName),
-        }).pipe(Effect.map((result) => (result ? [result] : []))),
-    })
-
-    const findFirst = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findFirst'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findFirst'>>
-    ): Effect.Effect<Option.Option<S['Type']>, never, S['Context'] | S['findFirst']['Context']> =>
-      findFirstSchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.findFirst\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const findFirstOrThrowSchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).findFirstOrThrow(request) as any,
-          catch: (error) => mapFindOrThrowError(error, 'findFirstOrThrow', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const findFirstOrThrow = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findFirstOrThrow'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findFirstOrThrow'>>
-    ): Effect.Effect<S['Type'], never, S['Context'] | S['findFirstOrThrow']['Context']> =>
-      findFirstOrThrowSchema(args).pipe(
-        Effect.map((result) => result as S['Type']),
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.findFirstOrThrow\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const findManySchema = SqlSchema.many({
-      Request: Schema.Unknown,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).findMany(request) as any,
-          catch: (error) => mapFindError(error, 'findMany', options.modelName),
-        }).pipe(Effect.map((result) => result as any)),
-    })
-
-    const findMany = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'findMany'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'findMany'>>
-    ): Effect.Effect<Array<S['Type']>, never, S['Context'] | S['findMany']['Context']> =>
-      findManySchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.findMany\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const createSchema = SqlSchema.single({
-      Request: Model.create,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).create({ data: request }),
-          catch: (error) => mapCreateError(error, 'create', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const create = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'create'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'create'>>,
-    ): Effect.Effect<S['Type'], never, S['Context'] | S['create']['Context']> =>
-      createSchema((args as any).data).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.create\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any).data },
-        }),
-      ) as any
-
-    const createManySchema = SqlSchema.single({
-      Request: Schema.Array(Model.createMany),
-      Result: Schema.Unknown,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).createMany({ data: request as any }),
-          catch: (error) => mapCreateError(error, 'createMany', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const createMany = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>,
-    ): Effect.Effect<PrismaNamespace.BatchPayload, never, S['Context'] | S['createMany']['Context']> =>
-      createManySchema((args as any).data).pipe(
-        Effect.map((res) => res as unknown as PrismaNamespace.BatchPayload),
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.createMany\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any).data },
-        }),
-      ) as any
-
-    const createManyAndReturnSchema = SqlSchema.many({
-      Request: Schema.Array(Model.createMany),
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () =>
-            ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).createManyAndReturn({
-              data: request as any,
-            }),
-          catch: (error) => mapCreateError(error, 'createManyAndReturn', options.modelName),
-        }),
-    })
-
-    const createManyAndReturn = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>,
-    ): Effect.Effect<Array<S['Type']>, never, S['Context'] | S['createManyAndReturn']['Context']> =>
-      createManyAndReturnSchema((args as any).data).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.createManyAndReturn\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any).data },
-        }),
-      ) as any
-
-    const countSchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Schema.Unknown,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).count(request),
-          catch: (error) => mapFindError(error, 'count', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const count = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'count'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'count'>>
-    ): Effect.Effect<unknown, never, S['Context']> =>
-      countSchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.count\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const updateSchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).update(request),
-          catch: (error) => mapUpdateError(error, 'update', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const update = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'update'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'update'>>
-    ): Effect.Effect<S['Type'], never, S['Context'] | S['update']['Context']> =>
-      updateSchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.update\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const deleteSchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).delete(request),
-          catch: (error) => mapDeleteError(error, 'delete', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const delete_ = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'delete'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'delete'>>
-    ): Effect.Effect<S['Type'], never, S['Context']> =>
-      deleteSchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.delete\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const upsertSchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Model,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).upsert(request),
-          catch: (error) => mapCreateError(error, 'upsert', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const upsert = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>
-    ): Effect.Effect<S['Type'], never, S['Context']> =>
-      upsertSchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.upsert\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const aggregateSchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Schema.Unknown,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).aggregate(request),
-          catch: (error) => mapFindError(error, 'aggregate', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const aggregate = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'aggregate'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'aggregate'>>
-    ): Effect.Effect<unknown, never, S['Context']> =>
-      aggregateSchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.aggregate\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const groupBySchema = SqlSchema.many({
-      Request: Schema.Unknown,
-      Result: Schema.Unknown,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).groupBy(request),
-          catch: (error) => mapFindError(error, 'groupBy', options.modelName),
-        }).pipe(Effect.map((result) => result as any)),
-    })
-
-    const groupBy = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'groupBy'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'groupBy'>>
-    ): Effect.Effect<unknown, never, S['Context']> =>
-      groupBySchema(args).pipe(
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.groupBy\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const updateManySchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Schema.Unknown,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).updateMany(request),
-          catch: (error) => mapUpdateManyError(error, 'updateMany', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const updateMany = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>
-    ): Effect.Effect<PrismaNamespace.BatchPayload, never, S['Context'] | S['update']['Context']> =>
-      updateManySchema(args).pipe(
-        Effect.map((res) => res as unknown as PrismaNamespace.BatchPayload),
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.updateMany\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    const deleteManySchema = SqlSchema.single({
-      Request: Schema.Unknown,
-      Result: Schema.Unknown,
-      execute: (request) =>
-        Effect.tryPromise({
-          try: () => ((prisma.tx as BasePrismaClient)[options.modelName as M] as any).deleteMany(request),
-          catch: (error) => mapDeleteManyError(error, 'deleteMany', options.modelName),
-        }).pipe(Effect.map((result) => [result] as any)),
-    })
-
-    const deleteMany = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'deleteMany'>>(
-      args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'deleteMany'>>
-    ): Effect.Effect<PrismaNamespace.BatchPayload, never, S['Context']> =>
-      deleteManySchema(args).pipe(
-        Effect.map((res) => res as unknown as PrismaNamespace.BatchPayload),
-        Effect.catchTag('ParseError', Effect.die),
-        Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(\`\${options.spanPrefix}.deleteMany\`, {
-          captureStackTrace: false,
-          attributes: { ...(args as any) },
-        }),
-      ) as any
-
-    return {
-      findUnique,
-      findUniqueOrThrow,
-      findFirst,
-      findFirstOrThrow,
-      findMany,
-      create,
-      createMany,
-      createManyAndReturn,
-      update,
-      updateMany,
-      delete: delete_,
-      deleteMany,
-      upsert,
-      count,
-      aggregate,
-      groupBy
-    } as const
-
-  })
-`;
-generatorHandler({
-    onManifest() {
-        return {
-            defaultOutput: '../generated/effect',
-            prettyName: 'Prisma Effect Generator',
-            // No engines required - we only read the DMMF schema
-            requiresEngines: [],
-        };
-    },
-    async onGenerate(options) {
-        const models = options.dmmf.datamodel.models;
-        const outputDir = options.generator.output?.value;
-        const schemaDir = path.dirname(options.schemaPath);
-        const configPath = options.generator.config.clientImportPath;
-        const clientImportPath = Array.isArray(configPath) ? configPath[0] : (configPath ?? '@prisma/client');
-        const errorConfigRaw = options.generator.config.errorImportPath;
-        const errorImportPathRaw = Array.isArray(errorConfigRaw) ? errorConfigRaw[0] : errorConfigRaw;
-        const importExtConfigRaw = options.generator.config.importFileExtension;
-        const importFileExtension = Array.isArray(importExtConfigRaw) ? importExtConfigRaw[0] : (importExtConfigRaw ?? '');
-        if (!outputDir) {
-            throw new Error('No output directory specified');
-        }
-        const addExtension = (filePath) => {
-            if (!importFileExtension) {
-                return filePath;
-            }
-            const ext = path.extname(filePath);
-            if (ext) {
-                return filePath;
-            }
-            return `${filePath}.${importFileExtension}`;
-        };
-        let errorImportPath;
-        if (errorImportPathRaw) {
-            const [modulePath, className] = errorImportPathRaw.split('#');
-            if (!(modulePath && className)) {
-                throw new Error(`Invalid errorImportPath format: "${errorImportPathRaw}". Expected "path/to/module#ErrorClassName"`);
-            }
-            if (modulePath.startsWith('.')) {
-                const absoluteErrorPath = path.resolve(schemaDir, modulePath);
-                const relativeToOutput = path.relative(outputDir, absoluteErrorPath);
-                const normalizedPath = relativeToOutput.startsWith('.') ? relativeToOutput : `./${relativeToOutput}`;
-                const pathWithExtension = addExtension(normalizedPath);
-                errorImportPath = `${pathWithExtension}#${className}`;
-            }
-            else {
-                errorImportPath = errorImportPathRaw;
-            }
-        }
-        // Clean output directory
-        // await fs.rm(outputDir, { recursive: true, force: true })
-        await fs.mkdir(outputDir, { recursive: true });
-        // Write static files
-        await fs.writeFile(path.join(outputDir, 'prisma-schema.ts'), prismaSchemaContent);
-        await fs.writeFile(path.join(outputDir, 'prisma-repository.ts'), getPrismaModelContent(clientImportPath));
-        // Generate unified index file with PrismaService
-        await generateUnifiedService([...models], outputDir, clientImportPath, errorImportPath);
-        // Fix imports in schemas/index.ts
-        await fixSchemaImports(outputDir);
-    },
-});
-async function fixSchemaImports(outputDir) {
-    const schemasDir = path.join(outputDir, 'schemas');
-    const indexFile = path.join(schemasDir, 'index.ts');
-    try {
-        const content = await fs.readFile(indexFile, 'utf-8');
-        const fixedContent = content
-            .replace(/export \* from '\.\/enums'/g, "export * from './enums.js'")
-            .replace(/export \* from '\.\/types'/g, "export * from './types.js'");
-        if (content !== fixedContent) {
-            await fs.writeFile(indexFile, fixedContent);
-        }
-    }
-    catch (_error) {
-        // Ignore if file doesn't exist
-    }
-}
-function generateRawSqlOperations(customError) {
-    const errorType = customError ? customError.className : 'PrismaError';
-    return `
-    $executeRaw: (args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]): Effect.Effect<number, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$executeRaw(args[0], ...args.slice(1)) : client.$executeRaw(args)),
-          catch: (error) => mapError(error, "$executeRaw", "Prisma")
-        })
-      ),
-
-    $executeRawUnsafe: (query: string, ...values: any[]): Effect.Effect<number, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => client.$executeRawUnsafe(query, ...values),
-          catch: (error) => mapError(error, "$executeRawUnsafe", "Prisma")
-        })
-      ),
-
-    $queryRaw: <T = unknown>(args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]): Effect.Effect<T, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$queryRaw(args[0], ...args.slice(1)) : client.$queryRaw(args)) as Promise<T>,
-          catch: (error) => mapError(error, "$queryRaw", "Prisma")
-        })
-      ),
-
-    $queryRawUnsafe: <T = unknown>(query: string, ...values: any[]): Effect.Effect<T, ${errorType}, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => client.$queryRawUnsafe(query, ...values) as Promise<T>,
-          catch: (error) => mapError(error, "$queryRawUnsafe", "Prisma")
-        })
-      ),`;
-}
-function generateModelClasses(models) {
-    const modelClasses = models
-        .map((model) => {
-        const modelName = model.name;
-        const className = `${modelName}Model`;
-        return `export class ${className} extends Model.Class<${className}>("${modelName}")({
-  ..._${modelName}.fields
-}) {}`;
-    })
-        .join('\n\n');
-    return modelClasses;
-}
-// Parse error import path like "./errors#PrismaError" into { path, className }
-function parseErrorImportPath(errorImportPath) {
-    if (!errorImportPath) {
-        return null;
-    }
-    const [path, className] = errorImportPath.split('#');
-    if (!(path && className)) {
-        throw new Error(`Invalid errorImportPath format: "${errorImportPath}". Expected "path/to/module#ErrorClassName"`);
-    }
-    return { path, className };
-}
-async function generateUnifiedService(models, outputDir, clientImportPath, errorImportPath) {
-    const customError = parseErrorImportPath(errorImportPath);
-    const rawSqlOperations = generateRawSqlOperations(customError);
-    const modelClasses = generateModelClasses(models);
-    // Generate different content based on whether custom error is configured
-    const serviceContent = customError
-        ? generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelClasses, models)
-        : generateDefaultErrorService(clientImportPath, rawSqlOperations, modelClasses, models);
-    await fs.writeFile(path.join(outputDir, 'index.ts'), serviceContent);
-}
-/**
- * Generate service with custom user-provided error class.
- */
-function generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelClasses, models) {
-    const schemaImports = models.map((m) => `_${m.name}`).join(', ');
-    return `${header}
-import { Context, Effect, Exit, Layer } from "effect"
-import { Service } from "effect/Effect"
-import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "${clientImportPath}"
-import { ${customError.className}, mapPrismaError } from "${customError.path}"
-import * as Model from "./prisma-repository.js"
-import { ${schemaImports} } from "./schemas/index.js"
-
-// Symbol used to identify intentional rollbacks vs actual errors
-const ROLLBACK = Symbol.for("prisma.effect.rollback")
-
-// Type for the flat transaction client with commit/rollback control
-type FlatTransactionClient = PrismaNamespace.TransactionClient & {
-  $commit: () => Promise<void>
-  $rollback: () => Promise<void>
-}
-
-/** Transaction options for $transaction and $isolatedTransaction */
-type TransactionOptions = {
-  maxWait?: number
-  timeout?: number
-  isolationLevel?: PrismaNamespace.TransactionIsolationLevel
-}
-
-/**
- * Context tag for the Prisma client instance.
- * Holds the transaction client (tx) and root client.
- */
-export class PrismaClient extends Context.Tag("PrismaClient")<
-  PrismaClient,
-  {
-    tx: BasePrismaClient | PrismaNamespace.TransactionClient
-    client: BasePrismaClient
-  }
->() {
-  static layer = (
-    ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.scoped(
-    PrismaClient,
-    Effect.gen(function* () {
-      const prisma = new BasePrismaClient(...args)
-      yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
-    })
-  )
-
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.scoped(
-    PrismaClient,
-    Effect.gen(function* () {
-      const options = yield* optionsEffect
-      const prisma = new BasePrismaClient(options)
-      yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
-    })
-  )
-}
-
-// Re-export the custom error type for convenience
-export { ${customError.className} }
-
-// Use the user-provided error mapper
-const mapError = mapPrismaError
-
-/**
- * Internal helper to begin a callback-free interactive transaction.
- */
-const $begin = (
-  client: BasePrismaClient,
-  options?: {
-    maxWait?: number
-    timeout?: number
-    isolationLevel?: PrismaNamespace.TransactionIsolationLevel
-  }
-): Effect.Effect<FlatTransactionClient, ${customError.className}> =>
-  Effect.async<FlatTransactionClient, ${customError.className}>((resume) => {
-    let setTxClient: (txClient: PrismaNamespace.TransactionClient) => void
-    let commit: () => void
-    let rollback: () => void
-
-    const txClientPromise = new Promise<PrismaNamespace.TransactionClient>((res) => {
-      setTxClient = res
-    })
-
-    const txPromise = new Promise<void>((_res, _rej) => {
-      commit = () => _res(undefined)
-      rollback = () => _rej(ROLLBACK)
-    })
-
-    const tx = client.$transaction((txClient) => {
-      setTxClient(txClient)
-      return txPromise
-    }, options).catch((e) => {
-      if (e === ROLLBACK) return
-      throw e
-    })
-
-    txClientPromise.then((innerTx) => {
-      const proxy = new Proxy(innerTx, {
-        get(target, prop) {
-          if (prop === "$commit") return () => { commit(); return tx }
-          if (prop === "$rollback") return () => { rollback(); return tx }
-          return target[prop as keyof typeof target]
-        },
-      }) as FlatTransactionClient
-      resume(Effect.succeed(proxy))
-    }).catch((error) => {
-      resume(Effect.fail(mapError(error, "$transaction", "Prisma")))
-    })
-  })
-
-/**
- * The main Prisma service with all database operations.
- * Provides type-safe, effectful access to your Prisma models.
- */
-export class Prisma extends Service<Prisma>()("Prisma", {
-  effect: Effect.gen(function* () {
-    return {
-      $transaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client, tx }): Effect.Effect<A, E | ${customError.className}, R> => {
-            const isRootClient = "$transaction" in tx
-            if (!isRootClient) {
-              return effect
-            }
-
-            return Effect.acquireUseRelease(
-              $begin(client, options),
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
-          }
-        ),
-
-      $isolatedTransaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client }): Effect.Effect<A, E | ${customError.className}, R> => {
-            return Effect.acquireUseRelease(
-              $begin(client, options),
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
-          }
-        ),
-      ${rawSqlOperations}
-    }
-  })
-}) {
-  static layer = (
-    ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.merge(PrismaClient.layer(...args), Prisma.Default)
-
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.merge(PrismaClient.layerEffect(optionsEffect), Prisma.Default)
-
-}
-
-// ============================================================================
-// Deprecated aliases for backward compatibility
-// ============================================================================
-
-export const PrismaClientService = PrismaClient
-export const PrismaService = Prisma
-export const makePrismaLayer = PrismaClient.layer
-export const makePrismaLayerEffect = PrismaClient.layerEffect
-
-${modelClasses}
-`;
-}
-/**
- * Generate service with default tagged error classes.
- */
-function generateDefaultErrorService(clientImportPath, rawSqlOperations, modelClasses, models) {
-    const schemaImports = models.map((m) => `_${m.name}`).join(', ');
-    return `${header}
-import { Context, Data, Effect, Exit, Layer } from "effect"
-import { Service } from "effect/Effect"
-import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "${clientImportPath}"
-import * as Model from "./prisma-repository.js"
-import { ${schemaImports} } from "./schemas/index.js"
-
-// Symbol used to identify intentional rollbacks vs actual errors
-const ROLLBACK = Symbol.for("prisma.effect.rollback")
-
-// Type for the flat transaction client with commit/rollback control
-type FlatTransactionClient = PrismaNamespace.TransactionClient & {
-  $commit: () => Promise<void>
-  $rollback: () => Promise<void>
-}
-
-/** Transaction options for $transaction and $isolatedTransaction */
-type TransactionOptions = {
-  maxWait?: number
-  timeout?: number
-  isolationLevel?: PrismaNamespace.TransactionIsolationLevel
-}
-
-/**
- * Context tag for the Prisma client instance.
- * Holds the transaction client (tx) and root client.
- */
-export class PrismaClient extends Context.Tag("PrismaClient")<
-  PrismaClient,
-  {
-    tx: BasePrismaClient | PrismaNamespace.TransactionClient
-    client: BasePrismaClient
-  }
->() {
-  static layer = (
-    ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.scoped(
-    PrismaClient,
-    Effect.gen(function* () {
-      const prisma = new BasePrismaClient(...args)
-      yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
-    })
-  )
-
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.scoped(
-    PrismaClient,
-    Effect.gen(function* () {
-      const options = yield* optionsEffect
-      const prisma = new BasePrismaClient(options)
-      yield* Effect.addFinalizer(() => Effect.promise(() => prisma.$disconnect()))
-      return { tx: prisma, client: prisma }
-    })
-  )
-}
-
-export class PrismaUniqueConstraintError extends Data.TaggedError("PrismaUniqueConstraintError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaForeignKeyConstraintError extends Data.TaggedError("PrismaForeignKeyConstraintError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaRecordNotFoundError extends Data.TaggedError("PrismaRecordNotFoundError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaRelationViolationError extends Data.TaggedError("PrismaRelationViolationError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaRelatedRecordNotFoundError extends Data.TaggedError("PrismaRelatedRecordNotFoundError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaTransactionConflictError extends Data.TaggedError("PrismaTransactionConflictError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaValueTooLongError extends Data.TaggedError("PrismaValueTooLongError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaValueOutOfRangeError extends Data.TaggedError("PrismaValueOutOfRangeError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaDbConstraintError extends Data.TaggedError("PrismaDbConstraintError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaConnectionError extends Data.TaggedError("PrismaConnectionError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaMissingRequiredValueError extends Data.TaggedError("PrismaMissingRequiredValueError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export class PrismaInputValidationError extends Data.TaggedError("PrismaInputValidationError")<{
-  cause: PrismaNamespace.PrismaClientKnownRequestError
-  operation: string
-  model: string
-}> {}
-
-export type PrismaCreateError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaRelatedRecordNotFoundError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaTransactionConflictError
-
-export type PrismaUpdateError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaRelationViolationError
-  | PrismaRelatedRecordNotFoundError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-  | PrismaTransactionConflictError
-
-export type PrismaDeleteError =
-  | PrismaForeignKeyConstraintError
-  | PrismaRelationViolationError
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-  | PrismaTransactionConflictError
-
-export type PrismaFindOrThrowError =
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-
-export type PrismaFindError =
-  | PrismaConnectionError
-
-export type PrismaDeleteManyError =
-  | PrismaForeignKeyConstraintError
-  | PrismaRelationViolationError
-  | PrismaConnectionError
-  | PrismaTransactionConflictError
-
-export type PrismaUpdateManyError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaTransactionConflictError
-
-export type PrismaError =
-  | PrismaValueTooLongError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaDbConstraintError
-  | PrismaInputValidationError
-  | PrismaMissingRequiredValueError
-  | PrismaRelationViolationError
-  | PrismaRelatedRecordNotFoundError
-  | PrismaValueOutOfRangeError
-  | PrismaConnectionError
-  | PrismaRecordNotFoundError
-  | PrismaTransactionConflictError
-
-// Generic mapper for raw operations and fallback
-const mapError = (error: unknown, operation: string, model: string): PrismaError => {
-  if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
-      case "P2000":
-        return new PrismaValueTooLongError({ cause: error, operation, model });
-      case "P2002":
-        return new PrismaUniqueConstraintError({ cause: error, operation, model });
-      case "P2003":
-        return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
-      case "P2004":
-        return new PrismaDbConstraintError({ cause: error, operation, model });
-      case "P2005":
-      case "P2006":
-      case "P2019":
-        return new PrismaInputValidationError({ cause: error, operation, model });
-      case "P2011":
-      case "P2012":
-        return new PrismaMissingRequiredValueError({ cause: error, operation, model });
-      case "P2014":
-        return new PrismaRelationViolationError({ cause: error, operation, model });
-      case "P2015":
-      case "P2018":
-        return new PrismaRelatedRecordNotFoundError({ cause: error, operation, model });
-      case "P2020":
-        return new PrismaValueOutOfRangeError({ cause: error, operation, model });
-      case "P2024":
-        return new PrismaConnectionError({ cause: error, operation, model });
-      case "P2025":
-        return new PrismaRecordNotFoundError({ cause: error, operation, model });
-      case "P2034":
-        return new PrismaTransactionConflictError({ cause: error, operation, model });
-    }
-  }
-  // Unknown errors are not handled and will be treated as defects
-  throw error;
-}
-
-/**
- * Internal helper to begin a callback-free interactive transaction.
- */
-const $begin = (
-  client: BasePrismaClient,
-  options?: {
-    maxWait?: number
-    timeout?: number
-    isolationLevel?: PrismaNamespace.TransactionIsolationLevel
-  }
-): Effect.Effect<FlatTransactionClient, PrismaError> =>
-  Effect.async<FlatTransactionClient, PrismaError>((resume) => {
-    let setTxClient: (txClient: PrismaNamespace.TransactionClient) => void
-    let commit: () => void
-    let rollback: () => void
-
-    const txClientPromise = new Promise<PrismaNamespace.TransactionClient>((res) => {
-      setTxClient = res
-    })
-
-    const txPromise = new Promise<void>((_res, _rej) => {
-      commit = () => _res(undefined)
-      rollback = () => _rej(ROLLBACK)
-    })
-
-    const tx = client.$transaction((txClient) => {
-      setTxClient(txClient)
-      return txPromise
-    }, options).catch((e) => {
-      if (e === ROLLBACK) return
-      throw e
-    })
-
-    txClientPromise.then((innerTx) => {
-      const proxy = new Proxy(innerTx, {
-        get(target, prop) {
-          if (prop === "$commit") return () => { commit(); return tx }
-          if (prop === "$rollback") return () => { rollback(); return tx }
-          return target[prop as keyof typeof target]
-        },
-      }) as FlatTransactionClient
-      resume(Effect.succeed(proxy))
-    }).catch((error) => {
-      resume(Effect.fail(mapError(error, "$transaction", "Prisma")))
-    })
-  })
-
-/**
- * The main Prisma service with all database operations.
- * Provides type-safe, effectful access to your Prisma models.
- */
-export class Prisma extends Service<Prisma>()("Prisma", {
-  effect: Effect.gen(function* () {
-    return {
-      $transaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client, tx }): Effect.Effect<A, E | PrismaError, R> => {
-            const isRootClient = "$transaction" in tx
-            if (!isRootClient) {
-              return effect
-            }
-
-            return Effect.acquireUseRelease(
-              $begin(client, options),
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
-          }
-        ),
-
-      $isolatedTransaction: <R, E, A>(
-        effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
-      ) =>
-        Effect.flatMap(
-          PrismaClient,
-          ({ client }): Effect.Effect<A, E | PrismaError, R> => {
-            return Effect.acquireUseRelease(
-              $begin(client, options),
-              (txClient) =>
-                effect.pipe(
-                  Effect.provideService(PrismaClient, { tx: txClient, client })
-                ),
-              (txClient, exit) =>
-                Exit.isSuccess(exit)
-                  ? Effect.promise(() => txClient.$commit())
-                  : Effect.promise(() => txClient.$rollback())
-            )
-          }
-        ),
-      ${rawSqlOperations}
-    }
-  })
-}) {
-  static layer = (
-    ...args: ConstructorParameters<typeof BasePrismaClient>
-  ) => Layer.merge(PrismaClient.layer(...args), Prisma.Default)
-
-  static layerEffect = <R, E>(
-    optionsEffect: Effect.Effect<ConstructorParameters<typeof BasePrismaClient>[0], E, R>
-  ) => Layer.merge(PrismaClient.layerEffect(optionsEffect), Prisma.Default)
-
-}
-
-// ============================================================================
-// Deprecated aliases for backward compatibility
-// ============================================================================
-
-export const PrismaClientService = PrismaClient
-export const PrismaService = Prisma
-export const makePrismaLayer = PrismaClient.layer
-export const makePrismaLayerEffect = PrismaClient.layerEffect
-
-${modelClasses}
-`;
-}