@yielded/auth-persistence 0.1.0-beta.7

package/src/drizzle/session-target.ts

@@ -0,0 +1,338 @@
+import {
+  coordinateCommit,
+  hasCommitScope,
+  type LifecycleHooks,
+  type HookConfigurationError,
+} from "@yielded/auth/Hooks";
+import {
+  AuthenticationAuthority,
+  SessionUnavailable,
+  type PendingAuthentication,
+  type SessionRepository,
+  type SignedSessionValidity,
+  type StatefulSessionPersistence,
+  type SessionStepUpPersistence,
+} from "@yielded/auth/Sessions";
+/* oxlint-disable no-explicit-any -- target entrypoints restore each concrete Drizzle database/table type. */
+import { type Context, Effect, Layer } from "effect";
+import type * as SqlError from "effect/unstable/sql/SqlError";
+
+import {
+  makeSqlAuthenticationAuthority,
+  makeSqlPendingAuthentication,
+  makeSqlSignedValidity,
+  makeSqlStatefulSessions,
+  makeSqlSessionStepUp,
+  CurrentSessionSql,
+  type SessionSqlDatabase,
+  type SessionSqlOptions,
+} from "./session-sql";
+import { sqlClientStandaloneGuard } from "./standalone-guard";
+
+export interface SessionTargetConfiguration {
+  readonly mode: "interactive" | "synchronous";
+  readonly locking: boolean;
+  readonly standaloneGuard: Effect.Effect<void, SessionUnavailable>;
+  readonly coordinatorGuard?: Effect.Effect<void, SessionUnavailable>;
+}
+
+interface TransactionOwner<Transaction> {
+  readonly transaction: <A, E, R>(
+    body: (transaction: Transaction) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E | SqlError.SqlError, R>;
+}
+
+type CoordinatorError<E> = E | SessionUnavailable | HookConfigurationError | SqlError.SqlError;
+
+export const sqlClientSessionStandaloneGuard = (
+  database: unknown,
+): Effect.Effect<void, SessionUnavailable> =>
+  sqlClientStandaloneGuard(database, () => SessionUnavailable.make({}));
+
+const options = (
+  configuration: SessionTargetConfiguration,
+  transactionBound = false,
+): SessionSqlOptions => ({
+  mode: configuration.mode,
+  locking: configuration.locking,
+  standaloneGuard: transactionBound ? Effect.void : configuration.standaloneGuard,
+});
+
+export const makeTargetAuthenticationAuthorityServices = <Claims>(
+  database: any,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+) =>
+  Effect.map(
+    makeSqlAuthenticationAuthority<Claims>(database, mapping, options(configuration)),
+    (authenticationAuthority) => ({ authenticationAuthority }),
+  );
+
+export const makeTargetPendingAuthenticationServices = <Claims>(
+  database: any,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+) =>
+  Effect.map(
+    makeSqlPendingAuthentication<Claims>(database, mapping, options(configuration)),
+    (pendingAuthentication) => ({ pendingAuthentication }),
+  );
+
+export const makeTargetStatefulSessionServices = <Claims>(
+  database: any,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+) => makeSqlStatefulSessions<Claims>(database, mapping, options(configuration));
+
+export const makeTargetSignedSessionValidityServices = (
+  database: any,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+) =>
+  Effect.map(
+    makeSqlSignedValidity(database, mapping, options(configuration)),
+    (signedSessionValidity) => ({
+      signedSessionValidity,
+    }),
+  );
+
+/**
+ * The native transaction is the root commit owner. Interruption or owner
+ * failure rolls it back and discards the child journal; this adapter performs
+ * no hidden retry. A caller that can safely retry must rerun the complete owner
+ * operation and prepare fresh bearer material. The low-level coordinator keeps
+ * caller failures intact, including Drizzle query wrappers, and exposes a
+ * native `SqlError` when transaction acquisition fails. Captured service
+ * operations normalize their own driver failures to `SessionUnavailable`.
+ */
+const coordinate = <Transaction, Services, A, E, R>(
+  database: TransactionOwner<Transaction>,
+  configuration: SessionTargetConfiguration,
+  make: (transaction: Transaction) => Effect.Effect<Services, never, LifecycleHooks>,
+  owner: (transaction: Transaction, services: Services) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, CoordinatorError<E>, R | LifecycleHooks> =>
+  Effect.gen(function* (): Effect.fn.Return<A, CoordinatorError<E>, R | LifecycleHooks> {
+    if (yield* hasCommitScope) return yield* SessionUnavailable.make({});
+    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
+
+    const result = yield* coordinateCommit(
+      () =>
+        database.transaction((transaction) =>
+          Effect.gen(function* () {
+            const services = yield* make(transaction);
+
+            return yield* owner(transaction, services);
+          }).pipe(
+            Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
+          ),
+        ),
+      { mode: configuration.mode },
+    );
+
+    return result.value;
+  });
+
+export const coordinateTargetAuthenticationAuthority = <Claims, Transaction, A, E, R>(
+  database: TransactionOwner<Transaction>,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+  owner: (
+    transaction: Transaction,
+    services: { readonly authenticationAuthority: AuthenticationAuthority["Service"] },
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinate(
+    database,
+    configuration,
+    (transaction) =>
+      Effect.map(
+        makeSqlAuthenticationAuthority<Claims>(
+          transaction as unknown as SessionSqlDatabase,
+          mapping,
+          options(configuration, true),
+        ),
+        (authenticationAuthority) => ({ authenticationAuthority }),
+      ),
+    owner,
+  );
+
+export const coordinateTargetPendingAuthentication = <Claims, Transaction, A, E, R>(
+  database: TransactionOwner<Transaction>,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+  owner: (
+    transaction: Transaction,
+    services: { readonly pendingAuthentication: PendingAuthentication<Claims> },
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinate(
+    database,
+    configuration,
+    (transaction) =>
+      Effect.map(
+        makeSqlPendingAuthentication<Claims>(
+          transaction as unknown as SessionSqlDatabase,
+          mapping,
+          options(configuration, true),
+        ),
+        (pendingAuthentication) => ({ pendingAuthentication }),
+      ),
+    owner,
+  );
+
+export const coordinateTargetStatefulSessions = <Claims, Transaction, A, E, R>(
+  database: TransactionOwner<Transaction>,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+  owner: (
+    transaction: Transaction,
+    services: {
+      readonly statefulSessionPersistence: StatefulSessionPersistence<Claims>;
+      readonly sessionRepository: SessionRepository;
+    },
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinate(
+    database,
+    configuration,
+    (transaction) =>
+      makeSqlStatefulSessions<Claims>(
+        transaction as unknown as SessionSqlDatabase,
+        mapping,
+        options(configuration, true),
+      ),
+    owner,
+  );
+
+export const coordinateTargetSignedSessionValidity = <Transaction, A, E, R>(
+  database: TransactionOwner<Transaction>,
+  mapping: any,
+  configuration: SessionTargetConfiguration,
+  owner: (
+    transaction: Transaction,
+    services: { readonly signedSessionValidity: SignedSessionValidity },
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinate(
+    database,
+    configuration,
+    (transaction) =>
+      Effect.map(
+        makeSqlSignedValidity(
+          transaction as unknown as SessionSqlDatabase,
+          mapping,
+          options(configuration, true),
+        ),
+        (signedSessionValidity) => ({ signedSessionValidity }),
+      ),
+    owner,
+  );
+
+export const authenticationAuthorityLayer = (
+  services: Effect.Effect<
+    {
+      readonly authenticationAuthority: AuthenticationAuthority["Service"];
+    },
+    never,
+    LifecycleHooks
+  >,
+) =>
+  Layer.effect(
+    AuthenticationAuthority,
+    Effect.map(services, (value) => value.authenticationAuthority),
+  );
+
+export const statefulSessionLayers = <Claims>(
+  module: {
+    readonly StatefulSessionPersistence: any;
+    readonly SessionRepository: any;
+  },
+  services: Effect.Effect<
+    {
+      readonly statefulSessionPersistence: StatefulSessionPersistence<Claims>;
+      readonly sessionRepository: SessionRepository;
+    },
+    never,
+    LifecycleHooks
+  >,
+) =>
+  Layer.merge(
+    Layer.effect(
+      module.StatefulSessionPersistence,
+      Effect.map(services, (value) => value.statefulSessionPersistence),
+    ),
+    Layer.effect(
+      module.SessionRepository,
+      Effect.map(services, (value) => value.sessionRepository),
+    ),
+  );
+
+export const pendingAuthenticationLayer = <Claims>(
+  module: { readonly PendingAuthentication: any },
+  services: Effect.Effect<
+    {
+      readonly pendingAuthentication: PendingAuthentication<Claims>;
+    },
+    never,
+    LifecycleHooks
+  >,
+) =>
+  Layer.effect(
+    module.PendingAuthentication,
+    Effect.map(services, (value) => value.pendingAuthentication),
+  );
+
+export const signedSessionValidityLayer = (
+  module: { readonly SignedSessionValidity: any },
+  services: Effect.Effect<
+    {
+      readonly signedSessionValidity: SignedSessionValidity;
+    },
+    never,
+    LifecycleHooks
+  >,
+) =>
+  Layer.effect(
+    module.SignedSessionValidity,
+    Effect.map(services, (value) => value.signedSessionValidity),
+  );
+
+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)),
+    (sessionStepUpPersistence) => ({
+      sessionStepUpPersistence: target.of(sessionStepUpPersistence),
+    }),
+  );
+
+export const coordinateTargetSessionStepUp = <Claims, Id, Transaction, A, E, R>(
+  database: TransactionOwner<Transaction>,
+  mapping: any,
+  target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
+  configuration: SessionTargetConfiguration,
+  owner: (
+    transaction: Transaction,
+    services: { readonly sessionStepUpPersistence: SessionStepUpPersistence<Claims> },
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinate(
+    database,
+    configuration,
+    (transaction) =>
+      Effect.map(
+        makeSqlSessionStepUp<Claims>(
+          transaction as unknown as SessionSqlDatabase,
+          mapping,
+          options(configuration, true),
+        ),
+        (sessionStepUpPersistence) => ({
+          sessionStepUpPersistence: target.of(sessionStepUpPersistence),
+        }),
+      ),
+    owner,
+  );

package/src/drizzle/sqlite-emails.ts

@@ -0,0 +1,366 @@
+import { EmailAddressPersistence, type EmailUnavailable } from "@yielded/auth/Email";
+import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks";
+/* oxlint-disable no-explicit-any -- proof mapping tables are independently typed by the proof owner; this driver forwards them unchanged to the shared target. */
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectLibsqlDatabase } from "drizzle-orm/effect-libsql";
+import type { EffectSQLiteBunDatabase } from "drizzle-orm/effect-sqlite-bun";
+import type { EffectSQLiteDoDatabase as DODatabase } from "drizzle-orm/effect-sqlite-do";
+import type { EffectSQLiteNodeDatabase as NodeDatabase } from "drizzle-orm/effect-sqlite-node";
+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 {
+  EmailAddressMapping,
+  EmailRegistrationMapping,
+  EmailSignInMapping,
+} from "./email-model";
+import type { EmailRegistrationAuthority } from "./email-registration";
+import type { EmailSqlQuery } from "./email-sql";
+import {
+  coordinateTargetEmailAddress,
+  coordinateTargetEmailRegistration,
+  makeTargetEmailAddressServices,
+  makeTargetEmailRegistrationServices,
+  makeTargetEmailSignInServices,
+  type EmailTargetConfiguration,
+} from "./email-target";
+import type { ProofPersistenceMapping } from "./proof-model";
+import type { ProofSqlQuery } from "./proof-sql";
+import type { SuppliedService } from "./SuppliedService";
+
+export type SqliteEmailDatabase =
+  | NodeDatabase<AnyRelations>
+  | EffectSQLiteBunDatabase<AnyRelations>
+  | EffectLibsqlDatabase<AnyRelations>
+  | WasmDatabase<AnyRelations>
+  | DODatabase<AnyRelations>;
+
+type TransactionOf<D extends SqliteEmailDatabase> = Parameters<Parameters<D["transaction"]>[0]>[0];
+type ProofMapping = ProofPersistenceMapping<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+
+export const sqliteEmailConfiguration = (
+  mode: "interactive" | "synchronous",
+  standaloneGuard: EmailTargetConfiguration["standaloneGuard"],
+  proofStandaloneGuard: EmailTargetConfiguration["proof"]["standaloneGuard"],
+  coordinatorGuard?: EmailTargetConfiguration["coordinatorGuard"],
+): EmailTargetConfiguration => ({
+  mode,
+  locking: false,
+  standaloneGuard,
+  ...(coordinatorGuard === undefined ? {} : { coordinatorGuard }),
+  generatedSubjectRows: (query: EmailSqlQuery) => query.returning(),
+  proof: {
+    mode,
+    locking: false,
+    standaloneGuard: proofStandaloneGuard,
+    insertIfAbsent: (query: ProofSqlQuery) => query.onConflictDoNothing(),
+  },
+});
+
+export const makeSqliteEmailTarget = <
+  D extends SqliteEmailDatabase,
+  Synchronous extends boolean = false,
+>(
+  configuration: EmailTargetConfiguration | ((database: D) => EmailTargetConfiguration),
+) => {
+  const configurationFor = (database: D) =>
+    typeof configuration === "function" ? configuration(database) : configuration;
+
+  function coordinateEmailAddress<
+    Database extends D,
+    S extends AnySQLiteTable,
+    I extends AnySQLiteTable,
+    C extends AnySQLiteTable,
+    AC extends AnySQLiteTable,
+    M extends AnySQLiteTable,
+    NativeId,
+    Out,
+    E,
+    R,
+    DatabaseError,
+    DatabaseRequirements,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
+      readonly proofMapping: ProofMapping;
+      readonly transaction?: never;
+    },
+    body: Effect.Effect<Out, E, Synchronous extends true ? NoInfer<EmailAddressPersistence> : R>,
+  ): Effect.Effect<
+    Out,
+    E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
+    | (Synchronous extends true ? never : Exclude<R, EmailAddressPersistence>)
+    | LifecycleHooks
+    | DatabaseRequirements
+  >;
+  function coordinateEmailAddress<
+    Database extends D,
+    S extends AnySQLiteTable,
+    I extends AnySQLiteTable,
+    C extends AnySQLiteTable,
+    AC extends AnySQLiteTable,
+    M extends AnySQLiteTable,
+    NativeId,
+    Out,
+    E,
+    R,
+    DatabaseError,
+    DatabaseRequirements,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
+      readonly proofMapping: ProofMapping;
+      readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<
+      Out,
+      E,
+      Synchronous extends true ? NoInfer<EmailAddressPersistence | TxId> : R
+    >,
+  ): Effect.Effect<
+    Out,
+    E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
+    | (Synchronous extends true ? never : Exclude<R, EmailAddressPersistence | TxId>)
+    | LifecycleHooks
+    | DatabaseRequirements
+  >;
+  function coordinateEmailAddress<
+    Database extends D,
+    S extends AnySQLiteTable,
+    I extends AnySQLiteTable,
+    C extends AnySQLiteTable,
+    AC extends AnySQLiteTable,
+    M extends AnySQLiteTable,
+    NativeId,
+    Out,
+    E,
+    R,
+    DatabaseError,
+    DatabaseRequirements,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
+      readonly proofMapping: ProofMapping;
+      readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<Out, E, R>,
+  ): Effect.Effect<
+    Out,
+    E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
+    Exclude<R, EmailAddressPersistence> | LifecycleHooks | DatabaseRequirements
+  > {
+    return Effect.flatMap(acquire, (database) =>
+      coordinateTargetEmailAddress<
+        TransactionOf<Database>,
+        Out,
+        E,
+        Exclude<R, EmailAddressPersistence>
+      >(
+        database,
+        options.mapping,
+        options.proofMapping,
+        configurationFor(database),
+        (
+          transaction: TransactionOf<Database>,
+          services: { readonly emailAddressPersistence: EmailAddressPersistence["Service"] },
+        ) => {
+          const provided = Context.make(EmailAddressPersistence, services.emailAddressPersistence);
+          const work = Effect.provideContext(body, provided);
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+      ),
+    );
+  }
+  function coordinateEmailRegistration<
+    Database extends D,
+    TargetId,
+    Registration,
+    S extends AnySQLiteTable,
+    I extends AnySQLiteTable,
+    C extends AnySQLiteTable,
+    AC extends AnySQLiteTable,
+    Rq extends AnySQLiteTable,
+    NativeId,
+    Out,
+    E,
+    R,
+    DatabaseError,
+    DatabaseRequirements,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+      readonly proofMapping: ProofMapping;
+      readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+      readonly transaction?: never;
+    },
+    body: Effect.Effect<Out, E, Synchronous extends true ? NoInfer<TargetId> : R>,
+  ): Effect.Effect<
+    Out,
+    E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
+    | (Synchronous extends true ? never : Exclude<R, TargetId>)
+    | LifecycleHooks
+    | DatabaseRequirements
+  >;
+  function coordinateEmailRegistration<
+    Database extends D,
+    TargetId,
+    Registration,
+    S extends AnySQLiteTable,
+    I extends AnySQLiteTable,
+    C extends AnySQLiteTable,
+    AC extends AnySQLiteTable,
+    Rq extends AnySQLiteTable,
+    NativeId,
+    Out,
+    E,
+    R,
+    DatabaseError,
+    DatabaseRequirements,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+      readonly proofMapping: ProofMapping;
+      readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+      readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<Out, E, Synchronous extends true ? NoInfer<TargetId | TxId> : R>,
+  ): Effect.Effect<
+    Out,
+    E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
+    | (Synchronous extends true ? never : Exclude<R, TargetId | TxId>)
+    | LifecycleHooks
+    | DatabaseRequirements
+  >;
+  function coordinateEmailRegistration<
+    Database extends D,
+    TargetId,
+    Registration,
+    S extends AnySQLiteTable,
+    I extends AnySQLiteTable,
+    C extends AnySQLiteTable,
+    AC extends AnySQLiteTable,
+    Rq extends AnySQLiteTable,
+    NativeId,
+    Out,
+    E,
+    R,
+    DatabaseError,
+    DatabaseRequirements,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+      readonly proofMapping: ProofMapping;
+      readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+      readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<Out, E, R>,
+  ): Effect.Effect<
+    Out,
+    E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
+    Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+  > {
+    return Effect.flatMap(acquire, (database) =>
+      coordinateTargetEmailRegistration<
+        Registration,
+        TransactionOf<Database>,
+        Out,
+        E,
+        Exclude<R, TargetId>
+      >(
+        database,
+        options.mapping,
+        options.proofMapping,
+        configurationFor(database),
+        (
+          transaction: TransactionOf<Database>,
+          services: { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },
+        ) => {
+          const provided = Context.make(options.target, services.registrationAuthority);
+          const work = Effect.provideContext(body, provided);
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+      ),
+    );
+  }
+
+  return {
+    makeEmailSignInServices: <
+      S extends AnySQLiteTable,
+      I extends AnySQLiteTable,
+      C extends AnySQLiteTable,
+      NativeId,
+    >(
+      database: D,
+      mapping: EmailSignInMapping<S, I, C, NativeId>,
+    ) => makeTargetEmailSignInServices(database, mapping, configurationFor(database)),
+    makeEmailAddressServices: <
+      S extends AnySQLiteTable,
+      I extends AnySQLiteTable,
+      C extends AnySQLiteTable,
+      AC extends AnySQLiteTable,
+      M extends AnySQLiteTable,
+      NativeId,
+    >(
+      database: D,
+      mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>,
+      proofMapping: ProofMapping,
+    ) =>
+      makeTargetEmailAddressServices(database, mapping, proofMapping, configurationFor(database)),
+    coordinateEmailAddress,
+    makeEmailRegistrationServices: <
+      Registration,
+      S extends AnySQLiteTable,
+      I extends AnySQLiteTable,
+      C extends AnySQLiteTable,
+      AC extends AnySQLiteTable,
+      Rq extends AnySQLiteTable,
+      NativeId,
+    >(
+      database: D,
+      mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
+      proofMapping: ProofMapping,
+    ) =>
+      makeTargetEmailRegistrationServices<Registration>(
+        database,
+        mapping,
+        proofMapping,
+        configurationFor(database),
+      ),
+    coordinateEmailRegistration,
+  };
+};