@effectify/prisma 0.1.1 → 1.0.0

package/src/generators/prisma-effect-generator.ts

@@ -1,496 +0,0 @@
-#!/usr/bin/env tsx
-// biome-ignore-all lint: Generated code
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import gh, { type GeneratorOptions } from '@prisma/generator-helper'
-
-const header = '// This file was generated by prisma-effect-generator, do not edit manually.\n'
-
-// Utility function to convert PascalCase to camelCase
-function toCamelCase(str: string) {
-  return str.charAt(0).toLowerCase() + str.slice(1)
-}
-
-// Export the generator function for use in CLI
-export async function generateEffectPrisma(options: GeneratorOptions) {
-  const models = options.dmmf.datamodel.models
-  const outputDir = options.generator.output?.value
-
-  if (!outputDir) {
-    throw new Error('No output directory specified')
-  }
-
-  // Clean output directory
-  await fs.rm(outputDir, { recursive: true, force: true })
-  await fs.mkdir(outputDir, { recursive: true })
-
-  // Generate unified index file with PrismaService
-  await generateUnifiedService(models, outputDir)
-
-  // Generate types file
-  await generateTypes(models, outputDir)
-}
-
-gh.generatorHandler({
-  onManifest() {
-    return {
-      defaultOutput: '../src/generated/effect-prisma',
-      prettyName: 'Prisma Effect Generator',
-      requiresEngines: ['queryEngine'] as any,
-    }
-  },
-
-  async onGenerate(options) {
-    await generateEffectPrisma(options)
-  },
-})
-
-function generateErrorTypes(models: readonly any[]) {
-  const modelNames = models.map((model) => `"${model.name}"`).join(' | ')
-  const operationNames = [
-    '"findMany"',
-    '"findUnique"',
-    '"findFirst"',
-    '"findUniqueOrThrow"',
-    '"findFirstOrThrow"',
-    '"create"',
-    '"createMany"',
-    '"createManyAndReturn"',
-    '"update"',
-    '"updateMany"',
-    '"upsert"',
-    '"delete"',
-    '"deleteMany"',
-    '"count"',
-    '"aggregate"',
-    '"groupBy"',
-    '"$executeRaw"',
-    '"$executeRawUnsafe"',
-    '"$queryRaw"',
-    '"$queryRawUnsafe"',
-  ].join(' | ')
-
-  return `
-// String literal types for exhaustive error handling
-export type ModelName = ${modelNames}
-export type OperationName = ${operationNames}
-
-// Specific Prisma error types for exhaustive error handling
-export class PrismaRecordNotFoundError extends Data.TaggedError("PrismaRecordNotFound")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  where?: unknown
-}> {}
-
-export class PrismaUniqueConstraintError extends Data.TaggedError("PrismaUniqueConstraint")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  field?: string
-  value?: unknown
-}> {}
-
-export class PrismaForeignKeyConstraintError extends Data.TaggedError("PrismaForeignKeyConstraint")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  field?: string
-  referencedModel?: string
-}> {}
-
-export class PrismaRequiredFieldError extends Data.TaggedError("PrismaRequiredField")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  field: string
-}> {}
-
-export class PrismaConnectionError extends Data.TaggedError("PrismaConnection")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  message?: string
-}> {}
-
-export class PrismaValidationError extends Data.TaggedError("PrismaValidation")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  message: string
-}> {}
-
-export class PrismaUnknownError extends Data.TaggedError("PrismaUnknown")<{
-  model: ModelName | "Prisma"
-  operation: OperationName
-  originalError: unknown
-}> {}
-
-// Error conversion function
-function convertPrismaError(error: unknown, model: ModelName | "Prisma", operation: OperationName):
-  | PrismaRecordNotFoundError
-  | PrismaUniqueConstraintError
-  | PrismaForeignKeyConstraintError
-  | PrismaRequiredFieldError
-  | PrismaConnectionError
-  | PrismaValidationError
-  | PrismaUnknownError {
-
-  // Handle Prisma-specific errors
-  if (error && typeof error === 'object') {
-    const prismaError = error as any
-
-    // PrismaClientKnownRequestError
-    if (prismaError.code) {
-      switch (prismaError.code) {
-        case 'P2002': // Unique constraint violation
-          return new PrismaUniqueConstraintError({
-            model,
-            operation,
-            field: prismaError.meta?.target?.[0] as string,
-            value: prismaError.meta?.value
-          })
-
-        case 'P2025': // Record not found
-        case 'P2016': // Query interpretation error (record not found)
-          return new PrismaRecordNotFoundError({
-            model,
-            operation,
-            where: prismaError.meta
-          })
-
-        case 'P2003': // Foreign key constraint violation
-        case 'P2014': // Required relation violation
-          return new PrismaForeignKeyConstraintError({
-            model,
-            operation,
-            field: prismaError.meta?.field_name as string,
-            referencedModel: prismaError.meta?.model_name as string
-          })
-
-        case 'P2012': // Missing required field
-        case 'P2011': // Null constraint violation
-          return new PrismaRequiredFieldError({
-            model,
-            operation,
-            field: prismaError.meta?.field as string
-          })
-
-        case 'P1000': // Authentication failed
-        case 'P1001': // Can't reach database server
-        case 'P1002': // Database server timeout
-        case 'P1008': // Operations timed out
-          return new PrismaConnectionError({
-            model,
-            operation,
-            message: prismaError.message as string
-          })
-      }
-    }
-
-    // PrismaClientValidationError
-    if (prismaError.name === 'PrismaClientValidationError') {
-      return new PrismaValidationError({
-        model,
-        operation,
-        message: prismaError.message as string
-      })
-    }
-
-    // PrismaClientInitializationError
-    if (prismaError.name === 'PrismaClientInitializationError') {
-      return new PrismaConnectionError({
-        model,
-        operation,
-        message: prismaError.message as string
-      })
-    }
-  }
-
-  // Fallback to unknown error
-  return new PrismaUnknownError({
-    model,
-    operation,
-    originalError: error
-  })
-}
-`
-}
-
-function generateErrorUnionTypes(models: readonly any[]) {
-  return models
-    .map((model: { name: any }) => {
-      const modelName = model.name
-      return `
-// Error unions for ${modelName}
-export type ${modelName}FindErrors = PrismaConnectionError | PrismaUnknownError
-export type ${modelName}FindOrThrowErrors = PrismaRecordNotFoundError | PrismaConnectionError | PrismaUnknownError
-export type ${modelName}CreateErrors = PrismaUniqueConstraintError | PrismaForeignKeyConstraintError | PrismaRequiredFieldError | PrismaValidationError | PrismaConnectionError | PrismaUnknownError
-export type ${modelName}UpdateErrors = PrismaRecordNotFoundError | PrismaUniqueConstraintError | PrismaForeignKeyConstraintError | PrismaValidationError | PrismaConnectionError | PrismaUnknownError
-export type ${modelName}UpsertErrors = PrismaUniqueConstraintError | PrismaForeignKeyConstraintError | PrismaRequiredFieldError | PrismaValidationError | PrismaConnectionError | PrismaUnknownError
-export type ${modelName}DeleteErrors = PrismaRecordNotFoundError | PrismaForeignKeyConstraintError | PrismaConnectionError | PrismaUnknownError
-export type ${modelName}AggregateErrors = PrismaConnectionError | PrismaValidationError | PrismaUnknownError`
-    })
-    .join('\n')
-}
-
-function generateRawSqlOperations() {
-  return `
-  // eslint-disable-next-line @typescript-eslint/array-type
-      $executeRaw: (args: Prisma.Sql | [Prisma.Sql, ...any[]]) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$executeRaw(args[0], ...args.slice(1)) : client.$executeRaw(args)),
-          catch: (error) => convertPrismaError(error, "Prisma", "$executeRaw")
-        }),
-
-  // eslint-disable-next-line @typescript-eslint/array-type
-      $executeRawUnsafe: (query: string, ...values: any[]) =>
-        Effect.tryPromise({
-          try: () => client.$executeRawUnsafe(query, ...values),
-          catch: (error) => convertPrismaError(error, "Prisma", "$executeRawUnsafe")
-        }),
-
-    // eslint-disable-next-line @typescript-eslint/array-type
-      $queryRaw: (args: Prisma.Sql | [Prisma.Sql, ...any[]]) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$queryRaw(args[0], ...args.slice(1)) : client.$queryRaw(args)),
-          catch: (error) => convertPrismaError(error, "Prisma", "$queryRaw")
-        }),
-
-    // eslint-disable-next-line @typescript-eslint/array-type
-      $queryRawUnsafe: (query: string, ...values: any[]) =>
-        Effect.tryPromise({
-          try: () => client.$queryRawUnsafe(query, ...values),
-          catch: (error) => convertPrismaError(error, "Prisma", "$queryRawUnsafe")
-        }),`
-}
-
-function generateModelOperations(models: readonly any[]) {
-  return models
-    .map((model: { name: any }) => {
-      const modelName = model.name
-      const modelNameCamel = toCamelCase(modelName)
-
-      return `      ${modelNameCamel}: {
-        // Find operations
-        findMany: (args?: Prisma.${modelName}FindManyArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findMany(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "findMany")
-          }),
-
-        findUnique: (args: Prisma.${modelName}FindUniqueArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findUnique(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "findUnique")
-          }),
-
-        findFirst: (args?: Prisma.${modelName}FindFirstArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findFirst(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "findFirst")
-          }),
-
-        findUniqueOrThrow: (args: Prisma.${modelName}FindUniqueOrThrowArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findUniqueOrThrow(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "findUniqueOrThrow")
-          }),
-
-        findFirstOrThrow: (args?: Prisma.${modelName}FindFirstOrThrowArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.findFirstOrThrow(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "findFirstOrThrow")
-          }),
-
-        // Create operations
-        create: (args: Prisma.${modelName}CreateArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.create(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "create")
-          }),
-
-        createMany: (args: Prisma.${modelName}CreateManyArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.createMany(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "createMany")
-          }),
-
-        createManyAndReturn: (args: Prisma.${modelName}CreateManyAndReturnArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.createManyAndReturn(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "createManyAndReturn")
-          }),
-
-        // Update operations
-        update: (args: Prisma.${modelName}UpdateArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.update(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "update")
-          }),
-
-        updateMany: (args: Prisma.${modelName}UpdateManyArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.updateMany(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "updateMany")
-          }),
-
-        upsert: (args: Prisma.${modelName}UpsertArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.upsert(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "upsert")
-          }),
-
-        // Delete operations
-        delete: (args: Prisma.${modelName}DeleteArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.delete(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "delete")
-          }),
-
-        deleteMany: (args?: Prisma.${modelName}DeleteManyArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.deleteMany(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "deleteMany")
-          }),
-
-        // Aggregate operations
-        count: (args?: Prisma.${modelName}CountArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.count(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "count")
-          }),
-
-        aggregate: (args: Prisma.${modelName}AggregateArgs) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.aggregate(args),
-            catch: (error) => convertPrismaError(error, "${modelName}", "aggregate")
-          }),
-
-        groupBy: <T extends Prisma.${modelName}GroupByArgs>(args: T) =>
-          Effect.tryPromise({
-            try: () => client.${modelNameCamel}.groupBy(args as any),
-            catch: (error) => convertPrismaError(error, "${modelName}", "groupBy")
-          })
-      }`
-    })
-    .join(',\n\n')
-}
-
-async function generateUnifiedService(models: readonly any[], outputDir: string) {
-  const errorTypes = generateErrorTypes(models)
-  const errorUnions = generateErrorUnionTypes(models)
-  const rawSqlOperations = generateRawSqlOperations()
-  const modelOperations = generateModelOperations(models)
-
-  const serviceContent = `${header}
-import { Context, Data, Effect, Layer } from "effect"
-import { Service } from "effect/Effect"
-import { type Prisma, PrismaClient } from "../prisma/index.js"
-
-export class PrismaClientService extends Context.Tag("PrismaClientService")<
-  PrismaClientService,
-  {
-    tx: PrismaClient | Prisma.TransactionClient
-    client: PrismaClient
-  }
->() {}
-
-export const LivePrismaLayer = Layer.effect(
-  PrismaClientService,
-  Effect.sync(() => {
-    const prisma = new PrismaClient()
-    return {
-      // The \`tx\` property (transaction) can be shared and overridden,
-      // but the \`client\` property must always be a PrismaClient instance.
-      tx: prisma,
-      client: prisma
-    }
-  })
-)
-
-${errorTypes}
-
-${errorUnions}
-
-export class PrismaService extends Service<PrismaService>()("PrismaService", {
-  effect: Effect.gen(function* () {
-    const { tx: client } = yield* PrismaClientService
-    return {
-${rawSqlOperations}
-
-${modelOperations}
-    }
-  })
-}) {}
-`
-
-  await fs.writeFile(path.join(outputDir, 'index.ts'), serviceContent)
-}
-
-async function generateTypes(models: readonly any[], outputDir: string) {
-  const modelTypeDefinitions = models
-    .map((model: { name: any }) => {
-      const modelName = model.name
-      const modelNameCamel = toCamelCase(modelName)
-
-      return `    ${modelNameCamel}: {
-      findMany: (args?: Prisma.${modelName}FindManyArgs) => Effect.Effect<Array<${modelName}>, ${modelName}FindErrors>
-      findUnique: (args: Prisma.${modelName}FindUniqueArgs) => Effect.Effect<${modelName} | null, ${modelName}FindErrors>
-      findFirst: (args?: Prisma.${modelName}FindFirstArgs) => Effect.Effect<${modelName} | null, ${modelName}FindErrors>
-      findUniqueOrThrow: (args: Prisma.${modelName}FindUniqueOrThrowArgs) => Effect.Effect<${modelName}, ${modelName}FindOrThrowErrors>
-      findFirstOrThrow: (args?: Prisma.${modelName}FindFirstOrThrowArgs) => Effect.Effect<${modelName}, ${modelName}FindOrThrowErrors>
-      create: (args: Prisma.${modelName}CreateArgs) => Effect.Effect<${modelName}, ${modelName}CreateErrors>
-      createMany: (args: Prisma.${modelName}CreateManyArgs) => Effect.Effect<Prisma.BatchPayload, ${modelName}CreateErrors>
-      createManyAndReturn: (args: Prisma.${modelName}CreateManyAndReturnArgs) => Effect.Effect<Array<${modelName}>, ${modelName}CreateErrors>
-      update: (args: Prisma.${modelName}UpdateArgs) => Effect.Effect<${modelName}, ${modelName}UpdateErrors>
-      updateMany: (args: Prisma.${modelName}UpdateManyArgs) => Effect.Effect<Prisma.BatchPayload, ${modelName}UpdateErrors>
-      upsert: (args: Prisma.${modelName}UpsertArgs) => Effect.Effect<${modelName}, ${modelName}UpsertErrors>
-      delete: (args: Prisma.${modelName}DeleteArgs) => Effect.Effect<${modelName}, ${modelName}DeleteErrors>
-      deleteMany: (args?: Prisma.${modelName}DeleteManyArgs) => Effect.Effect<Prisma.BatchPayload, ${modelName}DeleteErrors>
-      count: (args?: Prisma.${modelName}CountArgs) => Effect.Effect<number, ${modelName}AggregateErrors>
-      aggregate: (args: Prisma.${modelName}AggregateArgs) => Effect.Effect<any, ${modelName}AggregateErrors>
-      groupBy: <T extends Prisma.${modelName}GroupByArgs>(args: T) => Effect.Effect<any, ${modelName}AggregateErrors>
-    }`
-    })
-    .join('\n')
-
-  const rawSqlErrorType = 'PrismaConnectionError | PrismaValidationError | PrismaUnknownError'
-
-  const typeContent = `${header}
-import type { Effect } from "effect"
-import type { Prisma } from "../prisma/index.js"
-import type {
-  ModelName,
-  OperationName,
-  PrismaRecordNotFoundError,
-  PrismaUniqueConstraintError,
-  PrismaForeignKeyConstraintError,
-  PrismaRequiredFieldError,
-  PrismaConnectionError,
-  PrismaValidationError,
-  PrismaUnknownError,
-${models.map((model: { name: any }) => `  ${model.name}FindErrors,\n  ${model.name}FindOrThrowErrors,\n  ${model.name}CreateErrors,\n  ${model.name}UpdateErrors,\n  ${model.name}UpsertErrors,\n  ${model.name}DeleteErrors,\n  ${model.name}AggregateErrors`).join(',\n')}
-} from "./index.js"
-
-export type EffectPrismaService = {
-  // eslint-disable-next-line @typescript-eslint/array-type
-  $executeRaw: (args: Prisma.Sql | [Prisma.Sql, ...any[]]) => Effect.Effect<number, ${rawSqlErrorType}>
-  // eslint-disable-next-line @typescript-eslint/array-type
-  $executeRawUnsafe: (query: string, ...values: any[]) => Effect.Effect<number, ${rawSqlErrorType}>
-  // eslint-disable-next-line @typescript-eslint/array-type
-  $queryRaw: (args: Prisma.Sql | [Prisma.Sql, ...any[]]) => Effect.Effect<unknown, ${rawSqlErrorType}>
-  // eslint-disable-next-line @typescript-eslint/array-type
-  $queryRawUnsafe: (query: string, ...values: any[]) => Effect.Effect<unknown, ${rawSqlErrorType}>
-${modelTypeDefinitions}
-}
-
-// Individual model types
-${models
-  .map(
-    (model: { name: any }) => `
-
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  export type ${model.name} = Prisma.${model.name}GetPayload<{}>
-  `,
-  )
-  .join('\n')}
-`
-
-  await fs.writeFile(path.join(outputDir, 'types.ts'), typeContent)
-}

package/src/generators/sql-schema-generator.ts

@@ -1,75 +0,0 @@
-#!/usr/bin/env tsx
-// biome-ignore-all lint: Generated code
-
-import { execSync } from 'node:child_process'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import gh from '@prisma/generator-helper'
-
-const header = `-- This file was generated by sql-schema-generator, do not edit manually.
--- Generated at: ${new Date().toISOString()}
-
-`
-
-// Types for generator options
-type SqlGeneratorOptions = {
-  generator: {
-    output?: {
-      value: string
-    }
-  }
-}
-
-// Export the generator function for use in CLI
-export async function generateSqlSchema(options: SqlGeneratorOptions) {
-  const outputDir = options.generator.output?.value || '../generated'
-  const datasourceUrl = 'prisma/dev.db'
-
-  if (!datasourceUrl) {
-    throw new Error('No datasource URL found')
-  }
-
-  // Ensure output directory exists
-  await fs.mkdir(outputDir, { recursive: true })
-
-  try {
-    // Extract the database path from the URL (assuming sqlite)
-    let dbPath = datasourceUrl
-    if (dbPath.startsWith('file:')) {
-      dbPath = dbPath.replace('file:', '')
-    }
-
-    // Make path relative to current working directory if needed
-    if (!path.isAbsolute(dbPath)) {
-      dbPath = path.resolve(process.cwd(), dbPath)
-    }
-
-    // Use sqlite3 to dump only the schema (no data)
-    const schemaOutput = execSync(`sqlite3 "${dbPath}" ".schema"`, { encoding: 'utf8' })
-
-    // Write the schema to the output file
-    const outputPath = path.join(outputDir, 'schema.sql')
-    await fs.writeFile(outputPath, header + schemaOutput)
-  } catch (error) {
-    console.error('❌ Failed to generate schema dump:', error)
-    throw error
-  }
-}
-
-gh.generatorHandler({
-  onManifest() {
-    return {
-      defaultOutput: '../generated',
-      prettyName: 'SQL Schema Generator',
-      requiresEngines: [],
-    }
-  },
-
-  async onGenerate(options) {
-    await generateSqlSchema({
-      generator: {
-        output: options?.generator?.output ? { value: options.generator.output.value || '' } : undefined,
-      },
-    })
-  },
-})