@yielded/auth-persistence-drizzle 0.1.0-beta.25 → 0.1.0-beta.26

package/src/drizzle/mysql-passwords.ts

@@ -1,343 +0,0 @@
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-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/sql/SqlError";
-
-import { Database as DatabaseService } from "./mysql-database";
-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,
-  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 TransactionService,
-  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];
-
-const configuration = (service: TransactionService | undefined) => ({
-  mode: "interactive" as const,
-  locking: true,
-  standaloneGuard: sqlClientPasswordStandaloneGuard(service),
-  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(service),
-    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,
-  M extends AnyMySqlTable,
-  NativeId,
-> = PasswordPersistenceMapping<S, I, C, AC, M, NativeId>;
-
-export const makeMysqlPasswordPersistenceServices = <
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  M extends AnyMySqlTable,
-  NativeId,
->(
-  mapping: Mapping<S, I, C, AC, M, NativeId>,
-  proofMapping?: ProofPersistenceMapping<
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  >,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) => makeTargetPasswordPersistenceServices(mapping, configuration, proofMapping),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-export function coordinateMysqlPasswordPersistence<
-  D extends Database,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC 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, 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,
-  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, 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,
-  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, 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(nativeDatabase(acquire), (database) =>
-    coordinateTargetPasswordPersistence<TransactionOf<D>, Out, E, Exclude<R, PasswordPersistence>>(
-      database,
-      options.mapping,
-      configuration(transactionService(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));
-      },
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );
-}
-
-export const makeMysqlPasswordRegistrationServices = <
-  Registration,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  Rq extends AnyMySqlTable,
-  NativeId,
->(
-  mapping: PasswordRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) => makeTargetPasswordRegistrationServices<Registration>(mapping, configuration),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-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(nativeDatabase(acquire), (database) =>
-    coordinateTargetPasswordRegistration<
-      Registration,
-      TransactionOf<D>,
-      Out,
-      E,
-      Exclude<R, TargetId>
-    >(
-      database,
-      options.mapping,
-      configuration(transactionService(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));
-      },
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );
-}
-
-export { configuration as mysqlPasswordConfiguration };

package/src/drizzle/mysql-proofs.ts

@@ -1,196 +0,0 @@
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks";
-import { type ProofUnavailable, ProofPersistence } from "@yielded/auth/Proofs";
-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/sql/SqlError";
-
-import { updateValues } from "./model";
-import { Database as DatabaseService } from "./mysql-database";
-import { nativeDatabase } from "./native-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 = EffectMysql2Database<AnyRelations>;
-type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
-type Mapping<
-  Rq extends AnyMySqlTable,
-  S extends AnyMySqlTable,
-  G extends AnyMySqlTable,
-  Cn extends AnyMySqlTable,
-  Rs extends AnyMySqlTable,
-  A extends AnyMySqlTable,
-  F extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  Sub extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  Cr extends AnyMySqlTable,
-  NativeId,
-> = ProofPersistenceMapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>;
-
-const configuration = (service: TransactionService | undefined) => ({
-  mode: "interactive" as const,
-  locking: true,
-  standaloneGuard: sqlClientProofStandaloneGuard(service),
-  insertIfAbsent: (query: ProofSqlQuery, selfKey: string, selfValue: unknown) =>
-    query.onDuplicateKeyUpdate({
-      set: updateValues([[selfKey, selfValue]]),
-    }),
-});
-
-export const makeMysqlProofPersistenceServices = <
-  Rq extends AnyMySqlTable,
-  S extends AnyMySqlTable,
-  G extends AnyMySqlTable,
-  Cn extends AnyMySqlTable,
-  Rs extends AnyMySqlTable,
-  A extends AnyMySqlTable,
-  F extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  Sub extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  Cr extends AnyMySqlTable,
-  NativeId,
->(
-  mapping: Mapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) => makeTargetProofPersistenceServices(mapping, configuration),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentProofSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-export function coordinateMysqlProofPersistence<
-  D extends Database,
-  Rq extends AnyMySqlTable,
-  S extends AnyMySqlTable,
-  G extends AnyMySqlTable,
-  Cn extends AnyMySqlTable,
-  Rs extends AnyMySqlTable,
-  Aev extends AnyMySqlTable,
-  F extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  Sub extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  Cr extends AnyMySqlTable,
-  NativeId,
-  A,
-  E,
-  R,
-  DatabaseError,
-  DatabaseRequirements,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: {
-    readonly mapping: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;
-    readonly transaction?: never;
-  },
-  body: Effect.Effect<A, E, R>,
-): Effect.Effect<
-  A,
-  E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, ProofPersistence> | LifecycleHooks | DatabaseRequirements
->;
-
-export function coordinateMysqlProofPersistence<
-  D extends Database,
-  Rq extends AnyMySqlTable,
-  S extends AnyMySqlTable,
-  G extends AnyMySqlTable,
-  Cn extends AnyMySqlTable,
-  Rs extends AnyMySqlTable,
-  Aev extends AnyMySqlTable,
-  F extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  Sub extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  Cr extends AnyMySqlTable,
-  NativeId,
-  A,
-  E,
-  R,
-  DatabaseError,
-  DatabaseRequirements,
-  TxId,
-  TxShape,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: {
-    readonly mapping: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;
-    readonly transaction: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
-  },
-  body: Effect.Effect<A, E, R>,
-): Effect.Effect<
-  A,
-  E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, ProofPersistence | TxId> | LifecycleHooks | DatabaseRequirements
->;
-
-export function coordinateMysqlProofPersistence<
-  D extends Database,
-  Rq extends AnyMySqlTable,
-  S extends AnyMySqlTable,
-  G extends AnyMySqlTable,
-  Cn extends AnyMySqlTable,
-  Rs extends AnyMySqlTable,
-  Aev extends AnyMySqlTable,
-  F extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  Sub extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  Cr extends AnyMySqlTable,
-  NativeId,
-  A,
-  E,
-  R,
-  DatabaseError,
-  DatabaseRequirements,
-  TxId,
-  TxShape,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: {
-    readonly mapping: Mapping<Rq, S, G, Cn, Rs, Aev, F, C, Sub, I, Cr, NativeId>;
-    readonly transaction?: SuppliedService<TxId, NoInfer<Transaction>, TxShape>;
-  },
-  body: Effect.Effect<A, E, R>,
-): Effect.Effect<
-  A,
-  E | ProofUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, ProofPersistence> | LifecycleHooks | DatabaseRequirements
-> {
-  return Effect.flatMap(nativeDatabase(acquire), (database) =>
-    coordinateTargetProofPersistence<Transaction, A, E, Exclude<R, ProofPersistence>>(
-      database,
-      options.mapping,
-      configuration(transactionService(database)),
-      (
-        transaction: Transaction,
-        services: { readonly proofPersistence: ProofPersistence["Service"] },
-      ) => {
-        const provided = Context.make(ProofPersistence, services.proofPersistence);
-        const work = Effect.provideContext(body, provided);
-
-        return options.transaction === undefined
-          ? work
-          : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
-      },
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );
-}