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

package/src/drizzle/pg-sessions.ts

@@ -15,12 +15,15 @@ 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 { Database as DatabaseService } from "./pg-database";
 import type {
   AuthenticationAuthorityMapping,
   PendingAuthenticationMapping,
   SignedSessionValidityMapping,
   StatefulSessionMapping,
 } from "./session-model";
+import { CurrentSessionSql } from "./session-sql";
 import {
   coordinateTargetAuthenticationAuthority,
   coordinateTargetPendingAuthentication,
@@ -34,15 +37,20 @@ import {
   makeTargetSessionStepUpServices,
   coordinateTargetSessionStepUp,
 } from "./session-target";
+import {
+  type TransactionService,
+  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];
 
-const configuration = (database: Database) => ({
+const configuration = (service: TransactionService | undefined) => ({
   mode: "interactive" as const,
   locking: true,
-  standaloneGuard: sqlClientSessionStandaloneGuard(database),
+  standaloneGuard: sqlClientSessionStandaloneGuard(service),
 });
 
 export const makePgAuthenticationAuthorityServices = <
@@ -53,7 +61,6 @@ export const makePgAuthenticationAuthorityServices = <
   Pending extends AnyPgTable,
   NativeSubjectId,
 >(
-  database: Database,
   mapping: AuthenticationAuthorityMapping<
     Claims,
     Subject,
@@ -62,7 +69,11 @@ export const makePgAuthenticationAuthorityServices = <
     Pending,
     NativeSubjectId
   >,
-) => makeTargetAuthenticationAuthorityServices<Claims>(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetAuthenticationAuthorityServices<Claims>(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(DatabaseService)));
 
 export const makePgPendingAuthenticationServices = <
   Claims,
@@ -72,7 +83,6 @@ export const makePgPendingAuthenticationServices = <
   Flow extends AnyPgTable,
   NativeSubjectId,
 >(
-  database: Database,
   mapping: PendingAuthenticationMapping<
     Claims,
     Subject,
@@ -81,7 +91,11 @@ export const makePgPendingAuthenticationServices = <
     Flow,
     NativeSubjectId
   >,
-) => makeTargetPendingAuthenticationServices<Claims>(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetPendingAuthenticationServices<Claims>(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(DatabaseService)));
 
 export const makePgStatefulSessionServices = <
   Claims,
@@ -93,7 +107,6 @@ export const makePgStatefulSessionServices = <
   NativeSubjectId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: StatefulSessionMapping<
     Claims,
     Subject,
@@ -104,7 +117,11 @@ export const makePgStatefulSessionServices = <
     NativeSubjectId,
     NativeSessionId
   >,
-) => makeTargetStatefulSessionServices<Claims>(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetStatefulSessionServices<Claims>(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(DatabaseService)));
 
 export const makePgSignedSessionValidityServices = <
   Subject extends AnyPgTable,
@@ -112,9 +129,12 @@ export const makePgSignedSessionValidityServices = <
   NativeSubjectId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: SignedSessionValidityMapping<Subject, Tombstone, NativeSubjectId, NativeSessionId>,
-) => makeTargetSignedSessionValidityServices(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetSignedSessionValidityServices(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgAuthenticationAuthority<
   Claims,
@@ -207,7 +227,7 @@ export function coordinatePgAuthenticationAuthority<
     >(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly authenticationAuthority: AuthenticationAuthority["Service"] },
@@ -314,7 +334,7 @@ export function coordinatePgPendingAuthentication<
     coordinateTargetPendingAuthentication<Claims, TransactionOf<D>, A, E, Exclude<R, TargetId>>(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly pendingAuthentication: PendingAuthentication<Claims> },
@@ -466,7 +486,7 @@ export function coordinatePgStatefulSessions<
     >(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: {
@@ -574,7 +594,7 @@ export function coordinatePgSignedSessionValidity<
     coordinateTargetSignedSessionValidity<TransactionOf<D>, A, E, Exclude<R, TargetId>>(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly signedSessionValidity: SignedSessionValidity },
@@ -603,10 +623,13 @@ export const makePgSessionStepUpServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>,
   target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
-) => makeTargetSessionStepUpServices(database, mapping, target, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetSessionStepUpServices(mapping, target, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgSessionStepUp<
   Claims,
@@ -733,7 +756,7 @@ export function coordinatePgSessionStepUp<
       database,
       options.mapping,
       options.target,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly sessionStepUpPersistence: SessionStepUpPersistence<Claims> },

package/src/drizzle/phone-target.ts

@@ -1,4 +1,5 @@
 import { randomId } from "@yielded/auth-crypto";
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import { LifecycleHooks } from "@yielded/auth/Hooks";
 import {
   PhoneConfigurationError,
@@ -21,6 +22,7 @@ import type { Statement } from "effect/sql/Statement";
 import { CurrentD1PlanningDatabase } from "./d1-planning";
 import { compileD1ProofCompletionPlan } from "./d1-proofs";
 import type { PersistenceMappingError } from "./model";
+import { nativeDatabase } from "./native-database";
 import {
   phoneProofs,
   type PhoneMapping,
@@ -59,8 +61,8 @@ export type PhoneCoordinatorError<E> =
   | PersistenceMappingError;
 
 export const sqlClientPhoneStandaloneGuard = (
-  database: Parameters<typeof sqlClientTransactionStandaloneGuard>[1],
-) => sqlClientTransactionStandaloneGuard(unavailable, database);
+  service: Parameters<typeof sqlClientTransactionStandaloneGuard>[1],
+) => sqlClientTransactionStandaloneGuard(unavailable, service);
 
 const validateMapping = <M>(original: M, configuration: PhoneTargetConfiguration): M => {
   const mapping = original as any;
@@ -95,12 +97,13 @@ const validateMapping = <M>(original: M, configuration: PhoneTargetConfiguration
   });
 };
 
-const services = (
+const services = Effect.fnUntraced(function* (
   mapping: any,
   execution: TransactionExecution<PhoneUnavailable, CurrentPhoneTransaction>,
-  hooks: LifecycleHooks["Service"],
   configuration: PhoneTargetConfiguration,
-): PhonePersistenceServices => {
+): Effect.fn.Return<PhonePersistenceServices, never, LifecycleHooks> {
+  const hooks = yield* LifecycleHooks;
+
   const run = <A, E, R>(effect: Effect.Effect<A, E, R>, mutation = true) =>
     execution.admit.pipe(
       Effect.andThen(execution.run(effect, mutation)),
@@ -253,7 +256,7 @@ const services = (
         }).pipe(Effect.catchDefect(() => Effect.fail(unavailable()))),
     }),
   };
-};
+});
 
 export const makeTargetPhonePersistence = <
   S extends Table,
@@ -263,12 +266,10 @@ export const makeTargetPhonePersistence = <
   N,
   RSetup = never,
 >(
-  database: TransactionNativeDatabase,
   source: PhoneMappingSource<PhoneMapping<S, I, C, F, N>, RSetup>,
   configuration: PhoneTargetConfiguration,
 ) =>
   Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
     const original = yield* Effect.isEffect(source) ? source : Effect.succeed(source);
 
     const mapping = yield* Effect.try({
@@ -276,15 +277,14 @@ export const makeTargetPhonePersistence = <
       catch: () => PhoneConfigurationError.make({}),
     });
 
-    const execution = makeTransactionExecution(
+    const execution = yield* makeTransactionExecution(
       CurrentPhoneTransaction,
-      database,
       configuration,
       unavailable,
       randomId,
     );
 
-    return services(mapping, execution, hooks, configuration);
+    return yield* services(mapping, execution, configuration);
   });
 
 export const coordinateTargetPhone = <M, A, E, R, RSetup = never>(
@@ -298,7 +298,6 @@ export const coordinateTargetPhone = <M, A, E, R, RSetup = never>(
   ) => Effect.Effect<A, E, R>,
 ): Effect.Effect<A, PhoneCoordinatorError<E>, R | RSetup | LifecycleHooks> =>
   Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
     const original = yield* Effect.isEffect(source) ? source : Effect.succeed(source);
 
     const mapping = yield* Effect.try({
@@ -313,8 +312,11 @@ export const coordinateTargetPhone = <M, A, E, R, RSetup = never>(
       Effect.void,
       unavailable,
       randomId,
-      (execution) => services(mapping, execution, hooks, configuration),
-      body,
+      (execution) => services(mapping, execution, configuration),
+      (transaction, acquireServices, append) =>
+        Effect.flatMap(acquireServices, (boundServices) =>
+          body(transaction, boundServices, append),
+        ),
     );
   });
 
@@ -324,11 +326,13 @@ type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => an
 
 /** Concrete driver wrappers select transaction mode; cryptography always precedes these owners. */
 export const makePhoneTarget = <
+  DatabaseId,
   D extends { readonly transaction: any },
   T extends Table,
   Extra = unknown,
   Synchronous extends boolean = false,
 >(
+  databaseService: Context.Service<DatabaseId, D>,
   configuration: PhoneTargetConfiguration,
 ) => {
   function coordinatePhonePersistence<
@@ -456,7 +460,6 @@ export const makePhoneTarget = <
 
   return {
     makePhonePersistenceServices: <
-      Database extends D,
       S extends T,
       I extends T,
       F extends T,
@@ -464,9 +467,11 @@ export const makePhoneTarget = <
       N,
       RSetup = never,
     >(
-      database: Database,
       mapping: PhoneMappingSource<PhoneMapping<S, I, C, F, N> & Extra, RSetup>,
-    ) => makeTargetPhonePersistence(database as any, mapping, configuration),
+    ) =>
+      makeTargetPhonePersistence(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     coordinatePhonePersistence,
   };
 };

package/src/drizzle/proof-target.ts

@@ -10,12 +10,13 @@ import { Effect, Layer } from "effect";
 import type * as SqlError from "effect/sql/SqlError";
 
 import {
+  CurrentProofSql,
   makeSqlProofPersistence,
   type ProofSqlConfiguration,
   type ProofSqlDatabase,
   type ProofSqlQuery,
 } from "./proof-sql";
-import { sqlClientStandaloneGuard } from "./standalone-guard";
+import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
 
 export interface ProofTargetConfiguration {
   readonly mode: "interactive" | "synchronous";
@@ -42,9 +43,9 @@ export type ProofCoordinatorError<E> =
   | SqlError.SqlError;
 
 export const sqlClientProofStandaloneGuard = (
-  database: unknown,
+  service: TransactionService | undefined,
 ): Effect.Effect<void, ProofUnavailable> =>
-  sqlClientStandaloneGuard(database, () => ProofUnavailable.make({}));
+  sqlClientStandaloneGuard(service, () => ProofUnavailable.make({}));
 
 const options = (
   configuration: ProofTargetConfiguration,
@@ -59,13 +60,12 @@ const options = (
 });
 
 export const makeTargetProofPersistenceServices = (
-  database: any,
   mapping: any,
   configuration: ProofTargetConfiguration,
 ) =>
   Effect.gen(function* () {
     return {
-      proofPersistence: yield* makeSqlProofPersistence(database, mapping, options(configuration)),
+      proofPersistence: yield* makeSqlProofPersistence(mapping, options(configuration)),
     };
   });
 
@@ -96,9 +96,10 @@ export const coordinateTargetProofPersistence = <Transaction, A, E, R>(
           Effect.gen(function* () {
             return yield* owner(transaction, {
               proofPersistence: yield* makeSqlProofPersistence(
-                transaction as unknown as ProofSqlDatabase,
                 mapping,
                 options(configuration, true),
+              ).pipe(
+                Effect.provideService(CurrentProofSql, transaction as unknown as ProofSqlDatabase),
               ),
             });
           }),
@@ -109,12 +110,8 @@ export const coordinateTargetProofPersistence = <Transaction, A, E, R>(
     return result.value;
   });
 
-export const proofPersistenceLayer = (
-  services: Effect.Effect<
-    { readonly proofPersistence: ProofPersistence["Service"] },
-    never,
-    LifecycleHooks
-  >,
+export const proofPersistenceLayer = <E, R>(
+  services: Effect.Effect<{ readonly proofPersistence: ProofPersistence["Service"] }, E, R>,
 ) =>
   Layer.effect(
     ProofPersistence,

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),