@effectify/prisma 1.0.0 → 1.1.0

package/README.md

@@ -13,7 +13,7 @@ A powerful Prisma generator that creates **Effect** services and layers from you
 ## 📦 Installation
 
 ```bash
-pnpm add -D @effectify/prisma prisma-effect-kysely
+pnpm add -D @effectify/prisma
 pnpm add effect @prisma/client
 ```
 
@@ -26,11 +26,6 @@ generator client {
   provider = "prisma-client-js"
 }
 
-generator effect_schemas {
-  provider = "prisma-effect-kysely"
-  output   = "./generated/effect/schemas"
-}
-
 generator effect {
   provider = "effect-prisma"
   output   = "./generated/effect"
@@ -57,17 +52,17 @@ pnpm prisma generate
 The generator creates a `Prisma` service for transactions and raw queries, and Model classes that you can use to create repositories.
 
 ```typescript
-import { Effect, Layer } from "effect";
-import { Prisma, UserModel } from "./generated/effect/index.js";
-import * as PrismaRepository from "./generated/effect/prisma-repository.js";
+import { Effect, Layer } from "effect"
+import { Prisma, UserModel } from "./generated/effect/index.js"
+import * as PrismaRepository from "./generated/effect/prisma-repository.js"
 
 // Define a program using the generated Prisma service
-const program = Effect.gen(function* () {
+const program = Effect.gen(function*() {
   // Create a repository for the User model
   const userRepo = yield* PrismaRepository.make(UserModel, {
     modelName: "user",
     spanPrefix: "User",
-  });
+  })
 
   // Create a new user
   const newUser = yield* userRepo.create({
@@ -75,24 +70,24 @@ const program = Effect.gen(function* () {
       email: "hello@effect.website",
       name: "Effect User",
     },
-  });
+  })
 
   // Find the user
   const user = yield* userRepo.findUnique({
     where: { id: newUser.id },
-  });
+  })
 
-  return user;
-});
+  return user
+})
 
 // Provide the Prisma layer
 const MainLayer = Prisma.layer({
   // Prisma Client options
   log: ["query", "info", "warn", "error"],
-});
+})
 
 // Run the program
-Effect.runPromise(program.pipe(Effect.provide(MainLayer)));
+Effect.runPromise(program.pipe(Effect.provide(MainLayer)))
 ```
 
 ## 🧪 Testing
@@ -100,27 +95,26 @@ Effect.runPromise(program.pipe(Effect.provide(MainLayer)));
 The generated layers make testing easy by allowing you to provide alternative implementations or test databases.
 
 ```typescript
-import { it } from "@effect/vitest";
-import { Effect } from "effect";
-import { Prisma, UserModel } from "./generated/effect/index.js";
-import * as PrismaRepository from "./generated/effect/prisma-repository.js";
+import { it } from "@effect/vitest"
+import { Effect } from "effect"
+import { Prisma, UserModel } from "./generated/effect/index.js"
+import * as PrismaRepository from "./generated/effect/prisma-repository.js"
 
 it.effect("should create a user", () =>
-  Effect.gen(function* () {
+  Effect.gen(function*() {
     const userRepo = yield* PrismaRepository.make(UserModel, {
       modelName: "user",
       spanPrefix: "User",
-    });
+    })
 
     const user = yield* userRepo.create({
       data: { email: "test@example.com" },
-    });
+    })
 
-    expect(user.email).toBe("test@example.com");
+    expect(user.email).toBe("test@example.com")
   }).pipe(
-    Effect.provide(Prisma.layer()) // In tests, you might want to use a specific test DB url
-  )
-);
+    Effect.provide(Prisma.layer()), // In tests, you might want to use a specific test DB url
+  ))
 ```
 
 ## ⚠️ Error Handling
@@ -128,25 +122,26 @@ it.effect("should create a user", () =>
 All Prisma errors are mapped to specific tagged errors in Effect, allowing you to handle them precisely.
 
 ```typescript
-import { Effect } from "effect";
-import { Prisma, UserModel } from "./generated/effect/index.js";
-import * as PrismaRepository from "./generated/effect/prisma-repository.js";
+import { Effect } from "effect"
+import { Prisma, UserModel } from "./generated/effect/index.js"
+import * as PrismaRepository from "./generated/effect/prisma-repository.js"
 
 const createUser = (email: string) =>
-  Effect.gen(function* () {
+  Effect.gen(function*() {
     const userRepo = yield* PrismaRepository.make(UserModel, {
       modelName: "user",
       spanPrefix: "User",
-    });
+    })
 
     return yield* userRepo.create({
       data: { email },
-    });
+    })
   }).pipe(
-    Effect.catchTag("PrismaUniqueConstraintError", (error) =>
-      Effect.logError(`User with email ${email} already exists`)
-    )
-  );
+    Effect.catchTag(
+      "PrismaUniqueConstraintError",
+      (error) => Effect.logError(`User with email ${email} already exists`),
+    ),
+  )
 ```
 
 ## 📝 License

package/dist/src/cli.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env -S pnpm dlx tsx
+#!/usr/bin/env node
 export {};

package/dist/src/cli.js

@@ -1,17 +1,18 @@
-#!/usr/bin/env -S pnpm dlx tsx
-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 Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { initCommand } from './commands/init.js';
-import { prismaCommand } from './commands/prisma.js';
-import { GeneratorService } from './services/generator-service.js';
-import { RenderService } from './services/render-service.js';
+#!/usr/bin/env node
+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 Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { initCommand } from "./commands/init.js";
+import { prismaCommand } from "./commands/prisma.js";
+import { GeneratorService } from "./services/generator-service.js";
+import { RenderService } from "./services/render-service.js";
+import { FormatterService } from "./services/formatter-service.js";
 const cli = Command.run(prismaCommand.pipe(Command.withSubcommands([initCommand])), {
-    name: '@effectify/prisma CLI',
-    version: '0.1.0',
+    name: "@effectify/prisma CLI",
+    version: "0.1.0",
 });
-const GeneratorLayer = GeneratorService.Live.pipe(Layer.provide(RenderService.Live), Layer.provide(NodeContext.layer));
-const MainLayer = Layer.mergeAll(GeneratorLayer, RenderService.Live, NodeContext.layer);
+const GeneratorLayer = GeneratorService.Live.pipe(Layer.provide(RenderService.Live), Layer.provide(FormatterService.Live), Layer.provide(NodeContext.layer));
+const MainLayer = Layer.mergeAll(GeneratorLayer, RenderService.Live, FormatterService.Live, NodeContext.layer);
 cli(process.argv).pipe(Effect.provide(MainLayer), NodeRuntime.runMain);

package/dist/src/commands/init.d.ts

@@ -1,4 +1,4 @@
-import * as Command from '@effect/cli/Command';
+import * as Command from "@effect/cli/Command";
 export declare const initCommand: Command.Command<"init", never, import("@effect/platform/Error").PlatformError | Error, {
     readonly output: string;
 }>;

package/dist/src/commands/init.js

@@ -1,13 +1,13 @@
-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';
+import * as Command from "@effect/cli/Command";
+import * as Options from "@effect/cli/Options";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as NodePath from "@effect/platform-node/NodePath";
+import * as FileSystem from "@effect/platform/FileSystem";
+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'));
+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) => Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
@@ -26,74 +26,63 @@ const writeFileContent = (path, content) => Effect.gen(function* () {
 });
 // 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');
+    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];
-    return Match.value(lockFiles).pipe(Match.when([true, false, false], () => 'pnpm'), Match.when([false, true, false], () => 'bun'), Match.when([false, false, true], () => 'npm'), Match.orElse(() => 'npm'));
+    return Match.value(lockFiles).pipe(Match.when([true, false, false], () => "pnpm"), Match.when([false, true, false], () => "bun"), Match.when([false, false, true], () => "npm"), Match.orElse(() => "npm"));
 });
 // Check if Prisma is already initialized
 const checkPrismaSetup = () => Effect.gen(function* () {
-    const schemaExists = yield* fileExists('prisma/schema.prisma');
+    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("❌ 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'));
+        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) => Effect.gen(function* () {
-    yield* Console.log('🔧 Configuring Prisma schema with Effect generators...');
+    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.');
+    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!');
+    if (existingContent.includes('provider = "effect-prisma"')) {
+        yield* Console.log("✅ Effect generators already configured!");
         return;
     }
     // Add our generators to existing schema
-    yield* Console.log('🔧 Adding Effect 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"
+  provider = "effect-prisma"
+  output   = "../${options.output}/generated/effect"
 }
 `;
     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');
+    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: npx prisma generate");
     yield* Effect.sync(() => process.exit(0));
 });
-export const initCommand = Command.make('init', {
+export const initCommand = Command.make("init", {
     output: outputOption,
 }, ({ output }) => initializePrismaSchema({
     output,

package/dist/src/commands/prisma.d.ts

@@ -1,5 +1,5 @@
-import * as Command from '@effect/cli/Command';
-import type * as NodeContext from '@effect/platform-node/NodeContext';
-import { GeneratorService } from '../services/generator-service.js';
-import type { RenderService } from '../services/render-service.js';
+import * as Command from "@effect/cli/Command";
+import type * as NodeContext from "@effect/platform-node/NodeContext";
+import { GeneratorService } from "../services/generator-service.js";
+import type { RenderService } from "../services/render-service.js";
 export declare const prismaCommand: Command.Command<"prisma", RenderService | GeneratorService | NodeContext.NodeContext, never, {}>;

package/dist/src/commands/prisma.js

@@ -1,13 +1,13 @@
-import * as Command from '@effect/cli/Command';
-import generatorHelper from '@prisma/generator-helper';
-import * as Deferred from 'effect/Deferred';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Runtime from 'effect/Runtime';
-import * as Stream from 'effect/Stream';
-import { GeneratorContext } from '../services/generator-context.js';
-import { GeneratorService } from '../services/generator-service.js';
-export const prismaCommand = Command.make('prisma', {}, () => Effect.gen(function* () {
+import * as Command from "@effect/cli/Command";
+import generatorHelper from "@prisma/generator-helper";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Runtime from "effect/Runtime";
+import * as Stream from "effect/Stream";
+import { GeneratorContext } from "../services/generator-context.js";
+import { GeneratorService } from "../services/generator-service.js";
+export const prismaCommand = Command.make("prisma", {}, () => Effect.gen(function* () {
     const generator = yield* GeneratorService;
     const runtime = yield* Effect.runtime();
     const run = Runtime.runPromise(runtime);
@@ -15,8 +15,8 @@ export const prismaCommand = Command.make('prisma', {}, () => Effect.gen(functio
         generatorHelper.generatorHandler({
             onManifest() {
                 return {
-                    defaultOutput: '../generated/effect',
-                    prettyName: 'Prisma Effect Generator',
+                    defaultOutput: "../generated/effect",
+                    prettyName: "Prisma Effect Generator",
                     requiresEngines: [],
                 };
             },

package/dist/src/generators/sql-schema-generator.js

@@ -1,49 +1,48 @@
 #!/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';
+import gh from "@prisma/generator-helper";
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
 const header = `-- This file was generated by sql-schema-generator, do not edit manually.
 -- Generated at: ${new Date().toISOString()}
 
 `;
 export async function generateSqlSchema(options) {
-    const outputDir = options.generator.output?.value || '../generated';
-    const datasourceUrl = 'prisma/dev.db';
+    const outputDir = options.generator.output?.value || "../generated";
+    const datasourceUrl = "prisma/dev.db";
     if (!datasourceUrl) {
-        throw new Error('No datasource URL found');
+        throw new Error("No datasource URL found");
     }
     await fs.mkdir(outputDir, { recursive: true });
     try {
         let dbPath = datasourceUrl;
-        if (dbPath.startsWith('file:')) {
-            dbPath = dbPath.replace('file:', '');
+        if (dbPath.startsWith("file:")) {
+            dbPath = dbPath.replace("file:", "");
         }
         if (!path.isAbsolute(dbPath)) {
             dbPath = path.resolve(process.cwd(), dbPath);
         }
-        const schemaOutput = execSync(`sqlite3 "${dbPath}" ".schema"`, { encoding: 'utf8' });
-        const outputPath = path.join(outputDir, 'schema.sql');
+        const schemaOutput = execSync(`sqlite3 "${dbPath}" ".schema"`, { encoding: "utf8" });
+        const outputPath = path.join(outputDir, "schema.sql");
         await fs.writeFile(outputPath, header + schemaOutput);
     }
     catch (error) {
-        console.error('❌ Failed to generate schema dump:', error);
+        console.error("❌ Failed to generate schema dump:", error);
         throw error;
     }
 }
 gh.generatorHandler({
     onManifest() {
         return {
-            defaultOutput: '../generated',
-            prettyName: 'SQL Schema Generator',
+            defaultOutput: "../generated",
+            prettyName: "SQL Schema Generator",
             requiresEngines: [],
         };
     },
     async onGenerate(options) {
         await generateSqlSchema({
             generator: {
-                output: options?.generator?.output ? { value: options.generator.output.value || '' } : undefined,
+                output: options?.generator?.output ? { value: options.generator.output.value || "" } : undefined,
             },
         });
     },