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

package/src/drizzle/email-registration.ts

@@ -540,10 +540,14 @@ const prepareConflict = Effect.fn("Drizzle.prepareConflict")(function* <Registra
 
 export const makeSqlEmailRegistrationAuthority = Effect.fn("makeSqlEmailRegistrationAuthority")(
   function* <Registration>(
-    database: EmailSqlDatabase,
     mapping: Mapping<Registration>,
     configuration: EmailRegistrationConfiguration,
-  ): Effect.fn.Return<EmailRegistrationAuthority<Registration>, never, LifecycleHooks> {
+  ): Effect.fn.Return<
+    EmailRegistrationAuthority<Registration>,
+    never,
+    LifecycleHooks | CurrentEmailSql
+  > {
+    const database = yield* CurrentEmailSql;
     const hooks = yield* LifecycleHooks;
 
     return {

package/src/drizzle/email-target.ts

@@ -7,7 +7,7 @@ import {
 } from "@yielded/auth/Hooks";
 /* oxlint-disable no-explicit-any -- public driver wrappers restore concrete Drizzle generics. */
 import { type Context, Effect, Layer } from "effect";
-import type * as SqlError from "effect/unstable/sql/SqlError";
+import type * as SqlError from "effect/sql/SqlError";
 
 import {
   makeSqlEmailRegistrationAuthority,
@@ -15,6 +15,7 @@ import {
   type EmailRegistrationConfiguration,
 } from "./email-registration";
 import {
+  CurrentEmailSql,
   makeSqlEmailAddressPersistence,
   makeSqlEmailSignInTargets,
   type EmailSqlConfiguration,
@@ -22,7 +23,7 @@ import {
   type EmailSqlQuery,
 } from "./email-sql";
 import type { ProofTargetConfiguration } from "./proof-target";
-import { sqlClientStandaloneGuard } from "./standalone-guard";
+import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
 
 export interface EmailTargetConfiguration {
   readonly mode: "interactive" | "synchronous";
@@ -46,9 +47,9 @@ export type EmailCoordinatorError<E> =
   | SqlError.SqlError;
 
 export const sqlClientEmailStandaloneGuard = (
-  database: unknown,
+  service: TransactionService | undefined,
 ): Effect.Effect<void, EmailUnavailable> =>
-  sqlClientStandaloneGuard(database, () => EmailUnavailable.make({}));
+  sqlClientStandaloneGuard(service, () => EmailUnavailable.make({}));
 
 const proofConfiguration = (configuration: EmailTargetConfiguration, coordinated = false) => ({
   mode: configuration.proof.mode,
@@ -93,13 +94,12 @@ const registrationOptions = (
 });
 
 export const makeTargetEmailSignInServices = (
-  database: any,
   mapping: any,
   configuration: EmailTargetConfiguration,
 ) =>
   Effect.gen(function* () {
     return {
-      emailSignInTargets: yield* makeSqlEmailSignInTargets(database, mapping, {
+      emailSignInTargets: yield* makeSqlEmailSignInTargets(mapping, {
         mode: configuration.mode,
         locking: false,
         standaloneGuard: configuration.standaloneGuard,
@@ -108,7 +108,6 @@ export const makeTargetEmailSignInServices = (
   });
 
 export const makeTargetEmailAddressServices = (
-  database: any,
   mapping: any,
   proofMapping: any,
   configuration: EmailTargetConfiguration,
@@ -116,7 +115,6 @@ export const makeTargetEmailAddressServices = (
   Effect.gen(function* () {
     return {
       emailAddressPersistence: yield* makeSqlEmailAddressPersistence(
-        database,
         mapping,
         addressOptions(configuration, proofMapping),
       ),
@@ -124,7 +122,6 @@ export const makeTargetEmailAddressServices = (
   });
 
 export const makeTargetEmailRegistrationServices = <Registration>(
-  database: any,
   mapping: any,
   proofMapping: any,
   configuration: EmailTargetConfiguration,
@@ -132,7 +129,6 @@ export const makeTargetEmailRegistrationServices = <Registration>(
   Effect.gen(function* () {
     return {
       registrationAuthority: yield* makeSqlEmailRegistrationAuthority<Registration>(
-        database,
         mapping,
         registrationOptions(configuration, proofMapping),
       ),
@@ -161,9 +157,10 @@ export const coordinateTargetEmailAddress = <Transaction, A, E, R>(
           Effect.gen(function* () {
             return yield* owner(transaction, {
               emailAddressPersistence: yield* makeSqlEmailAddressPersistence(
-                transaction as unknown as EmailSqlDatabase,
                 mapping,
                 addressOptions(configuration, proofMapping, true),
+              ).pipe(
+                Effect.provideService(CurrentEmailSql, transaction as unknown as EmailSqlDatabase),
               ),
             });
           }),
@@ -196,9 +193,10 @@ export const coordinateTargetEmailRegistration = <Registration, Transaction, A,
           Effect.gen(function* () {
             return yield* owner(transaction, {
               registrationAuthority: yield* makeSqlEmailRegistrationAuthority<Registration>(
-                transaction as unknown as EmailSqlDatabase,
                 mapping,
                 registrationOptions(configuration, proofMapping, true),
+              ).pipe(
+                Effect.provideService(CurrentEmailSql, transaction as unknown as EmailSqlDatabase),
               ),
             });
           }),
@@ -209,19 +207,19 @@ export const coordinateTargetEmailRegistration = <Registration, Transaction, A,
     return result.value;
   });
 
-export const emailSignInTargetsLayer = (
-  services: Effect.Effect<{ readonly emailSignInTargets: EmailSignInTargets["Service"] }>,
+export const emailSignInTargetsLayer = <E, R>(
+  services: Effect.Effect<{ readonly emailSignInTargets: EmailSignInTargets["Service"] }, E, R>,
 ) =>
   Layer.effect(
     EmailSignInTargets,
     Effect.map(services, (value) => value.emailSignInTargets),
   );
 
-export const emailAddressPersistenceLayer = (
+export const emailAddressPersistenceLayer = <E, R>(
   services: Effect.Effect<
     { readonly emailAddressPersistence: EmailAddressPersistence["Service"] },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(
@@ -229,12 +227,12 @@ export const emailAddressPersistenceLayer = (
     Effect.map(services, (value) => value.emailAddressPersistence),
   );
 
-export const emailRegistrationLayer = <Id, Registration>(
+export const emailRegistrationLayer = <Id, Registration, E, R>(
   tag: Context.Key<Id, EmailRegistrationAuthority<Registration>>,
   services: Effect.Effect<
     { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },
-    never,
-    LifecycleHooks
+    E,
+    R
   >,
 ) =>
   Layer.effect(

package/src/drizzle/model.ts

@@ -1,6 +1,3 @@
-import { requireStandalone } from "@yielded/auth-persistence/Adapter";
-import { AuthStore } from "@yielded/auth/AuthStore";
-import { AuthStoreError } from "@yielded/auth/Errors";
 import {
   ExternalIdentityMutation,
   SubjectProvisioner,
@@ -8,48 +5,11 @@ import {
   type ExternalIdentity,
   type LoginIdentifier,
 } from "@yielded/auth/Identity";
-import { OAuthStateStore, type OAuthState } from "@yielded/auth/OAuth";
-import {
-  type ConsumeChallenge,
-  type NewChallenge,
-  type NewRegistration,
-  type PendingRegistration,
-} from "@yielded/auth/Schema";
-import {
-  getTableColumns,
-  type AnyColumn,
-  type InferInsertModel,
-  type InferSelectModel,
-  type Table,
-} from "drizzle-orm";
+import { getTableColumns, type AnyColumn, type InferInsertModel, type Table } from "drizzle-orm";
 import { Context, DateTime, Effect, Layer } from "effect";
-import type * as SqlClient from "effect/unstable/sql/SqlClient";
 
 export type CommitMode = "interactive" | "synchronous" | "batch";
 
-/**
- * Ordinary error-channel consumes must own their commit. Coordinated callers
- * use the decision methods inside their outer transaction and translate only
- * after that owner commits.
- */
-export interface SqlClientTransactionDatabase {
-  readonly $client: Pick<SqlClient.SqlClient, "transactionService">;
-}
-
-export const requireStandaloneConsume = (
-  database: SqlClientTransactionDatabase,
-): Effect.Effect<void, AuthStoreError> =>
-  requireStandalone(
-    () =>
-      AuthStoreError.make({
-        message: "Use the decision consume API inside an outer database transaction",
-      }),
-    database.$client,
-  );
-
-export type { ChallengeConsumeDecision } from "@yielded/auth/Persistence";
-export type { ConsumeDecision } from "@yielded/auth/AuthStore";
-
 export {
   PersistenceMappingError,
   isMappedConstraintConflict,
@@ -62,156 +22,8 @@ export interface InstantCodec<NativeInstant> {
   readonly decode: (native: NativeInstant) => Effect.Effect<DateTime.Utc, PersistenceMappingError>;
 }
 
-export interface RequiredAuthStoreConstraints {
-  readonly series: "unique(namespace,value,purpose)";
-  readonly challengeDigest: "unique(tokenDigest)";
-  readonly registrationDigest: "unique(tokenDigest)";
-}
-
-export interface RequiredOAuthStateConstraints {
-  readonly oauthStateDigest: "unique(stateDigest)";
-}
-
-export interface RequiredAuthConstraints
-  extends RequiredAuthStoreConstraints, RequiredOAuthStateConstraints {}
-
-export const requiredAuthConstraints: RequiredAuthConstraints = {
-  series: "unique(namespace,value,purpose)",
-  challengeDigest: "unique(tokenDigest)",
-  registrationDigest: "unique(tokenDigest)",
-  oauthStateDigest: "unique(stateDigest)",
-};
-
-export const requiredAuthStoreConstraints: RequiredAuthStoreConstraints = {
-  series: "unique(namespace,value,purpose)",
-  challengeDigest: "unique(tokenDigest)",
-  registrationDigest: "unique(tokenDigest)",
-};
-
-export const requiredOAuthStateConstraints: RequiredOAuthStateConstraints = {
-  oauthStateDigest: "unique(stateDigest)",
-};
-
 type ColumnKey<T extends Table> = Extract<keyof T["_"]["columns"], string>;
 
-export interface ChallengeRecord {
-  readonly challenge: NewChallenge;
-  readonly namespace: string;
-  readonly failedAttempts: number;
-  readonly consumed: boolean;
-}
-
-export interface ChallengeColumns<T extends Table> {
-  readonly challengeId: ColumnKey<T>;
-  readonly tokenDigest: ColumnKey<T>;
-  readonly namespace: ColumnKey<T>;
-  readonly value: ColumnKey<T>;
-  readonly purpose: ColumnKey<T>;
-  readonly otpKeyId: ColumnKey<T>;
-  readonly otpDigest: ColumnKey<T>;
-  readonly issuedAt: ColumnKey<T>;
-  readonly expiresAt: ColumnKey<T>;
-  readonly attemptLimit: ColumnKey<T>;
-  readonly failedAttempts: ColumnKey<T>;
-  readonly consumed: ColumnKey<T>;
-}
-
-/**
- * Inputs are immutable server-created issuances. Replacements must advance
- * issuedAt; equal or older issuances fail even after consumption or expiry.
- * Instant encoding must preserve this ordering. Retain the series row as an
- * issuance watermark until every previously accepted issuance has expired;
- * current-row expiry alone is insufficient if historical lifetimes were longer.
- */
-export interface ChallengeTableMapping<T extends Table> {
-  readonly table: T;
-  readonly columns: ChallengeColumns<T>;
-  readonly identifierNamespace: string;
-  readonly encodeInstant: (instant: DateTime.Utc) => unknown;
-  readonly encodeInsert: (
-    input: NewChallenge,
-    state: {
-      readonly namespace: string;
-      readonly failedAttempts: number;
-      readonly consumed: false;
-    },
-  ) => InferInsertModel<T>;
-  readonly encodeUpdate: (
-    input: NewChallenge,
-    state: {
-      readonly namespace: string;
-      readonly failedAttempts: unknown;
-      readonly consumed: false;
-    },
-  ) => Readonly<Record<string, unknown>>;
-  readonly decode: (
-    row: InferSelectModel<T>,
-  ) => Effect.Effect<ChallengeRecord, PersistenceMappingError>;
-}
-
-export interface RegistrationRecord {
-  readonly registration: PendingRegistration;
-  readonly consumed: boolean;
-}
-
-export interface RegistrationColumns<T extends Table> {
-  readonly registrationId: ColumnKey<T>;
-  readonly tokenDigest: ColumnKey<T>;
-  readonly expiresAt: ColumnKey<T>;
-  readonly consumed: ColumnKey<T>;
-}
-
-export interface RegistrationTableMapping<T extends Table> {
-  readonly table: T;
-  readonly columns: RegistrationColumns<T>;
-  readonly encodeInstant: (instant: DateTime.Utc) => unknown;
-  readonly encodeInsert: (input: NewRegistration, consumed: false) => InferInsertModel<T>;
-  readonly decode: (
-    row: InferSelectModel<T>,
-  ) => Effect.Effect<RegistrationRecord, PersistenceMappingError>;
-}
-
-export interface OAuthStateColumns<T extends Table> {
-  readonly stateDigest: ColumnKey<T>;
-  readonly expiresAt: ColumnKey<T>;
-  readonly consumed: ColumnKey<T>;
-}
-
-export interface OAuthStateTableMapping<T extends Table> {
-  readonly table: T;
-  readonly columns: OAuthStateColumns<T>;
-  readonly encodeInstant: (instant: DateTime.Utc) => unknown;
-  readonly encodeInsert: (state: OAuthState, consumed: false) => InferInsertModel<T>;
-  readonly decode: (
-    row: InferSelectModel<T>,
-  ) => Effect.Effect<
-    { readonly state: OAuthState; readonly consumed: boolean },
-    PersistenceMappingError
-  >;
-}
-
-export interface AuthStoreTables<Challenge extends Table, Registration extends Table> {
-  readonly constraints: RequiredAuthStoreConstraints;
-  readonly challenge: ChallengeTableMapping<Challenge>;
-  readonly registration: RegistrationTableMapping<Registration>;
-}
-
-export interface OAuthStateTables<State extends Table> {
-  readonly constraints: RequiredOAuthStateConstraints;
-  readonly oauthState: OAuthStateTableMapping<State>;
-}
-
-export interface AuthTables<
-  Challenge extends Table,
-  Registration extends Table,
-  State extends Table,
-> {
-  readonly constraints: RequiredAuthConstraints;
-  readonly challenge: ChallengeTableMapping<Challenge>;
-  readonly registration: RegistrationTableMapping<Registration>;
-  readonly oauthState: OAuthStateTableMapping<State>;
-}
-
 export interface RequiredIdentityConstraints {
   readonly identifier: "unique(namespace,value)";
   readonly externalIdentity: "unique(provider,issuer,subject)";
@@ -420,25 +232,6 @@ export const updateValues = <T extends Table>(
   entries: ReadonlyArray<readonly [ColumnKey<T>, unknown]>,
 ): Partial<InferInsertModel<T>> => Object.fromEntries(entries) as Partial<InferInsertModel<T>>;
 
-export type ChallengeInput = ConsumeChallenge;
-
-/** Acquire an application database in Effect and expose the auth stores as one layer. */
-export const authServicesLayer = <E, R>(
-  acquire: Effect.Effect<
-    {
-      readonly authStore: AuthStore["Service"];
-      readonly oauthStateStore: OAuthStateStore["Service"];
-    },
-    E,
-    R
-  >,
-) =>
-  Layer.effectContext(
-    Effect.map(acquire, ({ authStore, oauthStateStore }) =>
-      Context.make(AuthStore, authStore).pipe(Context.add(OAuthStateStore, oauthStateStore)),
-    ),
-  );
-
 /** Acquire an application database in Effect and expose the identity services as one layer. */
 export const identityServicesLayer = <E, R>(
   acquire: Effect.Effect<

package/src/drizzle/mysql-database.ts

@@ -0,0 +1,8 @@
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import { Context } from "effect";
+
+/** Application-owned MySQL database used to construct persistence services. */
+export class Database extends Context.Service<Database, EffectMysql2Database<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/Mysql2/Database",
+) {}

package/src/drizzle/mysql-emails.ts

@@ -5,7 +5,7 @@ import type { AnyRelations } from "drizzle-orm";
 import type { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
 import type { AnyMySqlTable } from "drizzle-orm/mysql-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   EmailAddressMapping,
@@ -13,6 +13,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,
@@ -22,9 +23,16 @@ import {
   makeTargetEmailSignInServices,
   sqlClientEmailStandaloneGuard,
 } from "./email-target";
+import { Database as DatabaseService } from "./mysql-database";
+import { nativeDatabase } from "./native-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 = EffectMysql2Database<AnyRelations>;
@@ -44,15 +52,15 @@ type ProofMapping = ProofPersistenceMapping<
   any
 >;
 
-const configuration = (database: Database) => ({
+const configuration = (service: TransactionService | undefined) => ({
   mode: "interactive" as const,
   locking: true,
-  standaloneGuard: sqlClientEmailStandaloneGuard(database),
+  standaloneGuard: sqlClientEmailStandaloneGuard(service),
   generatedSubjectRows: (query: EmailSqlQuery) => query.$returningId(),
   proof: {
     mode: "interactive" as const,
     locking: true,
-    standaloneGuard: sqlClientProofStandaloneGuard(database),
+    standaloneGuard: sqlClientProofStandaloneGuard(service),
     insertIfAbsent: (query: ProofSqlQuery, selfKey: string, selfValue: unknown) =>
       query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),
   },
@@ -64,9 +72,12 @@ export const makeMysqlEmailSignInServices = <
   C extends AnyMySqlTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailSignInMapping<S, I, C, NativeId>,
-) => makeTargetEmailSignInServices(database, mapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetEmailSignInServices(mapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)));
 
 export const makeMysqlEmailAddressServices = <
   S extends AnyMySqlTable,
@@ -76,10 +87,13 @@ export const makeMysqlEmailAddressServices = <
   M extends AnyMySqlTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>,
   proofMapping: ProofMapping,
-) => makeTargetEmailAddressServices(database, mapping, proofMapping, configuration(database));
+) =>
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) => makeTargetEmailAddressServices(mapping, proofMapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)));
 
 export function coordinateMysqlEmailAddress<
   D extends Database,
@@ -170,7 +184,7 @@ export function coordinateMysqlEmailAddress<
       database,
       options.mapping,
       options.proofMapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly emailAddressPersistence: EmailAddressPersistence["Service"] },
@@ -195,16 +209,14 @@ export const makeMysqlEmailRegistrationServices = <
   Rq extends AnyMySqlTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
   proofMapping: ProofMapping,
 ) =>
-  makeTargetEmailRegistrationServices<Registration>(
-    database,
-    mapping,
-    proofMapping,
-    configuration(database),
-  );
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) =>
+      makeTargetEmailRegistrationServices<Registration>(mapping, proofMapping, configuration),
+  ).pipe(Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)));
 
 export function coordinateMysqlEmailRegistration<
   TargetId,
@@ -304,7 +316,7 @@ export function coordinateMysqlEmailRegistration<
       database,
       options.mapping,
       options.proofMapping,
-      configuration(database),
+      configuration(transactionService(database)),
       (
         transaction: TransactionOf<D>,
         services: { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },

package/src/drizzle/mysql-identity.ts

@@ -10,7 +10,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 { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
 import type { AnyMySqlTable, MySqlColumn } from "drizzle-orm/mysql-core";
 import { Cause, Effect, Schema } from "effect";
@@ -24,8 +24,8 @@ import {
   type IdentityTables,
   type SubjectProvisioningTables,
 } from "./model";
+import { Database as DatabaseService } from "./mysql-database";
 
-type Database = EffectMysql2Database<AnyRelations>;
 type RuntimeDatabase = EffectMysql2Database<any>;
 const unavailable = () => IdentityUnavailable.make();
 const isIdentityFailure = Schema.is(Schema.Union([IdentityConflict, IdentityUnavailable]));
@@ -39,15 +39,14 @@ const mapUnavailable = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     ),
   );
 
-export const makeMysqlSubjectProvisioningServices = <
+export const makeMysqlSubjectProvisioningServices = Effect.fnUntraced(function* <
   Subject extends AnyMySqlTable,
   Identifier extends AnyMySqlTable,
   Request extends AnyMySqlTable,
   NativeId,
->(
-  database: Database,
-  mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => {
+>(mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>) {
+  const database = yield* DatabaseService;
+
   const db = database as RuntimeDatabase;
   const requestTable = mapping.provisioningRequest.table;
 
@@ -190,16 +189,15 @@ export const makeMysqlSubjectProvisioningServices = <
   }, mapUnavailable);
 
   return { subjectProvisioner: SubjectProvisioner.of({ provision }) } as const;
-};
+});
 
-export const makeMysqlExternalIdentityServices = <
+export const makeMysqlExternalIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnyMySqlTable,
   External extends AnyMySqlTable,
   NativeId,
->(
-  database: Database,
-  mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => {
+>(mapping: ExternalIdentityTables<Subject, External, NativeId>) {
+  const database = yield* DatabaseService;
+
   const db = database as RuntimeDatabase;
   const externalTable = mapping.externalIdentity.table;
 
@@ -307,18 +305,17 @@ export const makeMysqlExternalIdentityServices = <
   }, mapUnavailable);
 
   return { externalIdentityMutation: ExternalIdentityMutation.of({ bind }) } as const;
-};
+});
 
-export const makeMysqlIdentityServices = <
+export const makeMysqlIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnyMySqlTable,
   Identifier extends AnyMySqlTable,
   External extends AnyMySqlTable,
   Request extends AnyMySqlTable,
   NativeId,
->(
-  database: Database,
-  mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => ({
-  ...makeMysqlSubjectProvisioningServices(database, mapping),
-  ...makeMysqlExternalIdentityServices(database, mapping),
+>(mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>) {
+  return {
+    ...(yield* makeMysqlSubjectProvisioningServices(mapping)),
+    ...(yield* makeMysqlExternalIdentityServices(mapping)),
+  };
 });

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

@@ -4,9 +4,11 @@ import type { AnyRelations } from "drizzle-orm";
 import type { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
 import type { AnyMySqlTable } from "drizzle-orm/mysql-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
+import { Database as DatabaseService } from "./mysql-database";
 import { mysqlPasswordConfiguration as configuration } from "./mysql-passwords";
+import { nativeDatabase } from "./native-database";
 import type {
   PasswordPreparedPersistenceMapping,
   PasswordPreparedProofMapping,
@@ -15,6 +17,8 @@ import {
   makeTargetPasswordPreparedPersistenceServices,
   coordinateTargetPasswordPreparedPersistence,
 } from "./password-prepared-target";
+import { CurrentPasswordSql } from "./password-sql";
+import { acquireTransactionService, transactionService } from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 type Database = EffectMysql2Database<AnyRelations>;
 type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
@@ -39,16 +43,14 @@ export const makeMySqlPasswordPreparedPersistenceServices = <
   PCr extends AnyMySqlTable = AnyMySqlTable,
   PNativeId = unknown,
 >(
-  database: Database,
   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,
-    configuration(database),
-    proofMapping,
-  );
+  Effect.flatMap(
+    Effect.map(acquireTransactionService(DatabaseService), configuration),
+    (configuration) =>
+      makeTargetPasswordPreparedPersistenceServices(mapping, configuration, proofMapping),
+  ).pipe(Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)));
 
 export function coordinateMySqlPasswordPreparedPersistence<
   TargetId,
@@ -186,7 +188,7 @@ export function coordinateMySqlPasswordPreparedPersistence<
     coordinateTargetPasswordPreparedPersistence<TransactionOf<D>, Out, E, Exclude<R, TargetId>>(
       database,
       options.mapping,
-      configuration(database),
+      configuration(transactionService(database)),
       options.proofMapping,
       (
         transaction: TransactionOf<D>,