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

package/src/drizzle/pg-passwords.ts

@@ -8,8 +8,10 @@ import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
 import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model";
 import type { PasswordRegistrationAuthority } from "./password-registration";
+import { CurrentPasswordSql } from "./password-sql";
 import type { PasswordSqlQuery } from "./password-sql";
 import {
   coordinateTargetPasswordPersistence,
@@ -18,24 +20,30 @@ import {
   makeTargetPasswordRegistrationServices,
   sqlClientPasswordStandaloneGuard,
 } from "./password-target";
+import { Database as DatabaseService } from "./pg-database";
 import type { ProofPersistenceMapping } from "./proof-model";
 import type { ProofSqlQuery } from "./proof-sql";
 import { sqlClientProofStandaloneGuard } from "./proof-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;
 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: sqlClientPasswordStandaloneGuard(database),
+  standaloneGuard: sqlClientPasswordStandaloneGuard(service),
   insertIfAbsent: (query: PasswordSqlQuery) => query.onConflictDoNothing(),
   generatedSubjectRows: (query: PasswordSqlQuery) => query.returning(),
   proof: {
     mode: "interactive" as const,
     locking: true,
-    standaloneGuard: sqlClientProofStandaloneGuard(database),
+    standaloneGuard: sqlClientProofStandaloneGuard(service),
     insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),
   },
 });
@@ -63,7 +71,6 @@ export const makePgPasswordPersistenceServices = <
   M extends AnyPgTable,
   NativeId,
 >(
-  database: Database,
   mapping: PasswordMapping<S, I, C, AC, A, RS, CE, M, NativeId>,
   proofMapping?: ProofPersistenceMapping<
     any,
@@ -80,7 +87,10 @@ export const makePgPasswordPersistenceServices = <
     any
   >,
 ) =>
-  makeTargetPasswordPersistenceServices(database, mapping, configuration(database), proofMapping);
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetPasswordPersistenceServices(mapping, configuration, proofMapping),
+  ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgPasswordPersistence<
   D extends Database,
@@ -188,7 +198,7 @@ export function coordinatePgPasswordPersistence<
     coordinateTargetPasswordPersistence<TransactionOf<D>, Out, E, Exclude<R, PasswordPersistence>>(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       options.proofMapping,
       (
         transaction: TransactionOf<D>,
@@ -214,10 +224,12 @@ export const makePgPasswordRegistrationServices = <
   Rq extends AnyPgTable,
   NativeId,
 >(
-  database: Database,
   mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
 ) =>
-  makeTargetPasswordRegistrationServices<Registration>(database, mapping, configuration(database));
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetPasswordRegistrationServices<Registration>(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgPasswordRegistration<
   TargetId,
@@ -319,7 +331,7 @@ export function coordinatePgPasswordRegistration<
     >(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly registrationAuthority: PasswordRegistrationAuthority<Registration> },

package/src/drizzle/pg-proofs.ts

@@ -7,13 +7,21 @@ 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 { ProofPersistenceMapping } from "./proof-model";
+import { CurrentProofSql } from "./proof-sql";
 import type { ProofSqlQuery } from "./proof-sql";
 import {
   coordinateTargetProofPersistence,
   makeTargetProofPersistenceServices,
   sqlClientProofStandaloneGuard,
 } from "./proof-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database = PostgresDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;
@@ -46,10 +54,10 @@ type Mapping<
   NativeSubjectId
 >;
 
-const configuration = (database: Database) => ({
+const configuration = (service: TransactionService | undefined) => ({
   mode: "interactive" as const,
   locking: true,
-  standaloneGuard: sqlClientProofStandaloneGuard(database),
+  standaloneGuard: sqlClientProofStandaloneGuard(service),
   insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),
 });
 
@@ -67,9 +75,12 @@ export const makePgProofPersistenceServices = <
   Cr extends AnyPgTable,
   NativeId,
 >(
-  database: Database,
   mapping: Mapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>,
-) => makeTargetProofPersistenceServices(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetProofPersistenceServices(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentProofSql, nativeDatabase(DatabaseService)));
 
 export function coordinatePgProofPersistence<
   D extends Database,
@@ -174,7 +185,7 @@ export function coordinatePgProofPersistence<
     coordinateTargetProofPersistence<TransactionOf<D>, A, E, Exclude<R, ProofPersistence>>(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly proofPersistence: ProofPersistence["Service"] },

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,