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

package/src/drizzle/session-target.ts

@@ -27,7 +27,7 @@ import {
   type SessionSqlDatabase,
   type SessionSqlOptions,
 } from "./session-sql";
-import { sqlClientStandaloneGuard } from "./standalone-guard";
+import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
 
 export interface SessionTargetConfiguration {
   readonly mode: "interactive" | "synchronous";
@@ -45,9 +45,9 @@ interface TransactionOwner<Transaction> {
 type CoordinatorError<E> = E | SessionUnavailable | HookConfigurationError | SqlError.SqlError;
 
 export const sqlClientSessionStandaloneGuard = (
-  database: unknown,
+  service: TransactionService | undefined,
 ): Effect.Effect<void, SessionUnavailable> =>
-  sqlClientStandaloneGuard(database, () => SessionUnavailable.make({}));
+  sqlClientStandaloneGuard(service, () => SessionUnavailable.make({}));
 
 const options = (
   configuration: SessionTargetConfiguration,
@@ -59,42 +59,35 @@ const options = (
 });
 
 export const makeTargetAuthenticationAuthorityServices = <Claims>(
-  database: any,
   mapping: any,
   configuration: SessionTargetConfiguration,
 ) =>
   Effect.map(
-    makeSqlAuthenticationAuthority<Claims>(database, mapping, options(configuration)),
+    makeSqlAuthenticationAuthority<Claims>(mapping, options(configuration)),
     (authenticationAuthority) => ({ authenticationAuthority }),
   );
 
 export const makeTargetPendingAuthenticationServices = <Claims>(
-  database: any,
   mapping: any,
   configuration: SessionTargetConfiguration,
 ) =>
   Effect.map(
-    makeSqlPendingAuthentication<Claims>(database, mapping, options(configuration)),
+    makeSqlPendingAuthentication<Claims>(mapping, options(configuration)),
     (pendingAuthentication) => ({ pendingAuthentication }),
   );
 
 export const makeTargetStatefulSessionServices = <Claims>(
-  database: any,
   mapping: any,
   configuration: SessionTargetConfiguration,
-) => makeSqlStatefulSessions<Claims>(database, mapping, options(configuration));
+) => makeSqlStatefulSessions<Claims>(mapping, options(configuration));
 
 export const makeTargetSignedSessionValidityServices = (
-  database: any,
   mapping: any,
   configuration: SessionTargetConfiguration,
 ) =>
-  Effect.map(
-    makeSqlSignedValidity(database, mapping, options(configuration)),
-    (signedSessionValidity) => ({
-      signedSessionValidity,
-    }),
-  );
+  Effect.map(makeSqlSignedValidity(mapping, options(configuration)), (signedSessionValidity) => ({
+    signedSessionValidity,
+  }));
 
 /**
  * The native transaction is the root commit owner. Interruption or owner
@@ -146,10 +139,8 @@ export const coordinateTargetAuthenticationAuthority = <Claims, Transaction, A,
     configuration,
     (transaction) =>
       Effect.map(
-        makeSqlAuthenticationAuthority<Claims>(
-          transaction as unknown as SessionSqlDatabase,
-          mapping,
-          options(configuration, true),
+        makeSqlAuthenticationAuthority<Claims>(mapping, options(configuration, true)).pipe(
+          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
         ),
         (authenticationAuthority) => ({ authenticationAuthority }),
       ),
@@ -170,10 +161,8 @@ export const coordinateTargetPendingAuthentication = <Claims, Transaction, A, E,
     configuration,
     (transaction) =>
       Effect.map(
-        makeSqlPendingAuthentication<Claims>(
-          transaction as unknown as SessionSqlDatabase,
-          mapping,
-          options(configuration, true),
+        makeSqlPendingAuthentication<Claims>(mapping, options(configuration, true)).pipe(
+          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
         ),
         (pendingAuthentication) => ({ pendingAuthentication }),
       ),
@@ -196,10 +185,8 @@ export const coordinateTargetStatefulSessions = <Claims, Transaction, A, E, R>(
     database,
     configuration,
     (transaction) =>
-      makeSqlStatefulSessions<Claims>(
-        transaction as unknown as SessionSqlDatabase,
-        mapping,
-        options(configuration, true),
+      makeSqlStatefulSessions<Claims>(mapping, options(configuration, true)).pipe(
+        Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
       ),
     owner,
   );
@@ -218,23 +205,21 @@ export const coordinateTargetSignedSessionValidity = <Transaction, A, E, R>(
     configuration,
     (transaction) =>
       Effect.map(
-        makeSqlSignedValidity(
-          transaction as unknown as SessionSqlDatabase,
-          mapping,
-          options(configuration, true),
+        makeSqlSignedValidity(mapping, options(configuration, true)).pipe(
+          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
         ),
         (signedSessionValidity) => ({ signedSessionValidity }),
       ),
     owner,
   );
 
-export const authenticationAuthorityLayer = (
+export const authenticationAuthorityLayer = <E, R>(
   services: Effect.Effect<
     {
       readonly authenticationAuthority: AuthenticationAuthority["Service"];
     },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(
@@ -242,7 +227,7 @@ export const authenticationAuthorityLayer = (
     Effect.map(services, (value) => value.authenticationAuthority),
   );
 
-export const statefulSessionLayers = <Claims>(
+export const statefulSessionLayers = <Claims, E, R>(
   module: {
     readonly StatefulSessionPersistence: any;
     readonly SessionRepository: any;
@@ -252,8 +237,8 @@ export const statefulSessionLayers = <Claims>(
       readonly statefulSessionPersistence: StatefulSessionPersistence<Claims>;
       readonly sessionRepository: SessionRepository;
     },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.merge(
@@ -267,14 +252,14 @@ export const statefulSessionLayers = <Claims>(
     ),
   );
 
-export const pendingAuthenticationLayer = <Claims>(
+export const pendingAuthenticationLayer = <Claims, E, R>(
   module: { readonly PendingAuthentication: any },
   services: Effect.Effect<
     {
       readonly pendingAuthentication: PendingAuthentication<Claims>;
     },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(
@@ -282,14 +267,14 @@ export const pendingAuthenticationLayer = <Claims>(
     Effect.map(services, (value) => value.pendingAuthentication),
   );
 
-export const signedSessionValidityLayer = (
+export const signedSessionValidityLayer = <E, R>(
   module: { readonly SignedSessionValidity: any },
   services: Effect.Effect<
     {
       readonly signedSessionValidity: SignedSessionValidity;
     },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(
@@ -298,13 +283,12 @@ export const signedSessionValidityLayer = (
   );
 
 export const makeTargetSessionStepUpServices = <Claims, Id>(
-  database: any,
   mapping: any,
   target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
   configuration: SessionTargetConfiguration,
 ) =>
   Effect.map(
-    makeSqlSessionStepUp<Claims>(database, mapping, options(configuration)),
+    makeSqlSessionStepUp<Claims>(mapping, options(configuration)),
     (sessionStepUpPersistence) => ({
       sessionStepUpPersistence: target.of(sessionStepUpPersistence),
     }),
@@ -325,10 +309,8 @@ export const coordinateTargetSessionStepUp = <Claims, Id, Transaction, A, E, R>(
     configuration,
     (transaction) =>
       Effect.map(
-        makeSqlSessionStepUp<Claims>(
-          transaction as unknown as SessionSqlDatabase,
-          mapping,
-          options(configuration, true),
+        makeSqlSessionStepUp<Claims>(mapping, options(configuration, true)).pipe(
+          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
         ),
         (sessionStepUpPersistence) => ({
           sessionStepUpPersistence: target.of(sessionStepUpPersistence),

package/src/drizzle/sqlite-emails.ts

@@ -17,6 +17,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,
@@ -26,8 +27,14 @@ import {
   makeTargetEmailSignInServices,
   type EmailTargetConfiguration,
 } from "./email-target";
+import { nativeDatabase } from "./native-database";
 import type { ProofPersistenceMapping } from "./proof-model";
 import type { ProofSqlQuery } from "./proof-sql";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 export type SqliteEmailDatabase =
@@ -73,13 +80,24 @@ export const sqliteEmailConfiguration = (
 });
 
 export const makeSqliteEmailTarget = <
+  DatabaseId,
   D extends SqliteEmailDatabase,
   Synchronous extends boolean = false,
 >(
-  configuration: EmailTargetConfiguration | ((database: D) => EmailTargetConfiguration),
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | EmailTargetConfiguration
+    | ((service: TransactionService | undefined) => EmailTargetConfiguration),
 ) => {
   const configurationFor = (database: D) =>
-    typeof configuration === "function" ? configuration(database) : configuration;
+    typeof configuration === "function"
+      ? configuration(transactionService(database))
+      : configuration;
+
+  const standaloneConfiguration =
+    typeof configuration === "function"
+      ? Effect.map(acquireTransactionService(databaseService), configuration)
+      : Effect.succeed(configuration);
 
   function coordinateEmailAddress<
     Database extends D,
@@ -325,9 +343,11 @@ export const makeSqliteEmailTarget = <
       C extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: EmailSignInMapping<S, I, C, NativeId>,
-    ) => makeTargetEmailSignInServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeTargetEmailSignInServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(databaseService))),
     makeEmailAddressServices: <
       S extends AnySQLiteTable,
       I extends AnySQLiteTable,
@@ -336,11 +356,12 @@ export const makeSqliteEmailTarget = <
       M extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>,
       proofMapping: ProofMapping,
     ) =>
-      makeTargetEmailAddressServices(database, mapping, proofMapping, configurationFor(database)),
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeTargetEmailAddressServices(mapping, proofMapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(databaseService))),
     coordinateEmailAddress,
     makeEmailRegistrationServices: <
       Registration,
@@ -351,16 +372,12 @@ export const makeSqliteEmailTarget = <
       Rq extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
       proofMapping: ProofMapping,
     ) =>
-      makeTargetEmailRegistrationServices<Registration>(
-        database,
-        mapping,
-        proofMapping,
-        configurationFor(database),
-      ),
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeTargetEmailRegistrationServices<Registration>(mapping, proofMapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(databaseService))),
     coordinateEmailRegistration,
   };
 };

package/src/drizzle/sqlite-identity.ts

@@ -1,3 +1,4 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import {
   ExternalIdentityMutation,
   type ExternalIdentity,
@@ -10,7 +11,7 @@ import {
 import { reportPersistenceFailure } from "@yielded/auth/Persistence";
 import type { SubjectId } from "@yielded/auth/Schema";
 /* oxlint-disable no-explicit-any -- Drizzle generic query types are narrowed at this technology boundary. */
-import { and, eq, type AnyRelations } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import type { QueryEffectHKTBase } from "drizzle-orm/effect-core";
 import type { AnySQLiteTable, SQLiteColumn } from "drizzle-orm/sqlite-core";
 import type { SQLiteEffectDatabase } from "drizzle-orm/sqlite-core/effect/db";
@@ -27,16 +28,7 @@ import {
 } from "./model";
 
 type ClosedQueryEffectHKT = QueryEffectHKTBase & { readonly context: never };
-type Database<HKT extends ClosedQueryEffectHKT, RunResult> = SQLiteEffectDatabase<
-  HKT,
-  RunResult,
-  AnyRelations
->;
-type RuntimeDatabase<HKT extends ClosedQueryEffectHKT, RunResult> = SQLiteEffectDatabase<
-  HKT,
-  RunResult,
-  any
->;
+type RuntimeDatabase = SQLiteEffectDatabase<ClosedQueryEffectHKT, unknown, any>;
 const unavailable = () => IdentityUnavailable.make();
 const isIdentityFailure = Schema.is(Schema.Union([IdentityConflict, IdentityUnavailable]));
 
@@ -49,19 +41,18 @@ const mapUnavailable = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     ),
   );
 
-export const makeSqliteSubjectProvisioningServices = <
+export const makeSqliteSubjectProvisioningServices = Effect.fnUntraced(function* <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
   Request extends AnySQLiteTable,
   NativeId,
-  HKT extends ClosedQueryEffectHKT = ClosedQueryEffectHKT,
-  RunResult = unknown,
 >(
-  database: Database<HKT, RunResult>,
   mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
   mode: "interactive" | "synchronous",
-) => {
-  const db = database as RuntimeDatabase<HKT, RunResult>;
+) {
+  const database = yield* NativeDatabase;
+
+  const db = database as unknown as RuntimeDatabase;
   const requestTable = mapping.provisioningRequest.table;
 
   const requestIdColumn = column(
@@ -158,14 +149,7 @@ export const makeSqliteSubjectProvisioningServices = <
 
     const nativeId = yield* attempt.pipe(
       Effect.catchCause(
-        (
-          cause,
-        ): Effect.Effect<
-          NativeId,
-          | Effect.Error<typeof attempt>
-          | Effect.Error<ReturnType<typeof findReceipt>>
-          | IdentityConflict
-        > => {
+        (cause): Effect.Effect<NativeId, Effect.Error<typeof attempt> | IdentityConflict> => {
           if (
             cause.reasons.length === 0 ||
             !cause.reasons.every(
@@ -207,19 +191,16 @@ export const makeSqliteSubjectProvisioningServices = <
   }, mapUnavailable);
 
   return { subjectProvisioner: SubjectProvisioner.of({ provision }) } as const;
-};
+});
 
-export const makeSqliteExternalIdentityServices = <
+export const makeSqliteExternalIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
-  HKT extends ClosedQueryEffectHKT = ClosedQueryEffectHKT,
-  RunResult = unknown,
->(
-  database: Database<HKT, RunResult>,
-  mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => {
-  const db = database as RuntimeDatabase<HKT, RunResult>;
+>(mapping: ExternalIdentityTables<Subject, External, NativeId>) {
+  const database = yield* NativeDatabase;
+
+  const db = database as unknown as RuntimeDatabase;
   const externalTable = mapping.externalIdentity.table;
 
   const externalProviderColumn = column(
@@ -324,21 +305,20 @@ export const makeSqliteExternalIdentityServices = <
   }, mapUnavailable);
 
   return { externalIdentityMutation: ExternalIdentityMutation.of({ bind }) } as const;
-};
+});
 
-export const makeSqliteIdentityServices = <
+export const makeSqliteIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
   External extends AnySQLiteTable,
   Request extends AnySQLiteTable,
   NativeId,
-  HKT extends ClosedQueryEffectHKT = ClosedQueryEffectHKT,
-  RunResult = unknown,
 >(
-  database: Database<HKT, RunResult>,
   mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
   mode: "interactive" | "synchronous",
-) => ({
-  ...makeSqliteSubjectProvisioningServices(database, mapping, mode),
-  ...makeSqliteExternalIdentityServices(database, mapping),
+) {
+  return {
+    ...(yield* makeSqliteSubjectProvisioningServices(mapping, mode)),
+    ...(yield* makeSqliteExternalIdentityServices(mapping)),
+  };
 });

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

@@ -4,6 +4,7 @@ import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
 import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type {
   PasswordPreparedPersistenceMapping,
   PasswordPreparedProofMapping,
@@ -12,21 +13,38 @@ import {
   makeTargetPasswordPreparedPersistenceServices,
   coordinateTargetPasswordPreparedPersistence,
 } from "./password-prepared-target";
+import { CurrentPasswordSql } from "./password-sql";
 import type { PasswordTargetConfiguration } from "./password-target";
 import type { SqlitePasswordDatabase } from "./sqlite-passwords";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 type TransactionOf<D extends SqlitePasswordDatabase> = Parameters<
   Parameters<D["transaction"]>[0]
 >[0];
 
 export const makeSqlitePasswordPreparedTarget = <
+  DatabaseId,
   D extends SqlitePasswordDatabase,
   Synchronous extends boolean = false,
 >(
-  configuration: PasswordTargetConfiguration | ((database: D) => PasswordTargetConfiguration),
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | PasswordTargetConfiguration
+    | ((service: TransactionService | undefined) => PasswordTargetConfiguration),
 ) => {
   const configurationFor = (database: D) =>
-    typeof configuration === "function" ? configuration(database) : configuration;
+    typeof configuration === "function"
+      ? configuration(transactionService(database))
+      : configuration;
+
+  const standaloneConfiguration =
+    typeof configuration === "function"
+      ? Effect.map(acquireTransactionService(databaseService), configuration)
+      : Effect.succeed(configuration);
 
   function coordinatePasswordPreparedPersistence<
     Database extends D,
@@ -245,16 +263,12 @@ export const makeSqlitePasswordPreparedTarget = <
       PCr extends AnySQLiteTable = AnySQLiteTable,
       PNativeId = unknown,
     >(
-      database: D,
       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,
-        configurationFor(database),
-        proofMapping,
-      ),
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeTargetPasswordPreparedPersistenceServices(mapping, configuration, proofMapping),
+      ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(databaseService))),
     coordinatePasswordPreparedPersistence,
   };
 };

package/src/drizzle/sqlite-passwords.ts

@@ -11,8 +11,10 @@ import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
 import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model";
 import type { PasswordRegistrationAuthority } from "./password-registration";
+import { CurrentPasswordSql } from "./password-sql";
 import type { PasswordSqlQuery } from "./password-sql";
 import {
   coordinateTargetPasswordPersistence,
@@ -23,6 +25,11 @@ import {
 } from "./password-target";
 import type { ProofPersistenceMapping } from "./proof-model";
 import type { ProofSqlQuery } from "./proof-sql";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 export type SqlitePasswordDatabase =
@@ -79,7 +86,6 @@ export const makeSqlitePasswordPersistenceServices = <
   M extends AnySQLiteTable,
   NativeId,
 >(
-  database: SqlitePasswordDatabase,
   mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>,
   configuration: PasswordTargetConfiguration,
   proofMapping?: ProofPersistenceMapping<
@@ -96,7 +102,7 @@ export const makeSqlitePasswordPersistenceServices = <
     any,
     any
   >,
-) => makeTargetPasswordPersistenceServices(database, mapping, configuration, proofMapping);
+) => makeTargetPasswordPersistenceServices(mapping, configuration, proofMapping);
 
 export const coordinateSqlitePasswordPersistence = <
   D extends SqlitePasswordDatabase,
@@ -142,10 +148,9 @@ export const makeSqlitePasswordRegistrationServices = <
   Rq extends AnySQLiteTable,
   NativeId,
 >(
-  database: SqlitePasswordDatabase,
   mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
   configuration: PasswordTargetConfiguration,
-) => makeTargetPasswordRegistrationServices<Registration>(database, mapping, configuration);
+) => makeTargetPasswordRegistrationServices<Registration>(mapping, configuration);
 
 export const coordinateSqlitePasswordRegistration = <
   Registration,
@@ -176,13 +181,24 @@ export const coordinateSqlitePasswordRegistration = <
   );
 
 export const makeSqlitePasswordTarget = <
+  DatabaseId,
   D extends SqlitePasswordDatabase,
   Synchronous extends boolean = false,
 >(
-  configuration: PasswordTargetConfiguration | ((database: D) => PasswordTargetConfiguration),
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | PasswordTargetConfiguration
+    | ((service: TransactionService | undefined) => PasswordTargetConfiguration),
 ) => {
   const configurationFor = (database: D) =>
-    typeof configuration === "function" ? configuration(database) : configuration;
+    typeof configuration === "function"
+      ? configuration(transactionService(database))
+      : configuration;
+
+  const standaloneConfiguration =
+    typeof configuration === "function"
+      ? Effect.map(acquireTransactionService(databaseService), configuration)
+      : Effect.succeed(configuration);
 
   function coordinatePasswordPersistence<
     Database extends D,
@@ -456,7 +472,6 @@ export const makeSqlitePasswordTarget = <
       M extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>,
       proofMapping?: ProofPersistenceMapping<
         any,
@@ -473,12 +488,9 @@ export const makeSqlitePasswordTarget = <
         any
       >,
     ) =>
-      makeSqlitePasswordPersistenceServices(
-        database,
-        mapping,
-        configurationFor(database),
-        proofMapping,
-      ),
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqlitePasswordPersistenceServices(mapping, configuration, proofMapping),
+      ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(databaseService))),
     coordinatePasswordPersistence,
     makePasswordRegistrationServices: <
       Registration,
@@ -489,9 +501,11 @@ export const makeSqlitePasswordTarget = <
       Rq extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
-    ) => makeSqlitePasswordRegistrationServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqlitePasswordRegistrationServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(databaseService))),
     coordinatePasswordRegistration,
   };
 };