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

package/src/drizzle/email-model.ts

@@ -1,6 +1,7 @@
 import type * as Shared from "@yielded/auth-persistence/Adapter";
 import type { SQL, Table } from "drizzle-orm";
 
+import type { ClockMapping } from "./native-clock";
 import type { DrizzleTableModel } from "./table-model";
 
 export {
@@ -8,7 +9,6 @@ export {
   requiredEmailSignInConstraints,
   type RequiredEmailAddressConstraints,
   requiredEmailAddressConstraints,
-  type EmailRegistrationState,
   type EmailRegistrationIntent,
   type RequiredEmailRegistrationConstraints,
   requiredEmailRegistrationConstraints,
@@ -60,64 +60,37 @@ export type EmailAuthorityCredentialTable<
   NativeSubjectId,
 > = Shared.EmailAuthorityCredentialTable<DrizzleTableModel<Credential>, NativeSubjectId>;
 
-export type EmailCommandTable<Command extends Table> = Shared.EmailCommandTable<
-  DrizzleTableModel<Command>
->;
-
 export type EmailSignInMapping<
   Subject extends Table,
   Identifier extends Table,
   Credential extends Table,
+  AuthorityCredential extends Table,
   NativeSubjectId,
 > = Shared.EmailSignInMapping<
   DrizzleTableModel<Subject>,
   DrizzleTableModel<Identifier>,
   DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
   NativeSubjectId
 >;
 
-export type EmailD1Clock = Shared.EmailD1Clock<SQL>;
-
 export type EmailAddressMapping<
   Subject extends Table,
   Identifier extends Table,
   Credential extends Table,
   AuthorityCredential extends Table,
-  Command extends Table,
-  NativeSubjectId,
-> = Shared.EmailAddressMapping<
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  DrizzleTableModel<AuthorityCredential>,
-  DrizzleTableModel<Command>,
   NativeSubjectId,
-  SQL
+> = ClockMapping<
+  Shared.EmailAddressMapping<
+    DrizzleTableModel<Subject>,
+    DrizzleTableModel<Identifier>,
+    DrizzleTableModel<Credential>,
+    DrizzleTableModel<AuthorityCredential>,
+    NativeSubjectId,
+    SQL
+  >
 >;
 
-export type D1EmailAddressMapping<
-  Subject extends Table,
-  Identifier extends Table,
-  Credential extends Table,
-  AuthorityCredential extends Table,
-  Command extends Table,
-  NativeSubjectId,
-> = Shared.D1EmailAddressMapping<
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  DrizzleTableModel<AuthorityCredential>,
-  DrizzleTableModel<Command>,
-  NativeSubjectId,
-  SQL
->;
-
-export type EmailRegistrationTable<
-  Registration,
-  Request extends Table,
-  NativeSubjectId,
-> = Shared.EmailRegistrationTable<Registration, DrizzleTableModel<Request>, NativeSubjectId>;
-
 export type EmailRegistrationProvisioning<
   Registration,
   Subject extends Table,
@@ -148,29 +121,22 @@ export type EmailRegistrationMapping<
   Identifier extends Table,
   Credential extends Table,
   AuthorityCredential extends Table,
-  Request extends Table,
   NativeSubjectId,
-> = Shared.EmailRegistrationMapping<
-  Registration,
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  DrizzleTableModel<AuthorityCredential>,
-  DrizzleTableModel<Request>,
-  NativeSubjectId,
-  SQL
+> = ClockMapping<
+  Shared.EmailRegistrationMapping<
+    Registration,
+    DrizzleTableModel<Subject>,
+    DrizzleTableModel<Identifier>,
+    DrizzleTableModel<Credential>,
+    DrizzleTableModel<AuthorityCredential>,
+    NativeSubjectId,
+    SQL
+  >
 >;
 
-export type AnyEmailSignInMapping = EmailSignInMapping<Table, Table, Table, unknown>;
+export type AnyEmailSignInMapping = EmailSignInMapping<Table, Table, Table, Table, unknown>;
 
-export type AnyEmailAddressMapping = EmailAddressMapping<
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  unknown
->;
+export type AnyEmailAddressMapping = EmailAddressMapping<Table, Table, Table, Table, unknown>;
 
 export type AnyEmailRegistrationMapping<Registration = unknown> = EmailRegistrationMapping<
   Registration,
@@ -178,25 +144,5 @@ export type AnyEmailRegistrationMapping<Registration = unknown> = EmailRegistrat
   Table,
   Table,
   Table,
-  Table,
   unknown
 >;
-
-export type D1EmailRegistrationMapping<
-  Registration,
-  Subject extends Table,
-  Identifier extends Table,
-  Credential extends Table,
-  AuthorityCredential extends Table,
-  Request extends Table,
-  NativeSubjectId,
-> = Shared.D1EmailRegistrationMapping<
-  Registration,
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  DrizzleTableModel<AuthorityCredential>,
-  DrizzleTableModel<Request>,
-  NativeSubjectId,
-  SQL
->;

package/src/drizzle/email-target.ts

@@ -1,236 +1,125 @@
-import type { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-import { EmailAddressPersistence, EmailSignInTargets, EmailUnavailable } from "@yielded/auth/Email";
 import {
-  coordinateCommit,
-  hasCommitScope,
-  LifecycleHooks,
-  type HookConfigurationError,
-} from "@yielded/auth/Hooks";
-/* oxlint-disable no-explicit-any -- public driver wrappers restore concrete Drizzle generics. */
+  makeNativeEmailAddressServices,
+  makeNativeEmailSignInServices,
+  makeNativeEmailRegistrationServices,
+  requireStandalone,
+  type AnyEmailAddressMapping as SharedEmailMapping,
+  type EmailRegistrationAuthority,
+} from "@yielded/auth-persistence/Adapter";
+import { EmailAddressPersistence, EmailSignInTargets, EmailUnavailable } from "@yielded/auth/Email";
 import { type Context, Effect, Layer } from "effect";
-import type * as SqlError from "effect/sql/SqlError";
 
+import type {
+  AnyEmailAddressMapping,
+  AnyEmailSignInMapping,
+  AnyEmailRegistrationMapping,
+} from "./email-model";
+import { nativeClock } from "./native-clock";
+import type { NativeDatabaseHandle } from "./native-database";
 import {
-  makeSqlEmailRegistrationAuthority,
-  type EmailRegistrationAuthority,
-  type EmailRegistrationConfiguration,
-} from "./email-registration";
-import {
-  CurrentEmailSql,
-  makeSqlEmailAddressPersistence,
-  makeSqlEmailSignInTargets,
-  type EmailSqlConfiguration,
-  type EmailSqlDatabase,
-  type EmailSqlQuery,
-} from "./email-sql";
-import type { ProofTargetConfiguration } from "./proof-target";
-import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
+  nativeTarget,
+  coordinateNativeTarget,
+  type NativeTargetConfiguration,
+} from "./native-target";
+import type { AnyProofPersistenceMapping } from "./proof-model";
+import { nativeProofMapping } from "./proof-target";
 import { validateDrizzleStorage } from "./storage-validation";
 
-export interface EmailTargetConfiguration {
-  readonly mode: "interactive" | "synchronous";
-  readonly locking: boolean;
-  readonly standaloneGuard: Effect.Effect<void, EmailUnavailable>;
-  readonly coordinatorGuard?: Effect.Effect<void, EmailUnavailable>;
-  readonly generatedSubjectRows: (query: EmailSqlQuery) => EmailSqlQuery;
-  readonly proof: ProofTargetConfiguration;
-}
-
-interface TransactionOwner<Transaction> {
-  readonly transaction: <A, E, R>(
-    body: (transaction: Transaction) => Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E | SqlError.SqlError, R>;
-}
+const unavailable = () => EmailUnavailable.make({});
 
-export type EmailCoordinatorError<E> =
-  | E
-  | EmailUnavailable
-  | HookConfigurationError
-  | SqlError.SqlError;
+export const sqlClientEmailStandaloneGuard = (marker: Parameters<typeof requireStandalone>[1]) =>
+  requireStandalone(unavailable, marker);
 
-export const sqlClientEmailStandaloneGuard = (
-  service: TransactionService | undefined,
-): Effect.Effect<void, EmailUnavailable> =>
-  sqlClientStandaloneGuard(service, () => EmailUnavailable.make({}));
-
-const proofConfiguration = (configuration: EmailTargetConfiguration, coordinated = false) => ({
-  mode: configuration.proof.mode,
-  locking: configuration.proof.locking,
-
-  standaloneGuard: Effect.void,
-  coordinated,
-  insertIfAbsent: configuration.proof.insertIfAbsent,
+const mapped = (value: AnyEmailAddressMapping): SharedEmailMapping => ({
+  ...value,
+  clock: nativeClock(value.clock),
 });
 
-const addressOptions = (
-  configuration: EmailTargetConfiguration,
-  proofMapping: any,
-  coordinated = false,
-): EmailSqlConfiguration => ({
-  mode: configuration.mode,
-  locking: configuration.locking,
-
-  standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,
-  coordinated,
-  proof: {
-    mapping: proofMapping,
-    configuration: proofConfiguration(configuration, true),
-  },
+export const makeTargetEmailAddressServices = Effect.fnUntraced(function* (
+  mapping: AnyEmailAddressMapping,
+  configuration: NativeTargetConfiguration,
+  proofs?: AnyProofPersistenceMapping,
+) {
+  yield* validateDrizzleStorage(mapping).pipe(Effect.mapError(unavailable));
+  if (proofs !== undefined)
+    yield* validateDrizzleStorage(proofs).pipe(Effect.mapError(unavailable));
+  if (
+    configuration.mode === "batch" &&
+    (mapping.d1?.primary !== true || (proofs !== undefined && proofs.d1?.primary !== true))
+  )
+    return yield* unavailable();
+  const target = yield* nativeTarget(configuration);
+
+  return yield* target.provide(
+    makeNativeEmailAddressServices(
+      target.tables,
+      mapped(mapping),
+      proofs === undefined ? undefined : nativeProofMapping(proofs),
+    ),
+  );
 });
 
-const registrationOptions = (
-  configuration: EmailTargetConfiguration,
-  proofMapping: any,
-  coordinated = false,
-): EmailRegistrationConfiguration => ({
-  mode: configuration.mode,
-  locking: configuration.locking,
-
-  standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,
-  generatedSubjectRows: configuration.generatedSubjectRows,
-  coordinated,
-  proof: {
-    mapping: proofMapping,
-    configuration: proofConfiguration(configuration, true),
-  },
+export const makeTargetEmailRegistrationServices = Effect.fnUntraced(function* <Registration>(
+  mapping: AnyEmailRegistrationMapping<Registration>,
+  configuration: NativeTargetConfiguration,
+  proofs: AnyProofPersistenceMapping,
+) {
+  yield* validateDrizzleStorage(mapping).pipe(Effect.mapError(unavailable));
+  yield* validateDrizzleStorage(proofs).pipe(Effect.mapError(unavailable));
+  if (
+    configuration.mode === "batch" &&
+    (mapping.d1?.primary !== true || proofs.d1?.primary !== true)
+  )
+    return yield* unavailable();
+  const target = yield* nativeTarget(configuration);
+
+  return yield* target.provide(
+    makeNativeEmailRegistrationServices(
+      target.tables,
+      {
+        ...mapping,
+        clock: nativeClock(mapping.clock),
+      },
+      nativeProofMapping(proofs),
+      target.batch,
+    ),
+  );
 });
 
-export const makeTargetEmailSignInServices = (
-  mapping: any,
-  configuration: EmailTargetConfiguration,
-) =>
-  Effect.gen(function* () {
-    return {
-      emailSignInTargets: yield* makeSqlEmailSignInTargets(mapping, {
-        mode: configuration.mode,
-        locking: false,
-        standaloneGuard: configuration.standaloneGuard,
-      }),
-    };
-  });
-
-export const makeTargetEmailAddressServices = (
-  mapping: any,
-  proofMapping: any,
-  configuration: EmailTargetConfiguration,
-) =>
-  Effect.gen(function* () {
-    return {
-      emailAddressPersistence: yield* makeSqlEmailAddressPersistence(
-        mapping,
-        addressOptions(configuration, proofMapping),
-      ),
-    };
-  });
-
-export const makeTargetEmailRegistrationServices = <Registration>(
-  mapping: any,
-  proofMapping: any,
-  configuration: EmailTargetConfiguration,
-) =>
-  Effect.gen(function* () {
-    return {
-      registrationAuthority: yield* makeSqlEmailRegistrationAuthority<Registration>(
-        mapping,
-        registrationOptions(configuration, proofMapping),
-      ),
-    };
-  });
-
 export const coordinateTargetEmailAddress = <Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  proofMapping: any,
-  configuration: EmailTargetConfiguration,
-  owner: (
+  database: NativeDatabaseHandle,
+  mapping: AnyEmailAddressMapping,
+  configuration: NativeTargetConfiguration,
+  body: (
     transaction: Transaction,
     services: { readonly emailAddressPersistence: EmailAddressPersistence["Service"] },
   ) => Effect.Effect<A, E, R>,
-): Effect.Effect<A, EmailCoordinatorError<E>, R | LifecycleHooks | NativeDatabase> =>
-  Effect.gen(function* (): Effect.fn.Return<
-    A,
-    EmailCoordinatorError<E>,
-    R | LifecycleHooks | NativeDatabase
-  > {
-    const hooks = yield* LifecycleHooks;
-
-    if (yield* hasCommitScope) return yield* EmailUnavailable.make({});
-    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
-
-    yield* validateDrizzleStorage({ ...mapping, proof: proofMapping }).pipe(
-      Effect.mapError(() => EmailUnavailable.make({})),
-    );
-
-    const result = yield* coordinateCommit(
-      () =>
-        database.transaction((transaction) =>
-          Effect.gen(function* () {
-            return yield* owner(transaction, {
-              emailAddressPersistence: yield* makeSqlEmailAddressPersistence(
-                mapping,
-                addressOptions(configuration, proofMapping, true),
-              ).pipe(
-                Effect.provideService(CurrentEmailSql, transaction as unknown as EmailSqlDatabase),
-              ),
-            });
-          }),
-        ),
-      { mode: configuration.mode },
-    ).pipe(Effect.provideService(LifecycleHooks, hooks));
-
-    return result.value;
-  });
+  proofs?: AnyProofPersistenceMapping,
+) =>
+  coordinateNativeTarget(
+    unavailable,
+    database,
+    configuration,
+    makeTargetEmailAddressServices(mapping, configuration, proofs),
+    body,
+  );
 
 export const coordinateTargetEmailRegistration = <Registration, Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  proofMapping: any,
-  configuration: EmailTargetConfiguration,
-  owner: (
+  database: NativeDatabaseHandle,
+  mapping: AnyEmailRegistrationMapping<Registration>,
+  configuration: NativeTargetConfiguration,
+  proofs: AnyProofPersistenceMapping,
+  body: (
     transaction: Transaction,
     services: { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },
   ) => Effect.Effect<A, E, R>,
-): Effect.Effect<A, EmailCoordinatorError<E>, R | LifecycleHooks | NativeDatabase> =>
-  Effect.gen(function* (): Effect.fn.Return<
-    A,
-    EmailCoordinatorError<E>,
-    R | LifecycleHooks | NativeDatabase
-  > {
-    const hooks = yield* LifecycleHooks;
-
-    if (yield* hasCommitScope) return yield* EmailUnavailable.make({});
-    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
-
-    yield* validateDrizzleStorage({ ...mapping, proof: proofMapping }).pipe(
-      Effect.mapError(() => EmailUnavailable.make({})),
-    );
-
-    const result = yield* coordinateCommit(
-      () =>
-        database.transaction((transaction) =>
-          Effect.gen(function* () {
-            return yield* owner(transaction, {
-              registrationAuthority: yield* makeSqlEmailRegistrationAuthority<Registration>(
-                mapping,
-                registrationOptions(configuration, proofMapping, true),
-              ).pipe(
-                Effect.provideService(CurrentEmailSql, transaction as unknown as EmailSqlDatabase),
-              ),
-            });
-          }),
-        ),
-      { mode: configuration.mode },
-    ).pipe(Effect.provideService(LifecycleHooks, hooks));
-
-    return result.value;
-  });
-
-export const emailSignInTargetsLayer = <E, R>(
-  services: Effect.Effect<{ readonly emailSignInTargets: EmailSignInTargets["Service"] }, E, R>,
 ) =>
-  Layer.effect(
-    EmailSignInTargets,
-    Effect.map(services, (value) => value.emailSignInTargets),
+  coordinateNativeTarget(
+    unavailable,
+    database,
+    configuration,
+    makeTargetEmailRegistrationServices(mapping, configuration, proofs),
+    body,
   );
 
 export const emailAddressPersistenceLayer = <E, R>(
@@ -246,7 +135,7 @@ export const emailAddressPersistenceLayer = <E, R>(
   );
 
 export const emailRegistrationLayer = <Id, Registration, E, R>(
-  tag: Context.Key<Id, EmailRegistrationAuthority<Registration>>,
+  target: Context.Key<Id, EmailRegistrationAuthority<Registration>>,
   services: Effect.Effect<
     { readonly registrationAuthority: EmailRegistrationAuthority<Registration> },
     E,
@@ -254,6 +143,24 @@ export const emailRegistrationLayer = <Id, Registration, E, R>(
   >,
 ) =>
   Layer.effect(
-    tag,
+    target,
     Effect.map(services, (value) => value.registrationAuthority),
   );
+
+export const makeTargetEmailSignInServices = Effect.fnUntraced(function* (
+  mapping: AnyEmailSignInMapping,
+  configuration: NativeTargetConfiguration,
+) {
+  yield* validateDrizzleStorage(mapping).pipe(Effect.mapError(unavailable));
+  const target = yield* nativeTarget(configuration);
+
+  return yield* target.provide(makeNativeEmailSignInServices(target.tables, mapping));
+});
+
+export const emailSignInTargetsLayer = <E, R>(
+  services: Effect.Effect<{ readonly emailSignInTargets: EmailSignInTargets["Service"] }, E, R>,
+) =>
+  Layer.effect(
+    EmailSignInTargets,
+    Effect.map(services, (value) => value.emailSignInTargets),
+  );

package/src/drizzle/model.ts

@@ -8,8 +8,6 @@ import {
 import { getTableColumns, type AnyColumn, type InferInsertModel, type Table } from "drizzle-orm";
 import { Context, DateTime, Effect, Layer } from "effect";
 
-export type CommitMode = "interactive" | "synchronous" | "batch";
-
 export {
   PersistenceMappingError,
   isMappedConstraintConflict,

package/src/drizzle/mysql-identity.ts

@@ -1,4 +1,4 @@
-import { withStorageValidation, NativeDatabase } from "@yielded/auth-persistence/Adapter";
+import { withStorageValidation } from "@yielded/auth-persistence/Adapter";
 import {
   ExternalIdentityMutation,
   type ExternalIdentity,
@@ -26,7 +26,7 @@ import {
   type SubjectProvisioningTables,
 } from "./model";
 import { Database as DatabaseService } from "./mysql-database";
-import { nativeDatabase } from "./native-database";
+import { NativeDatabase, nativeDatabase } from "./native-database";
 import { validateDrizzleStorage } from "./storage-validation";
 
 type RuntimeDatabase = EffectMysql2Database<any>;
@@ -75,13 +75,6 @@ export const makeMysqlSubjectProvisioningServices = Effect.fnUntraced(function*
 
   const identifierTable = mapping.identifier.table;
 
-  const identifierNamespaceColumn = column(
-    identifierTable,
-    mapping.identifier.namespace,
-  ) as MySqlColumn;
-
-  const identifierValueColumn = column(identifierTable, mapping.identifier.value) as MySqlColumn;
-
   const findReceipt = Effect.fn("DrizzleMysqlIdentity.findReceipt")(function* (requestId: string) {
     const rows = yield* db
       .select({ fingerprint: requestFingerprintColumn, subjectId: requestSubjectColumn })
@@ -170,21 +163,8 @@ export const makeMysqlSubjectProvisioningServices = Effect.fnUntraced(function*
             Effect.flatMap((receipt) => {
               if (receipt !== undefined && receipt.fingerprint === fingerprint)
                 return Effect.succeed(receipt.subjectId as NativeId);
-              if (input.identifier === undefined) return IdentityConflict.make();
-
-              return db
-                .select({
-                  subjectId: column(identifierTable, mapping.identifier.subjectId) as MySqlColumn,
-                })
-                .from(identifierTable as any)
-                .where(
-                  and(
-                    eq(identifierNamespaceColumn, input.identifier.namespace),
-                    eq(identifierValueColumn, input.identifier.value),
-                  ),
-                )
-                .limit(1)
-                .pipe(Effect.flatMap(() => IdentityConflict.make()));
+
+              return IdentityConflict.make();
             }),
           );
         },

package/src/drizzle/native-clock.ts

@@ -0,0 +1,21 @@
+import type { ProofClock, SqlExpression } from "@yielded/auth-persistence/Adapter";
+import { is, SQL, sql } from "drizzle-orm";
+
+export type MappedClock = ProofClock<SQL> | ProofClock<SqlExpression>;
+export type ClockMapping<M> = Omit<M, "clock"> & { readonly clock: MappedClock };
+
+/** Shared storage mappings already accept native expressions. Only a clock
+ * declared with a real Drizzle SQL expression needs the foreign parameter bridge.
+ * Never probe callbacks by executing and retrying them with another representation. */
+export const nativeClock = (clock: MappedClock): ProofClock<SqlExpression> => {
+  if (!is(clock.engineNowMillis, SQL)) return clock as ProofClock<SqlExpression>;
+  // The physical expression identifies the callback family. This erases only
+  // foreign compiler variance; persisted times still use the declared codecs.
+  const drizzle = clock as ProofClock<SQL>;
+
+  return {
+    ...drizzle,
+    toMillis: (value) => drizzle.toMillis(sql`${sql.param(value)}`),
+    fromMillis: (value) => drizzle.fromMillis(sql`${sql.param(value)}`),
+  };
+};