@effectify/prisma 0.1.1 → 1.0.0

package/dist/src/cli.d.ts

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

package/dist/src/cli.js

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

package/dist/src/commands/init.js

@@ -91,10 +91,8 @@ generator sqlSchema {
     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({

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

@@ -0,0 +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';
+export declare const prismaCommand: Command.Command<"prisma", RenderService | GeneratorService | NodeContext.NodeContext, never, {}>;

package/dist/src/commands/prisma.js

@@ -0,0 +1,35 @@
+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);
+    const events = Stream.async((emit) => {
+        generatorHelper.generatorHandler({
+            onManifest() {
+                return {
+                    defaultOutput: '../generated/effect',
+                    prettyName: 'Prisma Effect Generator',
+                    requiresEngines: [],
+                };
+            },
+            async onGenerate(options) {
+                await run(Effect.gen(function* () {
+                    const deferred = yield* Deferred.make();
+                    yield* Effect.promise(() => emit.single([options, deferred]));
+                    yield* Deferred.await(deferred);
+                }));
+                // Cerrar el stream después de procesar la generación
+                emit.end();
+            },
+        });
+    });
+    yield* events.pipe(Stream.runForEach(([options, deferred]) => generator.generate.pipe(Effect.provide(Layer.succeed(GeneratorContext, options)), Effect.intoDeferred(deferred))));
+}));

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

@@ -1 +1,10 @@
+#!/usr/bin/env tsx
+type SqlGeneratorOptions = {
+    generator: {
+        output?: {
+            value: string;
+        };
+    };
+};
+export declare function generateSqlSchema(options: SqlGeneratorOptions): Promise<void>;
 export {};

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

@@ -1,58 +1,50 @@
-// #!/usr/bin/env tsx
-export {};
-// 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
-// interface 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.message)
-//     throw error
-//   }
-// }
-// gh.generatorHandler({
-//   onManifest() {
-//     return {
-//       defaultOutput: '../generated',
-//       prettyName: 'SQL Schema Generator',
-//       requiresEngines: [],
-//     }
-//   },
-//   async onGenerate(options) {
-//     await generateSqlSchema(options)
-//   },
-// })
+#!/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()}
+
+`;
+export async function generateSqlSchema(options) {
+    const outputDir = options.generator.output?.value || '../generated';
+    const datasourceUrl = 'prisma/dev.db';
+    if (!datasourceUrl) {
+        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 (!path.isAbsolute(dbPath)) {
+            dbPath = path.resolve(process.cwd(), dbPath);
+        }
+        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);
+        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,
+            },
+        });
+    },
+});

package/dist/src/services/generator-context.d.ts

@@ -0,0 +1,6 @@
+import type { GeneratorOptions } from '@prisma/generator-helper';
+import * as Context from 'effect/Context';
+declare const GeneratorContext_base: Context.TagClass<GeneratorContext, "GeneratorContext", GeneratorOptions>;
+export declare class GeneratorContext extends GeneratorContext_base {
+}
+export {};

package/dist/src/services/generator-context.js

@@ -0,0 +1,3 @@
+import * as Context from 'effect/Context';
+export class GeneratorContext extends Context.Tag('GeneratorContext')() {
+}

package/dist/src/services/generator-service.d.ts

@@ -0,0 +1,14 @@
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+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';
+declare const GeneratorService_base: Context.TagClass<GeneratorService, "GeneratorService", {
+    readonly generate: Effect.Effect<void, Error, GeneratorContext>;
+}>;
+export declare class GeneratorService extends GeneratorService_base {
+    static Live: Layer.Layer<GeneratorService, never, FileSystem.FileSystem | Path.Path | RenderService>;
+}
+export {};

package/dist/src/services/generator-service.js

@@ -0,0 +1,121 @@
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+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')() {
+    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) => {
+            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, extension) => {
+            if (!extension) {
+                return filePath;
+            }
+            const ext = path.extname(filePath);
+            if (ext) {
+                return filePath;
+            }
+            return `${filePath}.${extension}`;
+        };
+        const fixSchemaImports = (outputDir) => 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) => Array.isArray(config.clientImportPath)
+            ? config.clientImportPath[0]
+            : (config.clientImportPath ?? '@prisma/client');
+        const getErrorImportPath = (config) => Array.isArray(config.errorImportPath) ? config.errorImportPath[0] : config.errorImportPath;
+        const getImportFileExtension = (config) => Array.isArray(config.importFileExtension) ? config.importFileExtension[0] : (config.importFileExtension ?? '');
+        const getCustomError = (config, options, schemaDir) => {
+            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, schemaDir) => {
+            const { config } = options.generator;
+            const clientImportPath = getClientImportPath(config);
+            const customError = getCustomError(config, options, schemaDir);
+            return { clientImportPath, customError };
+        };
+        const generatePrismaSchema = (outputDir) => Effect.gen(function* () {
+            const content = yield* render('prisma-schema', {});
+            yield* fs.writeFileString(path.join(outputDir, 'prisma-schema.ts'), content);
+        });
+        const generatePrismaRepository = (outputDir, clientImportPath) => Effect.gen(function* () {
+            const content = yield* render('prisma-repository', { clientImportPath });
+            yield* fs.writeFileString(path.join(outputDir, 'prisma-repository.ts'), content);
+        });
+        const generateModels = (outputDir, models) => 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, models, clientImportPath, customError) => 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/dist/src/services/render-service.d.ts

@@ -0,0 +1,10 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+declare const RenderService_base: Context.TagClass<RenderService, "RenderService", {
+    readonly render: (templateName: string, data: Record<string, unknown>) => Effect.Effect<string, Error>;
+}>;
+export declare class RenderService extends RenderService_base {
+    static Live: Layer.Layer<RenderService, never, never>;
+}
+export {};

package/dist/src/services/render-service.js

@@ -0,0 +1,23 @@
+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')() {
+    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, data) => Effect.try({
+                try: () => eta.render(templateName, data),
+                catch: (error) => new Error(`Failed to render template ${templateName}: ${error}`),
+            }),
+        };
+    });
+}

package/dist/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 %>
+

package/{prisma/generated/effect/index.ts → dist/src/templates/index-default.eta}

@@ -2,9 +2,7 @@
 
 import { Context, Data, Effect, Exit, Layer } from "effect"
 import { Service } from "effect/Effect"
-import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "@prisma/client"
-import * as Model from "./prisma-repository.js"
-import { _Todo } from "./schemas/index.js"
+import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "<%= it.clientImportPath %>"
 
 // Symbol used to identify intentional rollbacks vs actual errors
 const ROLLBACK = Symbol.for("prisma.effect.rollback")
@@ -338,38 +336,7 @@ export class Prisma extends Service<Prisma>()("Prisma", {
             )
           }
         ),
-      
-    $executeRaw: (args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]): Effect.Effect<number, PrismaError, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$executeRaw(args[0], ...args.slice(1)) : client.$executeRaw(args)),
-          catch: (error) => mapError(error, "$executeRaw", "Prisma")
-        })
-      ),
-
-    $executeRawUnsafe: (query: string, ...values: any[]): Effect.Effect<number, PrismaError, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => client.$executeRawUnsafe(query, ...values),
-          catch: (error) => mapError(error, "$executeRawUnsafe", "Prisma")
-        })
-      ),
-
-    $queryRaw: <T = unknown>(args: PrismaNamespace.Sql | [PrismaNamespace.Sql, ...any[]]): Effect.Effect<T, PrismaError, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => (Array.isArray(args) ? client.$queryRaw(args[0], ...args.slice(1)) : client.$queryRaw(args)) as Promise<T>,
-          catch: (error) => mapError(error, "$queryRaw", "Prisma")
-        })
-      ),
-
-    $queryRawUnsafe: <T = unknown>(query: string, ...values: any[]): Effect.Effect<T, PrismaError, PrismaClient> =>
-      Effect.flatMap(PrismaClient, ({ tx: client }) =>
-        Effect.tryPromise({
-          try: () => client.$queryRawUnsafe(query, ...values) as Promise<T>,
-          catch: (error) => mapError(error, "$queryRawUnsafe", "Prisma")
-        })
-      ),
+      <%~ it.rawSqlOperations %>
     }
   })
 }) {
@@ -392,6 +359,5 @@ export const PrismaService = Prisma
 export const makePrismaLayer = PrismaClient.layer
 export const makePrismaLayerEffect = PrismaClient.layerEffect
 
-export class TodoModel extends Model.Class<TodoModel>("Todo")({
-  ..._Todo.fields
-}) {}
+<%~ it.modelExports %>
+