@yielded/auth-persistence 0.1.0-beta.11 → 0.1.0-beta.12

package/src/internal/sql-persistence.ts

@@ -38,7 +38,7 @@ export const AuthPersistence: PersistenceApi<Table> & { readonly table: typeof t
           reason: "Use an explicit adapter for this SQL dialect",
         });
 
-      return makeSqlDatabase(sql, dialect);
+      return yield* makeSqlDatabase(dialect);
     }),
   }),
   table,

package/src/internal/sql-query.ts

@@ -1,5 +1,5 @@
 import { Effect, Predicate } from "effect";
-import type { SqlClient } from "effect/sql/SqlClient";
+import { SqlClient } from "effect/sql/SqlClient";
 import type { SqlError } from "effect/sql/SqlError";
 
 import { PersistenceMappingError } from "./mapping-error";
@@ -213,7 +213,9 @@ const compile = (state: QueryState, compiler: Compiler): string => {
 };
 
 /** Captures one Effect SQL client. Its transaction service remains the physical owner. */
-export const makeSqlDatabase = (client: SqlClient, dialect: Dialect): SqlDatabase => {
+export const makeSqlDatabase = Effect.fnUntraced(function* (dialect: Dialect) {
+  const client = yield* SqlClient;
+
   const query = (state: QueryState): Query => {
     const execute = Effect.suspend(() => {
       const compiler: Compiler = { dialect, parameters: [] };
@@ -267,7 +269,7 @@ export const makeSqlDatabase = (client: SqlClient, dialect: Dialect): SqlDatabas
   };
 
   return database;
-};
+});
 
 interface Query extends Effect.Effect<Row[], SqlError> {
   toSQL(): { readonly sql: string; readonly params: ReadonlyArray<unknown> };

package/src/internal/standalone.ts

@@ -4,17 +4,15 @@ import type * as SqlClient from "effect/sql/SqlClient";
 /** Standalone operations must observe their own durable commit. */
 export const requireStandalone = <Failure>(
   unavailable: () => Failure,
-  client?: {
-    readonly transactionService: Context.Key<
-      SqlClient.TransactionConnection,
-      SqlClient.TransactionConnection.Service
-    >;
-  },
+  transactionService?: Context.Key<
+    SqlClient.TransactionConnection,
+    SqlClient.TransactionConnection.Service
+  >,
 ): Effect.Effect<void, Failure> =>
   Effect.withFiber((fiber) => {
     const services = fiber.context.mapUnsafe;
 
-    if (client !== undefined && services.has(client.transactionService.key))
+    if (transactionService !== undefined && services.has(transactionService.key))
       return Effect.fail(unavailable());
 
     // rc.117 libSQL uses a private per-client marker that is not exposed through

package/src/internal/storage-validation.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import type { SqlClient } from "effect/sql/SqlClient";
+import { SqlClient } from "effect/sql/SqlClient";
 
 import { PersistenceConfigurationError } from "./configuration";
 import type { StorageTable } from "./storage-tables";
@@ -16,13 +16,14 @@ export const qualifiedTableName = (table: Pick<StorageTable, "name" | "schema">)
 
 /** Validate physical uniqueness before the first authentication operation. A
  * partial or expression index cannot establish these unconditional guarantees. */
-export const validateStorage = (
-  client: SqlClient,
-  dialect: "pg" | "sqlite",
-  table: StorageTable,
-  required: ReadonlyArray<ReadonlyArray<string>>,
-) =>
-  Effect.gen(function* () {
+export const validateStorage = Effect.fnUntraced(
+  function* (
+    dialect: "pg" | "sqlite",
+    table: StorageTable,
+    required: ReadonlyArray<ReadonlyArray<string>>,
+  ) {
+    const client = yield* SqlClient;
+
     const physicalKeys: ReadonlyArray<ReadonlyArray<string>> = yield* dialect === "sqlite"
       ? Effect.gen(function* () {
           if (table.schema !== undefined && table.schema !== "main")
@@ -106,12 +107,15 @@ export const validateStorage = (
           reason: `Missing unique key on ${table.name} (${keys.join(", ")})`,
         });
     }
-  }).pipe(
-    Effect.mapError((error) =>
-      Schema.is(PersistenceConfigurationError)(error)
-        ? error
-        : PersistenceConfigurationError.make({
-            reason: `Cannot validate SQL storage for ${table.name}`,
-          }),
+  },
+  (effect, _dialect, table) =>
+    effect.pipe(
+      Effect.mapError((error) =>
+        Schema.is(PersistenceConfigurationError)(error)
+          ? error
+          : PersistenceConfigurationError.make({
+              reason: `Cannot validate SQL storage for ${table.name}`,
+            }),
+      ),
     ),
-  );
+);

package/src/internal/transaction-execution-kernel.ts

@@ -14,6 +14,7 @@ import type { Statement } from "effect/sql/Statement";
 
 import { requireStandalone } from "./standalone";
 import {
+  NativeDatabase,
   type TransactionNativeDatabase,
   type TransactionOwner,
   type makeTransactionKernel,
@@ -23,7 +24,10 @@ export interface TransactionTargetConfiguration<Failure> {
   readonly mode: "interactive" | "synchronous" | "batch";
   readonly dialect: "pg" | "mysql" | "sqlite";
   readonly locking: boolean;
-  readonly standaloneGuard: (database: any) => Effect.Effect<void, Failure>;
+  /** The captured database's transaction marker; batch drivers may omit it. */
+  readonly standaloneGuard: (
+    transactionService: SqlClient.SqlClient["transactionService"] | undefined,
+  ) => Effect.Effect<void, Failure>;
   readonly transaction?: <A, E, R>(
     database: any,
     body: (transaction: any) => Effect.Effect<A, E, R>,
@@ -65,19 +69,18 @@ export const makeTransactionExecutionKernel = (
 
   const sqlClientTransactionStandaloneGuard = <Failure>(
     unavailable: () => Failure,
-    database: {
-      readonly $client: Pick<SqlClient.SqlClient, "transactionService">;
-    },
-  ) => requireStandalone(unavailable, database.$client);
+    transactionService: SqlClient.SqlClient["transactionService"] | undefined,
+  ) => requireStandalone(unavailable, transactionService);
 
-  const makeTransactionExecution = <Failure, OwnerId>(
+  const makeTransactionExecution = Effect.fnUntraced(function* <Failure, OwnerId>(
     ownerTag: Context.Key<OwnerId, TransactionOwner<Failure>>,
-    database: TransactionNativeDatabase,
     configuration: TransactionTargetConfiguration<Failure>,
     unavailable: () => Failure,
     nonce: () => string,
     bound?: TransactionBound<Failure>,
-  ): TransactionExecution<Failure, OwnerId> => {
+  ): Effect.fn.Return<TransactionExecution<Failure, OwnerId>, never, NativeDatabase> {
+    const database = yield* NativeDatabase;
+
     const invariant: (value: unknown) => asserts value = (value) => {
       if (!value) throw unavailable();
     };
@@ -90,7 +93,7 @@ export const makeTransactionExecutionKernel = (
           ? Effect.suspend(() => (bound.active ? Effect.void : Effect.fail(unavailable())))
           : Effect.gen(function* () {
               if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
-              yield* configuration.standaloneGuard(database);
+              yield* configuration.standaloneGuard(database.$client.transactionService);
             }),
       poison: () => {
         if (bound !== undefined) bound.poisoned = true;
@@ -144,7 +147,7 @@ export const makeTransactionExecutionKernel = (
                 )
               : Effect.gen(function* () {
                   if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
-                  yield* configuration.standaloneGuard(database);
+                  yield* configuration.standaloneGuard(database.$client.transactionService);
                   const marker = nonce();
 
                   const result = yield* coordinateCommit(
@@ -193,7 +196,7 @@ export const makeTransactionExecutionKernel = (
         });
       },
     };
-  };
+  });
 
   const coordinateTransactionOwner = <
     Failure,
@@ -225,7 +228,7 @@ export const makeTransactionExecutionKernel = (
   > => {
     return Effect.gen(function* () {
       if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
-      yield* configuration.standaloneGuard(database);
+      yield* configuration.standaloneGuard(database.$client.transactionService);
 
       // Allocation is independent of registration data and always precedes the physical owner.
       const resources = yield* allocate.pipe(
@@ -260,14 +263,13 @@ export const makeTransactionExecutionKernel = (
                 const value = yield* owner(
                   tx as Transaction,
                   services(
-                    makeTransactionExecution(
+                    yield* makeTransactionExecution(
                       ownerTag,
-                      tx,
                       configuration,
                       unavailable,
                       nonce,
                       bound,
-                    ),
+                    ).pipe(Effect.provideService(NativeDatabase, tx)),
                     resources,
                   ),
                   (statement) => {

package/src/internal/transaction-kernel.ts

@@ -1,7 +1,7 @@
 import { type CommitJournal, type PreparedCommit } from "@yielded/auth/Hooks";
 import { reportAuthFailure } from "@yielded/auth/Persistence";
 /* oxlint-disable no-explicit-any -- existing storage kernels erase foreign table shapes; domain errors remain typed. */
-import { Cause, Effect } from "effect";
+import { Cause, Context, Effect } from "effect";
 import type * as SqlClient from "effect/sql/SqlClient";
 import type { SqlError } from "effect/sql/SqlError";
 import type { Statement } from "effect/sql/Statement";
@@ -31,6 +31,12 @@ export interface TransactionNativeDatabase {
   ) => Effect.Effect<A, E | SqlError, R>;
 }
 
+/** Root native database required only while constructing standalone services.
+ * Active transactions remain owned by their coordinator and journal. */
+export class NativeDatabase extends Context.Service<NativeDatabase, TransactionNativeDatabase>()(
+  "effect-auth/persistence/NativeDatabase",
+) {}
+
 export interface Observation {
   readonly table: Table;
   readonly where: SQL;