prisma-generator-effect 1.1.2-beta.1 → 1.1.3-beta.2

package/README.md

@@ -8,6 +8,7 @@ A Prisma generator that creates a fully-typed, Effect-based service wrapper for
 - 🛡️ **Type Safety**: Full TypeScript support with generated types matching your Prisma schema.
 - 🧩 **Dependency Injection**: Integrates seamlessly with Effect's `Layer` and `Context` system.
 - 🔍 **Error Handling**: Automatically catches and wraps Prisma errors into typed `PrismaError` variants.
+- 🔀 **Read Replicas**: Optional `PrismaReplicas` service automatically routes reads to replicas, with `$primary()` / `$replica()` escape hatches for explicit routing.
 
 ## Installation
 
@@ -605,3 +606,104 @@ await Effect.runPromise(
 ```
 
 For long-running applications (like servers), you typically provide the layer once at startup and it stays connected for the lifetime of the application.
+
+### Read Replicas
+
+The generator emits an optional `PrismaReplicas` service tag that, when provided in
+the layer context, causes read operations to be routed to a randomly selected replica
+instead of the primary client. This is inspired by
+[`@prisma/extension-read-replicas`](https://github.com/prisma/extension-read-replicas)
+but implemented natively at the Effect service level (no extension runtime dependency).
+
+#### Layer setup
+
+Provide replicas alongside the primary `Prisma.layer(...)`:
+
+```typescript
+import { Layer } from "effect"
+import { Prisma, PrismaReplicas } from "./generated/effect"
+
+const AppLayer = Layer.mergeAll(
+  // Primary - handles writes, transactions, raw SQL
+  Prisma.layer({ adapter: primaryAdapter }),
+  // Replicas - handle reads (optional)
+  PrismaReplicas.layer([
+    { adapter: replica1Adapter },
+    { adapter: replica2Adapter },
+  ]),
+)
+```
+
+`PrismaReplicas` also exposes a `layerEffect` constructor (for when the replica configs
+come from an Effect, e.g. a config service) and a `layerFromClients` helper (for passing
+already-constructed `PrismaClient` instances whose lifecycle you manage yourself).
+
+Each replica client created by `PrismaReplicas.layer` is automatically disconnected when
+the layer scope ends (identical to `PrismaClient.layer`).
+
+#### Routing rules
+
+With `PrismaReplicas` present:
+
+| Operation | Routed to |
+|---|---|
+| `findUnique`, `findUniqueOrThrow`, `findFirst`, `findFirstOrThrow`, `findMany` | Random replica |
+| `count`, `aggregate`, `groupBy` | Random replica |
+| `create`, `createMany`, `createManyAndReturn`, `upsert` | Primary |
+| `update`, `updateMany`, `updateManyAndReturn` | Primary |
+| `delete`, `deleteMany` | Primary |
+| `$transaction`, `$transactionWith`, `$isolatedTransaction*` | Primary |
+| `$executeRaw*`, `$queryRaw*` | Primary (by default - SQL intent cannot be detected automatically) |
+| Any operation inside an active `$transaction` | Transaction client (replicas ignored) |
+
+Without `PrismaReplicas`, every operation is routed to the primary - behavior is identical
+to a service constructed without replicas, so you can adopt this feature incrementally.
+
+#### `$primary()` / `$replica()` escape hatches
+
+Two escape hatches are available on the generated service to force routing:
+
+- `prisma.$primary()` returns a sub-service where **all** operations (including reads)
+  are pinned to the primary client. Useful for read-your-own-writes scenarios or when you
+  need strong consistency.
+- `prisma.$replica()` returns a sub-service where **all** operations (including writes
+  and raw SQL) are pinned to a random replica. If no replicas are configured, falls back
+  to the primary.
+
+```typescript
+const program = Effect.gen(function* () {
+  const prisma = yield* Prisma
+
+  // Auto-routed: reads go to a random replica
+  const users = yield* prisma.user.findMany()
+
+  // Force the primary (e.g. after a recent write where replication lag matters)
+  const fresh = yield* prisma.$primary().user.findMany()
+
+  // Force a replica, even for raw SQL
+  const stats = yield* prisma.$replica().$queryRawUnsafe<Array<{ n: number }>>(
+    "SELECT count(*) as n FROM User",
+  )
+})
+```
+
+Sub-services returned by `$primary()` / `$replica()` implement the full `IPrismaService`
+interface and themselves expose `$primary()` / `$replica()`, so chaining type-checks:
+
+```typescript
+// These all type-check and resolve to the expected pinned sub-service:
+prisma.$primary().$replica().user.findMany()
+prisma.$replica().$primary().$transaction(/* ... */)
+```
+
+#### Notes
+
+- Transactions always execute against the primary - replicas cannot participate in a
+  multi-statement transaction. Inside a `$transaction` callback, every operation (reads
+  included) uses the transaction client.
+- Raw SQL (`$executeRaw*` / `$queryRaw*`) defaults to the primary because the generator
+  cannot inspect the SQL to decide whether it is a read or a write. Use `$replica()` to
+  opt a specific raw query into replica routing.
+- Replica selection is uniformly random. If you need weighted or round-robin selection,
+  provide your own `PrismaClient` instances via `PrismaReplicas.layerFromClients` and wrap
+  the selection in your own logic, or open an issue.

package/dist/index.js

@@ -115,7 +115,7 @@ function generateRawSqlOperations(customError, enableTelemetry) {
         : `Effect.fnUntraced(${generatorFn})`;
     return `
     $executeRaw: ${wrapTelemetry("Prisma.$executeRaw", `function* (args) {
-      const actualClient = yield* clientOrTx(client);
+      const actualClient = yield* writeClient(client, pin);
       return yield* Effect.tryPromise<any, ${errorType}>({
         try: () => (Array.isArray(args) ? actualClient.$executeRaw(args[0], ...args.slice(1)) : actualClient.$executeRaw(args)) as any,
         catch: (error) => mapError(error, "$executeRaw", "Prisma")
@@ -123,7 +123,7 @@ function generateRawSqlOperations(customError, enableTelemetry) {
     }`)},
 
     $executeRawUnsafe: ${wrapTelemetry("Prisma.$executeRawUnsafe", `function* (query, ...values) {
-      const actualClient = yield* clientOrTx(client);
+      const actualClient = yield* writeClient(client, pin);
       return yield* Effect.tryPromise<any, ${errorType}>({
         try: () => actualClient.$executeRawUnsafe(query, ...values) as any,
         catch: (error) => mapError(error, "$executeRawUnsafe", "Prisma")
@@ -131,7 +131,7 @@ function generateRawSqlOperations(customError, enableTelemetry) {
     }`)},
 
     $queryRaw: ${wrapTelemetry("Prisma.$queryRaw", `function* (args) {
-      const actualClient = yield* clientOrTx(client);
+      const actualClient = yield* writeClient(client, pin);
       return yield* Effect.tryPromise<any, ${errorType}>({
         try: () => (Array.isArray(args) ? actualClient.$queryRaw(args[0], ...args.slice(1)) : actualClient.$queryRaw(args)) as any,
         catch: (error) => mapError(error, "$queryRaw", "Prisma")
@@ -139,7 +139,7 @@ function generateRawSqlOperations(customError, enableTelemetry) {
     }`)},
 
     $queryRawUnsafe: ${wrapTelemetry("Prisma.$queryRawUnsafe", `function* (query, ...values) {
-      const actualClient = yield* clientOrTx(client);
+      const actualClient = yield* writeClient(client, pin);
       return yield* Effect.tryPromise<any, ${errorType}>({
         try: () => actualClient.$queryRawUnsafe(query, ...values) as any,
         catch: (error) => mapError(error, "$queryRawUnsafe", "Prisma")
@@ -306,6 +306,17 @@ function generatePrismaInterface(models, customError, supportsManyAndReturn) {
  */
 export interface IPrismaService {
   client: BasePrismaClient
+  // Read-replica routing escape hatches
+  /**
+   * Return a sub-service where all operations (including reads) are pinned to the primary client.
+   * Useful when you need strong consistency for a specific read (e.g. read-your-own-writes).
+   */
+  $primary: () => IPrismaService
+  /**
+   * Return a sub-service where all operations (including writes and raw queries) are pinned to a random replica.
+   * If no replicas are configured, falls back to the primary client.
+   */
+  $replica: () => IPrismaService
   // Transaction operations
   $transaction: <R, E, A>(
     effect: EffectType<A, E, R>
@@ -352,6 +363,150 @@ ${modelInterfaces}
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+ * Generate the PrismaReplicas Context.Service class declaration.
+ * This is an optional service that, when provided in the layer context, causes read
+ * operations to be routed to a randomly selected replica instead of the primary client.
+ */
+function generatePrismaReplicasClass() {
+    return `/**
+ * Context tag for read replica clients.
+ *
+ * When provided alongside \`PrismaClient\`, read operations (\`findUnique\`, \`findFirst\`,
+ * \`findMany\`, \`count\`, \`aggregate\`, \`groupBy\`, etc.) are routed to a random replica.
+ * Write operations, transactions, and raw SQL always use the primary client by default.
+ *
+ * Use \`prisma.$primary()\` / \`prisma.$replica()\` on the service to force routing.
+ *
+ * @example
+ * const AppLayer = Layer.mergeAll(
+ *   Prisma.layer({ adapter: primaryAdapter }),
+ *   PrismaReplicas.layer([{ adapter: replica1Adapter }, { adapter: replica2Adapter }])
+ * )
+ */
+export class PrismaReplicas extends Context.Service<PrismaReplicas, ReadonlyArray<BasePrismaClient>>()("PrismaReplicas") {
+  /**
+   * Create a PrismaReplicas layer from an array of PrismaClient constructor options.
+   * Each replica client will be automatically disconnected when the layer scope ends.
+   */
+  static layer: (
+    configs: ReadonlyArray<ConstructorParameters<typeof BasePrismaClient>[0]>
+  ) => Layer.Layer<PrismaReplicas, never, never> = (configs) => Layer.effect(
+    PrismaReplicas,
+    Effect.gen(function* () {
+      const clients: ReadonlyArray<BasePrismaClient> = configs.map((c) => new BasePrismaClient(c))
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(() =>
+          Promise.all(clients.map((c) => c.$disconnect())).then(() => undefined)
+        )
+      )
+      return clients
+    })
+  )
+
+  /**
+   * Create a PrismaReplicas layer from an Effect that yields the replica configs.
+   * Useful when replica configuration depends on an Effect service (e.g. config lookup).
+   */
+  static layerEffect: <R, E>(
+    configsEffect: EffectType<ReadonlyArray<ConstructorParameters<typeof BasePrismaClient>[0]>, E, R>
+  ) => Layer.Layer<PrismaReplicas, E, Exclude<R, Scope.Scope>> = (configsEffect) => Layer.effect(
+    PrismaReplicas,
+    Effect.gen(function* () {
+      const configs = yield* configsEffect
+      const clients: ReadonlyArray<BasePrismaClient> = configs.map((c) => new BasePrismaClient(c))
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(() =>
+          Promise.all(clients.map((c) => c.$disconnect())).then(() => undefined)
+        )
+      )
+      return clients
+    })
+  )
+
+  /**
+   * Create a PrismaReplicas layer from an array of already-constructed PrismaClient instances.
+   * The caller is responsible for managing the lifecycle of the provided clients.
+   */
+  static layerFromClients: (
+    clients: ReadonlyArray<BasePrismaClient>
+  ) => Layer.Layer<PrismaReplicas, never, never> = (clients) => Layer.succeed(PrismaReplicas, clients)
+}`;
+}
+/**
+ * Generate the read/write routing helpers.
+ * These helpers consult the current transaction context and the optional PrismaReplicas service
+ * to decide which underlying client should handle a given operation.
+ */
+function generateRoutingHelpers() {
+    return `/** Pin parameter controlling replica routing for a sub-service. */
+type PrismaRoutingPin = "primary" | "replica" | undefined
+
+/** Pick a random replica from the provided array. Caller ensures non-empty. */
+const pickReplica = (replicas: ReadonlyArray<BasePrismaClient>): BasePrismaClient =>
+  replicas[Math.floor(Math.random() * replicas.length)] as BasePrismaClient
+
+/**
+ * Resolve the client to use for a READ operation.
+ *
+ * Priority:
+ *   1. Transaction client (if inside \`$transaction\`)
+ *   2. Primary client (if pin === "primary")
+ *   3. Random replica (if replicas are configured and non-empty)
+ *   4. Primary client (fallback)
+ */
+const readClient = (client: BasePrismaClient, pin: PrismaRoutingPin) => Effect.gen(function* () {
+  const tx = yield* Effect.serviceOption(PrismaTransactionClientService)
+  if (Option.isSome(tx)) return tx.value as BasePrismaClient
+  if (pin === "primary") return client
+  const replicas = yield* Effect.serviceOption(PrismaReplicas)
+  if (Option.isNone(replicas) || replicas.value.length === 0) return client
+  return pickReplica(replicas.value)
+})
+
+/**
+ * Resolve the client to use for a WRITE or raw SQL operation.
+ *
+ * Priority:
+ *   1. Transaction client (if inside \`$transaction\`)
+ *   2. Random replica (only if pin === "replica" AND replicas are configured)
+ *   3. Primary client (default - writes/raw always go here unless explicitly pinned to replica)
+ */
+const writeClient = (client: BasePrismaClient, pin: PrismaRoutingPin) => Effect.gen(function* () {
+  const tx = yield* Effect.serviceOption(PrismaTransactionClientService)
+  if (Option.isSome(tx)) return tx.value as BasePrismaClient
+  if (pin === "replica") {
+    const replicas = yield* Effect.serviceOption(PrismaReplicas)
+    if (Option.isSome(replicas) && replicas.value.length > 0) {
+      return pickReplica(replicas.value)
+    }
+  }
+  return client
+})`;
+}
+/**
+ * Wrap a service body string in the buildService(pin) closure that also constructs
+ * the primary and replica sub-services. This is shared between both error-service variants.
+ *
+ * The generated scaffolding:
+ *   1. Declares \`primaryService\` / \`replicaService\` with definite-assignment assertions.
+ *   2. Defines \`buildService(pin)\` - captures \`pin\` so every read/write helper call
+ *      resolves to the correct client at runtime.
+ *   3. Builds the primary and replica sub-services first, then returns the main service
+ *      with pin=undefined (auto-routing).
+ */
+function wrapBuildService(body) {
+    return `let primaryService!: IPrismaService;
+  let replicaService!: IPrismaService;
+
+  const buildService = (pin: PrismaRoutingPin): IPrismaService => ({
+${body}
+  });
+
+  primaryService = buildService("primary");
+  replicaService = buildService("replica");
+  return buildService(undefined);`;
+}
 function generateModelOperations(models, customError, enableTelemetry, supportsManyAndReturn) {
     return models
         .map((model) => {
@@ -383,7 +538,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
         // Implementation without explicit types - the IPrismaService interface provides all type checking
         return `    ${modelNameCamel}: {
       findUnique: ${wrapTelemetry(`Prisma.${modelNameCamel}.findUnique`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
           try: () => actualClient.${modelNameCamel}.findUnique(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapFindError")}(error, "findUnique", "${modelName}")
@@ -391,7 +546,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       findUniqueOrThrow: ${wrapTelemetry(`Prisma.${modelNameCamel}.findUniqueOrThrow`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindOrThrowError")}>({
           try: () => actualClient.${modelNameCamel}.findUniqueOrThrow(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapFindOrThrowError")}(error, "findUniqueOrThrow", "${modelName}")
@@ -399,7 +554,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       findFirst: ${wrapTelemetry(`Prisma.${modelNameCamel}.findFirst`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
           try: () => actualClient.${modelNameCamel}.findFirst(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapFindError")}(error, "findFirst", "${modelName}")
@@ -407,7 +562,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       findFirstOrThrow: ${wrapTelemetry(`Prisma.${modelNameCamel}.findFirstOrThrow`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindOrThrowError")}>({
           try: () => actualClient.${modelNameCamel}.findFirstOrThrow(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapFindOrThrowError")}(error, "findFirstOrThrow", "${modelName}")
@@ -415,7 +570,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       findMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.findMany`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
           try: () => actualClient.${modelNameCamel}.findMany(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapFindError")}(error, "findMany", "${modelName}")
@@ -423,7 +578,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       create: ${wrapTelemetry(`Prisma.${modelNameCamel}.create`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
           try: () => actualClient.${modelNameCamel}.create(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapCreateError")}(error, "create", "${modelName}")
@@ -431,7 +586,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       createMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.createMany`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
           try: () => actualClient.${modelNameCamel}.createMany(args as any),
           catch: (error) => ${mapperFn("mapCreateError")}(error, "createMany", "${modelName}")
@@ -440,7 +595,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
             ? `
 
       createManyAndReturn: ${wrapTelemetry(`Prisma.${modelNameCamel}.createManyAndReturn`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
           try: () => actualClient.${modelNameCamel}.createManyAndReturn(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapCreateError")}(error, "createManyAndReturn", "${modelName}")
@@ -449,7 +604,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
             : ""}
 
       delete: ${wrapTelemetry(`Prisma.${modelNameCamel}.delete`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaDeleteError")}>({
           try: () => actualClient.${modelNameCamel}.delete(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapDeleteError")}(error, "delete", "${modelName}")
@@ -457,7 +612,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       update: ${wrapTelemetry(`Prisma.${modelNameCamel}.update`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaUpdateError")}>({
           try: () => actualClient.${modelNameCamel}.update(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapUpdateError")}(error, "update", "${modelName}")
@@ -465,7 +620,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       deleteMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.deleteMany`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaDeleteManyError")}>({
           try: () => actualClient.${modelNameCamel}.deleteMany(args as any),
           catch: (error) => ${mapperFn("mapDeleteManyError")}(error, "deleteMany", "${modelName}")
@@ -473,7 +628,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       updateMany: ${wrapTelemetry(`Prisma.${modelNameCamel}.updateMany`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaUpdateManyError")}>({
           try: () => actualClient.${modelNameCamel}.updateMany(args as any),
           catch: (error) => ${mapperFn("mapUpdateManyError")}(error, "updateMany", "${modelName}")
@@ -482,7 +637,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
             ? `
 
       updateManyAndReturn: ${wrapTelemetry(`Prisma.${modelNameCamel}.updateManyAndReturn`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaUpdateManyError")}>({
           try: () => actualClient.${modelNameCamel}.updateManyAndReturn(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapUpdateManyError")}(error, "updateManyAndReturn", "${modelName}")
@@ -491,7 +646,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
             : ""}
 
       upsert: ${wrapTelemetry(`Prisma.${modelNameCamel}.upsert`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* writeClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaCreateError")}>({
           try: () => actualClient.${modelNameCamel}.upsert(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapCreateError")}(error, "upsert", "${modelName}")
@@ -500,7 +655,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
 
       // Aggregation operations
       count: ${wrapTelemetry(`Prisma.${modelNameCamel}.count`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
           try: () => actualClient.${modelNameCamel}.count(args as any)${promiseCast()},
           catch: (error) => ${mapperFn("mapFindError")}(error, "count", "${modelName}")
@@ -508,7 +663,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       aggregate: ${wrapTelemetry(`Prisma.${modelNameCamel}.aggregate`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
           try: () => actualClient.${modelNameCamel}.aggregate(args as any)${strongPromiseCast()},
           catch: (error) => ${mapperFn("mapFindError")}(error, "aggregate", "${modelName}")
@@ -516,7 +671,7 @@ function generateModelOperations(models, customError, enableTelemetry, supportsM
       }`)},
 
       groupBy: ${wrapTelemetry(`Prisma.${modelNameCamel}.groupBy`, `function* (args) {
-        const actualClient = yield* clientOrTx(client);
+        const actualClient = yield* readClient(client, pin);
         return yield* Effect.tryPromise<any, ${errorType("PrismaFindError")}>({
           try: () => actualClient.${modelNameCamel}.groupBy(args as any)${strongPromiseCast()},
           catch: (error) => ${mapperFn("mapFindError")}(error, "groupBy", "${modelName}")
@@ -681,20 +836,15 @@ export class PrismaClient extends Context.Service<PrismaClient, BasePrismaClient
  */
 export class PrismaTransactionClientService extends Context.Service<PrismaTransactionClientService, PrismaNamespace.TransactionClient>()("PrismaTransactionClientService") {}
 
+${generatePrismaReplicasClass()}
+
 // Re-export the custom error type for convenience
 export { ${customError.className} }
 
 // Use the user-provided error mapper
 const mapError = mapPrismaError
 
-/**
- * Helper to get the current client - either the transaction client if in a transaction,
- * or the root client if not. Uses Effect.serviceOption to detect transaction context.
- */
-const clientOrTx = (client: BasePrismaClient) => Effect.map(
-  Effect.serviceOption(PrismaTransactionClientService),
-  Option.getOrElse(() => client),
-);
+${generateRoutingHelpers()}
 
 /**
  * Like Effect.acquireUseRelease, but allows the release function to fail.
@@ -804,8 +954,13 @@ const $begin = (
 const makePrismaService = Effect.gen(function* () {
   const client = yield* PrismaClient;
 
-  const prismaService: IPrismaService = {
+  let primaryService!: IPrismaService;
+  let replicaService!: IPrismaService;
+
+  const buildService = (pin: PrismaRoutingPin): IPrismaService => ({
       client,
+      $primary: () => primaryService,
+      $replica: () => replicaService,
       /**
        * Execute an effect within a database transaction.
        * All operations within the effect will be atomic - they either all succeed or all fail.
@@ -1018,9 +1173,11 @@ const makePrismaService = Effect.gen(function* () {
       ${rawSqlOperations}
 
       ${modelOperations}
-  };
+  });
 
-  return prismaService;
+  primaryService = buildService("primary");
+  replicaService = buildService("replica");
+  return buildService(undefined);
 });
 
 export class Prisma extends Context.Service<Prisma, IPrismaService>()("Prisma") {
@@ -1221,6 +1378,8 @@ export class PrismaClient extends Context.Service<PrismaClient, BasePrismaClient
  */
 export class PrismaTransactionClientService extends Context.Service<PrismaTransactionClientService, PrismaNamespace.TransactionClient>()("PrismaTransactionClientService") {}
 
+${generatePrismaReplicasClass()}
+
 export class PrismaUniqueConstraintError extends Data.TaggedError("PrismaUniqueConstraintError")<{
   cause: PrismaNamespace.PrismaClientKnownRequestError
   operation: string
@@ -1572,14 +1731,7 @@ const mapUpdateManyError = (error: unknown, operation: string, model: string): P
   throw error;
 }
 
-/**
- * Helper to get the current client - either the transaction client if in a transaction,
- * or the root client if not. Uses Effect.serviceOption to detect transaction context.
- */
-const clientOrTx = (client: BasePrismaClient) => Effect.map(
-  Effect.serviceOption(PrismaTransactionClientService),
-  Option.getOrElse(() => client),
-);
+${generateRoutingHelpers()}
 
 /**
  * Like Effect.acquireUseRelease, but allows the release function to fail.
@@ -1689,8 +1841,13 @@ const $begin = (
 const makePrismaService = Effect.gen(function* () {
   const client = yield* PrismaClient;
 
-  const prismaService: IPrismaService = {
+  let primaryService!: IPrismaService;
+  let replicaService!: IPrismaService;
+
+  const buildService = (pin: PrismaRoutingPin): IPrismaService => ({
       client,
+      $primary: () => primaryService,
+      $replica: () => replicaService,
       /**
        * Execute an effect within a database transaction.
        * All operations within the effect will be atomic - they either all succeed or all fail.
@@ -1902,9 +2059,11 @@ const makePrismaService = Effect.gen(function* () {
       ${rawSqlOperations}
 
       ${modelOperations}
-  };
+  });
 
-  return prismaService;
+  primaryService = buildService("primary");
+  replicaService = buildService("replica");
+  return buildService(undefined);
 });
 
 export class Prisma extends Context.Service<Prisma, IPrismaService>()("Prisma") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-generator-effect",
-  "version": "1.1.2-beta.1",
+  "version": "1.1.3-beta.2",
   "description": "Prisma generator for Effect",
   "main": "dist/index.js",
   "bin": {