@yielded/auth-persistence-drizzle 0.1.0-beta.1 → 0.1.0-beta.13

package/src/drizzle/passkey-drivers.ts

@@ -1,8 +1,10 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { LifecycleHooks } from "@yielded/auth/Hooks";
 import { PasskeyPersistence } from "@yielded/auth/Passkey";
 import type { Table } from "drizzle-orm";
 import { Effect, Context } from "effect";
 
+import { nativeDatabase } from "./native-database";
 import type {
   PasskeyCredentialMapping,
   PasskeyEnrollmentContextMapping,
@@ -33,11 +35,13 @@ type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => an
   : never;
 
 export const makePasskeyTarget = <
+  DatabaseId,
   D,
   T extends Table,
   Extra = unknown,
   Synchronous extends boolean = false,
 >(
+  databaseService: Context.Service<DatabaseId, D>,
   configuration: PasskeyTargetConfiguration,
 ) => {
   function coordinatePasskeyPersistence<
@@ -304,9 +308,8 @@ export const makePasskeyTarget = <
   }
 
   return {
-    ...makePasskeyWriteTarget<D, T, Extra, Synchronous>(configuration),
+    ...makePasskeyWriteTarget<DatabaseId, D, T, Extra, Synchronous>(databaseService, configuration),
     makePasskeyCredentialServices: <
-      Database extends D,
       S extends T,
       C extends T,
       F extends T,
@@ -315,11 +318,12 @@ export const makePasskeyTarget = <
       N,
       RSetup = never,
     >(
-      database: Database,
       mapping: PasskeyMappingSource<PasskeyCredentialMapping<S, C, F, O, H, N> & Extra, RSetup>,
-    ) => makeTargetPasskeyCredentials(database, mapping, configuration),
+    ) =>
+      makeTargetPasskeyCredentials(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     makePasskeyEnrollmentContextServices: <
-      Database extends D,
       S extends T,
       C extends T,
       F extends T,
@@ -329,14 +333,15 @@ export const makePasskeyTarget = <
       N,
       RSetup = never,
     >(
-      database: Database,
       mapping: PasskeyMappingSource<
         PasskeyEnrollmentContextMapping<PasskeyCredentialMapping<S, C, F, O, H, N>, M, N> & Extra,
         RSetup
       >,
-    ) => makeTargetPasskeyEnrollmentContext(database, mapping, configuration),
+    ) =>
+      makeTargetPasskeyEnrollmentContext(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     makePasskeyPersistenceServices: <
-      Database extends D,
       S extends T,
       C extends T,
       F extends T,
@@ -349,7 +354,6 @@ export const makePasskeyTarget = <
       N,
       RSetup = never,
     >(
-      database: Database,
       mapping: PasskeyMappingSource<
         PasskeyPersistenceMapping<
           PasskeyCredentialMapping<S, C, F, O, H, N>,
@@ -362,9 +366,11 @@ export const makePasskeyTarget = <
           Extra,
         RSetup
       >,
-    ) => makeTargetPasskeyPersistence(database, mapping, configuration),
+    ) =>
+      makeTargetPasskeyPersistence(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     makePasskeyRegistrationCeremonyServices: <
-      Database extends D,
       M extends T,
       Flow extends T,
       Admission extends T,
@@ -373,12 +379,14 @@ export const makePasskeyTarget = <
       H extends T,
       RSetup = never,
     >(
-      database: Database,
       mapping: PasskeyMappingSource<
         PasskeyRegistrationCeremonyMapping<M, Flow, Admission, Charge, Intent, H> & Extra,
         RSetup
       >,
-    ) => makeTargetPasskeyRegistration(database, mapping, configuration),
+    ) =>
+      makeTargetPasskeyRegistration(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     coordinatePasskeyPersistence,
     coordinatePasskeyRegistrationCeremony,
   };

package/src/drizzle/passkey-write-drivers.ts

@@ -1,8 +1,10 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { LifecycleHooks } from "@yielded/auth/Hooks";
 import { PasskeyManagementPersistence, PasskeyPersistence } from "@yielded/auth/Passkey";
 import type { Table } from "drizzle-orm";
 import { Context, Effect } from "effect";
 
+import { nativeDatabase } from "./native-database";
 import type { PasskeyMappingSource } from "./passkey-model";
 import type { PasskeyCoordinatorError, PasskeyTargetConfiguration } from "./passkey-target";
 import type {
@@ -23,11 +25,13 @@ type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => an
   : never;
 
 export const makePasskeyWriteTarget = <
+  DatabaseId,
   D,
   T extends Table,
   Extra = unknown,
   Synchronous extends boolean = false,
 >(
+  databaseService: Context.Service<DatabaseId, D>,
   configuration: PasskeyTargetConfiguration,
 ) => {
   function coordinatePasskeyManagement<
@@ -180,7 +184,6 @@ export const makePasskeyWriteTarget = <
   }
 
   const makePasskeyManagementServices = <
-    Database extends D,
     S extends T,
     C extends T,
     F extends T,
@@ -194,12 +197,14 @@ export const makePasskeyWriteTarget = <
     N,
     RSetup = never,
   >(
-    database: Database,
     mapping: PasskeyMappingSource<
       PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
       RSetup
     >,
-  ) => makeTargetPasskeyManagement(database, mapping, configuration);
+  ) =>
+    makeTargetPasskeyManagement(mapping, configuration).pipe(
+      Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+    );
 
   function coordinatePasskeyRegistration<
     Database extends D,
@@ -357,7 +362,6 @@ export const makePasskeyWriteTarget = <
   }
 
   const makePasskeyRegistrationServices = <
-    Database extends D,
     S extends T,
     C extends T,
     F extends T,
@@ -372,7 +376,6 @@ export const makePasskeyWriteTarget = <
     Value,
     RSetup = never,
   >(
-    database: Database,
     mapping: PasskeyMappingSource<
       PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
         Extra,
@@ -384,7 +387,9 @@ export const makePasskeyWriteTarget = <
         Extra,
       Value,
       RSetup
-    >(database, mapping, configuration);
+    >(mapping, configuration).pipe(
+      Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+    );
 
   return {
     makePasskeyManagementServices,

package/src/drizzle/password-prepared-sql.ts

@@ -50,7 +50,6 @@ import {
   CurrentPasswordSql,
   passwordSqlKernel as kernel,
   type PasswordSqlConfiguration,
-  type PasswordSqlDatabase,
   type PasswordSqlQuery,
 } from "./password-sql";
 import { checkProofCompletionIn, completeProofPlanIn } from "./proof-sql";
@@ -85,7 +84,6 @@ const translateContextFailure = <A, E, R>(
   );
 
 type Mapping = AnyPasswordPreparedPersistenceMapping;
-type Database = PasswordSqlDatabase;
 const nowMillis = DateTime.now.pipe(Effect.map(DateTime.toEpochMillis));
 
 const read = (query: PasswordSqlQuery, locking: boolean) =>
@@ -410,10 +408,10 @@ const terminal = Effect.fn("DrizzlePasswordPrepared.terminal")(function* (
 
 export const makeSqlPasswordPreparedPersistence = Effect.fn("makeSqlPasswordPreparedPersistence")(
   function* (
-    database: Database,
     mapping: Mapping,
     configuration: PasswordSqlConfiguration,
-  ): Effect.fn.Return<PasswordPreparedPersistence, never, LifecycleHooks> {
+  ): Effect.fn.Return<PasswordPreparedPersistence, never, LifecycleHooks | CurrentPasswordSql> {
+    const database = yield* CurrentPasswordSql;
     const hooks = yield* LifecycleHooks;
 
     const p = mapping.password,

package/src/drizzle/password-prepared-target.ts

@@ -16,6 +16,7 @@ import { type Context, Cause, Effect, Layer } from "effect";
 import type * as SqlError from "effect/sql/SqlError";
 
 import { makeSqlPasswordPreparedPersistence } from "./password-prepared-sql";
+import { CurrentPasswordSql } from "./password-sql";
 import type { PasswordSqlDatabase } from "./password-sql";
 import {
   passwordOptions,
@@ -24,7 +25,6 @@ import {
 } from "./password-target";
 
 export const makeTargetPasswordPreparedPersistenceServices = (
-  database: any,
   mapping: any,
   configuration: PasswordTargetConfiguration,
   proofMapping?: any,
@@ -32,7 +32,6 @@ export const makeTargetPasswordPreparedPersistenceServices = (
   Effect.gen(function* () {
     return {
       passwordPreparedPersistence: yield* makeSqlPasswordPreparedPersistence(
-        database,
         mapping,
         passwordOptions(configuration, proofMapping),
       ),
@@ -69,9 +68,13 @@ export const coordinateTargetPasswordPreparedPersistence = <Transaction, A, E, R
             let acceptingPostconditions = true;
 
             const services = yield* makeSqlPasswordPreparedPersistence(
-              transaction as unknown as PasswordSqlDatabase,
               mapping,
               passwordOptions(configuration, proofMapping, true),
+            ).pipe(
+              Effect.provideService(
+                CurrentPasswordSql,
+                transaction as unknown as PasswordSqlDatabase,
+              ),
             );
 
             const protect = <Out, Err, Env>(effect: Effect.Effect<Out, Err, Env>) =>
@@ -146,12 +149,12 @@ export const coordinateTargetPasswordPreparedPersistence = <Transaction, A, E, R
     return result.value;
   });
 
-export const passwordPreparedPersistenceLayer = <Id>(
+export const passwordPreparedPersistenceLayer = <Id, E, R>(
   tag: Context.Key<Id, PasswordPreparedPersistence>,
   services: Effect.Effect<
     { readonly passwordPreparedPersistence: PasswordPreparedPersistence },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(

package/src/drizzle/password-registration.ts

@@ -23,14 +23,9 @@ import {
   type AnyPasswordRegistrationMapping,
   requiredPasswordRegistrationConstraints,
 } from "./password-model";
-import {
-  CurrentPasswordSql,
-  type PasswordSqlDatabase,
-  type PasswordSqlQuery,
-} from "./password-sql";
+import { CurrentPasswordSql, type PasswordSqlQuery } from "./password-sql";
 import { CurrentProofSql, type ProofSqlDatabase } from "./proof-sql";
 
-type Database = PasswordSqlDatabase;
 type Mapping<Registration> = AnyPasswordRegistrationMapping<Registration>;
 const unavailable = () => PasswordUnavailable.make({});
 
@@ -219,10 +214,14 @@ const registerIn = Effect.fn("DrizzlePasswordRegistration.registerIn")(function*
 export const makeSqlPasswordRegistrationAuthority = Effect.fn(
   "makeSqlPasswordRegistrationAuthority",
 )(function* <Registration>(
-  database: Database,
   mapping: Mapping<Registration>,
   configuration: PasswordRegistrationConfiguration,
-): Effect.fn.Return<PasswordRegistrationAuthority<Registration>, never, LifecycleHooks> {
+): Effect.fn.Return<
+  PasswordRegistrationAuthority<Registration>,
+  never,
+  LifecycleHooks | CurrentPasswordSql
+> {
+  const database = yield* CurrentPasswordSql;
   const hooks = yield* LifecycleHooks;
 
   return {

package/src/drizzle/password-target.ts

@@ -15,13 +15,14 @@ import {
   type PasswordRegistrationConfiguration,
 } from "./password-registration";
 import {
+  CurrentPasswordSql,
   makeSqlPasswordPersistence,
   type PasswordSqlConfiguration,
   type PasswordSqlDatabase,
   type PasswordSqlQuery,
 } from "./password-sql";
 import type { ProofTargetConfiguration } from "./proof-target";
-import { sqlClientStandaloneGuard } from "./standalone-guard";
+import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
 
 export interface PasswordTargetConfiguration {
   readonly mode: "interactive" | "synchronous";
@@ -50,9 +51,9 @@ export type PasswordCoordinatorError<E> =
   | SqlError.SqlError;
 
 export const sqlClientPasswordStandaloneGuard = (
-  database: unknown,
+  service: TransactionService | undefined,
 ): Effect.Effect<void, PasswordUnavailable> =>
-  sqlClientStandaloneGuard(database, () => PasswordUnavailable.make({}));
+  sqlClientStandaloneGuard(service, () => PasswordUnavailable.make({}));
 
 export const passwordOptions = (
   configuration: PasswordTargetConfiguration,
@@ -96,7 +97,6 @@ const registrationOptions = (
 });
 
 export const makeTargetPasswordPersistenceServices = (
-  database: any,
   mapping: any,
   configuration: PasswordTargetConfiguration,
   proofMapping?: any,
@@ -104,7 +104,6 @@ export const makeTargetPasswordPersistenceServices = (
   Effect.gen(function* () {
     return {
       passwordPersistence: yield* makeSqlPasswordPersistence(
-        database,
         mapping,
         passwordOptions(configuration, proofMapping),
       ),
@@ -112,14 +111,12 @@ export const makeTargetPasswordPersistenceServices = (
   });
 
 export const makeTargetPasswordRegistrationServices = <Registration>(
-  database: any,
   mapping: any,
   configuration: PasswordTargetConfiguration,
 ) =>
   Effect.gen(function* () {
     return {
       registrationAuthority: yield* makeSqlPasswordRegistrationAuthority<Registration>(
-        database,
         mapping,
         registrationOptions(configuration),
       ),
@@ -149,9 +146,13 @@ export const coordinateTargetPasswordPersistence = <Transaction, A, E, R>(
           Effect.gen(function* () {
             return yield* owner(transaction, {
               passwordPersistence: yield* makeSqlPasswordPersistence(
-                transaction as unknown as PasswordSqlDatabase,
                 mapping,
                 passwordOptions(configuration, proofMapping, true),
+              ).pipe(
+                Effect.provideService(
+                  CurrentPasswordSql,
+                  transaction as unknown as PasswordSqlDatabase,
+                ),
               ),
             });
           }),
@@ -185,9 +186,13 @@ export const coordinateTargetPasswordRegistration = <Registration, Transaction,
           Effect.gen(function* () {
             return yield* owner(transaction, {
               registrationAuthority: yield* makeSqlPasswordRegistrationAuthority<Registration>(
-                transaction as unknown as PasswordSqlDatabase,
                 mapping,
                 registrationOptions(configuration, true),
+              ).pipe(
+                Effect.provideService(
+                  CurrentPasswordSql,
+                  transaction as unknown as PasswordSqlDatabase,
+                ),
               ),
             });
           }),
@@ -198,24 +203,20 @@ export const coordinateTargetPasswordRegistration = <Registration, Transaction,
     return result.value;
   });
 
-export const passwordPersistenceLayer = (
-  services: Effect.Effect<
-    { readonly passwordPersistence: PasswordPersistence["Service"] },
-    never,
-    LifecycleHooks
-  >,
+export const passwordPersistenceLayer = <E, R>(
+  services: Effect.Effect<{ readonly passwordPersistence: PasswordPersistence["Service"] }, E, R>,
 ) =>
   Layer.effect(
     PasswordPersistence,
     Effect.map(services, (value) => value.passwordPersistence),
   );
 
-export const passwordRegistrationLayer = <Id, Registration>(
+export const passwordRegistrationLayer = <Id, Registration, E, R>(
   tag: Context.Key<Id, PasswordRegistrationAuthority<Registration>>,
   services: Effect.Effect<
     { readonly registrationAuthority: PasswordRegistrationAuthority<Registration> },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(

package/src/drizzle/pg-database.ts

@@ -0,0 +1,10 @@
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pglite";
+import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
+import { Context } from "effect";
+
+/** Application-owned PostgreSQL database; Postgres and Pglite share this service. */
+export class Database extends Context.Service<
+  Database,
+  PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>
+>()("effect-auth/persistence-drizzle/Postgres/Database") {}

package/src/drizzle/pg-emails.ts

@@ -14,6 +14,7 @@ import type {
   EmailSignInMapping,
 } from "./email-model";
 import type { EmailRegistrationAuthority } from "./email-registration";
+import { CurrentEmailSql } from "./email-sql";
 import type { EmailSqlQuery } from "./email-sql";
 import {
   coordinateTargetEmailAddress,
@@ -23,9 +24,16 @@ import {
   makeTargetEmailSignInServices,
   sqlClientEmailStandaloneGuard,
 } from "./email-target";
+import { nativeDatabase } from "./native-database";
+import { Database as DatabaseService } from "./pg-database";
 import type { ProofPersistenceMapping } from "./proof-model";
 import type { ProofSqlQuery } from "./proof-sql";
 import { sqlClientProofStandaloneGuard } from "./proof-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;
@@ -45,15 +53,15 @@ type ProofMapping = ProofPersistenceMapping<
   any
 >;
 
-const configuration = (database: Database) => ({
+const configuration = (service: TransactionService | undefined) => ({
   mode: "interactive" as const,
   locking: true,
-  standaloneGuard: sqlClientEmailStandaloneGuard(database),
+  standaloneGuard: sqlClientEmailStandaloneGuard(service),
   generatedSubjectRows: (query: EmailSqlQuery) => query.returning(),
   proof: {
     mode: "interactive" as const,
     locking: true,
-    standaloneGuard: sqlClientProofStandaloneGuard(database),
+    standaloneGuard: sqlClientProofStandaloneGuard(service),
     insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),
   },
 });
@@ -64,9 +72,12 @@ export const makePgEmailSignInServices = <
   C extends AnyPgTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailSignInMapping<S, I, C, NativeId>,
-) => makeTargetEmailSignInServices(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetEmailSignInServices(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)));
 
 export const makePgEmailAddressServices = <
   S extends AnyPgTable,
@@ -76,10 +87,13 @@ export const makePgEmailAddressServices = <
   M extends AnyPgTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>,
   proofMapping: ProofMapping,
-) => makeTargetEmailAddressServices(database, mapping, proofMapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetEmailAddressServices(mapping, proofMapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgEmailAddress<
   D extends Database,
@@ -170,7 +184,7 @@ export function coordinatePgEmailAddress<
       database,
       options.mapping,
       options.proofMapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly emailAddressPersistence: EmailAddressPersistence["Service"] },
@@ -195,16 +209,14 @@ export const makePgEmailRegistrationServices = <
   Rq extends AnyPgTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
   proofMapping: ProofMapping,
 ) =>
-  makeTargetEmailRegistrationServices<Registration>(
-    database,
-    mapping,
-    proofMapping,
-    configuration(database),
-  );
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) =>
+      makeTargetEmailRegistrationServices<Registration>(mapping, proofMapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgEmailRegistration<
   TargetId,
@@ -304,7 +316,7 @@ export function coordinatePgEmailRegistration<
       database,
       options.mapping,
       options.proofMapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },

package/src/drizzle/pg-identity.ts

@@ -10,8 +10,7 @@ import {
 import { reportPersistenceFailure } from "@yielded/auth/Persistence";
 import type { SubjectId } from "@yielded/auth/Schema";
 /* oxlint-disable no-explicit-any -- Drizzle's generic query builders lose the concrete consumer table through a runtime column map. Assertions stay in this adapter. */
-import { and, eq, type AnyRelations } from "drizzle-orm";
-import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pglite";
+import { and, eq } from "drizzle-orm";
 import type { EffectPgDatabase as PgDatabase } from "drizzle-orm/effect-postgres";
 import { type AnyPgTable, type PgColumn } from "drizzle-orm/pg-core";
 import { Cause, Effect, Schema } from "effect";
@@ -25,8 +24,8 @@ import {
   type IdentityTables,
   type SubjectProvisioningTables,
 } from "./model";
+import { Database as DatabaseService } from "./pg-database";
 
-type Database = PgDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;
 type RuntimeDatabase = PgDatabase<any>;
 
 const identityUnavailable = () => IdentityUnavailable.make();
@@ -41,15 +40,14 @@ const mapIdentityFailure = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     ),
   );
 
-export const makePgSubjectProvisioningServices = <
+export const makePgSubjectProvisioningServices = Effect.fnUntraced(function* <
   Subject extends AnyPgTable,
   Identifier extends AnyPgTable,
   Request extends AnyPgTable,
   NativeId,
->(
-  database: Database,
-  mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => {
+>(mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>) {
+  const database = yield* DatabaseService;
+
   const db = database as RuntimeDatabase;
   const requestTable = mapping.provisioningRequest.table;
   const requestIdColumn = column(requestTable, mapping.provisioningRequest.requestId);
@@ -174,16 +172,15 @@ export const makePgSubjectProvisioningServices = <
   return {
     subjectProvisioner: SubjectProvisioner.of({ provision }),
   } as const;
-};
+});
 
-export const makePgExternalIdentityServices = <
+export const makePgExternalIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnyPgTable,
   External extends AnyPgTable,
   NativeId,
->(
-  database: Database,
-  mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => {
+>(mapping: ExternalIdentityTables<Subject, External, NativeId>) {
+  const database = yield* DatabaseService;
+
   const db = database as RuntimeDatabase;
   const externalTable = mapping.externalIdentity.table;
 
@@ -284,18 +281,17 @@ export const makePgExternalIdentityServices = <
   }, mapIdentityFailure);
 
   return { externalIdentityMutation: ExternalIdentityMutation.of({ bind }) } as const;
-};
+});
 
-export const makePgIdentityServices = <
+export const makePgIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnyPgTable,
   Identifier extends AnyPgTable,
   External extends AnyPgTable,
   Request extends AnyPgTable,
   NativeId,
->(
-  database: Database,
-  mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => ({
-  ...makePgSubjectProvisioningServices(database, mapping),
-  ...makePgExternalIdentityServices(database, mapping),
+>(mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>) {
+  return {
+    ...(yield* makePgSubjectProvisioningServices(mapping)),
+    ...(yield* makePgExternalIdentityServices(mapping)),
+  };
 });

package/src/drizzle/pg-password-prepared.ts

@@ -7,6 +7,7 @@ import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
 import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type {
   PasswordPreparedPersistenceMapping,
   PasswordPreparedProofMapping,
@@ -15,7 +16,10 @@ import {
   makeTargetPasswordPreparedPersistenceServices,
   coordinateTargetPasswordPreparedPersistence,
 } from "./password-prepared-target";
+import { CurrentPasswordSql } from "./password-sql";
+import { Database as DatabaseService } from "./pg-database";
 import { pgPasswordConfiguration as configuration } from "./pg-passwords";
+import { acquireTransactionService, transactionService } from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 type Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;
 type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
@@ -40,16 +44,14 @@ export const makePgPasswordPreparedPersistenceServices = <
   PCr extends AnyPgTable = AnyPgTable,
   PNativeId = unknown,
 >(
-  database: Database,
   mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>,
   proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>,
 ) =>
-  makeTargetPasswordPreparedPersistenceServices(
-    database,
-    mapping,
-    configuration(database),
-    proofMapping,
-  );
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) =>
+      makeTargetPasswordPreparedPersistenceServices(mapping, configuration, proofMapping),
+  ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgPasswordPreparedPersistence<
   TargetId,
@@ -187,7 +189,7 @@ export function coordinatePgPasswordPreparedPersistence<
     coordinateTargetPasswordPreparedPersistence<TransactionOf<D>, Out, E, Exclude<R, TargetId>>(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       options.proofMapping,
       (
         transaction: TransactionOf<D>,