@yielded/auth-persistence 0.1.0-beta.7

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

@@ -0,0 +1,204 @@
+import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks";
+import type { PasswordUnavailable, PasswordPreparedPersistence } from "@yielded/auth/Password";
+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 { mysqlPasswordConfiguration as configuration } from "./mysql-passwords";
+import type {
+  PasswordPreparedPersistenceMapping,
+  PasswordPreparedProofMapping,
+} from "./password-prepared-model";
+import {
+  makeTargetPasswordPreparedPersistenceServices,
+  coordinateTargetPasswordPreparedPersistence,
+} from "./password-prepared-target";
+import type { SuppliedService } from "./SuppliedService";
+type Database = EffectMysql2Database<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+
+export const makeMySqlPasswordPreparedPersistenceServices = <
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  B extends AnyMySqlTable,
+  NativeId,
+  PS extends AnyMySqlTable = AnyMySqlTable,
+  PC extends AnyMySqlTable = AnyMySqlTable,
+  PM extends AnyMySqlTable = AnyMySqlTable,
+  PSub extends AnyMySqlTable = AnyMySqlTable,
+  PI extends AnyMySqlTable = AnyMySqlTable,
+  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,
+  );
+
+export function coordinateMySqlPasswordPreparedPersistence<
+  TargetId,
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  B extends AnyMySqlTable,
+  NativeId,
+  PS extends AnyMySqlTable,
+  PC extends AnyMySqlTable,
+  PM extends AnyMySqlTable,
+  PSub extends AnyMySqlTable,
+  PI extends AnyMySqlTable,
+  PCr extends AnyMySqlTable,
+  PNativeId,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly proofMapping?:
+      | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
+      | undefined;
+    readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMySqlPasswordPreparedPersistence<
+  TargetId,
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  B extends AnyMySqlTable,
+  NativeId,
+  PS extends AnyMySqlTable,
+  PC extends AnyMySqlTable,
+  PM extends AnyMySqlTable,
+  PSub extends AnyMySqlTable,
+  PI extends AnyMySqlTable,
+  PCr extends AnyMySqlTable,
+  PNativeId,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly proofMapping?:
+      | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
+      | undefined;
+    readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;
+    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMySqlPasswordPreparedPersistence<
+  TargetId,
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  T extends AnyMySqlTable,
+  B extends AnyMySqlTable,
+  NativeId,
+  PS extends AnyMySqlTable,
+  PC extends AnyMySqlTable,
+  PM extends AnyMySqlTable,
+  PSub extends AnyMySqlTable,
+  PI extends AnyMySqlTable,
+  PCr extends AnyMySqlTable,
+  PNativeId,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly proofMapping?:
+      | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
+      | undefined;
+    readonly target: SuppliedService<TargetId, PasswordPreparedPersistence>;
+    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasswordPreparedPersistence<TransactionOf<D>, Out, E, Exclude<R, TargetId>>(
+      database,
+      options.mapping,
+      configuration(database),
+      options.proofMapping,
+      (
+        transaction: TransactionOf<D>,
+        services: { readonly passwordPreparedPersistence: PasswordPreparedPersistence },
+      ) => {
+        const provided = Context.make(options.target, services.passwordPreparedPersistence);
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}

package/src/drizzle/mysql-passwords.ts

@@ -0,0 +1,339 @@
+import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks";
+import { type PasswordUnavailable, PasswordPersistence } from "@yielded/auth/Password";
+/* 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 { 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 { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model";
+import type { PasswordRegistrationAuthority } from "./password-registration";
+import type { PasswordSqlQuery } from "./password-sql";
+import {
+  coordinateTargetPasswordPersistence,
+  coordinateTargetPasswordRegistration,
+  makeTargetPasswordPersistenceServices,
+  makeTargetPasswordRegistrationServices,
+  sqlClientPasswordStandaloneGuard,
+} from "./password-target";
+import type { ProofPersistenceMapping } from "./proof-model";
+import type { ProofSqlQuery } from "./proof-sql";
+import { sqlClientProofStandaloneGuard } from "./proof-target";
+import type { SuppliedService } from "./SuppliedService";
+
+type Database = EffectMysql2Database<AnyRelations>;
+type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
+
+const configuration = (database: Database) => ({
+  mode: "interactive" as const,
+  locking: true,
+  standaloneGuard: sqlClientPasswordStandaloneGuard(database),
+  insertIfAbsent: (query: PasswordSqlQuery, selfKey: string, selfValue: unknown) =>
+    query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),
+  generatedSubjectRows: (query: PasswordSqlQuery) => query.$returningId(),
+  proof: {
+    mode: "interactive" as const,
+    locking: true,
+    standaloneGuard: sqlClientProofStandaloneGuard(database),
+    insertIfAbsent: (query: ProofSqlQuery, selfKey: string, selfValue: unknown) =>
+      query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),
+  },
+});
+
+type Mapping<
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  NativeId,
+> = PasswordPersistenceMapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+
+export const makeMysqlPasswordPersistenceServices = <
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>,
+  proofMapping?: ProofPersistenceMapping<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >,
+) =>
+  makeTargetPasswordPersistenceServices(database, mapping, configuration(database), proofMapping);
+
+export function coordinateMysqlPasswordPersistence<
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  NativeId,
+  PM extends
+    | ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>
+    | undefined,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+    readonly proofMapping?: PM;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, PasswordPersistence> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlPasswordPersistence<
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  NativeId,
+  PM extends
+    | ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>
+    | undefined,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+    readonly proofMapping?: PM;
+    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, PasswordPersistence | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlPasswordPersistence<
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  A extends AnyMySqlTable,
+  RS extends AnyMySqlTable,
+  CE extends AnyMySqlTable,
+  M extends AnyMySqlTable,
+  NativeId,
+  PM extends
+    | ProofPersistenceMapping<any, any, any, any, any, any, any, any, any, any, any, any>
+    | undefined,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+    readonly proofMapping?: PM;
+    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, PasswordPersistence> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasswordPersistence<TransactionOf<D>, Out, E, Exclude<R, PasswordPersistence>>(
+      database,
+      options.mapping,
+      configuration(database),
+      options.proofMapping,
+      (
+        transaction: TransactionOf<D>,
+        services: { readonly passwordPersistence: PasswordPersistence["Service"] },
+      ) => {
+        const provided = Context.make(PasswordPersistence, services.passwordPersistence);
+        const work = Effect.provideContext(body, provided);
+
+        return options.transaction === undefined
+          ? work
+          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+      },
+    ),
+  );
+}
+
+export const makeMysqlPasswordRegistrationServices = <
+  Registration,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  Rq extends AnyMySqlTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
+) =>
+  makeTargetPasswordRegistrationServices<Registration>(database, mapping, configuration(database));
+
+export function coordinateMysqlPasswordRegistration<
+  TargetId,
+  Registration,
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  Rq extends AnyMySqlTable,
+  NativeId,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+    readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+    readonly transaction?: never;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlPasswordRegistration<
+  TargetId,
+  Registration,
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  Rq extends AnyMySqlTable,
+  NativeId,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+    readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements
+>;
+
+export function coordinateMysqlPasswordRegistration<
+  TargetId,
+  Registration,
+  D extends Database,
+  S extends AnyMySqlTable,
+  I extends AnyMySqlTable,
+  C extends AnyMySqlTable,
+  AC extends AnyMySqlTable,
+  Rq extends AnyMySqlTable,
+  NativeId,
+  Out,
+  E,
+  R,
+  DatabaseError,
+  DatabaseRequirements,
+  TxId,
+  TxShape,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PasswordRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
+    readonly target: SuppliedService<TargetId, PasswordRegistrationAuthority<Registration>>;
+    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
+  },
+  body: Effect.Effect<Out, E, R>,
+): Effect.Effect<
+  Out,
+  E | PasswordUnavailable | HookConfigurationError | SqlError | DatabaseError,
+  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
+> {
+  return Effect.flatMap(acquire, (database) =>
+    coordinateTargetPasswordRegistration<
+      Registration,
+      TransactionOf<D>,
+      Out,
+      E,
+      Exclude<R, TargetId>
+    >(
+      database,
+      options.mapping,
+      configuration(database),
+      (
+        transaction: TransactionOf<D>,
+        services: { readonly registrationAuthority: PasswordRegistrationAuthority<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));
+      },
+    ),
+  );
+}
+
+export { configuration as mysqlPasswordConfiguration };