@effectify/prisma 0.1.1 → 0.1.2

package/src/services/generator-service.ts

@@ -0,0 +1,178 @@
+import * as FileSystem from '@effect/platform/FileSystem'
+import * as Path from '@effect/platform/Path'
+import type { DMMF, GeneratorOptions } from '@prisma/generator-helper'
+import * as Context from 'effect/Context'
+import * as Effect from 'effect/Effect'
+import * as Layer from 'effect/Layer'
+import { GeneratorContext } from './generator-context.js'
+import { RenderService } from './render-service.js'
+
+export class GeneratorService extends Context.Tag('GeneratorService')<
+  GeneratorService,
+  {
+    readonly generate: Effect.Effect<void, Error, GeneratorContext>
+  }
+>() {
+  static Live = Layer.effect(
+    GeneratorService,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+      const path = yield* Path.Path
+      const { render } = yield* RenderService
+
+      const parseErrorImportPath = (
+        errorImportPath: string | undefined,
+      ): { path: string; className: string } | null => {
+        if (!errorImportPath) {
+          return null
+        }
+        const [modulePath, className] = errorImportPath.split('#')
+        if (!(modulePath && className)) {
+          throw new Error(
+            `Invalid errorImportPath format: "${errorImportPath}". Expected "path/to/module#ErrorClassName"`,
+          )
+        }
+        return { path: modulePath, className }
+      }
+
+      const addExtension = (filePath: string, extension: string): string => {
+        if (!extension) {
+          return filePath
+        }
+        const ext = path.extname(filePath)
+        if (ext) {
+          return filePath
+        }
+        return `${filePath}.${extension}`
+      }
+
+      const fixSchemaImports = (outputDir: string) =>
+        Effect.gen(function* () {
+          const schemasDir = path.join(outputDir, 'schemas')
+          const indexFile = path.join(schemasDir, 'index.ts')
+
+          const exists = yield* fs.exists(indexFile)
+          if (!exists) {
+            return
+          }
+
+          const content = yield* fs.readFileString(indexFile)
+          const fixedContent = content
+            .replace(/export \* from '\.\/enums'/g, "export * from './enums.js'")
+            .replace(/export \* from '\.\/types'/g, "export * from './types.js'")
+
+          if (content !== fixedContent) {
+            yield* fs.writeFileString(indexFile, fixedContent)
+          }
+        })
+
+      const getClientImportPath = (config: GeneratorOptions['generator']['config']) =>
+        Array.isArray(config.clientImportPath)
+          ? config.clientImportPath[0]
+          : (config.clientImportPath ?? '@prisma/client')
+
+      const getErrorImportPath = (config: GeneratorOptions['generator']['config']) =>
+        Array.isArray(config.errorImportPath) ? config.errorImportPath[0] : config.errorImportPath
+
+      const getImportFileExtension = (config: GeneratorOptions['generator']['config']) =>
+        Array.isArray(config.importFileExtension) ? config.importFileExtension[0] : (config.importFileExtension ?? '')
+
+      const getCustomError = (
+        config: GeneratorOptions['generator']['config'],
+        options: GeneratorOptions,
+        schemaDir: string,
+      ) => {
+        const errorImportPathRaw = getErrorImportPath(config)
+        const importFileExtension = getImportFileExtension(config)
+
+        let customError = parseErrorImportPath(errorImportPathRaw)
+
+        if (customError?.path.startsWith('.')) {
+          const outputDir = options.generator.output?.value
+          if (outputDir) {
+            const absoluteErrorPath = path.resolve(schemaDir, customError.path)
+            const relativeToOutput = path.relative(outputDir, absoluteErrorPath)
+            const normalizedPath = relativeToOutput.startsWith('.') ? relativeToOutput : `./${relativeToOutput}`
+            const pathWithExtension = addExtension(normalizedPath, importFileExtension)
+            customError = { ...customError, path: pathWithExtension }
+          }
+        }
+        return customError
+      }
+
+      const getGeneratorConfig = (options: GeneratorOptions, schemaDir: string) => {
+        const { config } = options.generator
+        const clientImportPath = getClientImportPath(config)
+        const customError = getCustomError(config, options, schemaDir)
+
+        return { clientImportPath, customError }
+      }
+
+      const generatePrismaSchema = (outputDir: string) =>
+        Effect.gen(function* () {
+          const content = yield* render('prisma-schema', {})
+          yield* fs.writeFileString(path.join(outputDir, 'prisma-schema.ts'), content)
+        })
+
+      const generatePrismaRepository = (outputDir: string, clientImportPath: string) =>
+        Effect.gen(function* () {
+          const content = yield* render('prisma-repository', { clientImportPath })
+          yield* fs.writeFileString(path.join(outputDir, 'prisma-repository.ts'), content)
+        })
+
+      const generateModels = (outputDir: string, models: readonly DMMF.Model[]) =>
+        Effect.gen(function* () {
+          yield* fs.makeDirectory(path.join(outputDir, 'models'), { recursive: true })
+          for (const model of models) {
+            const content = yield* render('model', { model })
+            yield* fs.writeFileString(path.join(outputDir, 'models', `${model.name}.ts`), content)
+          }
+        })
+
+      const generateIndex = (
+        outputDir: string,
+        models: readonly DMMF.Model[],
+        clientImportPath: string,
+        customError: { path: string; className: string } | null,
+      ) =>
+        Effect.gen(function* () {
+          const errorType = customError ? customError.className : 'PrismaError'
+          const rawSqlOperations = yield* render('prisma-raw-sql', { errorType })
+          const modelExports = models.map((m) => `export * from "./models/${m.name}.js"`).join('\n')
+
+          const templateName = customError ? 'index-custom-error' : 'index-default'
+          const content = yield* render(templateName, {
+            clientImportPath,
+            customError,
+            rawSqlOperations,
+            modelExports,
+          })
+
+          yield* fs.writeFileString(path.join(outputDir, 'index.ts'), content)
+        })
+
+      const generate = Effect.gen(function* () {
+        const options = yield* GeneratorContext
+        const models = options.dmmf.datamodel.models
+        const outputDir = options.generator.output?.value
+        const schemaDir = path.dirname(options.schemaPath)
+
+        if (!outputDir) {
+          return yield* Effect.fail(new Error('No output directory specified'))
+        }
+
+        const { clientImportPath, customError } = getGeneratorConfig(options, schemaDir)
+
+        yield* fs.makeDirectory(outputDir, { recursive: true })
+
+        yield* generatePrismaSchema(outputDir)
+        yield* generatePrismaRepository(outputDir, clientImportPath)
+        yield* generateModels(outputDir, models)
+        yield* generateIndex(outputDir, models, clientImportPath, customError)
+        yield* fixSchemaImports(outputDir)
+      })
+
+      return { generate }
+    }),
+  )
+}

package/src/services/render-service.ts

@@ -0,0 +1,32 @@
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import * as Context from 'effect/Context'
+import * as Effect from 'effect/Effect'
+import * as Layer from 'effect/Layer'
+import { Eta } from 'eta'
+
+export class RenderService extends Context.Tag('RenderService')<
+  RenderService,
+  {
+    readonly render: (templateName: string, data: Record<string, unknown>) => Effect.Effect<string, Error>
+  }
+>() {
+  static Live = Layer.sync(RenderService, () => {
+    const __filename = fileURLToPath(import.meta.url)
+    const __dirname = path.dirname(__filename)
+    const templatesDir = path.resolve(__dirname, '../templates')
+
+    const eta = new Eta({
+      views: templatesDir,
+      autoEscape: false,
+    })
+
+    return {
+      render: (templateName: string, data: Record<string, unknown>) =>
+        Effect.try({
+          try: () => eta.render(templateName, data),
+          catch: (error) => new Error(`Failed to render template ${templateName}: ${error}`),
+        }),
+    }
+  })
+}

package/src/templates/index-custom-error.eta

@@ -0,0 +1,190 @@
+// This file was generated by prisma-effect-generator, do not edit manually.
+
+import { Context, Effect, Exit, Layer } from "effect"
+import { Service } from "effect/Effect"
+import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "<%= it.clientImportPath %>"
+import { <%= it.customError.className %>, mapPrismaError } from "<%= it.customError.path %>"
+import * as Model from "./prisma-repository.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 { <%= it.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, <%= it.customError.className %>> =>
+  Effect.async<FlatTransactionClient, <%= it.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 | <%= it.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 | <%= it.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())
+            )
+          }
+        ),
+      <%~ it.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
+
+<%~ it.modelExports %>
+