@riordanpawley/effect-prisma-generator 0.5.0 → 0.5.2

package/README.md

@@ -343,6 +343,46 @@ const program = Effect.gen(function* () {
 });
 ```
 
+#### Custom Transaction Options
+
+For transactions that need custom options (isolation level, timeout, etc.), use `$transactionWith`:
+
+```typescript
+// Custom isolation level
+yield* prisma.$transactionWith(
+  Effect.gen(function* () {
+    const user = yield* prisma.user.create({ data: { name: "Alice" } });
+    return user;
+  }),
+  { isolationLevel: "Serializable", timeout: 10000 }
+);
+
+// Point-free style for cleaner composition
+import { pipe } from "effect";
+
+const myEffect = Effect.gen(function* () {
+  const prisma = yield* Prisma;
+  return yield* prisma.user.findMany();
+});
+
+// Clean, functional composition!
+pipe(
+  myEffect,
+  prisma.$transaction  // No options? Use $transaction directly!
+);
+
+// With options, use $transactionWith
+const withSerializable = (eff: Effect.Effect<any, any, any>) =>
+  prisma.$transactionWith(eff, { isolationLevel: "Serializable" });
+
+pipe(myEffect, withSerializable);
+```
+
+Available transaction options:
+- `isolationLevel`: `"ReadUncommitted" | "ReadCommitted" | "RepeatableRead" | "Serializable"`
+- `maxWait`: Maximum time (ms) Prisma Client will wait to acquire a transaction
+- `timeout`: Maximum time (ms) the transaction can run before being canceled
+
 #### Transaction Rollback Behavior
 
 **Any uncaught error in the Effect error channel triggers a rollback:**

package/dist/index.js

@@ -126,13 +126,42 @@ function generateRawSqlOperations(customError) {
         })
       ),`;
 }
+/**
+ * Generate type aliases for a model to reduce redundant type computation.
+ * TypeScript performance is significantly improved when complex types are
+ * computed once and reused via aliases rather than inline.
+ */
+function generateModelTypeAliases(models) {
+    return models
+        .map((model) => {
+        const modelName = model.name;
+        const modelNameCamel = toCamelCase(modelName);
+        // Operations that need Args/Result type aliases
+        const operations = [
+            'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow',
+            'findMany', 'create', 'createMany', 'createManyAndReturn',
+            'delete', 'update', 'deleteMany', 'updateMany', 'updateManyAndReturn',
+            'upsert', 'count', 'aggregate', 'groupBy'
+        ];
+        const argsAliases = operations
+            .map(op => `type ${modelName}${capitalize(op)}Args = PrismaNamespace.Args<BasePrismaClient['${modelNameCamel}'], '${op}'>`)
+            .join('\n');
+        return argsAliases;
+    })
+        .join('\n\n');
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
 function generateModelOperations(models, customError) {
     return models
         .map((model) => {
         const modelName = model.name;
         const modelNameCamel = toCamelCase(modelName);
-        // Type alias for the model delegate (e.g., BasePrismaClient['user'])
+        // Use pre-computed type alias for delegate
         const delegate = `BasePrismaClient['${modelNameCamel}']`;
+        // Helper to get pre-computed Args type alias
+        const argsType = (op) => `${modelName}${capitalize(op)}Args`;
         // Cast Promise results to ensure consistent typing across Prisma versions
         // This handles Prisma 7's GlobalOmitConfig and works fine with Prisma 6 too
         const promiseCast = (op, nullable = false) => {
@@ -153,9 +182,13 @@ function generateModelOperations(models, customError) {
         // Without custom error: use per-operation error types and mappers
         const errorType = (opErrorType) => customError ? customError.className : opErrorType;
         const mapperFn = (defaultMapper) => customError ? "mapError" : defaultMapper;
+        // Optimized signatures:
+        // - Use pre-computed Args type aliases instead of inline PrismaNamespace.Args
+        // - Remove Exact wrapper - the extends constraint already provides type safety
+        // - This reduces TypeScript's type computation workload significantly
         return `    ${modelNameCamel}: {
-      findUnique: <A extends PrismaNamespace.Args<${delegate}, 'findUnique'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findUnique'>>
+      findUnique: <A extends ${argsType('findUnique')}>(
+        args: A
       ): Effect.Effect<${resultType('findUnique', true)}, ${errorType('PrismaFindError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -164,8 +197,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      findUniqueOrThrow: <A extends PrismaNamespace.Args<${delegate}, 'findUniqueOrThrow'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findUniqueOrThrow'>>
+      findUniqueOrThrow: <A extends ${argsType('findUniqueOrThrow')}>(
+        args: A
       ): Effect.Effect<${resultType('findUniqueOrThrow')}, ${errorType('PrismaFindOrThrowError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -174,8 +207,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      findFirst: <A extends PrismaNamespace.Args<${delegate}, 'findFirst'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findFirst'>>
+      findFirst: <A extends ${argsType('findFirst')} = {}>(
+        args?: A
       ): Effect.Effect<${resultType('findFirst', true)}, ${errorType('PrismaFindError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -184,8 +217,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      findFirstOrThrow: <A extends PrismaNamespace.Args<${delegate}, 'findFirstOrThrow'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findFirstOrThrow'>>
+      findFirstOrThrow: <A extends ${argsType('findFirstOrThrow')} = {}>(
+        args?: A
       ): Effect.Effect<${resultType('findFirstOrThrow')}, ${errorType('PrismaFindOrThrowError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -194,8 +227,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      findMany: <A extends PrismaNamespace.Args<${delegate}, 'findMany'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'findMany'>>
+      findMany: <A extends ${argsType('findMany')} = {}>(
+        args?: A
       ): Effect.Effect<${resultType('findMany')}, ${errorType('PrismaFindError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -204,8 +237,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      create: <A extends PrismaNamespace.Args<${delegate}, 'create'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'create'>>
+      create: <A extends ${argsType('create')}>(
+        args: A
       ): Effect.Effect<${resultType('create')}, ${errorType('PrismaCreateError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -215,7 +248,7 @@ function generateModelOperations(models, customError) {
         ),
 
       createMany: (
-        args?: PrismaNamespace.Args<${delegate}, 'createMany'>
+        args?: ${argsType('createMany')}
       ): Effect.Effect<PrismaNamespace.BatchPayload, ${errorType('PrismaCreateError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -224,8 +257,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      createManyAndReturn: <A extends PrismaNamespace.Args<${delegate}, 'createManyAndReturn'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'createManyAndReturn'>>
+      createManyAndReturn: <A extends ${argsType('createManyAndReturn')}>(
+        args: A
       ): Effect.Effect<${resultType('createManyAndReturn')}, ${errorType('PrismaCreateError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -234,8 +267,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      delete: <A extends PrismaNamespace.Args<${delegate}, 'delete'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'delete'>>
+      delete: <A extends ${argsType('delete')}>(
+        args: A
       ): Effect.Effect<${resultType('delete')}, ${errorType('PrismaDeleteError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -244,8 +277,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      update: <A extends PrismaNamespace.Args<${delegate}, 'update'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'update'>>
+      update: <A extends ${argsType('update')}>(
+        args: A
       ): Effect.Effect<${resultType('update')}, ${errorType('PrismaUpdateError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -255,7 +288,7 @@ function generateModelOperations(models, customError) {
         ),
 
       deleteMany: (
-        args?: PrismaNamespace.Args<${delegate}, 'deleteMany'>
+        args?: ${argsType('deleteMany')}
       ): Effect.Effect<PrismaNamespace.BatchPayload, ${errorType('PrismaDeleteManyError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -265,7 +298,7 @@ function generateModelOperations(models, customError) {
         ),
 
       updateMany: (
-        args: PrismaNamespace.Args<${delegate}, 'updateMany'>
+        args: ${argsType('updateMany')}
       ): Effect.Effect<PrismaNamespace.BatchPayload, ${errorType('PrismaUpdateManyError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -274,8 +307,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      updateManyAndReturn: <A extends PrismaNamespace.Args<${delegate}, 'updateManyAndReturn'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'updateManyAndReturn'>>
+      updateManyAndReturn: <A extends ${argsType('updateManyAndReturn')}>(
+        args: A
       ): Effect.Effect<${resultType('updateManyAndReturn')}, ${errorType('PrismaUpdateManyError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -284,8 +317,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      upsert: <A extends PrismaNamespace.Args<${delegate}, 'upsert'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'upsert'>>
+      upsert: <A extends ${argsType('upsert')}>(
+        args: A
       ): Effect.Effect<${resultType('upsert')}, ${errorType('PrismaCreateError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -295,8 +328,8 @@ function generateModelOperations(models, customError) {
         ),
 
       // Aggregation operations
-      count: <A extends PrismaNamespace.Args<${delegate}, 'count'> = {}>(
-        args?: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'count'>>
+      count: <A extends ${argsType('count')} = {}>(
+        args?: A
       ): Effect.Effect<${resultType('count')}, ${errorType('PrismaFindError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -305,8 +338,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      aggregate: <A extends PrismaNamespace.Args<${delegate}, 'aggregate'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'aggregate'>>
+      aggregate: <A extends ${argsType('aggregate')}>(
+        args: A
       ): Effect.Effect<${resultType('aggregate')}, ${errorType('PrismaFindError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -315,8 +348,8 @@ function generateModelOperations(models, customError) {
           })
         ),
 
-      groupBy: <A extends PrismaNamespace.Args<${delegate}, 'groupBy'>>(
-        args: PrismaNamespace.Exact<A, PrismaNamespace.Args<${delegate}, 'groupBy'>>
+      groupBy: <A extends ${argsType('groupBy')}>(
+        args: A
       ): Effect.Effect<${resultType('groupBy')}, ${errorType('PrismaFindError')}, PrismaClient> =>
         Effect.flatMap(PrismaClient, ({ tx: client }) =>
           Effect.tryPromise({
@@ -341,24 +374,32 @@ function parseErrorImportPath(errorImportPath) {
 async function generateUnifiedService(models, outputDir, clientImportPath, errorImportPath) {
     const customError = parseErrorImportPath(errorImportPath);
     const rawSqlOperations = generateRawSqlOperations(customError);
+    const modelTypeAliases = generateModelTypeAliases(models);
     const modelOperations = generateModelOperations(models, customError);
     // Generate different content based on whether custom error is configured
     const serviceContent = customError
-        ? generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelOperations)
-        : generateDefaultErrorService(clientImportPath, rawSqlOperations, modelOperations);
+        ? generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelTypeAliases, modelOperations)
+        : generateDefaultErrorService(clientImportPath, rawSqlOperations, modelTypeAliases, modelOperations);
     await promises_1.default.writeFile(node_path_1.default.join(outputDir, "index.ts"), serviceContent);
 }
 /**
  * Generate service with custom user-provided error class.
  * All operations use a single error type and a simple mapError function.
  */
-function generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelOperations) {
+function generateCustomErrorService(customError, clientImportPath, rawSqlOperations, modelTypeAliases, modelOperations) {
     return `${header}
 import { Context, Effect, Exit, Layer } from "effect"
 import { Service } from "effect/Effect"
 import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "${clientImportPath}"
 import { ${customError.className}, mapPrismaError } from "${customError.path}"
 
+// ============================================================================
+// Type aliases for model operations (performance optimization)
+// These are computed once and reused, reducing TypeScript's type-checking workload
+// ============================================================================
+
+${modelTypeAliases}
+
 // Symbol used to identify intentional rollbacks vs actual errors
 const ROLLBACK = Symbol.for("prisma.effect.rollback")
 
@@ -557,7 +598,8 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * This implementation uses a callback-free transaction pattern that keeps the effect
        * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
        *
-       * Options passed here override any defaults set via TransactionConfig layer.
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$transactionWith\`.
        *
        * @example
        * const result = yield* prisma.$transaction(
@@ -567,16 +609,63 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        *     return user
        *   })
        * )
+       */
+      $transaction: <R, E, A>(
+        effect: Effect.Effect<A, E, R>
+      ) =>
+        Effect.flatMap(
+          PrismaClient,
+          ({ client, tx }): Effect.Effect<A, E | ${customError.className}, R> => {
+            // If we're already in a transaction, just run the effect directly (no nesting)
+            const isRootClient = "$transaction" in tx
+            if (!isRootClient) {
+              return effect
+            }
+
+            // Use acquireUseRelease to manage the transaction lifecycle
+            // This keeps everything in the same fiber, preserving Ref/FiberRef/Context
+            return Effect.acquireUseRelease(
+              // Acquire: begin a new transaction with default options
+              $begin(client),
+
+              // Use: run the effect with the transaction client injected
+              (txClient) =>
+                effect.pipe(
+                  Effect.provideService(PrismaClient, { tx: txClient, client })
+                ),
+
+              // Release: commit on success, rollback on failure/interruption
+              (txClient, exit) =>
+                Exit.isSuccess(exit)
+                  ? Effect.promise(() => txClient.$commit())
+                  : Effect.promise(() => txClient.$rollback())
+            )
+          }
+        ),
+
+      /**
+       * Execute an effect within a database transaction with custom options.
+       * All operations within the effect will be atomic - they either all succeed or all fail.
+       *
+       * This implementation uses a callback-free transaction pattern that keeps the effect
+       * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
        *
        * @example
        * // Override default isolation level for this transaction
-       * const result = yield* prisma.$transaction(myEffect, {
-       *   isolationLevel: "ReadCommitted"
-       * })
+       * const result = yield* prisma.$transactionWith(
+       *   Effect.gen(function* () {
+       *     const user = yield* prisma.user.create({ data: { name: "Alice" } })
+       *     yield* prisma.post.create({ data: { title: "Hello", authorId: user.id } })
+       *     return user
+       *   }),
+       *   { isolationLevel: "ReadCommitted", timeout: 10000 }
+       * )
        */
-      $transaction: <R, E, A>(
+      $transactionWith: <R, E, A>(
         effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
+        options: TransactionOptions
       ) =>
         Effect.flatMap(
           PrismaClient,
@@ -621,6 +710,9 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
        * or vice versa. Use carefully to avoid data inconsistencies.
        *
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$isolatedTransactionWith\`.
+       *
        * @example
        * yield* prisma.$transaction(
        *   Effect.gen(function* () {
@@ -634,8 +726,56 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * )
        */
       $isolatedTransaction: <R, E, A>(
+        effect: Effect.Effect<A, E, R>
+      ) =>
+        Effect.flatMap(
+          PrismaClient,
+          ({ client }): Effect.Effect<A, E | ${customError.className}, R> => {
+            // Always use the root client to create a fresh transaction
+            return Effect.acquireUseRelease(
+              $begin(client),
+              (txClient) =>
+                effect.pipe(
+                  Effect.provideService(PrismaClient, { tx: txClient, client })
+                ),
+              (txClient, exit) =>
+                Exit.isSuccess(exit)
+                  ? Effect.promise(() => txClient.$commit())
+                  : Effect.promise(() => txClient.$rollback())
+            )
+          }
+        ),
+
+      /**
+       * Execute an effect in a NEW transaction with custom options, even if already inside a transaction.
+       * Unlike \`$transaction\`, this always creates a fresh, independent transaction.
+       *
+       * Use this for operations that should NOT be rolled back with the parent:
+       * - Audit logging that must persist even if main operation fails
+       * - Saga pattern where each step has independent commit/rollback
+       * - Background job queuing that should commit immediately
+       *
+       * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
+       * or vice versa. Use carefully to avoid data inconsistencies.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
+       *
+       * @example
+       * yield* prisma.$transaction(
+       *   Effect.gen(function* () {
+       *     // This audit log commits independently with custom isolation level
+       *     yield* prisma.$isolatedTransactionWith(
+       *       prisma.auditLog.create({ data: { action: "attempt", userId } }),
+       *       { isolationLevel: "Serializable" }
+       *     )
+       *     // Main operation - if this fails, audit log is still committed
+       *     yield* prisma.user.delete({ where: { id: userId } })
+       *   })
+       * )
+       */
+      $isolatedTransactionWith: <R, E, A>(
         effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
+        options: TransactionOptions
       ) =>
         Effect.flatMap(
           PrismaClient,
@@ -749,12 +889,19 @@ export const makePrismaLayerEffect = PrismaClient.layerEffect
  * Generate service with default tagged error classes.
  * Operations have per-operation error types for fine-grained error handling.
  */
-function generateDefaultErrorService(clientImportPath, rawSqlOperations, modelOperations) {
+function generateDefaultErrorService(clientImportPath, rawSqlOperations, modelTypeAliases, modelOperations) {
     return `${header}
 import { Context, Data, Effect, Exit, Layer } from "effect"
 import { Service } from "effect/Effect"
 import { Prisma as PrismaNamespace, PrismaClient as BasePrismaClient } from "${clientImportPath}"
 
+// ============================================================================
+// Type aliases for model operations (performance optimization)
+// These are computed once and reused, reducing TypeScript's type-checking workload
+// ============================================================================
+
+${modelTypeAliases}
+
 // Symbol used to identify intentional rollbacks vs actual errors
 const ROLLBACK = Symbol.for("prisma.effect.rollback")
 
@@ -1290,7 +1437,8 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * This implementation uses a callback-free transaction pattern that keeps the effect
        * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
        *
-       * Options passed here override any defaults set via transactionOptions in the layer.
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$transactionWith\`.
        *
        * @example
        * const result = yield* prisma.$transaction(
@@ -1300,16 +1448,63 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        *     return user
        *   })
        * )
+       */
+      $transaction: <R, E, A>(
+        effect: Effect.Effect<A, E, R>
+      ) =>
+        Effect.flatMap(
+          PrismaClient,
+          ({ client, tx }): Effect.Effect<A, E | PrismaError, R> => {
+            // If we're already in a transaction, just run the effect directly (no nesting)
+            const isRootClient = "$transaction" in tx
+            if (!isRootClient) {
+              return effect
+            }
+
+            // Use acquireUseRelease to manage the transaction lifecycle
+            // This keeps everything in the same fiber, preserving Ref/FiberRef/Context
+            return Effect.acquireUseRelease(
+              // Acquire: begin a new transaction with default options
+              $begin(client),
+
+              // Use: run the effect with the transaction client injected
+              (txClient) =>
+                effect.pipe(
+                  Effect.provideService(PrismaClient, { tx: txClient, client })
+                ),
+
+              // Release: commit on success, rollback on failure/interruption
+              (txClient, exit) =>
+                Exit.isSuccess(exit)
+                  ? Effect.promise(() => txClient.$commit())
+                  : Effect.promise(() => txClient.$rollback())
+            )
+          }
+        ),
+
+      /**
+       * Execute an effect within a database transaction with custom options.
+       * All operations within the effect will be atomic - they either all succeed or all fail.
+       *
+       * This implementation uses a callback-free transaction pattern that keeps the effect
+       * running in the same fiber as the parent, preserving Ref, FiberRef, and Context access.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
        *
        * @example
        * // Override default isolation level for this transaction
-       * const result = yield* prisma.$transaction(myEffect, {
-       *   isolationLevel: "ReadCommitted"
-       * })
+       * const result = yield* prisma.$transactionWith(
+       *   Effect.gen(function* () {
+       *     const user = yield* prisma.user.create({ data: { name: "Alice" } })
+       *     yield* prisma.post.create({ data: { title: "Hello", authorId: user.id } })
+       *     return user
+       *   }),
+       *   { isolationLevel: "ReadCommitted", timeout: 10000 }
+       * )
        */
-      $transaction: <R, E, A>(
+      $transactionWith: <R, E, A>(
         effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
+        options: TransactionOptions
       ) =>
         Effect.flatMap(
           PrismaClient,
@@ -1354,6 +1549,9 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
        * or vice versa. Use carefully to avoid data inconsistencies.
        *
+       * Uses default transaction options from PrismaClient constructor.
+       * For custom options, use \`$isolatedTransactionWith\`.
+       *
        * @example
        * yield* prisma.$transaction(
        *   Effect.gen(function* () {
@@ -1367,8 +1565,56 @@ export class Prisma extends Service<Prisma>()("Prisma", {
        * )
        */
       $isolatedTransaction: <R, E, A>(
+        effect: Effect.Effect<A, E, R>
+      ) =>
+        Effect.flatMap(
+          PrismaClient,
+          ({ client }): Effect.Effect<A, E | PrismaError, R> => {
+            // Always use the root client to create a fresh transaction
+            return Effect.acquireUseRelease(
+              $begin(client),
+              (txClient) =>
+                effect.pipe(
+                  Effect.provideService(PrismaClient, { tx: txClient, client })
+                ),
+              (txClient, exit) =>
+                Exit.isSuccess(exit)
+                  ? Effect.promise(() => txClient.$commit())
+                  : Effect.promise(() => txClient.$rollback())
+            )
+          }
+        ),
+
+      /**
+       * Execute an effect in a NEW transaction with custom options, even if already inside a transaction.
+       * Unlike \`$transaction\`, this always creates a fresh, independent transaction.
+       *
+       * Use this for operations that should NOT be rolled back with the parent:
+       * - Audit logging that must persist even if main operation fails
+       * - Saga pattern where each step has independent commit/rollback
+       * - Background job queuing that should commit immediately
+       *
+       * ⚠️ WARNING: The isolated transaction can commit while the parent rolls back,
+       * or vice versa. Use carefully to avoid data inconsistencies.
+       *
+       * Options passed here override any defaults set in PrismaClient constructor.
+       *
+       * @example
+       * yield* prisma.$transaction(
+       *   Effect.gen(function* () {
+       *     // This audit log commits independently with custom isolation level
+       *     yield* prisma.$isolatedTransactionWith(
+       *       prisma.auditLog.create({ data: { action: "attempt", userId } }),
+       *       { isolationLevel: "Serializable" }
+       *     )
+       *     // Main operation - if this fails, audit log is still committed
+       *     yield* prisma.user.delete({ where: { id: userId } })
+       *   })
+       * )
+       */
+      $isolatedTransactionWith: <R, E, A>(
         effect: Effect.Effect<A, E, R>,
-        options?: TransactionOptions
+        options: TransactionOptions
       ) =>
         Effect.flatMap(
           PrismaClient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riordanpawley/effect-prisma-generator",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Prisma generator for Effect (fork with Prisma 7 support)",
   "main": "dist/index.js",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/riordanpawley/effect-prisma-generator.git"
+    "url": "git+https://github.com/riordanpawley/effect-prisma-generator.git"
   },
   "keywords": [
     "prisma",