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

package/src/drizzle/email-sql.ts

@@ -1,25 +0,0 @@
-import { makeEmailKernel } from "@yielded/auth-persistence/Adapter";
-
-import { completeProofPlanIn } from "./proof-sql";
-import { drizzleQueryOperations } from "./query-operations";
-
-export { CurrentEmailSql } from "@yielded/auth-persistence/Adapter";
-
-export type {
-  EmailSqlQuery,
-  EmailSqlDatabase,
-  EmailSqlConfiguration,
-  CurrentAddress,
-} from "@yielded/auth-persistence/Adapter";
-
-export const {
-  validEmailSignInConstraints,
-  emailLookupQuery,
-  decodeEmailSnapshot,
-  makeSqlEmailSignInTargets,
-  currentAddress,
-  sameEmailRevision,
-  snapshotEmailMutation,
-  validateEmailAuthority,
-  makeSqlEmailAddressPersistence,
-} = makeEmailKernel(drizzleQueryOperations, { completeProofPlanIn });

package/src/drizzle/mysql-emails.ts

@@ -1,343 +0,0 @@
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-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 { 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 type {
-  EmailAddressMapping,
-  EmailRegistrationMapping,
-  EmailSignInMapping,
-} from "./email-model";
-import type { EmailRegistrationAuthority } from "./email-registration";
-import { CurrentEmailSql } from "./email-sql";
-import type { EmailSqlQuery } from "./email-sql";
-import {
-  coordinateTargetEmailAddress,
-  coordinateTargetEmailRegistration,
-  makeTargetEmailAddressServices,
-  makeTargetEmailRegistrationServices,
-  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>;
-type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
-type ProofMapping = ProofPersistenceMapping<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
->;
-
-const configuration = (service: TransactionService | undefined) => ({
-  mode: "interactive" as const,
-  locking: true,
-  standaloneGuard: sqlClientEmailStandaloneGuard(service),
-  generatedSubjectRows: (query: EmailSqlQuery) => query.$returningId(),
-  proof: {
-    mode: "interactive" as const,
-    locking: true,
-    standaloneGuard: sqlClientProofStandaloneGuard(service),
-    insertIfAbsent: (query: ProofSqlQuery, selfKey: string, selfValue: unknown) =>
-      query.onDuplicateKeyUpdate({ set: { [selfKey]: selfValue } }),
-  },
-});
-
-export const makeMysqlEmailSignInServices = <
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  NativeId,
->(
-  mapping: EmailSignInMapping<S, I, C, NativeId>,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) => makeTargetEmailSignInServices(mapping, configuration),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-export const makeMysqlEmailAddressServices = <
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  M extends AnyMySqlTable,
-  NativeId,
->(
-  mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>,
-  proofMapping: ProofMapping,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) => makeTargetEmailAddressServices(mapping, proofMapping, configuration),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-export function coordinateMysqlEmailAddress<
-  D extends Database,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  M extends AnyMySqlTable,
-  NativeId,
-  Out,
-  E,
-  R,
-  DatabaseError,
-  DatabaseRequirements,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: {
-    readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
-    readonly proofMapping: ProofMapping;
-    readonly transaction?: never;
-  },
-  body: Effect.Effect<Out, E, R>,
-): Effect.Effect<
-  Out,
-  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, EmailAddressPersistence> | LifecycleHooks | DatabaseRequirements
->;
-
-export function coordinateMysqlEmailAddress<
-  D extends Database,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  M extends AnyMySqlTable,
-  NativeId,
-  Out,
-  E,
-  R,
-  DatabaseError,
-  DatabaseRequirements,
-  TxId,
-  TxShape,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: {
-    readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
-    readonly proofMapping: ProofMapping;
-    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-  },
-  body: Effect.Effect<Out, E, R>,
-): Effect.Effect<
-  Out,
-  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, EmailAddressPersistence | TxId> | LifecycleHooks | DatabaseRequirements
->;
-
-export function coordinateMysqlEmailAddress<
-  D extends Database,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  M extends AnyMySqlTable,
-  NativeId,
-  Out,
-  E,
-  R,
-  DatabaseError,
-  DatabaseRequirements,
-  TxId,
-  TxShape,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: {
-    readonly mapping: EmailAddressMapping<S, I, C, AC, M, NativeId>;
-    readonly proofMapping: ProofMapping;
-    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-  },
-  body: Effect.Effect<Out, E, R>,
-): Effect.Effect<
-  Out,
-  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, EmailAddressPersistence> | LifecycleHooks | DatabaseRequirements
-> {
-  return Effect.flatMap(nativeDatabase(acquire), (database) =>
-    coordinateTargetEmailAddress<TransactionOf<D>, Out, E, Exclude<R, EmailAddressPersistence>>(
-      database,
-      options.mapping,
-      options.proofMapping,
-      configuration(transactionService(database)),
-      (
-        transaction: TransactionOf<D>,
-        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));
-      },
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );
-}
-
-export const makeMysqlEmailRegistrationServices = <
-  Registration,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC extends AnyMySqlTable,
-  Rq extends AnyMySqlTable,
-  NativeId,
->(
-  mapping: EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
-  proofMapping: ProofMapping,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) =>
-      makeTargetEmailRegistrationServices<Registration>(mapping, proofMapping, configuration),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentEmailSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-export function coordinateMysqlEmailRegistration<
-  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: 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, R>,
-): Effect.Effect<
-  Out,
-  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
->;
-
-export function coordinateMysqlEmailRegistration<
-  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: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
-    readonly proofMapping: ProofMapping;
-    readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
-    readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-  },
-  body: Effect.Effect<Out, E, R>,
-): Effect.Effect<
-  Out,
-  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, TargetId | TxId> | LifecycleHooks | DatabaseRequirements
->;
-
-export function coordinateMysqlEmailRegistration<
-  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: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, Rq, NativeId>;
-    readonly proofMapping: ProofMapping;
-    readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
-    readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-  },
-  body: Effect.Effect<Out, E, R>,
-): Effect.Effect<
-  Out,
-  E | EmailUnavailable | HookConfigurationError | SqlError | DatabaseError,
-  Exclude<R, TargetId> | LifecycleHooks | DatabaseRequirements
-> {
-  return Effect.flatMap(nativeDatabase(acquire), (database) =>
-    coordinateTargetEmailRegistration<Registration, TransactionOf<D>, Out, E, Exclude<R, TargetId>>(
-      database,
-      options.mapping,
-      options.proofMapping,
-      configuration(transactionService(database)),
-      (
-        transaction: TransactionOf<D>,
-        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));
-      },
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );
-}

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

@@ -1,198 +0,0 @@
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-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/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,
-} from "./password-prepared-model";
-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];
-
-export const makeMySqlPasswordPreparedPersistenceServices = <
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC 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,
->(
-  mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, M, T, B, NativeId>,
-  proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>,
-) =>
-  Effect.flatMap(
-    Effect.map(acquireTransactionService(DatabaseService), configuration),
-    (configuration) =>
-      makeTargetPasswordPreparedPersistenceServices(mapping, configuration, proofMapping),
-  ).pipe(
-    Effect.provideServiceEffect(CurrentPasswordSql, nativeDatabase(DatabaseService)),
-    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
-  );
-
-export function coordinateMySqlPasswordPreparedPersistence<
-  TargetId,
-  D extends Database,
-  S extends AnyMySqlTable,
-  I extends AnyMySqlTable,
-  C extends AnyMySqlTable,
-  AC 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, 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,
-  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, 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,
-  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, 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(nativeDatabase(acquire), (database) =>
-    coordinateTargetPasswordPreparedPersistence<TransactionOf<D>, Out, E, Exclude<R, TargetId>>(
-      database,
-      options.mapping,
-      configuration(transactionService(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));
-      },
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );
-}