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

package/src/drizzle/oauth-connected-target.ts

@@ -1,4 +1,3 @@
-import { LifecycleHooks } from "@yielded/auth/Hooks";
 import * as M from "@yielded/auth/OAuth";
 import {
   OAuthConnectedPersistence,
@@ -185,32 +184,24 @@ export const makeRevocations = (
   );
 
 export const makeTargetOAuthConnectedServices = (
-  database: any,
   mapping: S.Mapping,
   configuration: OAuthTargetConfiguration,
 ) => {
   const retained = captured(mapping);
 
-  return Effect.map(LifecycleHooks, (hooks) => ({
-    oauthConnectedPersistence: makeConnected(
-      retained,
-      makeOAuthExecution(database, hooks, configuration),
-    ),
+  return Effect.map(makeOAuthExecution(configuration), (execution) => ({
+    oauthConnectedPersistence: makeConnected(retained, execution),
   }));
 };
 
 export const makeTargetOAuthConnectedRevocationServices = (
-  database: any,
   mapping: S.Revocations,
   configuration: OAuthTargetConfiguration,
 ) => {
   const retained = captured(mapping);
 
-  return Effect.map(LifecycleHooks, (hooks) => ({
-    oauthConnectedRevocations: makeRevocations(
-      retained,
-      makeOAuthExecution(database, hooks, configuration),
-    ),
+  return Effect.map(makeOAuthExecution(configuration), (execution) => ({
+    oauthConnectedRevocations: makeRevocations(retained, execution),
   }));
 };
 
@@ -256,16 +247,24 @@ export const coordinateTargetOAuthConnectedRevocations = <Transaction, A, E, R>(
     owner,
   );
 
-export const oauthConnectedPersistenceLayer = (
-  services: ReturnType<typeof makeTargetOAuthConnectedServices>,
+export const oauthConnectedPersistenceLayer = <E, R>(
+  services: Effect.Effect<
+    Effect.Success<ReturnType<typeof makeTargetOAuthConnectedServices>>,
+    E,
+    R
+  >,
 ) =>
   Layer.effect(
     OAuthConnectedPersistence,
     Effect.map(services, (value) => value.oauthConnectedPersistence),
   );
 
-export const oauthConnectedRevocationsLayer = (
-  services: ReturnType<typeof makeTargetOAuthConnectedRevocationServices>,
+export const oauthConnectedRevocationsLayer = <E, R>(
+  services: Effect.Effect<
+    Effect.Success<ReturnType<typeof makeTargetOAuthConnectedRevocationServices>>,
+    E,
+    R
+  >,
 ) =>
   Layer.effect(
     OAuthConnectedRevocations,

package/src/drizzle/oauth-drivers.ts

@@ -1,3 +1,4 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { LifecycleHooks } from "@yielded/auth/Hooks";
 import {
   OAuthAccountsPersistence,
@@ -7,6 +8,7 @@ import {
 import type { Table } from "drizzle-orm";
 import { Effect, Context } from "effect";
 
+import { nativeDatabase } from "./native-database";
 import { makeOAuthConnectedTarget } from "./oauth-connected-drivers";
 import type {
   OAuthAccountsMapping,
@@ -35,7 +37,13 @@ type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => an
   : never;
 
 /** Driver-specific entry points instantiate both the database and table family. */
-export const makeOAuthTarget = <D, T extends Table, Synchronous extends boolean = false>(
+export const makeOAuthTarget = <
+  DatabaseId,
+  D,
+  T extends Table,
+  Synchronous extends boolean = false,
+>(
+  databaseService: Context.Service<DatabaseId, D>,
   configuration: OAuthTargetConfiguration,
 ) => {
   function coordinateOAuthSignIn<
@@ -516,7 +524,7 @@ export const makeOAuthTarget = <D, T extends Table, Synchronous extends boolean
   }
 
   return {
-    ...makeOAuthConnectedTarget<D, T, {}, Synchronous>(configuration),
+    ...makeOAuthConnectedTarget<DatabaseId, D, T, {}, Synchronous>(databaseService, configuration),
     coordinateOAuthSignIn,
     coordinateOAuthRegistrationIntents,
     coordinateOAuthAccounts,
@@ -530,13 +538,17 @@ export const makeOAuthTarget = <D, T extends Table, Synchronous extends boolean
       U extends T,
       N,
     >(
-      database: D,
       mapping: OAuthAccountsMapping<S, O, C, AC, F, TA, U, N>,
-    ) => makeTargetOAuthAccountsServices(database, mapping, configuration),
+    ) =>
+      makeTargetOAuthAccountsServices(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     makeOAuthSignInServices: <S extends T, O extends T, C extends T, AC extends T, F extends T, N>(
-      database: D,
       mapping: OAuthSignInMapping<S, O, C, AC, F, N>,
-    ) => makeTargetOAuthSignInServices(database, mapping, configuration),
+    ) =>
+      makeTargetOAuthSignInServices(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     makeOAuthRegistrationIntentServices: <
       S extends T,
       O extends T,
@@ -547,9 +559,11 @@ export const makeOAuthTarget = <D, T extends Table, Synchronous extends boolean
       I extends T,
       N,
     >(
-      database: D,
       mapping: OAuthRegistrationIntentMapping<S, O, C, AC, F, TA, I, N>,
-    ) => makeTargetOAuthRegistrationIntentServices(database, mapping, configuration),
+    ) =>
+      makeTargetOAuthRegistrationIntentServices(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     makeOAuthRegistrationServices: <
       Registration,
       S extends T,
@@ -561,9 +575,11 @@ export const makeOAuthTarget = <D, T extends Table, Synchronous extends boolean
       R extends T,
       N,
     >(
-      database: D,
       mapping: OAuthRegistrationMapping<Registration, S, O, C, AC, TA, I, R, N>,
-    ) => makeTargetOAuthRegistrationServices<Registration>(database, mapping, configuration),
+    ) =>
+      makeTargetOAuthRegistrationServices<Registration>(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     coordinateOAuthRegistration,
   };
 };

package/src/drizzle/oauth-target.ts

@@ -1,3 +1,4 @@
+import type { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import { LifecycleHooks } from "@yielded/auth/Hooks";
 import {
   OAuthAccountRevision,
@@ -83,17 +84,16 @@ export type OAuthCoordinatorError<E> = TransactionCoordinatorError<E, OAuthUnava
 export type OAuthExecution = TransactionExecution<OAuthUnavailable, CurrentOAuthTransaction, never>;
 
 export const sqlClientOAuthStandaloneGuard = (
-  database: Parameters<typeof sqlClientTransactionStandaloneGuard>[1],
-) => sqlClientTransactionStandaloneGuard(unavailable, database);
+  service: Parameters<typeof sqlClientTransactionStandaloneGuard>[1],
+) => sqlClientTransactionStandaloneGuard(unavailable, service);
 
-export const makeOAuthExecution = (
-  database: OAuthNativeDatabase,
-  hooks: LifecycleHooks["Service"],
+export const makeOAuthExecution = Effect.fnUntraced(function* (
   configuration: OAuthTargetConfiguration,
-): OAuthExecution => {
-  const execution = makeTransactionExecution(
+): Effect.fn.Return<OAuthExecution, never, LifecycleHooks | NativeDatabase> {
+  const hooks = yield* LifecycleHooks;
+
+  const execution = yield* makeTransactionExecution(
     CurrentOAuthTransaction,
-    database,
     configuration,
     unavailable,
     nonce,
@@ -104,7 +104,7 @@ export const makeOAuthExecution = (
     run: (operation, mutation) =>
       execution.run(operation, mutation).pipe(Effect.provideService(LifecycleHooks, hooks)),
   };
-};
+});
 
 const prepareValue = <Value, A>(value: Value, prepare: PrepareOAuthCommit<Value, A>) =>
   Effect.flatMap(CurrentOAuthTransaction, (owner) =>
@@ -388,47 +388,35 @@ export const makeOAuthRegistration = <Registration>(
   );
 
 export const makeTargetOAuthSignInServices = (
-  database: any,
   mapping: any,
   configuration: OAuthTargetConfiguration,
 ) => {
   const captured = captureOAuthMapping(mapping);
 
-  return Effect.map(LifecycleHooks, (hooks) => ({
-    oauthSignInPersistence: makeOAuthSignIn(
-      captured,
-      makeOAuthExecution(database, hooks, configuration),
-    ),
+  return Effect.map(makeOAuthExecution(configuration), (execution) => ({
+    oauthSignInPersistence: makeOAuthSignIn(captured, execution),
   }));
 };
 
 export const makeTargetOAuthRegistrationIntentServices = (
-  database: any,
   mapping: any,
   configuration: OAuthTargetConfiguration,
 ) => {
   const captured = captureOAuthMapping(mapping);
 
-  return Effect.map(LifecycleHooks, (hooks) => ({
-    oauthRegistrationIntents: makeOAuthRegistrationIntents(
-      captured,
-      makeOAuthExecution(database, hooks, configuration),
-    ),
+  return Effect.map(makeOAuthExecution(configuration), (execution) => ({
+    oauthRegistrationIntents: makeOAuthRegistrationIntents(captured, execution),
   }));
 };
 
 export const makeTargetOAuthRegistrationServices = <Registration>(
-  database: any,
   mapping: any,
   configuration: OAuthTargetConfiguration,
 ) => {
   const captured = captureOAuthMapping(mapping);
 
-  return Effect.map(LifecycleHooks, (hooks) => ({
-    registrationAuthority: makeOAuthRegistration<Registration>(
-      captured,
-      makeOAuthExecution(database, hooks, configuration),
-    ),
+  return Effect.map(makeOAuthExecution(configuration), (execution) => ({
+    registrationAuthority: makeOAuthRegistration<Registration>(captured, execution),
   }));
 };
 
@@ -698,50 +686,50 @@ export const makeOAuthAccounts = (
   );
 
 export const makeTargetOAuthAccountsServices = (
-  database: any,
   mapping: any,
   configuration: OAuthTargetConfiguration,
 ) => {
   const captured = captureOAuthMapping(mapping);
 
-  return Effect.map(LifecycleHooks, (hooks) => ({
-    oauthAccountsPersistence: makeOAuthAccounts(
-      captured,
-      makeOAuthExecution(database, hooks, configuration),
-    ),
+  return Effect.map(makeOAuthExecution(configuration), (execution) => ({
+    oauthAccountsPersistence: makeOAuthAccounts(captured, execution),
   }));
 };
 
-export const oauthAccountsPersistenceLayer = (
-  services: ReturnType<typeof makeTargetOAuthAccountsServices>,
+export const oauthAccountsPersistenceLayer = <E, R>(
+  services: Effect.Effect<Effect.Success<ReturnType<typeof makeTargetOAuthAccountsServices>>, E, R>,
 ) =>
   Layer.effect(
     OAuthAccountsPersistence,
     Effect.map(services, (value) => value.oauthAccountsPersistence),
   );
 
-export const oauthSignInPersistenceLayer = (
-  services: ReturnType<typeof makeTargetOAuthSignInServices>,
+export const oauthSignInPersistenceLayer = <E, R>(
+  services: Effect.Effect<Effect.Success<ReturnType<typeof makeTargetOAuthSignInServices>>, E, R>,
 ) =>
   Layer.effect(
     OAuthSignInPersistence,
     Effect.map(services, (value) => value.oauthSignInPersistence),
   );
 
-export const oauthRegistrationIntentsLayer = (
-  services: ReturnType<typeof makeTargetOAuthRegistrationIntentServices>,
+export const oauthRegistrationIntentsLayer = <E, R>(
+  services: Effect.Effect<
+    Effect.Success<ReturnType<typeof makeTargetOAuthRegistrationIntentServices>>,
+    E,
+    R
+  >,
 ) =>
   Layer.effect(
     OAuthRegistrationIntents,
     Effect.map(services, (value) => value.oauthRegistrationIntents),
   );
 
-export const oauthRegistrationAuthorityLayer = <Id, Registration>(
+export const oauthRegistrationAuthorityLayer = <Id, Registration, E, R>(
   tag: Context.Key<Id, OAuthRegistrationAuthority<Registration>>,
   services: Effect.Effect<
     { readonly registrationAuthority: OAuthRegistrationAuthority<Registration> },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(

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 {