@effectify/prisma 0.1.1

package/prisma/migrations/20250721191716_dumb/migration.sql

@@ -0,0 +1,49 @@
+-- CreateTable
+CREATE TABLE "users" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "email" TEXT NOT NULL,
+    "name" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "tags" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "todo_tags" (
+    "todoId" TEXT NOT NULL,
+    "tagId" TEXT NOT NULL,
+
+    PRIMARY KEY ("todoId", "tagId"),
+    CONSTRAINT "todo_tags_todoId_fkey" FOREIGN KEY ("todoId") REFERENCES "todos" ("id") ON DELETE RESTRICT ON UPDATE CASCADE,
+    CONSTRAINT "todo_tags_tagId_fkey" FOREIGN KEY ("tagId") REFERENCES "tags" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_todos" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "title" TEXT NOT NULL,
+    "description" TEXT,
+    "completed" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "userId" TEXT,
+    CONSTRAINT "todos_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+INSERT INTO "new_todos" ("completed", "createdAt", "description", "id", "title", "updatedAt") SELECT "completed", "createdAt", "description", "id", "title", "updatedAt" FROM "todos";
+DROP TABLE "todos";
+ALTER TABLE "new_todos" RENAME TO "todos";
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_email_key" ON "users"("email");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "tags_name_key" ON "tags"("name");

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "sqlite"

package/prisma/schema.prisma

@@ -0,0 +1,31 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+  output   = "./generated"
+}
+
+generator effect_schemas {
+  provider = "prisma-effect-kysely"
+  output   = "./generated/effect/schemas"
+}
+
+generator effect {
+  provider = "tsx ./src/effect-prisma.ts"
+  output   = "./generated/effect"
+  clientImportPath = "@prisma/client"
+  importFileExtension = "js"
+}
+
+datasource db {
+  provider = "sqlite"
+}
+
+model Todo {
+  id        Int     @id @default(autoincrement())
+  title     String
+  content   String?
+  published Boolean @default(false)
+  authorId  Int
+}

package/prisma.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'prisma/config'
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  datasource: {
+    url: 'file:./prisma/dev.db',
+  },
+})

package/project.json

@@ -0,0 +1,48 @@
+{
+  "name": "@effectify/prisma",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/prisma/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "defaultConfiguration": "production",
+      "options": {
+        "outputPath": "packages/prisma/dist",
+        "main": "packages/prisma/src/cli.tsx",
+        "tsConfig": "packages/prisma/tsconfig.lib.json",
+        "format": ["esm"],
+        "generatePackageJson": false,
+        "updateBuildableProjectDepsInPackageJson": false,
+        "additionalEntryPoints": []
+      },
+      "configurations": {
+        "development": {},
+        "production": {}
+      }
+    },
+    "prisma:generate": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "pnpm dlx prisma generate",
+        "cwd": "packages/prisma"
+      }
+    },
+    "dev": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "tsx src/messaround.ts",
+        "cwd": "packages/prisma"
+      }
+    },
+    "cli": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "pnpm dlx tsx src/cli.tsx",
+        "cwd": "packages/prisma"
+      }
+    }
+  },
+  "tags": ["node", "react", "prisma"]
+}

package/scripts/cleanup-tests.ts

@@ -0,0 +1,26 @@
+import { existsSync } from 'node:fs'
+import { readdir, rmdir } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+async function cleanupTests() {
+  const testsDir = resolve('src/generated/tests')
+  const testDbsDir = resolve('src/generated/tests-dbs')
+
+  // Clean up test files
+  if (existsSync(testsDir)) {
+    await rmdir(testsDir, { recursive: true })
+  }
+
+  // Clean up test databases
+  if (existsSync(testDbsDir)) {
+    const files = await readdir(testDbsDir)
+    if (files.length > 0) {
+      await rmdir(testDbsDir, { recursive: true })
+    }
+  }
+}
+
+cleanupTests().catch((error) => {
+  console.error('❌ Cleanup failed:', error)
+  process.exit(1)
+})

package/scripts/generate-test-files.ts

@@ -0,0 +1,93 @@
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+// Configuration
+const testFileCount = Number.parseInt(process.argv[2], 10) || 5
+const testsPerFileCount = Number.parseInt(process.argv[3], 10) || 3
+
+const generateTestFile = (fileIndex: number, testsCount: number): string => {
+  const testCases = Array.from({ length: testsCount }, (_, testIndex) => {
+    const testName = `should handle test case ${testIndex + 1}`
+    const todoTitle = `Generated Todo ${fileIndex}-${testIndex + 1}`
+    const todoDescription = `Description for test ${fileIndex}-${testIndex + 1}`
+
+    return `
+const test${testIndex + 1}Effect = Effect.gen(function* () {
+  const prisma = yield* PrismaService
+  const user = yield* prisma.user.create({
+    data: {
+      email: "user${fileIndex}-${testIndex + 1}@test.com"
+    }
+  })
+
+  const created = yield* createTodo({
+    title: "${todoTitle}",
+    completed: ${Math.random() > 0.5},
+    description: "${todoDescription}",
+    userId: user.id
+  })
+
+  const allTodos = yield* getAllTodosForUser(user)
+  
+  expect(allTodos).toHaveLength(1)
+  expect(allTodos[0]?.title).toBe("${todoTitle}")
+  expect(allTodos[0]?.userId).toBe(user.id)
+}).pipe(Effect.provide(PrismaService.Default)).pipe(Effect.provide(TestPrismaLayer))
+
+it.scoped("${testName}", () => test${testIndex + 1}Effect)`
+  }).join('\n\n')
+
+  return `import { expect, it } from "@effect/vitest"
+import { Effect } from "effect"
+import type { Todo, User } from "../../generated/prisma/index.js"
+import { PrismaService } from "../../generated/effect-prisma/index.js"
+import { TestPrismaLayer } from "../../services/prisma.service.js"
+
+const createTodo = (input: Omit<Todo, "id" | "createdAt" | "updatedAt">) =>
+  Effect.gen(function* () {
+    const prisma = yield* PrismaService
+    return yield* prisma.todo.create({
+      data: input
+    })
+  })
+
+const getAllTodosForUser = (user: Pick<User, "id">) =>
+  Effect.gen(function* () {
+    const prisma = yield* PrismaService
+    return yield* prisma.todo.findMany({
+      where: {
+        userId: user.id
+      }
+    })
+  })
+
+${testCases}
+`
+}
+
+async function generateTestFiles() {
+  const testsDir = resolve('src/generated/tests')
+
+  // Create the tests directory if it doesn't exist
+  if (!existsSync(testsDir)) {
+    await mkdir(testsDir, { recursive: true })
+  }
+
+  // Generate test files
+  const filePromises: Promise<void>[] = []
+  for (let i = 1; i <= testFileCount; i++) {
+    const fileName = `stress-test-${i.toString().padStart(3, '0')}.test.ts`
+    const filePath = resolve(testsDir, fileName)
+    const fileContent = generateTestFile(i, testsPerFileCount)
+
+    filePromises.push(writeFile(filePath, fileContent, 'utf-8'))
+  }
+
+  await Promise.all(filePromises)
+}
+
+generateTestFiles().catch((error) => {
+  console.error('Failed to generate test files:', error)
+  process.exit(1)
+})

package/setup-tests.ts

@@ -0,0 +1,10 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import * as it from '@effect/vitest'
+
+it.addEqualityTesters()
+
+if (typeof __dirname === 'undefined') {
+  /** biome-ignore lint/suspicious/noExplicitAny: polyfill */
+  ;(globalThis as any).__dirname = path.dirname(fileURLToPath(import.meta.url))
+}

package/src/cli.tsx

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+import * as Command from '@effect/cli/Command'
+import * as NodeContext from '@effect/platform-node/NodeContext'
+import * as NodeRuntime from '@effect/platform-node/NodeRuntime'
+import * as Console from 'effect/Console'
+import * as Effect from 'effect/Effect'
+import { generateEffectCommand } from './commands/generate-effect.js'
+import { generateSqlSchemaCommand } from './commands/generate-sql-schema.js'
+import { initCommand } from './commands/init.js'
+
+// Main CLI command
+const prisma = Command.make('prisma', {}, () =>
+  Console.log('🚀 prisma CLI - Use --help to see available commands'),
+).pipe(Command.withSubcommands([initCommand, generateEffectCommand, generateSqlSchemaCommand]))
+
+// Run the CLI
+const cli = Command.run(prisma, {
+  name: '@effectify/prisma CLI',
+  version: '0.1.0',
+})
+
+cli(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain)

package/src/commands/generate-effect.ts

@@ -0,0 +1,109 @@
+import * as Command from '@effect/cli/Command'
+import * as FileSystem from '@effect/platform/FileSystem'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
+import * as NodePath from '@effect/platform-node/NodePath'
+import * as Console from 'effect/Console'
+import * as Effect from 'effect/Effect'
+import * as Match from 'effect/Match'
+
+// import { generateEffectPrisma } from '../generators/prisma-effect-generator.js'
+
+// Check if file exists
+const fileExists = (path: string) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    return yield* fs.exists(path)
+  })
+
+// Detect package manager using pattern matching
+const detectPackageManager = () =>
+  Effect.gen(function* () {
+    const pnpmExists = yield* fileExists('pnpm-lock.yaml')
+    const bunExists = yield* fileExists('bun.lockb')
+    const npmExists = yield* fileExists('package-lock.json')
+
+    // Create a tuple to match against
+    const lockFiles = [pnpmExists, bunExists, npmExists] as const
+
+    return Match.value(lockFiles).pipe(
+      Match.when([true, false, false], () => 'pnpm' as const),
+      Match.when([false, true, false], () => 'bun' as const),
+      Match.when([false, false, true], () => 'npm' as const),
+      Match.orElse(() => 'npm' as const), // default fallback
+    )
+  })
+
+// Check if Prisma schema exists
+const checkPrismaSchema = () =>
+  Effect.gen(function* () {
+    const schemaExists = yield* fileExists('prisma/schema.prisma')
+
+    if (!schemaExists) {
+      yield* Console.log('❌ Prisma schema not found.')
+      yield* Console.log('')
+      yield* Console.log('Please run the following command first:')
+
+      const packageManager = yield* detectPackageManager()
+
+      const initCommand = Match.value(packageManager).pipe(
+        Match.when('pnpm', () => 'pnpm dlx prisma init'),
+        Match.when('bun', () => 'bunx prisma init'),
+        Match.when('npm', () => 'npx prisma init'),
+        Match.exhaustive,
+      )
+
+      yield* Console.log(`  ${initCommand}`)
+      yield* Effect.fail(new Error('Prisma schema not found'))
+    }
+  })
+
+// Execute the Effect generator
+const generateEffectServices = () =>
+  Effect.gen(function* () {
+    // Check if we're being called by Prisma (no interactive output)
+    const isCalledByPrisma =
+      process.env.PRISMA_GENERATOR_INVOCATION === 'true' ||
+      process.argv.includes('--generator') ||
+      !process.stdout.isTTY
+
+    if (!isCalledByPrisma) {
+      yield* Console.log('🔧 Running Effect generator...')
+    }
+
+    // Check if Prisma schema exists
+    yield* checkPrismaSchema()
+
+    // Note: We don't need to check for local generator files
+    // since we're importing from our own package
+
+    if (!isCalledByPrisma) {
+      yield* Console.log('🚀 Executing Effect generator...')
+    }
+
+    // Execute the generator function
+    yield* Effect.tryPromise({
+      try: () => {
+        // Create mock options for the generator
+        // const mockOptions = {
+        //   dmmf: { datamodel: { models: [] } }, // Empty models for now
+        //   generator: { output: { value: 'src/generated/effect-prisma' } },
+        // }
+        return Promise.resolve()
+        // return generateEffectPrisma(mockOptions)
+      },
+      catch: (error) => new Error(`Generator execution failed: ${error}`),
+    })
+
+    if (!isCalledByPrisma) {
+      yield* Console.log('✅ Effect generator executed successfully!')
+      yield* Console.log('💡 Generated files are available in the configured output directory')
+    }
+
+    // Ensure the effect completes and exits
+    yield* Effect.sync(() => process.exit(0))
+  })
+
+// Export the generate-effect command
+export const generateEffectCommand = Command.make('generate-effect', {}, () =>
+  generateEffectServices().pipe(Effect.provide(NodeFileSystem.layer), Effect.provide(NodePath.layer)),
+)

package/src/commands/generate-sql-schema.ts

@@ -0,0 +1,109 @@
+import * as Command from '@effect/cli/Command'
+import * as FileSystem from '@effect/platform/FileSystem'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
+import * as NodePath from '@effect/platform-node/NodePath'
+import * as Console from 'effect/Console'
+import * as Effect from 'effect/Effect'
+import * as Match from 'effect/Match'
+
+// import { generateSqlSchema } from '../generators/sql-schema-generator.js'
+
+// Check if file exists
+const fileExists = (path: string) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    return yield* fs.exists(path)
+  })
+
+// Detect package manager using pattern matching
+const detectPackageManager = () =>
+  Effect.gen(function* () {
+    const pnpmExists = yield* fileExists('pnpm-lock.yaml')
+    const bunExists = yield* fileExists('bun.lockb')
+    const npmExists = yield* fileExists('package-lock.json')
+
+    // Create a tuple to match against
+    const lockFiles = [pnpmExists, bunExists, npmExists] as const
+
+    return Match.value(lockFiles).pipe(
+      Match.when([true, false, false], () => 'pnpm' as const),
+      Match.when([false, true, false], () => 'bun' as const),
+      Match.when([false, false, true], () => 'npm' as const),
+      Match.orElse(() => 'npm' as const), // default fallback
+    )
+  })
+
+// Check if Prisma schema exists
+const checkPrismaSchema = () =>
+  Effect.gen(function* () {
+    const schemaExists = yield* fileExists('prisma/schema.prisma')
+
+    if (!schemaExists) {
+      yield* Console.log('❌ Prisma schema not found.')
+      yield* Console.log('')
+      yield* Console.log('Please run the following command first:')
+
+      const packageManager = yield* detectPackageManager()
+
+      const initCommand = Match.value(packageManager).pipe(
+        Match.when('pnpm', () => 'pnpm dlx prisma init'),
+        Match.when('bun', () => 'bunx prisma init'),
+        Match.when('npm', () => 'npx prisma init'),
+        Match.exhaustive,
+      )
+
+      yield* Console.log(`  ${initCommand}`)
+      yield* Effect.fail(new Error('Prisma schema not found'))
+    }
+  })
+
+// Execute the SQL schema generator
+const generateSqlSchemaServices = () =>
+  Effect.gen(function* () {
+    // Check if we're being called by Prisma (no interactive output)
+    const isCalledByPrisma =
+      process.env.PRISMA_GENERATOR_INVOCATION === 'true' ||
+      process.argv.includes('--generator') ||
+      !process.stdout.isTTY
+
+    if (!isCalledByPrisma) {
+      yield* Console.log('🔧 Running SQL schema generator...')
+    }
+
+    // Check if Prisma schema exists
+    yield* checkPrismaSchema()
+
+    // Note: We don't need to check for local generator files
+    // since we're importing from our own package
+
+    if (!isCalledByPrisma) {
+      yield* Console.log('🚀 Executing SQL schema generator...')
+    }
+
+    // Execute the generator function
+    yield* Effect.tryPromise({
+      try: () => {
+        // Create mock options for the generator
+        // const mockOptions = {
+        //   generator: { output: { value: 'src/generated' } },
+        // }
+
+        // return generateSqlSchema(mockOptions)
+        return Promise.resolve()
+      },
+      catch: (error) => new Error(`Generator execution failed: ${error}`),
+    })
+
+    if (!isCalledByPrisma) {
+      yield* Console.log('✅ SQL schema generator executed successfully!')
+      yield* Console.log('💡 Generated files are available in the configured output directory')
+    }
+
+    // Ensure the effect completes and exits
+    yield* Effect.sync(() => process.exit(0))
+  })
+
+// Export the generate-sql-schema command
+export const generateSqlSchemaCommand = Command.make('generate-sql-schema', {}, () =>
+  generateSqlSchemaServices().pipe(Effect.provide(NodeFileSystem.layer), Effect.provide(NodePath.layer)),
+)

package/src/commands/init.ts

@@ -0,0 +1,155 @@
+import * as Command from '@effect/cli/Command'
+import * as Options from '@effect/cli/Options'
+import * as FileSystem from '@effect/platform/FileSystem'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
+import * as NodePath from '@effect/platform-node/NodePath'
+import * as Console from 'effect/Console'
+import * as Effect from 'effect/Effect'
+import * as Match from 'effect/Match'
+
+// Options for the init command
+const outputOption = Options.text('output').pipe(
+  Options.withAlias('o'),
+  Options.withDescription('Output directory path for generated files'),
+  Options.withDefault('src'),
+)
+
+// Check if file exists
+const fileExists = (path: string) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    return yield* fs.exists(path)
+  })
+
+// Read file content
+const readFileContent = (path: string) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const content = yield* fs.readFileString(path)
+    return content
+  })
+
+// Write file content
+const writeFileContent = (path: string, content: string) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    yield* fs.writeFileString(path, content)
+  })
+
+// Detect package manager using pattern matching
+const detectPackageManager = () =>
+  Effect.gen(function* () {
+    const pnpmExists = yield* fileExists('pnpm-lock.yaml')
+    const bunExists = yield* fileExists('bun.lockb')
+    const npmExists = yield* fileExists('package-lock.json')
+
+    // Create a tuple to match against
+    const lockFiles = [pnpmExists, bunExists, npmExists] as const
+
+    return Match.value(lockFiles).pipe(
+      Match.when([true, false, false], () => 'pnpm' as const),
+      Match.when([false, true, false], () => 'bun' as const),
+      Match.when([false, false, true], () => 'npm' as const),
+      Match.orElse(() => 'npm' as const), // default fallback
+    )
+  })
+
+// Check if Prisma is already initialized
+const checkPrismaSetup = () =>
+  Effect.gen(function* () {
+    const schemaExists = yield* fileExists('prisma/schema.prisma')
+
+    if (!schemaExists) {
+      const packageManager = yield* detectPackageManager()
+
+      yield* Console.log('❌ Prisma is not initialized in this project.')
+      yield* Console.log('')
+      yield* Console.log('Please run the following command first:')
+
+      const initCommand = Match.value(packageManager).pipe(
+        Match.when('pnpm', () => 'pnpm dlx prisma init'),
+        Match.when('bun', () => 'bunx prisma init'),
+        Match.when('npm', () => 'npx prisma init'),
+        Match.exhaustive,
+      )
+
+      yield* Console.log(`  ${initCommand}`)
+
+      yield* Console.log('')
+      yield* Console.log('For more information, visit:')
+      yield* Console.log(
+        '  https://www.prisma.io/docs/getting-started/setup-prisma/start-from-scratch/relational-databases-typescript-prismaPostgres',
+      )
+      yield* Effect.fail(new Error('Prisma not initialized'))
+    }
+  })
+
+// Initialize Prisma schema logic
+const initializePrismaSchema = (options: { output: string }) =>
+  Effect.gen(function* () {
+    yield* Console.log('🔧 Configuring Prisma schema with Effect generators...')
+    yield* Console.log(`📁 Output path: ${options.output}`)
+
+    // Check if Prisma is already set up
+    yield* checkPrismaSetup()
+
+    const schemaPath = 'prisma/schema.prisma'
+
+    yield* Console.log('📄 Schema file already exists.')
+
+    // Read existing content and check if it has our generators
+    const existingContent = yield* readFileContent(schemaPath)
+
+    if (existingContent.includes('@effectify/prisma prisma generate-effect')) {
+      yield* Console.log('✅ Effect generators already configured!')
+      return
+    }
+
+    // Add our generators to existing schema
+    yield* Console.log('🔧 Adding Effect generators to existing schema...')
+
+    const updatedContent =
+      existingContent +
+      `
+
+// Effect generators added by @effectify/prisma
+generator effectServices {
+  provider = "@effectify/prisma generate-effect"
+  output   = "../${options.output}/generated/effect-prisma"
+}
+
+generator effect {
+  provider = "prisma-effect-kysely"
+  output   = "../${options.output}/generated/effect-prisma"
+}
+
+generator sqlSchema {
+  provider = "@effectify/prisma generate-sql-schema"
+  output   = "../${options.output}/generated"
+}
+`
+
+    yield* writeFileContent(schemaPath, updatedContent)
+    yield* Console.log('✅ Effect generators added to existing schema!')
+
+    yield* Console.log('🎉 Prisma schema initialization completed!')
+    yield* Console.log('💡 Next steps:')
+    yield* Console.log('   1. Set your DATABASE_URL environment variable')
+    yield* Console.log('   2. Run: @effectify/prisma prisma generate-effect')
+    yield* Console.log('   3. Run: @effectify/prisma prisma generate-sql-schema')
+
+    // Ensure the effect completes and exits
+    yield* Effect.sync(() => process.exit(0))
+  })
+
+// Export the init command
+export const initCommand = Command.make(
+  'init',
+  {
+    output: outputOption,
+  },
+  ({ output }) =>
+    initializePrismaSchema({
+      output,
+    }).pipe(Effect.provide(NodeFileSystem.layer), Effect.provide(NodePath.layer)),
+)