@effectify/prisma 0.1.2 → 1.0.0

package/src/services/generator-service.ts

@@ -1,178 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/model.eta

@@ -1,6 +0,0 @@
-import * as Model from "../prisma-repository.js"
-import { _<%= it.model.name %> } from "../schemas/index.js"
-
-export class <%= it.model.name %>Model extends Model.Class<<%= it.model.name %>Model>("<%= it.model.name %>")({
-  ..._<%= it.model.name %>.fields
-}) {}

package/test/prisma-model.test.ts

@@ -1,340 +0,0 @@
-import { layer } from '@effect/vitest'
-import { Prisma, PrismaClient, TodoModel } from '@prisma/effect'
-import * as PrismaRepository from '@prisma/effect/prisma-repository.js'
-import { Effect, Layer, Option } from 'effect'
-import { beforeEach, expect } from 'vitest'
-import { prisma as db } from './utils.js'
-
-// Create the Prisma layer manually to use the existing client instance
-const ClientLayer = Layer.succeed(PrismaClient, { tx: db, client: db })
-const PrismaLayer = Layer.merge(ClientLayer, Prisma.Default.pipe(Layer.provide(ClientLayer)))
-
-layer(PrismaLayer)('Prisma Model Repository', (it) => {
-  beforeEach(async () => {
-    await db.todo.deleteMany({})
-  })
-
-  it.effect('create', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      const created = yield* todoRepo.create({
-        data: {
-          id: 1,
-          title: 'Create Test',
-          content: 'Content',
-          published: false,
-          authorId: 1,
-        },
-      })
-      expect(created.id).toBe(1)
-      expect(created.title).toBe('Create Test')
-    }),
-  )
-
-  it.effect('createMany', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      const result = yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'Todo 1', content: 'C1', published: false, authorId: 1 },
-          { id: 2, title: 'Todo 2', content: 'C2', published: true, authorId: 1 },
-        ],
-      })
-      expect(result.count).toBe(2)
-    }),
-  )
-
-  it.effect('createManyAndReturn', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      const result = yield* todoRepo.createManyAndReturn({
-        data: [
-          { id: 1, title: 'Todo 1', content: 'C1', published: false, authorId: 1 },
-          { id: 2, title: 'Todo 2', content: 'C2', published: true, authorId: 1 },
-        ],
-      })
-      expect(result).toHaveLength(2)
-      expect(result[0].title).toBe('Todo 1')
-      expect(result[1].title).toBe('Todo 2')
-    }),
-  )
-
-  it.effect('findUnique', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.create({
-        data: { id: 1, title: 'Find Unique', content: 'Content', published: false, authorId: 1 },
-      })
-
-      const found = yield* todoRepo.findUnique({
-        where: { id: 1 },
-      })
-      expect(Option.isSome(found)).toBe(true)
-      if (Option.isSome(found)) {
-        expect(found.value.title).toBe('Find Unique')
-      }
-
-      const notFound = yield* todoRepo.findUnique({
-        where: { id: 999 },
-      })
-      expect(Option.isNone(notFound)).toBe(true)
-    }),
-  )
-
-  it.effect('findUniqueOrThrow', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.create({
-        data: { id: 1, title: 'Find Unique Or Throw', content: 'Content', published: false, authorId: 1 },
-      })
-
-      const found = yield* todoRepo.findUniqueOrThrow({
-        where: { id: 1 },
-      })
-      expect(found.title).toBe('Find Unique Or Throw')
-
-      const error = yield* todoRepo
-        .findUniqueOrThrow({
-          where: { id: 999 },
-        })
-        .pipe(Effect.flip)
-
-      expect(error._tag).toBe('PrismaRecordNotFoundError')
-    }),
-  )
-
-  it.effect('findFirst', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.create({
-        data: { id: 1, title: 'Find First', content: 'Content', published: false, authorId: 1 },
-      })
-
-      const found = yield* todoRepo.findFirst({
-        where: { title: 'Find First' },
-      })
-      expect(Option.isSome(found)).toBe(true)
-    }),
-  )
-
-  it.effect('findFirstOrThrow', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.create({
-        data: { id: 1, title: 'Find First Or Throw', content: 'Content', published: false, authorId: 1 },
-      })
-
-      const found = yield* todoRepo.findFirstOrThrow({
-        where: { title: 'Find First Or Throw' },
-      })
-      expect(found.title).toBe('Find First Or Throw')
-
-      const error = yield* todoRepo
-        .findFirstOrThrow({
-          where: { title: 'Non Existent' },
-        })
-        .pipe(Effect.flip)
-
-      expect(error._tag).toBe('PrismaRecordNotFoundError')
-    }),
-  )
-
-  it.effect('findMany', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'T1', content: 'C', published: true, authorId: 1 },
-          { id: 2, title: 'T2', content: 'C', published: true, authorId: 1 },
-          { id: 3, title: 'T3', content: 'C', published: false, authorId: 1 },
-        ],
-      })
-
-      const found = yield* todoRepo.findMany({
-        where: { published: true },
-      })
-      expect(found).toHaveLength(2)
-    }),
-  )
-
-  it.effect('update', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.create({
-        data: { id: 1, title: 'Original', content: 'Content', published: false, authorId: 1 },
-      })
-
-      const updated = yield* todoRepo.update({
-        where: { id: 1 },
-        data: { title: 'Updated' },
-      })
-      expect(updated.title).toBe('Updated')
-    }),
-  )
-
-  it.effect('updateMany', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'T1', content: 'C', published: false, authorId: 1 },
-          { id: 2, title: 'T2', content: 'C', published: false, authorId: 1 },
-        ],
-      })
-
-      const result = yield* todoRepo.updateMany({
-        where: { published: false },
-        data: { published: true },
-      })
-      expect(result.count).toBe(2)
-    }),
-  )
-
-  it.effect('upsert', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      // Create new
-      const created = yield* todoRepo.upsert({
-        where: { id: 1 },
-        create: { id: 1, title: 'Upsert Created', content: 'Content', published: false, authorId: 1 },
-        update: { title: 'Upsert Updated' },
-      })
-      expect(created.title).toBe('Upsert Created')
-
-      // Update existing
-      const updated = yield* todoRepo.upsert({
-        where: { id: 1 },
-        create: { id: 1, title: 'Upsert Created', content: 'Content', published: false, authorId: 1 },
-        update: { title: 'Upsert Updated' },
-      })
-      expect(updated.title).toBe('Upsert Updated')
-    }),
-  )
-
-  it.effect('delete', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.create({
-        data: { id: 1, title: 'To Delete', content: 'Content', published: false, authorId: 1 },
-      })
-
-      const deleted = yield* todoRepo.delete({
-        where: { id: 1 },
-      })
-      expect(deleted.title).toBe('To Delete')
-
-      const found = yield* todoRepo.findUnique({
-        where: { id: 1 },
-      })
-      expect(Option.isNone(found)).toBe(true)
-    }),
-  )
-
-  it.effect('deleteMany', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'T1', content: 'C', published: false, authorId: 1 },
-          { id: 2, title: 'T2', content: 'C', published: false, authorId: 1 },
-        ],
-      })
-
-      const result = yield* todoRepo.deleteMany({
-        where: { published: false },
-      })
-      expect(result.count).toBe(2)
-    }),
-  )
-
-  it.effect('count', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'T1', content: 'C', published: false, authorId: 1 },
-          { id: 2, title: 'T2', content: 'C', published: false, authorId: 1 },
-        ],
-      })
-
-      const count = yield* todoRepo.count()
-      expect(count).toBe(2)
-
-      const filteredCount = yield* todoRepo.count({
-        where: { id: 1 },
-      })
-      expect(filteredCount).toBe(1)
-    }),
-  )
-
-  it.effect('aggregate', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'T1', content: 'C', published: false, authorId: 1 },
-          { id: 2, title: 'T2', content: 'C', published: false, authorId: 1 },
-        ],
-      })
-
-      const result: any = yield* todoRepo.aggregate({
-        _count: true,
-        _min: { id: true },
-        _max: { id: true },
-      })
-
-      expect(result._count).toBe(2)
-      expect(result._min.id).toBe(1)
-      expect(result._max.id).toBe(2)
-    }),
-  )
-
-  it.effect('groupBy', () =>
-    Effect.gen(function* () {
-      const todoRepo = yield* PrismaRepository.make(TodoModel, { modelName: 'todo', spanPrefix: 'todo' })
-
-      yield* todoRepo.createMany({
-        data: [
-          { id: 1, title: 'T1', content: 'C', published: true, authorId: 1 },
-          { id: 2, title: 'T2', content: 'C', published: true, authorId: 1 },
-          { id: 3, title: 'T3', content: 'C', published: false, authorId: 2 },
-        ],
-      })
-
-      const result: any = yield* todoRepo.groupBy({
-        by: ['published', 'authorId'],
-        _count: {
-          id: true,
-        },
-      })
-
-      expect(Array.isArray(result)).toBe(true)
-      expect(result.length).toBeGreaterThan(0)
-
-      // Check for the group with published: true, authorId: 1
-      const group1 = result.find((g: any) => g.published === true && g.authorId === 1)
-      expect(group1).toBeDefined()
-      expect(group1._count.id).toBe(2)
-
-      // Check for the group with published: false, authorId: 2
-      const group2 = result.find((g: any) => g.published === false && g.authorId === 2)
-      expect(group2).toBeDefined()
-      expect(group2._count.id).toBe(1)
-    }),
-  )
-})

package/test/utils.ts

@@ -1,10 +0,0 @@
-import path from 'node:path'
-import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3'
-import { PrismaClient } from '@prisma/client'
-
-const dbPath = path.join(__dirname, '../prisma/dev.db')
-const adapter = new PrismaBetterSqlite3({
-  url: `file:${dbPath}`,
-})
-
-export const prisma = new PrismaClient({ adapter })

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ],
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@prisma/client": ["node_modules/@prisma/client"],
-      "@prisma/*": ["./prisma/generated/*"]
-    }
-  }
-}

package/tsconfig.lib.json

@@ -1,24 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "baseUrl": ".",
-    "rootDir": "src",
-    "outDir": "dist",
-    "target": "es2022",
-    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
-    "emitDeclarationOnly": false,
-    "moduleResolution": "nodenext",
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"],
-    "paths": {
-      "@/*": ["./src/*"],
-      "@prisma/client": ["node_modules/@prisma/client"],
-      "@prisma/effect": ["./prisma/generated/effect/index.ts"],
-      "@prisma/effect/*": ["./prisma/generated/effect/*"],
-      "@prisma/*": ["./prisma/generated/*"]
-    }
-  },
-  "include": ["src/**/*.ts", "src/**/*.tsx"],
-  "references": []
-}

package/tsconfig.spec.json

@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist/out-tsc",
-    "types": ["vitest/globals", "node"],
-    "baseUrl": ".",
-    "paths": {
-      "@prisma/client": ["node_modules/@prisma/client"],
-      "@prisma/effect": ["./prisma/generated/effect/index.ts"],
-      "@prisma/effect/*": ["./prisma/generated/effect/*"],
-      "@prisma/*": ["./prisma/generated/*"]
-    }
-  },
-  "include": ["test/**/*.ts", "src/**/*.ts", "prisma/generated/**/*.ts"]
-}

package/vitest.config.ts

@@ -1,24 +0,0 @@
-import path from 'node:path'
-import tsconfigPaths from 'vite-tsconfig-paths'
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  plugins: [tsconfigPaths()],
-  test: {
-    setupFiles: [path.join(__dirname, 'setup-tests.ts')],
-    include: ['**/*.test.ts'],
-    exclude: ['**/node_modules/**', '**/dist/**', 'inspiration/**'],
-    globals: true,
-  },
-  resolve: {
-    alias: {
-      '@template/basic/test': path.join(__dirname, 'test'),
-      '@template/basic': path.join(__dirname, 'src'),
-      '@prisma/effect': path.join(__dirname, 'prisma/generated/effect'),
-    },
-    extensions: ['.ts', '.tsx', '.js', '.jsx', '.json'],
-  },
-  esbuild: {
-    target: 'node22',
-  },
-})