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

package/src/drizzle/sqlite-emails.ts

@@ -9,7 +9,7 @@ import type { EffectSQLiteNodeDatabase as NodeDatabase } from "drizzle-orm/effec
 import type { EffectSQLiteWasmDatabase as WasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   EmailAddressMapping,
@@ -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

@@ -2,8 +2,9 @@ import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks
 import type { PasswordUnavailable, PasswordPreparedPersistence } from "@yielded/auth/Password";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+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

@@ -9,10 +9,12 @@ import type { EffectSQLiteNodeDatabase as NodeDatabase } from "drizzle-orm/effec
 import type { EffectSQLiteWasmDatabase as WasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+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,
   };
 };

package/src/drizzle/sqlite-proofs.ts

@@ -8,14 +8,21 @@ import type { EffectSQLiteNodeDatabase } from "drizzle-orm/effect-sqlite-node";
 import type { EffectSQLiteWasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type { ProofPersistenceMapping } from "./proof-model";
+import { CurrentProofSql } from "./proof-sql";
 import {
   coordinateTargetProofPersistence,
   makeTargetProofPersistenceServices,
   type ProofTargetConfiguration,
 } from "./proof-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database =
@@ -52,11 +59,25 @@ export const sqliteProofConfiguration = (
   ...(coordinatorGuard === undefined ? {} : { coordinatorGuard }),
 });
 
-export const makeSqliteProofTarget = <D extends Database, Synchronous extends boolean = false>(
-  configuration: ProofTargetConfiguration | ((database: D) => ProofTargetConfiguration),
+export const makeSqliteProofTarget = <
+  DatabaseId,
+  D extends Database,
+  Synchronous extends boolean = false,
+>(
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | ProofTargetConfiguration
+    | ((service: TransactionService | undefined) => ProofTargetConfiguration),
 ) => {
   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 coordinateProofPersistence<
     Database extends D,
@@ -194,9 +215,11 @@ export const makeSqliteProofTarget = <D extends Database, Synchronous extends bo
       Cr extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: Mapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>,
-    ) => makeTargetProofPersistenceServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeTargetProofPersistenceServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentProofSql, nativeDatabase(databaseService))),
     coordinateProofPersistence,
   };
 };

package/src/drizzle/sqlite-sessions.ts

@@ -16,14 +16,16 @@ import type { EffectSQLiteNodeDatabase } from "drizzle-orm/effect-sqlite-node";
 import type { EffectSQLiteWasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Context, Effect } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type {
   AuthenticationAuthorityMapping,
   PendingAuthenticationMapping,
   SignedSessionValidityMapping,
   StatefulSessionMapping,
 } from "./session-model";
+import { CurrentSessionSql } from "./session-sql";
 import {
   coordinateTargetAuthenticationAuthority,
   coordinateTargetPendingAuthentication,
@@ -37,6 +39,11 @@ import {
   makeTargetSessionStepUpServices,
   coordinateTargetSessionStepUp,
 } from "./session-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database =
@@ -66,10 +73,9 @@ export const makeSqliteAuthenticationAuthorityServices = <
   P extends AnySQLiteTable,
   NativeId,
 >(
-  database: Database,
   mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetAuthenticationAuthorityServices<Claims>(database, mapping, configuration);
+) => makeTargetAuthenticationAuthorityServices<Claims>(mapping, configuration);
 
 export const makeSqlitePendingAuthenticationServices = <
   Claims,
@@ -79,10 +85,9 @@ export const makeSqlitePendingAuthenticationServices = <
   F extends AnySQLiteTable,
   NativeId,
 >(
-  database: Database,
   mapping: PendingAuthenticationMapping<Claims, S, C, P, F, NativeId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetPendingAuthenticationServices<Claims>(database, mapping, configuration);
+) => makeTargetPendingAuthenticationServices<Claims>(mapping, configuration);
 
 export const makeSqliteStatefulSessionServices = <
   Claims,
@@ -94,10 +99,9 @@ export const makeSqliteStatefulSessionServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: StatefulSessionMapping<Claims, S, C, Session, F, P, NativeId, NativeSessionId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetStatefulSessionServices<Claims>(database, mapping, configuration);
+) => makeTargetStatefulSessionServices<Claims>(mapping, configuration);
 
 export const makeSqliteSignedSessionValidityServices = <
   S extends AnySQLiteTable,
@@ -105,10 +109,9 @@ export const makeSqliteSignedSessionValidityServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetSignedSessionValidityServices(database, mapping, configuration);
+) => makeTargetSignedSessionValidityServices(mapping, configuration);
 
 export const coordinateSqliteAuthenticationAuthority = <
   Claims,
@@ -221,11 +224,25 @@ export const coordinateSqliteSignedSessionValidity = <
     owner,
   );
 
-export const makeSqliteSessionTarget = <D extends Database, Synchronous extends boolean = false>(
-  configuration: SessionTargetConfiguration | ((database: D) => SessionTargetConfiguration),
+export const makeSqliteSessionTarget = <
+  DatabaseId,
+  D extends Database,
+  Synchronous extends boolean = false,
+>(
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | SessionTargetConfiguration
+    | ((service: TransactionService | undefined) => SessionTargetConfiguration),
 ) => {
   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 coordinateSessionStepUp<
     Database extends D,
@@ -854,7 +871,6 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       NativeId,
       NativeSessionId,
     >(
-      database: D,
       mapping: SessionStepUpMapping<
         NoInfer<Claims>,
         S,
@@ -866,7 +882,10 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
         NativeSessionId
       >,
       target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
-    ) => makeSqliteSessionStepUpServices(database, mapping, target, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteSessionStepUpServices(mapping, target, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     coordinateSessionStepUp,
     makeAuthenticationAuthorityServices: <
       Claims,
@@ -876,9 +895,11 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       P extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>,
-    ) => makeSqliteAuthenticationAuthorityServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteAuthenticationAuthorityServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     makePendingAuthenticationServices: <
       Claims,
       S extends AnySQLiteTable,
@@ -887,9 +908,11 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       F extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: PendingAuthenticationMapping<Claims, S, C, P, F, NativeId>,
-    ) => makeSqlitePendingAuthenticationServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqlitePendingAuthenticationServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     makeStatefulSessionServices: <
       Claims,
       S extends AnySQLiteTable,
@@ -900,18 +923,22 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       NativeId,
       NativeSessionId,
     >(
-      database: D,
       mapping: StatefulSessionMapping<Claims, S, C, Session, F, P, NativeId, NativeSessionId>,
-    ) => makeSqliteStatefulSessionServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteStatefulSessionServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     makeSignedSessionValidityServices: <
       S extends AnySQLiteTable,
       T extends AnySQLiteTable,
       NativeId,
       NativeSessionId,
     >(
-      database: D,
       mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>,
-    ) => makeSqliteSignedSessionValidityServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteSignedSessionValidityServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     coordinateAuthenticationAuthority,
     coordinatePendingAuthentication,
     coordinateStatefulSessions,
@@ -932,11 +959,10 @@ export const makeSqliteSessionStepUpServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>,
   target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
   configuration: SessionTargetConfiguration,
-) => makeTargetSessionStepUpServices(database, mapping, target, configuration);
+) => makeTargetSessionStepUpServices(mapping, target, configuration);
 
 export const coordinateSqliteSessionStepUp = <
   Claims,