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

package/src/drizzle/proof-model.ts

@@ -1,139 +1,28 @@
 import type * as Shared from "@yielded/auth-persistence/Adapter";
 import type { SQL, Table } from "drizzle-orm";
 
+import type { ClockMapping, MappedClock } from "./native-clock";
 import type { DrizzleTableModel } from "./table-model";
 
 export {
-  type ProofAction,
-  type ProofScopeKind,
-  type ProofGenerationState,
-  type ProofDeliveryState,
-  type ProofCommandKind,
-  type ProofCommandDecision,
-  type ProofScopeKeys,
-  type ProofAuthorityInput,
-  type ProofContinuationRecord,
   type RequiredProofConstraints,
   requiredProofConstraints,
-  type ProofConstraintClassifier,
 } from "@yielded/auth-persistence/Adapter";
 
-export type ProofAuthorityTables<
-  Subject extends Table,
-  Identifier extends Table,
-  Credential extends Table,
-  NativeSubjectId,
-> = Shared.ProofAuthorityTables<
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  NativeSubjectId,
-  SQL
->;
-
-export type ProofRequestTable<Request extends Table> = Shared.ProofRequestTable<
-  DrizzleTableModel<Request>
->;
-
-export type ProofSeriesTable<Series extends Table> = Shared.ProofSeriesTable<
-  DrizzleTableModel<Series>
->;
-
-export type ProofGenerationTable<Generation extends Table> = Shared.ProofGenerationTable<
-  DrizzleTableModel<Generation>
->;
-
-export type ProofContinuationTable<Continuation extends Table> = Shared.ProofContinuationTable<
-  DrizzleTableModel<Continuation>
->;
-
-export type ProofRateScopeTable<RateScope extends Table> = Shared.ProofRateScopeTable<
-  DrizzleTableModel<RateScope>
->;
-
-export type ProofAbuseEventTable<AbuseEvent extends Table> = Shared.ProofAbuseEventTable<
-  DrizzleTableModel<AbuseEvent>
->;
-
-export type ProofFailureEventTable<FailureEvent extends Table> = Shared.ProofFailureEventTable<
-  DrizzleTableModel<FailureEvent>
->;
-
-export type ProofCommandTable<Command extends Table> = Shared.ProofCommandTable<
-  DrizzleTableModel<Command>
->;
-
-export type ProofD1Clock = Shared.ProofD1Clock<SQL>;
+export type ProofTable<Proof extends Table> = Shared.ProofTable<DrizzleTableModel<Proof>>;
+export type ProofClock = MappedClock;
 
 export type ProofPersistenceMapping<
-  Request extends Table,
-  Series extends Table,
-  Generation extends Table,
-  Continuation extends Table,
-  RateScope extends Table,
-  AbuseEvent extends Table,
-  FailureEvent extends Table,
-  Command extends Table,
+  Proof extends Table,
   Subject extends Table,
-  Identifier extends Table,
-  Credential extends Table,
   NativeSubjectId,
-> = Shared.ProofPersistenceMapping<
-  DrizzleTableModel<Request>,
-  DrizzleTableModel<Series>,
-  DrizzleTableModel<Generation>,
-  DrizzleTableModel<Continuation>,
-  DrizzleTableModel<RateScope>,
-  DrizzleTableModel<AbuseEvent>,
-  DrizzleTableModel<FailureEvent>,
-  DrizzleTableModel<Command>,
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  NativeSubjectId,
-  SQL
+> = ClockMapping<
+  Shared.ProofPersistenceMapping<
+    DrizzleTableModel<Proof>,
+    DrizzleTableModel<Subject>,
+    NativeSubjectId,
+    SQL
+  >
 >;
 
-export type D1ProofPersistenceMapping<
-  Request extends Table,
-  Series extends Table,
-  Generation extends Table,
-  Continuation extends Table,
-  RateScope extends Table,
-  AbuseEvent extends Table,
-  FailureEvent extends Table,
-  Command extends Table,
-  Subject extends Table,
-  Identifier extends Table,
-  Credential extends Table,
-  NativeSubjectId,
-> = Shared.D1ProofPersistenceMapping<
-  DrizzleTableModel<Request>,
-  DrizzleTableModel<Series>,
-  DrizzleTableModel<Generation>,
-  DrizzleTableModel<Continuation>,
-  DrizzleTableModel<RateScope>,
-  DrizzleTableModel<AbuseEvent>,
-  DrizzleTableModel<FailureEvent>,
-  DrizzleTableModel<Command>,
-  DrizzleTableModel<Subject>,
-  DrizzleTableModel<Identifier>,
-  DrizzleTableModel<Credential>,
-  NativeSubjectId,
-  SQL
->;
-
-export type AnyProofPersistenceMapping = ProofPersistenceMapping<
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  Table,
-  unknown
->;
+export type AnyProofPersistenceMapping = ProofPersistenceMapping<Table, Table, unknown>;

package/src/drizzle/proof-target.ts

@@ -1,122 +1,58 @@
-import type { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import {
-  coordinateCommit,
-  hasCommitScope,
-  LifecycleHooks,
-  type HookConfigurationError,
-} from "@yielded/auth/Hooks";
+  makeNativeProofServices,
+  requireStandalone,
+  type AnyProofPersistenceMapping as SharedMapping,
+} from "@yielded/auth-persistence/Adapter";
 import { ProofUnavailable, ProofPersistence } from "@yielded/auth/Proofs";
-/* oxlint-disable no-explicit-any -- public driver entrypoints restore concrete Drizzle types. */
 import { Effect, Layer } from "effect";
-import type * as SqlError from "effect/sql/SqlError";
 
+import { nativeClock } from "./native-clock";
+import type { NativeDatabaseHandle } from "./native-database";
 import {
-  CurrentProofSql,
-  makeSqlProofPersistence,
-  type ProofSqlConfiguration,
-  type ProofSqlDatabase,
-  type ProofSqlQuery,
-} from "./proof-sql";
-import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
+  coordinateNativeTarget,
+  nativeTarget,
+  type NativeTargetConfiguration,
+} from "./native-target";
+import type { AnyProofPersistenceMapping } from "./proof-model";
 import { validateDrizzleStorage } from "./storage-validation";
 
-export interface ProofTargetConfiguration {
-  readonly mode: "interactive" | "synchronous";
-  readonly locking: boolean;
-  readonly standaloneGuard: Effect.Effect<void, ProofUnavailable>;
-  readonly coordinatorGuard?: Effect.Effect<void, ProofUnavailable>;
-  readonly insertIfAbsent: (
-    query: ProofSqlQuery,
-    selfKey: string,
-    selfValue: unknown,
-  ) => ProofSqlQuery;
-}
+const unavailable = () => ProofUnavailable.make({});
 
-interface TransactionOwner<Transaction> {
-  readonly transaction: <A, E, R>(
-    body: (transaction: Transaction) => Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E | SqlError.SqlError, R>;
-}
+export const sqlClientProofStandaloneGuard = (marker: Parameters<typeof requireStandalone>[1]) =>
+  requireStandalone(unavailable, marker);
 
-export type ProofCoordinatorError<E> =
-  | E
-  | ProofUnavailable
-  | HookConfigurationError
-  | SqlError.SqlError;
-
-export const sqlClientProofStandaloneGuard = (
-  service: TransactionService | undefined,
-): Effect.Effect<void, ProofUnavailable> =>
-  sqlClientStandaloneGuard(service, () => ProofUnavailable.make({}));
+export const nativeProofMapping = (value: AnyProofPersistenceMapping): SharedMapping => ({
+  ...value,
+  clock: nativeClock(value.clock),
+});
 
-const options = (
-  configuration: ProofTargetConfiguration,
-  coordinated = false,
-): ProofSqlConfiguration => ({
-  mode: configuration.mode,
-  locking: configuration.locking,
+export const makeTargetProofPersistenceServices = Effect.fnUntraced(function* (
+  source: AnyProofPersistenceMapping,
+  configuration: NativeTargetConfiguration,
+) {
+  yield* validateDrizzleStorage(source).pipe(Effect.mapError(unavailable));
+  if (configuration.mode === "batch" && source.d1?.primary !== true) return yield* unavailable();
+  const target = yield* nativeTarget(configuration);
 
-  standaloneGuard: !coordinated ? configuration.standaloneGuard : Effect.void,
-  insertIfAbsent: configuration.insertIfAbsent,
-  coordinated,
+  return yield* target.provide(makeNativeProofServices(target.tables, nativeProofMapping(source)));
 });
 
-export const makeTargetProofPersistenceServices = (
-  mapping: any,
-  configuration: ProofTargetConfiguration,
-) =>
-  Effect.gen(function* () {
-    return {
-      proofPersistence: yield* makeSqlProofPersistence(mapping, options(configuration)),
-    };
-  });
-
-/**
- * The native transaction is the root commit owner. Interruption or owner failure
- * rolls it back and discards the journal. No owner effect is retried. Native
- * transaction-acquisition `SqlError`s are exposed; caller errors, including
- * Drizzle query wrappers, propagate unchanged.
- */
 export const coordinateTargetProofPersistence = <Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  configuration: ProofTargetConfiguration,
-  owner: (
+  database: NativeDatabaseHandle,
+  source: AnyProofPersistenceMapping,
+  configuration: NativeTargetConfiguration,
+  body: (
     transaction: Transaction,
     services: { readonly proofPersistence: ProofPersistence["Service"] },
   ) => Effect.Effect<A, E, R>,
-): Effect.Effect<A, ProofCoordinatorError<E>, R | LifecycleHooks | NativeDatabase> =>
-  Effect.gen(function* (): Effect.fn.Return<
-    A,
-    ProofCoordinatorError<E>,
-    R | LifecycleHooks | NativeDatabase
-  > {
-    const hooks = yield* LifecycleHooks;
-
-    if (yield* hasCommitScope) return yield* ProofUnavailable.make({});
-    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
-
-    yield* validateDrizzleStorage(mapping).pipe(Effect.mapError(() => ProofUnavailable.make({})));
-
-    const result = yield* coordinateCommit(
-      () =>
-        database.transaction((transaction) =>
-          Effect.gen(function* () {
-            return yield* owner(transaction, {
-              proofPersistence: yield* makeSqlProofPersistence(
-                mapping,
-                options(configuration, true),
-              ).pipe(
-                Effect.provideService(CurrentProofSql, transaction as unknown as ProofSqlDatabase),
-              ),
-            });
-          }),
-        ),
-      { mode: configuration.mode },
-    ).pipe(Effect.provideService(LifecycleHooks, hooks));
-
-    return result.value;
-  });
+) =>
+  coordinateNativeTarget(
+    unavailable,
+    database,
+    configuration,
+    makeTargetProofPersistenceServices(source, configuration),
+    body,
+  );
 
 export const proofPersistenceLayer = <E, R>(
   services: Effect.Effect<{ readonly proofPersistence: ProofPersistence["Service"] }, E, R>,