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

package/src/drizzle/phone-state.ts

@@ -1,21 +0,0 @@
-import { makePhoneKernel } from "@yielded/auth-persistence/Adapter";
-
-import { drizzleQueryOperations } from "./query-operations";
-import { both, makeTransactionRows } from "./transaction-owner";
-export { CurrentPhoneTransaction } from "@yielded/auth-persistence/Adapter";
-
-const kernel = makePhoneKernel(drizzleQueryOperations, { both, makeTransactionRows });
-
-export const {
-  unavailable,
-  equal,
-  copiedRow,
-  col,
-  capturePhone,
-  lookupPhone,
-  admitPhone,
-  preparePhoneMutation,
-  cleanupPhoneAdmission,
-} = kernel;
-
-export const invariant: (value: unknown) => asserts value = kernel.invariant;

package/src/drizzle/proof-sql.ts

@@ -1,10 +0,0 @@
-import { makeProofKernel } from "@yielded/auth-persistence/Adapter";
-
-import { drizzleQueryOperations } from "./query-operations";
-export type { ProofSqlQuery } from "@yielded/auth-persistence/Adapter";
-export type { ProofSqlDatabase } from "@yielded/auth-persistence/Adapter";
-export { CurrentProofSql } from "@yielded/auth-persistence/Adapter";
-export type { ProofSqlConfiguration } from "@yielded/auth-persistence/Adapter";
-
-export const { makeSqlProofPersistence, checkProofCompletionIn, completeProofPlanIn } =
-  makeProofKernel(drizzleQueryOperations);

package/src/drizzle/query-operations.ts

@@ -1,49 +0,0 @@
-import type { QueryOperations } from "@yielded/auth-persistence/Adapter";
-import {
-  type SQL,
-  type AnyColumn,
-  and,
-  asc,
-  or,
-  eq,
-  ne,
-  gt,
-  gte,
-  lte,
-  inArray,
-  isNull,
-  isNotNull,
-  notExists,
-  sql,
-  getTableColumns,
-} from "drizzle-orm";
-
-import { balancedD1And, compactD1GeneratedStatement } from "./d1-generated-statement";
-import { column, updateValues } from "./model";
-import { validateDrizzleStorage } from "./storage-validation";
-
-const operations = {
-  validateStorage: validateDrizzleStorage,
-  and,
-  asc,
-  or,
-  eq,
-  ne,
-  gt,
-  gte,
-  lte,
-  inArray,
-  isNull,
-  isNotNull,
-  notExists,
-  sql,
-  getTableColumns,
-  column,
-  updateValues,
-  balancedD1And,
-  compactD1GeneratedStatement,
-};
-
-/** The shared kernel only passes tables and expressions from this compiler.
- * Erasure stops at query shapes; row codecs and Effect errors remain explicit. */
-export const drizzleQueryOperations = operations as unknown as QueryOperations<SQL, AnyColumn>;

package/src/drizzle/session-sql.ts

@@ -1,15 +0,0 @@
-import { makeSessionKernel } from "@yielded/auth-persistence/Adapter";
-
-import { makeDrizzleSqlTables } from "./native-sql-table";
-import { drizzleQueryOperations } from "./query-operations";
-export type { SessionSqlDatabase } from "@yielded/auth-persistence/Adapter";
-export { CurrentSessionSql } from "@yielded/auth-persistence/Adapter";
-export type { SessionSqlOptions } from "@yielded/auth-persistence/Adapter";
-
-export const {
-  makeSqlAuthenticationAuthority,
-  makeSqlPendingAuthentication,
-  makeSqlStatefulSessions,
-  makeSqlSignedValidity,
-  makeSqlSessionStepUp,
-} = makeSessionKernel(drizzleQueryOperations, makeDrizzleSqlTables);

package/src/drizzle/session-target.ts

@@ -1,337 +0,0 @@
-import type { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-import {
-  coordinateCommit,
-  hasCommitScope,
-  type LifecycleHooks,
-  type HookConfigurationError,
-} from "@yielded/auth/Hooks";
-import {
-  AuthenticationAuthority,
-  SessionUnavailable,
-  type PendingAuthentication,
-  type SessionRepository,
-  type SignedSessionValidity,
-  type StatefulSessionPersistence,
-  type SessionStepUpPersistence,
-} from "@yielded/auth/Sessions";
-/* oxlint-disable no-explicit-any -- target entrypoints restore each concrete Drizzle database/table type. */
-import { type Context, Effect, Layer } from "effect";
-import type * as SqlError from "effect/sql/SqlError";
-
-import {
-  makeSqlAuthenticationAuthority,
-  makeSqlPendingAuthentication,
-  makeSqlSignedValidity,
-  makeSqlStatefulSessions,
-  makeSqlSessionStepUp,
-  CurrentSessionSql,
-  type SessionSqlDatabase,
-  type SessionSqlOptions,
-} from "./session-sql";
-import { sqlClientStandaloneGuard, type TransactionService } from "./standalone-guard";
-import { validateDrizzleStorage } from "./storage-validation";
-
-export interface SessionTargetConfiguration {
-  readonly mode: "interactive" | "synchronous";
-  readonly locking: boolean;
-  readonly standaloneGuard: Effect.Effect<void, SessionUnavailable>;
-  readonly coordinatorGuard?: Effect.Effect<void, SessionUnavailable>;
-}
-
-interface TransactionOwner<Transaction> {
-  readonly transaction: <A, E, R>(
-    body: (transaction: Transaction) => Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E | SqlError.SqlError, R>;
-}
-
-type CoordinatorError<E> = E | SessionUnavailable | HookConfigurationError | SqlError.SqlError;
-
-export const sqlClientSessionStandaloneGuard = (
-  service: TransactionService | undefined,
-): Effect.Effect<void, SessionUnavailable> =>
-  sqlClientStandaloneGuard(service, () => SessionUnavailable.make({}));
-
-const options = (
-  configuration: SessionTargetConfiguration,
-  transactionBound = false,
-): SessionSqlOptions => ({
-  coordinated: transactionBound,
-  mode: configuration.mode,
-  locking: configuration.locking,
-  standaloneGuard: transactionBound ? Effect.void : configuration.standaloneGuard,
-});
-
-export const makeTargetAuthenticationAuthorityServices = <Claims>(
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-) =>
-  Effect.map(
-    makeSqlAuthenticationAuthority<Claims>(mapping, options(configuration)),
-    (authenticationAuthority) => ({ authenticationAuthority }),
-  );
-
-export const makeTargetPendingAuthenticationServices = <Claims>(
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-) =>
-  Effect.map(
-    makeSqlPendingAuthentication<Claims>(mapping, options(configuration)),
-    (pendingAuthentication) => ({ pendingAuthentication }),
-  );
-
-export const makeTargetStatefulSessionServices = <Claims>(
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-) => makeSqlStatefulSessions<Claims>(mapping, options(configuration));
-
-export const makeTargetSignedSessionValidityServices = (
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-) =>
-  Effect.map(makeSqlSignedValidity(mapping, options(configuration)), (signedSessionValidity) => ({
-    signedSessionValidity,
-  }));
-
-/**
- * The native transaction is the root commit owner. Interruption or owner
- * failure rolls it back and discards the child journal; this adapter performs
- * no hidden retry. A caller that can safely retry must rerun the complete owner
- * operation and prepare fresh bearer material. The low-level coordinator keeps
- * caller failures intact, including Drizzle query wrappers, and exposes a
- * native `SqlError` when transaction acquisition fails. Captured service
- * operations normalize their own driver failures to `SessionUnavailable`.
- */
-const coordinate = <Transaction, Services, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  configuration: SessionTargetConfiguration,
-  mapping: object,
-  make: (
-    transaction: Transaction,
-  ) => Effect.Effect<Services, SessionUnavailable, LifecycleHooks | NativeDatabase>,
-  owner: (transaction: Transaction, services: Services) => Effect.Effect<A, E, R>,
-): Effect.Effect<A, CoordinatorError<E>, R | LifecycleHooks | NativeDatabase> =>
-  Effect.gen(function* (): Effect.fn.Return<
-    A,
-    CoordinatorError<E>,
-    R | LifecycleHooks | NativeDatabase
-  > {
-    if (yield* hasCommitScope) return yield* SessionUnavailable.make({});
-    yield* configuration.coordinatorGuard ?? configuration.standaloneGuard;
-
-    yield* validateDrizzleStorage(mapping).pipe(Effect.mapError(() => SessionUnavailable.make({})));
-
-    const result = yield* coordinateCommit(
-      () =>
-        database.transaction((transaction) =>
-          Effect.gen(function* () {
-            const services = yield* make(transaction);
-
-            return yield* owner(transaction, services);
-          }).pipe(
-            Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
-          ),
-        ),
-      { mode: configuration.mode },
-    );
-
-    return result.value;
-  });
-
-export const coordinateTargetAuthenticationAuthority = <Claims, Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-  owner: (
-    transaction: Transaction,
-    services: { readonly authenticationAuthority: AuthenticationAuthority["Service"] },
-  ) => Effect.Effect<A, E, R>,
-) =>
-  coordinate(
-    database,
-    configuration,
-    mapping,
-    (transaction) =>
-      Effect.map(
-        makeSqlAuthenticationAuthority<Claims>(mapping, options(configuration, true)).pipe(
-          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
-        ),
-        (authenticationAuthority) => ({ authenticationAuthority }),
-      ),
-    owner,
-  );
-
-export const coordinateTargetPendingAuthentication = <Claims, Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-  owner: (
-    transaction: Transaction,
-    services: { readonly pendingAuthentication: PendingAuthentication<Claims> },
-  ) => Effect.Effect<A, E, R>,
-) =>
-  coordinate(
-    database,
-    configuration,
-    mapping,
-    (transaction) =>
-      Effect.map(
-        makeSqlPendingAuthentication<Claims>(mapping, options(configuration, true)).pipe(
-          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
-        ),
-        (pendingAuthentication) => ({ pendingAuthentication }),
-      ),
-    owner,
-  );
-
-export const coordinateTargetStatefulSessions = <Claims, Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-  owner: (
-    transaction: Transaction,
-    services: {
-      readonly statefulSessionPersistence: StatefulSessionPersistence<Claims>;
-      readonly sessionRepository: SessionRepository;
-    },
-  ) => Effect.Effect<A, E, R>,
-) =>
-  coordinate(
-    database,
-    configuration,
-    mapping,
-    (transaction) =>
-      makeSqlStatefulSessions<Claims>(mapping, options(configuration, true)).pipe(
-        Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
-      ),
-    owner,
-  );
-
-export const coordinateTargetSignedSessionValidity = <Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  configuration: SessionTargetConfiguration,
-  owner: (
-    transaction: Transaction,
-    services: { readonly signedSessionValidity: SignedSessionValidity },
-  ) => Effect.Effect<A, E, R>,
-) =>
-  coordinate(
-    database,
-    configuration,
-    mapping,
-    (transaction) =>
-      Effect.map(
-        makeSqlSignedValidity(mapping, options(configuration, true)).pipe(
-          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
-        ),
-        (signedSessionValidity) => ({ signedSessionValidity }),
-      ),
-    owner,
-  );
-
-export const authenticationAuthorityLayer = <E, R>(
-  services: Effect.Effect<
-    {
-      readonly authenticationAuthority: AuthenticationAuthority["Service"];
-    },
-    E,
-    R
-  >,
-) =>
-  Layer.effect(
-    AuthenticationAuthority,
-    Effect.map(services, (value) => value.authenticationAuthority),
-  );
-
-export const statefulSessionLayers = <Claims, E, R>(
-  module: {
-    readonly StatefulSessionPersistence: any;
-    readonly SessionRepository: any;
-  },
-  services: Effect.Effect<
-    {
-      readonly statefulSessionPersistence: StatefulSessionPersistence<Claims>;
-      readonly sessionRepository: SessionRepository;
-    },
-    E,
-    R
-  >,
-) =>
-  Layer.merge(
-    Layer.effect(
-      module.StatefulSessionPersistence,
-      Effect.map(services, (value) => value.statefulSessionPersistence),
-    ),
-    Layer.effect(
-      module.SessionRepository,
-      Effect.map(services, (value) => value.sessionRepository),
-    ),
-  );
-
-export const pendingAuthenticationLayer = <Claims, E, R>(
-  module: { readonly PendingAuthentication: any },
-  services: Effect.Effect<
-    {
-      readonly pendingAuthentication: PendingAuthentication<Claims>;
-    },
-    E,
-    R
-  >,
-) =>
-  Layer.effect(
-    module.PendingAuthentication,
-    Effect.map(services, (value) => value.pendingAuthentication),
-  );
-
-export const signedSessionValidityLayer = <E, R>(
-  module: { readonly SignedSessionValidity: any },
-  services: Effect.Effect<
-    {
-      readonly signedSessionValidity: SignedSessionValidity;
-    },
-    E,
-    R
-  >,
-) =>
-  Layer.effect(
-    module.SignedSessionValidity,
-    Effect.map(services, (value) => value.signedSessionValidity),
-  );
-
-export const makeTargetSessionStepUpServices = <Claims, Id>(
-  mapping: any,
-  target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
-  configuration: SessionTargetConfiguration,
-) =>
-  Effect.map(
-    makeSqlSessionStepUp<Claims>(mapping, options(configuration)),
-    (sessionStepUpPersistence) => ({
-      sessionStepUpPersistence: target.of(sessionStepUpPersistence),
-    }),
-  );
-
-export const coordinateTargetSessionStepUp = <Claims, Id, Transaction, A, E, R>(
-  database: TransactionOwner<Transaction>,
-  mapping: any,
-  target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
-  configuration: SessionTargetConfiguration,
-  owner: (
-    transaction: Transaction,
-    services: { readonly sessionStepUpPersistence: SessionStepUpPersistence<Claims> },
-  ) => Effect.Effect<A, E, R>,
-) =>
-  coordinate(
-    database,
-    configuration,
-    mapping,
-    (transaction) =>
-      Effect.map(
-        makeSqlSessionStepUp<Claims>(mapping, options(configuration, true)).pipe(
-          Effect.provideService(CurrentSessionSql, transaction as unknown as SessionSqlDatabase),
-        ),
-        (sessionStepUpPersistence) => ({
-          sessionStepUpPersistence: target.of(sessionStepUpPersistence),
-        }),
-      ),
-    owner,
-  );