@yielded/auth-persistence-drizzle 0.1.0-beta.0

package/src/drizzle/passkey-write-drivers.ts

@@ -0,0 +1,395 @@
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import { PasskeyManagementPersistence, PasskeyPersistence } from "@yielded/auth/Passkey";
+import type { Table } from "drizzle-orm";
+import { Context, Effect } from "effect";
+
+import type { PasskeyMappingSource } from "./passkey-model";
+import type { PasskeyCoordinatorError, PasskeyTargetConfiguration } from "./passkey-target";
+import type {
+  PasskeyManagementMapping,
+  PasskeyRegistrationMapping,
+  PasskeyRegistrationWriter,
+} from "./passkey-write-model";
+import {
+  coordinateTargetPasskeyManagement,
+  coordinateTargetPasskeyRegistrationWriter,
+  makeTargetPasskeyManagement,
+  makeTargetPasskeyRegistrationWriter,
+} from "./passkey-write-target";
+import type { SuppliedService } from "./SuppliedService";
+// oxlint-disable-next-line no-explicit-any -- inspect the installed concrete transaction callback.
+type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => any }
+  ? Parameters<Parameters<D["transaction"]>[0]>[0]
+  : never;
+
+export const makePasskeyWriteTarget = <
+  D,
+  T extends Table,
+  Extra = unknown,
+  Synchronous extends boolean = false,
+>(
+  configuration: PasskeyTargetConfiguration,
+) => {
+  function coordinatePasskeyManagement<
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Command extends T,
+    N,
+    A,
+    E,
+    R,
+    RSetup = never,
+    DatabaseError = never,
+    DatabaseRequirements = never,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: PasskeyMappingSource<
+        PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+        RSetup
+      >;
+      readonly transaction?: never;
+    },
+    body: Effect.Effect<
+      A,
+      E,
+      Synchronous extends true ? NoInfer<PasskeyPersistence | PasskeyManagementPersistence> : R
+    >,
+  ): Effect.Effect<
+    A,
+    PasskeyCoordinatorError<E> | DatabaseError,
+    | (Synchronous extends true
+        ? never
+        : Exclude<R, PasskeyPersistence | PasskeyManagementPersistence>)
+    | LifecycleHooks
+    | RSetup
+    | DatabaseRequirements
+  >;
+  function coordinatePasskeyManagement<
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Command extends T,
+    N,
+    A,
+    E,
+    R,
+    TxId,
+    TxShape,
+    RSetup = never,
+    DatabaseError = never,
+    DatabaseRequirements = never,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: PasskeyMappingSource<
+        PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+        RSetup
+      >;
+      readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<
+      A,
+      E,
+      Synchronous extends true
+        ? NoInfer<PasskeyPersistence | PasskeyManagementPersistence | TxId>
+        : R
+    >,
+  ): Effect.Effect<
+    A,
+    PasskeyCoordinatorError<E> | DatabaseError,
+    | (Synchronous extends true
+        ? never
+        : Exclude<R, PasskeyPersistence | PasskeyManagementPersistence | TxId>)
+    | LifecycleHooks
+    | RSetup
+    | DatabaseRequirements
+  >;
+  function coordinatePasskeyManagement<
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Command extends T,
+    N,
+    A,
+    E,
+    R,
+    TxId,
+    TxShape,
+    RSetup = never,
+    DatabaseError = never,
+    DatabaseRequirements = never,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: PasskeyMappingSource<
+        PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+        RSetup
+      >;
+      readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    PasskeyCoordinatorError<E> | DatabaseError,
+    | Exclude<R, PasskeyPersistence | PasskeyManagementPersistence>
+    | LifecycleHooks
+    | RSetup
+    | DatabaseRequirements
+  > {
+    return Effect.flatMap(acquire, (database) =>
+      coordinateTargetPasskeyManagement(
+        database,
+        options.mapping,
+        configuration,
+        (transaction: TransactionOf<Database>, services) => {
+          const context = Context.make(PasskeyPersistence, services.passkeyPersistence).pipe(
+            Context.add(PasskeyManagementPersistence, services.passkeyManagementPersistence),
+          );
+
+          const work = Effect.provideContext(body, context);
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+      ),
+    );
+  }
+
+  const makePasskeyManagementServices = <
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Command extends T,
+    N,
+    RSetup = never,
+  >(
+    database: Database,
+    mapping: PasskeyMappingSource<
+      PasskeyManagementMapping<S, C, F, O, H, M, Flow, Admission, Charge, Command, N> & Extra,
+      RSetup
+    >,
+  ) => makeTargetPasskeyManagement(database, mapping, configuration);
+
+  function coordinatePasskeyRegistration<
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Intent extends T,
+    N,
+    Value,
+    A,
+    E,
+    R,
+    AuthorityId,
+    RSetup = never,
+    DatabaseError = never,
+    DatabaseRequirements = never,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: PasskeyMappingSource<
+        PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
+          Extra,
+        RSetup
+      >;
+      readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
+      readonly transaction?: never;
+    },
+    body: Effect.Effect<
+      A,
+      E,
+      Synchronous extends true ? NoInfer<PasskeyPersistence | AuthorityId> : R
+    >,
+  ): Effect.Effect<
+    A,
+    PasskeyCoordinatorError<E> | DatabaseError,
+    | (Synchronous extends true ? never : Exclude<R, PasskeyPersistence | AuthorityId>)
+    | LifecycleHooks
+    | RSetup
+    | DatabaseRequirements
+  >;
+  function coordinatePasskeyRegistration<
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Intent extends T,
+    N,
+    Value,
+    A,
+    E,
+    R,
+    AuthorityId,
+    TxId,
+    TxShape,
+    RSetup = never,
+    DatabaseError = never,
+    DatabaseRequirements = never,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: PasskeyMappingSource<
+        PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
+          Extra,
+        RSetup
+      >;
+      readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
+      readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<
+      A,
+      E,
+      Synchronous extends true ? NoInfer<PasskeyPersistence | AuthorityId | TxId> : R
+    >,
+  ): Effect.Effect<
+    A,
+    PasskeyCoordinatorError<E> | DatabaseError,
+    | (Synchronous extends true ? never : Exclude<R, PasskeyPersistence | AuthorityId | TxId>)
+    | LifecycleHooks
+    | RSetup
+    | DatabaseRequirements
+  >;
+  function coordinatePasskeyRegistration<
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Intent extends T,
+    N,
+    Value,
+    A,
+    E,
+    R,
+    AuthorityId,
+    TxId,
+    TxShape,
+    RSetup = never,
+    DatabaseError = never,
+    DatabaseRequirements = never,
+  >(
+    acquire: Effect.Effect<Database, DatabaseError, DatabaseRequirements>,
+    options: {
+      readonly mapping: PasskeyMappingSource<
+        PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
+          Extra,
+        RSetup
+      >;
+      readonly authority: Context.Key<AuthorityId, PasskeyRegistrationWriter<Value>>;
+      readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<Database>>, TxShape>;
+    },
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    PasskeyCoordinatorError<E> | DatabaseError,
+    Exclude<R, PasskeyPersistence | AuthorityId> | LifecycleHooks | RSetup | DatabaseRequirements
+  > {
+    return Effect.flatMap(acquire, (database) =>
+      coordinateTargetPasskeyRegistrationWriter(
+        database,
+        options.mapping,
+        configuration,
+        (
+          transaction: TransactionOf<Database>,
+          services: import("./passkey-write-model").PasskeyRegistrationServices<Value>,
+        ) => {
+          const context = Context.make(PasskeyPersistence, services.passkeyPersistence).pipe(
+            Context.add(options.authority, services.passkeyRegistrationAuthority),
+          );
+
+          const work = Effect.provideContext(body, context);
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+      ),
+    );
+  }
+
+  const makePasskeyRegistrationServices = <
+    Database extends D,
+    S extends T,
+    C extends T,
+    F extends T,
+    O extends T,
+    H extends T,
+    M extends T,
+    Flow extends T,
+    Admission extends T,
+    Charge extends T,
+    Intent extends T,
+    N,
+    Value,
+    RSetup = never,
+  >(
+    database: Database,
+    mapping: PasskeyMappingSource<
+      PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
+        Extra,
+      RSetup
+    >,
+  ) =>
+    makeTargetPasskeyRegistrationWriter<
+      PasskeyRegistrationMapping<S, C, F, O, H, M, Flow, Admission, Charge, Intent, N, Value> &
+        Extra,
+      Value,
+      RSetup
+    >(database, mapping, configuration);
+
+  return {
+    makePasskeyManagementServices,
+    makePasskeyRegistrationServices,
+    coordinatePasskeyManagement,
+    coordinatePasskeyRegistration,
+  };
+};

package/src/drizzle/passkey-write-model.ts

@@ -0,0 +1,103 @@
+import * as Shared from "@yielded/auth-persistence/Adapter";
+import type { InferInsertModel, SQL, Table } from "drizzle-orm";
+
+import type { DrizzleTableModel } from "./table-model";
+
+export {
+  type PasskeyCredentialInsert,
+  type PasskeyInvalidationInput,
+  requiredPasskeyManagementConstraints,
+  type PasskeyManagementServices,
+  type PasskeyRegistrationWriter,
+  type PasskeyRegistrationServices,
+  requiredPasskeyRegistrationWriteConstraints,
+} from "@yielded/auth-persistence/Adapter";
+
+export type PasskeyWriteTables<
+  S extends Table,
+  C extends Table,
+  F extends Table,
+  O extends Table,
+  H extends Table,
+  N,
+> = Shared.PasskeyWriteTables<
+  DrizzleTableModel<S>,
+  DrizzleTableModel<C>,
+  DrizzleTableModel<F>,
+  DrizzleTableModel<O>,
+  DrizzleTableModel<H>,
+  N,
+  SQL
+>;
+
+export type PasskeyInvalidationMutation<N> = Shared.PasskeyInvalidationMutation<N, SQL>;
+
+/** Same-owner updates for consumer session/pending tables. No external effects or callbacks after commit. */
+export const passkeyInvalidationMutation = <T extends Table, N>(input: {
+  readonly table: T;
+  readonly where: (input: Shared.PasskeyInvalidationInput<N>) => SQL;
+  readonly values: (input: Shared.PasskeyInvalidationInput<N>) => Partial<InferInsertModel<T>>;
+  readonly postcondition: (input: Shared.PasskeyInvalidationInput<N>) => SQL;
+}): PasskeyInvalidationMutation<N> =>
+  Shared.passkeyInvalidationMutation<DrizzleTableModel<T>, N, SQL>(input);
+
+export type PasskeyCommandTable<T extends Table, N> = Shared.PasskeyCommandTable<
+  DrizzleTableModel<T>,
+  N
+>;
+
+export type PasskeyManagementMapping<
+  S extends Table,
+  C extends Table,
+  F extends Table,
+  O extends Table,
+  H extends Table,
+  M extends Table,
+  Flow extends Table,
+  A extends Table,
+  Charge extends Table,
+  Command extends Table,
+  N,
+> = Shared.PasskeyManagementMapping<
+  DrizzleTableModel<S>,
+  DrizzleTableModel<C>,
+  DrizzleTableModel<F>,
+  DrizzleTableModel<O>,
+  DrizzleTableModel<H>,
+  DrizzleTableModel<M>,
+  DrizzleTableModel<Flow>,
+  DrizzleTableModel<A>,
+  DrizzleTableModel<Charge>,
+  DrizzleTableModel<Command>,
+  N,
+  SQL
+>;
+
+export type PasskeyRegistrationMapping<
+  S extends Table,
+  C extends Table,
+  F extends Table,
+  O extends Table,
+  H extends Table,
+  M extends Table,
+  Flow extends Table,
+  A extends Table,
+  Charge extends Table,
+  Intent extends Table,
+  N,
+  R,
+> = Shared.PasskeyRegistrationMapping<
+  DrizzleTableModel<S>,
+  DrizzleTableModel<C>,
+  DrizzleTableModel<F>,
+  DrizzleTableModel<O>,
+  DrizzleTableModel<H>,
+  DrizzleTableModel<M>,
+  DrizzleTableModel<Flow>,
+  DrizzleTableModel<A>,
+  DrizzleTableModel<Charge>,
+  DrizzleTableModel<Intent>,
+  N,
+  R,
+  SQL
+>;

package/src/drizzle/passkey-write-target.ts

@@ -0,0 +1,9 @@
+import { passkeyKernel } from "./passkey-kernel";
+
+export const {
+  passkeyManagementPersistenceLayer,
+  makeTargetPasskeyManagement,
+  makeTargetPasskeyRegistrationWriter,
+  coordinateTargetPasskeyManagement,
+  coordinateTargetPasskeyRegistrationWriter,
+} = passkeyKernel.writeTarget;

package/src/drizzle/password-model.ts

@@ -0,0 +1,169 @@
+import type * as Shared from "@yielded/auth-persistence/Adapter";
+import type { SQL, Table } from "drizzle-orm";
+
+import type { DrizzleTableModel } from "./table-model";
+
+export {
+  type PasswordAttemptAction,
+  type PasswordAttemptState,
+  type PasswordRateScopeKind,
+  type PasswordScopeKeys,
+  type PasswordAttemptRecord,
+  type RequiredPasswordConstraints,
+  requiredPasswordConstraints,
+  type PasswordConstraintClassifier,
+  type PasswordRegistrationState,
+  type PasswordRegistrationIntent,
+  type RequiredPasswordRegistrationConstraints,
+  requiredPasswordRegistrationConstraints,
+  type PasswordRegistrationConstraintClassifier,
+} from "@yielded/auth-persistence/Adapter";
+
+export type PasswordSubjectTable<
+  Subject extends Table,
+  _NativeSubjectId,
+> = Shared.PasswordSubjectTable<DrizzleTableModel<Subject>, _NativeSubjectId>;
+
+export type PasswordIdentifierTable<
+  Identifier extends Table,
+  NativeSubjectId,
+> = Shared.PasswordIdentifierTable<DrizzleTableModel<Identifier>, NativeSubjectId, SQL>;
+
+export type PasswordAuthorityCredentialTable<
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.PasswordAuthorityCredentialTable<DrizzleTableModel<Credential>, NativeSubjectId>;
+
+export type PasswordCredentialTable<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.PasswordCredentialTable<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  NativeSubjectId
+>;
+
+export type PasswordAttemptTable<
+  Attempt extends Table,
+  NativeSubjectId,
+> = Shared.PasswordAttemptTable<DrizzleTableModel<Attempt>, NativeSubjectId>;
+
+export type PasswordRateScopeTable<RateScope extends Table> = Shared.PasswordRateScopeTable<
+  DrizzleTableModel<RateScope>
+>;
+
+export type PasswordChargeTable<Charge extends Table> = Shared.PasswordChargeTable<
+  DrizzleTableModel<Charge>
+>;
+
+export type PasswordCommandTable<Command extends Table> = Shared.PasswordCommandTable<
+  DrizzleTableModel<Command>
+>;
+
+export type PasswordD1Clock = Shared.PasswordD1Clock<SQL>;
+
+export type PasswordPersistenceMapping<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Attempt extends Table,
+  RateScope extends Table,
+  Charge extends Table,
+  Command extends Table,
+  NativeSubjectId,
+> = Shared.PasswordPersistenceMapping<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Attempt>,
+  DrizzleTableModel<RateScope>,
+  DrizzleTableModel<Charge>,
+  DrizzleTableModel<Command>,
+  NativeSubjectId,
+  SQL
+>;
+
+export type D1PasswordPersistenceMapping<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Attempt extends Table,
+  RateScope extends Table,
+  Charge extends Table,
+  Command extends Table,
+  NativeSubjectId,
+> = Shared.D1PasswordPersistenceMapping<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Attempt>,
+  DrizzleTableModel<RateScope>,
+  DrizzleTableModel<Charge>,
+  DrizzleTableModel<Command>,
+  NativeSubjectId,
+  SQL
+>;
+
+export type PasswordRegistrationTable<
+  Registration,
+  Request extends Table,
+  NativeSubjectId,
+> = Shared.PasswordRegistrationTable<Registration, DrizzleTableModel<Request>, NativeSubjectId>;
+
+export type PasswordRegistrationProvisioning<
+  Registration,
+  Subject extends Table,
+  NativeSubjectId,
+> = Shared.PasswordRegistrationProvisioning<
+  Registration,
+  DrizzleTableModel<Subject>,
+  NativeSubjectId
+>;
+
+export type PasswordRegistrationMapping<
+  Registration,
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Request extends Table,
+  NativeSubjectId,
+> = Shared.PasswordRegistrationMapping<
+  Registration,
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Request>,
+  NativeSubjectId,
+  SQL
+>;
+
+export type AnyPasswordPersistenceMapping = PasswordPersistenceMapping<
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  unknown
+>;
+
+export type AnyPasswordRegistrationMapping<Registration = unknown> = PasswordRegistrationMapping<
+  Registration,
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  unknown
+>;