@yielded/auth-persistence 0.1.0-beta.7

package/src/drizzle/mysql-sessions.ts

@@ -0,0 +1,741 @@
+import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks";
+import {
+  AuthenticationAuthority,
+  type SessionUnavailable,
+  type PendingAuthentication,
+  type SessionRepository,
+  type SignedSessionValidity,
+  type StatefulSessionPersistence,
+  type SessionStepUpPersistence,
+} from "@yielded/auth/Sessions";
+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 {
+  AuthenticationAuthorityMapping,
+  PendingAuthenticationMapping,
+  SignedSessionValidityMapping,
+  StatefulSessionMapping,
+} from "./session-model";
+import {
+  coordinateTargetAuthenticationAuthority,
+  coordinateTargetPendingAuthentication,
+  coordinateTargetSignedSessionValidity,
+  coordinateTargetStatefulSessions,
+  makeTargetAuthenticationAuthorityServices,
+  makeTargetPendingAuthenticationServices,
+  makeTargetSignedSessionValidityServices,
+  makeTargetStatefulSessionServices,
+  sqlClientSessionStandaloneGuard,
+  makeTargetSessionStepUpServices,
+  coordinateTargetSessionStepUp,
+} from "./session-target";
+import type { SuppliedService } from "./SuppliedService";
+
+type Database = EffectMysql2Database<AnyRelations>;
+type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
+
+const configuration = (database: Database) => ({
+  mode: "interactive" as const,
+  locking: true,
+  standaloneGuard: sqlClientSessionStandaloneGuard(database),
+});
+
+export const makeMysqlAuthenticationAuthorityServices = <
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>,
+) => makeTargetAuthenticationAuthorityServices<Claims>(database, mapping, configuration(database));
+
+export const makeMysqlPendingAuthenticationServices = <
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: PendingAuthenticationMapping<Claims, S, C, P, F, NativeId>,
+) => makeTargetPendingAuthenticationServices<Claims>(database, mapping, configuration(database));
+
+export const makeMysqlStatefulSessionServices = <
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+>(
+  database: Database,
+  mapping: StatefulSessionMapping<Claims, S, C, Session, F, P, NativeId, NativeSessionId>,
+) => makeTargetStatefulSessionServices<Claims>(database, mapping, configuration(database));
+
+export const makeMysqlSignedSessionValidityServices = <
+  S extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+>(
+  database: Database,
+  mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>,
+) => makeTargetSignedSessionValidityServices(database, mapping, configuration(database));
+
+export function coordinateMysqlAuthenticationAuthority<
+  D extends Database,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, AuthenticationAuthority> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlAuthenticationAuthority<
+  D extends Database,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>;
+    readonly transaction: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, AuthenticationAuthority | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlAuthenticationAuthority<
+  D extends Database,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>;
+    readonly transaction?: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, AuthenticationAuthority> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetAuthenticationAuthority<
+      Claims,
+      Transaction,
+      A,
+      E,
+      Exclude<R, AuthenticationAuthority>
+    >(
+      database,
+      options.mapping,
+      configuration(database),
+      (
+        transaction: Transaction,
+        services: { readonly authenticationAuthority: AuthenticationAuthority["Service"] },
+      ) => {
+        const provided = Context.make(AuthenticationAuthority, services.authenticationAuthority);
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}
+
+export function coordinateMysqlPendingAuthentication<
+  D extends Database,
+  TargetId,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  NativeId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PendingAuthenticationMapping<NoInfer<Claims>, S, C, P, F, NativeId>;
+    readonly target: SuppliedService<TargetId, PendingAuthentication<Claims>>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlPendingAuthentication<
+  D extends Database,
+  TargetId,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  NativeId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PendingAuthenticationMapping<NoInfer<Claims>, S, C, P, F, NativeId>;
+    readonly target: SuppliedService<TargetId, PendingAuthentication<Claims>>;
+    readonly transaction: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlPendingAuthentication<
+  D extends Database,
+  TargetId,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  NativeId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PendingAuthenticationMapping<NoInfer<Claims>, S, C, P, F, NativeId>;
+    readonly target: SuppliedService<TargetId, PendingAuthentication<Claims>>;
+    readonly transaction?: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPendingAuthentication<Claims, Transaction, A, E, Exclude<R, TargetId>>(
+      database,
+      options.mapping,
+      configuration(database),
+      (
+        transaction: Transaction,
+        services: { readonly pendingAuthentication: PendingAuthentication<Claims> },
+      ) => {
+        const provided = Context.make(options.target, services.pendingAuthentication);
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}
+
+export function coordinateMysqlStatefulSessions<
+  D extends Database,
+  PersistenceId,
+  RepositoryId,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: StatefulSessionMapping<
+      NoInfer<Claims>,
+      S,
+      C,
+      Session,
+      F,
+      P,
+      NativeId,
+      NativeSessionId
+    >;
+    readonly persistence: SuppliedService<PersistenceId, StatefulSessionPersistence<Claims>>;
+    readonly repository: SuppliedService<RepositoryId, SessionRepository>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, PersistenceId | RepositoryId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlStatefulSessions<
+  D extends Database,
+  PersistenceId,
+  RepositoryId,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: StatefulSessionMapping<
+      NoInfer<Claims>,
+      S,
+      C,
+      Session,
+      F,
+      P,
+      NativeId,
+      NativeSessionId
+    >;
+    readonly persistence: SuppliedService<PersistenceId, StatefulSessionPersistence<Claims>>;
+    readonly repository: SuppliedService<RepositoryId, SessionRepository>;
+    readonly transaction: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, PersistenceId | RepositoryId | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlStatefulSessions<
+  D extends Database,
+  PersistenceId,
+  RepositoryId,
+  Claims,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  F extends AnyMySqlTable,
+  P extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: StatefulSessionMapping<
+      NoInfer<Claims>,
+      S,
+      C,
+      Session,
+      F,
+      P,
+      NativeId,
+      NativeSessionId
+    >;
+    readonly persistence: SuppliedService<PersistenceId, StatefulSessionPersistence<Claims>>;
+    readonly repository: SuppliedService<RepositoryId, SessionRepository>;
+    readonly transaction?: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, PersistenceId | RepositoryId> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetStatefulSessions<
+      Claims,
+      Transaction,
+      A,
+      E,
+      Exclude<R, PersistenceId | RepositoryId>
+    >(
+      database,
+      options.mapping,
+      configuration(database),
+      (
+        transaction: Transaction,
+        services: {
+          readonly statefulSessionPersistence: StatefulSessionPersistence<Claims>;
+          readonly sessionRepository: SessionRepository;
+        },
+      ) => {
+        const provided = Context.make(
+          options.persistence,
+          services.statefulSessionPersistence,
+        ).pipe(Context.add(options.repository, services.sessionRepository));
+
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}
+
+export function coordinateMysqlSignedSessionValidity<
+  D extends Database,
+  TargetId,
+  S extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>;
+    readonly target: SuppliedService<TargetId, SignedSessionValidity>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlSignedSessionValidity<
+  D extends Database,
+  TargetId,
+  S extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>;
+    readonly target: SuppliedService<TargetId, SignedSessionValidity>;
+    readonly transaction: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlSignedSessionValidity<
+  D extends Database,
+  TargetId,
+  S extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>;
+    readonly target: SuppliedService<TargetId, SignedSessionValidity>;
+    readonly transaction?: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetSignedSessionValidity<Transaction, A, E, Exclude<R, TargetId>>(
+      database,
+      options.mapping,
+      configuration(database),
+      (
+        transaction: Transaction,
+        services: { readonly signedSessionValidity: SignedSessionValidity },
+      ) => {
+        const provided = Context.make(options.target, services.signedSessionValidity);
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}
+
+import type { SessionStepUpMapping } from "./step-up-model";
+
+export const makeMysqlSessionStepUpServices = <
+  Claims,
+  Id,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  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));
+
+export function coordinateMysqlSessionStepUp<
+  Claims,
+  Id,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  D extends Database,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: SessionStepUpMapping<
+      NoInfer<Claims>,
+      S,
+      C,
+      I,
+      Session,
+      T,
+      NativeId,
+      NativeSessionId
+    >;
+    readonly target: SuppliedService<Id, SessionStepUpPersistence<Claims>>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, Id> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlSessionStepUp<
+  Claims,
+  Id,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  D extends Database,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: SessionStepUpMapping<
+      NoInfer<Claims>,
+      S,
+      C,
+      I,
+      Session,
+      T,
+      NativeId,
+      NativeSessionId
+    >;
+    readonly target: SuppliedService<Id, SessionStepUpPersistence<Claims>>;
+    readonly transaction: SuppliedService<
+      TxId,
+      NoInfer<Parameters<Parameters<D["transaction"]>[0]>[0]>,
+      TxShape
+    >;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, Id | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlSessionStepUp<
+  Claims,
+  Id,
+  S extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  Session extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  NativeId,
+  NativeSessionId,
+  D extends Database,
+  A,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: SessionStepUpMapping<
+      NoInfer<Claims>,
+      S,
+      C,
+      I,
+      Session,
+      T,
+      NativeId,
+      NativeSessionId
+    >;
+    readonly target: SuppliedService<Id, SessionStepUpPersistence<Claims>>;
+    readonly transaction?: SuppliedService<
+      TxId,
+      NoInfer<Parameters<Parameters<D["transaction"]>[0]>[0]>,
+      TxShape
+    >;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | SessionUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, Id> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetSessionStepUp<
+      Claims,
+      Id,
+      Parameters<Parameters<D["transaction"]>[0]>[0],
+      A,
+      E,
+      Exclude<R, Id>
+    >(
+      database,
+      options.mapping,
+      options.target,
+      configuration(database),
+      (
+        transaction: Parameters<Parameters<D["transaction"]>[0]>[0],
+        services: { readonly sessionStepUpPersistence: SessionStepUpPersistence<Claims> },
+      ) => {
+        const provided = Context.make(options.target, services.sessionStepUpPersistence);
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}