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

package/src/internal/sql-expression.ts

@@ -0,0 +1,94 @@
+import type { SqlClient } from "effect/sql/SqlClient";
+import * as Statement from "effect/sql/Statement";
+
+import { PersistenceMappingError } from "./mapping-error";
+import { Column, identifier, Table } from "./sql-table";
+
+/** Pure mapped SQL. Compilation binds values through the executing client's
+ * dialect; expressions neither acquire a client nor execute a query. */
+export class SqlExpression {
+  constructor(readonly compile: (client: SqlClient) => Statement.Fragment) {}
+}
+
+const quoted = (client: SqlClient, name: string) => {
+  if (name.includes("\0"))
+    throw PersistenceMappingError.make({ operation: "mapping", cause: "NUL in SQL identifier" });
+
+  return client.literal(identifier(name));
+};
+
+const tableName = (client: SqlClient, name: string, schema?: string) =>
+  schema === undefined
+    ? quoted(client, name)
+    : client`${quoted(client, schema)}.${quoted(client, name)}`;
+
+const value = (client: SqlClient, input: unknown): Statement.Fragment => {
+  if (Statement.isFragment(input)) return input;
+  if (input instanceof SqlExpression) return input.compile(client);
+  if (input instanceof Table) return tableName(client, input.name, input.schema);
+  if (input instanceof Column)
+    return client`${tableName(client, input.tableName, input.schema)}.${quoted(client, input.options.name)}`;
+
+  return Statement.fragment([
+    Statement.parameter(
+      typeof input === "boolean"
+        ? client.onDialectOrElse({ sqlite: () => Number(input), orElse: () => input })
+        : input,
+    ),
+  ]);
+};
+
+/** Reject foreign expression handles at the metadata boundary. */
+export const compileSqlExpression = (
+  client: SqlClient,
+  expression: unknown,
+): Statement.Fragment => {
+  if (
+    !Statement.isFragment(expression) &&
+    !(expression instanceof SqlExpression) &&
+    !(expression instanceof Table) &&
+    !(expression instanceof Column)
+  )
+    throw PersistenceMappingError.make({
+      operation: "mapping",
+      cause: "Expected a SQL expression",
+    });
+
+  return value(client, expression);
+};
+
+const template = (parts: TemplateStringsArray, ...values: ReadonlyArray<unknown>) =>
+  new SqlExpression((client) =>
+    client.join(
+      "",
+      false,
+    )(
+      parts.flatMap((part, index) =>
+        index === 0
+          ? [client.literal(part)]
+          : [value(client, values[index - 1]), client.literal(part)],
+      ),
+    ),
+  );
+
+export const sql = Object.assign(template, {
+  join: (values: ReadonlyArray<unknown>, separator: SqlExpression = template``) =>
+    new SqlExpression((client) =>
+      client.join(
+        "",
+        false,
+      )(
+        values.flatMap((input, index) =>
+          index === 0 ? [value(client, input)] : [separator.compile(client), value(client, input)],
+        ),
+      ),
+    ),
+});
+
+export const eq = (left: unknown, right: unknown): SqlExpression => sql`${left} = ${right}`;
+
+export const and = (...expressions: ReadonlyArray<SqlExpression | undefined>) => {
+  const present = expressions.filter((expression) => expression !== undefined);
+
+  return present.length === 0 ? undefined : sql`(${sql.join(present, sql` AND `)})`;
+};

package/src/internal/sql-metadata.ts

@@ -0,0 +1,100 @@
+import { Effect } from "effect";
+import type { SqlClient } from "effect/sql/SqlClient";
+import type { Fragment } from "effect/sql/Statement";
+
+import { PersistenceMappingError } from "./mapping-error";
+import { identifier, Table } from "./sql-table";
+
+/** Physical names are components, so a literal dot in a mapped name stays quoted. */
+export const sqlName = (sql: SqlClient, name: string): Fragment => sql.literal(identifier(name));
+
+export const sqlTable = (sql: SqlClient, table: Table): Fragment =>
+  sql.literal(
+    (table.schema === undefined ? "" : identifier(table.schema) + ".") + identifier(table.name),
+  );
+
+export const sqlColumn = (sql: SqlClient, table: Table, key: string, alias?: string): Fragment =>
+  sql`${alias === undefined ? sqlTable(sql, table) : sqlName(sql, alias)}.${sqlName(sql, table.columns[key]!.options.name)}`;
+
+export const sqlProjection = (
+  sql: SqlClient,
+  table: Table,
+  alias?: string,
+  prefix = "",
+): Fragment =>
+  sql.csv(
+    Object.keys(table.columns).map(
+      (key) => sql`${sqlColumn(sql, table, key, alias)} as ${sqlName(sql, prefix + key)}`,
+    ),
+  );
+
+export const sqlValue = (sql: SqlClient, table: Table, key: string, value: unknown): unknown =>
+  table.columns[key]!.options.type === "boolean" && typeof value === "boolean"
+    ? sql.onDialectOrElse({ sqlite: () => Number(value), orElse: () => value })
+    : value;
+
+export const sqlInsert = (
+  sql: SqlClient,
+  table: Table,
+  values: Readonly<Record<string, unknown>>,
+): Fragment => {
+  // The built-in insert/update helpers split dots in names and flatten SQL
+  // expression values. Keep physical name components and interpolated values.
+  const keys = Object.keys(table.columns).filter((key) => values[key] !== undefined);
+
+  return sql`(${sql.csv(keys.map((key) => sqlName(sql, table.columns[key]!.options.name)))}) values (${sql.csv(keys.map((key) => sql`${sqlValue(sql, table, key, values[key])}`))})`;
+};
+
+export const sqlInsertMany = (
+  sql: SqlClient,
+  table: Table,
+  rows: ReadonlyArray<Readonly<Record<string, unknown>>>,
+): Fragment => {
+  const keys = Object.keys(table.columns).filter((key) => rows[0]?.[key] !== undefined);
+
+  return sql`(${sql.csv(keys.map((key) => sqlName(sql, table.columns[key]!.options.name)))}) values ${sql.csv(rows.map((row) => sql`(${sql.csv(keys.map((key) => sql`${sqlValue(sql, table, key, row[key])}`))})`))}`;
+};
+
+export const sqlUpdate = (
+  sql: SqlClient,
+  table: Table,
+  values: Readonly<Record<string, unknown>>,
+): Fragment =>
+  sql.csv(
+    Object.entries(values)
+      .filter(([key, value]) => table.columns[key] !== undefined && value !== undefined)
+      .map(
+        ([key, value]) =>
+          sql`${sqlName(sql, table.columns[key]!.options.name)} = ${sqlValue(sql, table, key, value)}`,
+      ),
+  );
+
+export const decodeSqlRow = (table: Table, row: Readonly<Record<string, unknown>>, prefix = "") =>
+  Effect.try({
+    try: () =>
+      Object.fromEntries(
+        Object.entries(table.columns).map(([key, column]) => [
+          key,
+          column.decode(row[prefix + key]),
+        ]),
+      ),
+    catch: (cause) => PersistenceMappingError.make({ operation: "decode", cause }),
+  });
+
+export const requireSqlTable = (table: object): Table => {
+  if (!(table instanceof Table))
+    throw PersistenceMappingError.make({ operation: "mapping", cause: "Invalid SQL table" });
+
+  return table;
+};
+
+/** CTE names share a namespace with unqualified application tables. */
+export const sqlAlias = (tables: ReadonlyArray<Table | undefined>, name: string): string => {
+  const occupied = new Set(
+    tables.flatMap((table) => (table === undefined ? [] : [table.name.toLowerCase()])),
+  );
+
+  while (occupied.has(name.toLowerCase())) name += "_";
+
+  return name;
+};

package/src/internal/sql-oauth-connected-model.ts

@@ -1,144 +1,55 @@
-import * as Shared from "./models/oauth-connected-model";
+import type * as Shared from "./models/oauth-connected-model";
+import type { SqlExpression as SQL } from "./sql-expression";
 import type { SqlTableModel } from "./sql-oauth-model";
-import type { Fragment as SQL, Table } from "./sql-table";
+import type { Table } from "./sql-table";
 
 export {
   type OAuthConnectedAction,
-  type OAuthConnectedOrderCodec,
   type OAuthConnectedPolicyInput,
   requiredOAuthConnectedConstraints,
   requiredOAuthConnectedRevocationConstraints,
 } from "./models/oauth-connected-model";
 
-export type OAuthConnectedSubjectTable<S extends Table> = Shared.OAuthConnectedSubjectTable<
-  SqlTableModel<S>,
-  SQL
->;
-
-export type OAuthConnectedFlowTable<F extends Table, N> = Shared.OAuthConnectedFlowTable<
-  SqlTableModel<F>,
-  N
->;
-
 export type OAuthConnectedGrantTable<G extends Table, N> = Shared.OAuthConnectedGrantTable<
   SqlTableModel<G>,
   N
 >;
 
-/** Also stores a permanent provider/issuer scope anchor. clientKey must fit 52
- * ASCII characters. Empty clientRegistrationId is reserved for that anchor;
- * actual profile registrations are nonempty. Scope counter stays zero. */
-export type OAuthConnectedClientRegistrationTable<C extends Table> =
-  Shared.OAuthConnectedClientRegistrationTable<SqlTableModel<C>>;
-
-/** Remote authority: no local-subject column or subject-scoped key. Retain this
- * anchor/cutoff when a legitimately released tuple gains a different local owner. */
-export type OAuthConnectedCohortTable<C extends Table> = Shared.OAuthConnectedCohortTable<
-  SqlTableModel<C>
->;
-
-export type OAuthConnectedAdmissionTable<A extends Table, N> = Shared.OAuthConnectedAdmissionTable<
-  SqlTableModel<A>,
-  N
->;
-
-export type OAuthConnectedCommandTable<C extends Table, N> = Shared.OAuthConnectedCommandTable<
-  SqlTableModel<C>,
-  N
->;
-
 export type OAuthConnectedRevocationJobTable<
   J extends Table,
   N,
 > = Shared.OAuthConnectedRevocationJobTable<SqlTableModel<J>, N>;
 
-export type OAuthConnectedPolicyGuardTable<
-  T extends Table,
-  N,
-> = Shared.OAuthConnectedPolicyGuardTable<SqlTableModel<T>, N, SQL>;
-
-export type OAuthConnectedPolicyGuard<N> = Shared.OAuthConnectedPolicyGuard<N, SQL, Table>;
-
-export const oauthConnectedPolicyGuard = <T extends Table, N>(
-  input: OAuthConnectedPolicyGuardTable<T, N>,
-): OAuthConnectedPolicyGuard<N> =>
-  Shared.oauthConnectedPolicyGuard<SqlTableModel<T>, N, SQL>(input);
-
-export type OAuthConnectedSqlPolicy<N> = Shared.OAuthConnectedSqlPolicy<N, SQL, Table>;
-
-/** Existing ownership only; workers never allocate or acquire a tuple. */
-export type OAuthConnectedOwnershipRead<
-  T extends Table,
-  O extends Table,
-  N,
-> = Shared.OAuthConnectedOwnershipRead<SqlTableModel<T>, SqlTableModel<O>, N, SQL>;
-
-export type OAuthConnectedAuthorityMapping<
-  T extends Table,
-  O extends Table,
-  F extends Table,
-  G extends Table,
-  C extends Table,
-  H extends Table,
-  N,
-> = Shared.OAuthConnectedAuthorityMapping<
-  SqlTableModel<T>,
-  SqlTableModel<O>,
-  SqlTableModel<F>,
-  SqlTableModel<G>,
-  SqlTableModel<C>,
-  SqlTableModel<H>,
-  N,
-  SQL
->;
+export type OAuthConnectedSqlPolicy<N> = Shared.OAuthConnectedSqlPolicy<N, SQL>;
 
 export type OAuthConnectedMapping<
   S extends Table,
   AC extends Table,
-  T extends Table,
   O extends Table,
   F extends Table,
   G extends Table,
-  C extends Table,
-  H extends Table,
-  A extends Table,
-  D extends Table,
   N,
-  J extends Table = never,
+  J extends Table = Table,
 > = Shared.OAuthConnectedMapping<
   SqlTableModel<S>,
   SqlTableModel<AC>,
-  SqlTableModel<T>,
   SqlTableModel<O>,
   SqlTableModel<F>,
   SqlTableModel<G>,
-  SqlTableModel<C>,
-  SqlTableModel<H>,
-  SqlTableModel<A>,
-  SqlTableModel<D>,
   N,
   SqlTableModel<J>,
   SQL,
-  Table,
-  SqlTableModel<Table>
+  SqlTableModel
 >;
 
 export type OAuthConnectedRevocationMapping<
-  T extends Table,
   O extends Table,
-  F extends Table,
   G extends Table,
-  C extends Table,
-  H extends Table,
   J extends Table,
   N,
 > = Shared.OAuthConnectedRevocationMapping<
-  SqlTableModel<T>,
   SqlTableModel<O>,
-  SqlTableModel<F>,
   SqlTableModel<G>,
-  SqlTableModel<C>,
-  SqlTableModel<H>,
   SqlTableModel<J>,
   N,
   SQL

package/src/internal/sql-oauth-model.ts

@@ -1,27 +1,21 @@
 import * as Shared from "./models/oauth-model";
-import type { TableModel } from "./query-operations";
-import type { Fragment as SQL, Table } from "./sql-table";
+import type { SqlExpression as SQL } from "./sql-expression";
+import type { Table } from "./sql-table";
+import type { TableModel } from "./table-model";
 
 export interface SqlTableModel<T extends Table = Table> extends TableModel {
   readonly table: T;
 }
 
 export {
-  type OAuthFlowState,
-  type OAuthTupleState,
-  type OAuthRegistrationState,
   type OAuthAction,
   type OAuthEligibilityFact,
   type OAuthD1Mapping,
+  type OAuthRegistrationAuthority,
   requiredOAuthSignInConstraints,
-  requiredOAuthTupleConstraints,
   requiredOAuthRegistrationConstraints,
-  requiredOAuthAccountsConstraints,
-  type OAuthRegistrationAuthority,
 } from "./models/oauth-model";
 
-/** The engine writes every critical column explicitly after applying the pure
- * consumer encoder. Native instant values must roundtrip without precision loss. */
 export type OAuthClock = Shared.OAuthClock<SQL>;
 
 export type OAuthSubjectReadTable<S extends Table> = Shared.OAuthSubjectReadTable<
@@ -33,14 +27,12 @@ export type OAuthSubjectTable<S extends Table> = Shared.OAuthSubjectTable<SqlTab
 
 export type OAuthOwnershipReadTable<O extends Table, N> = Shared.OAuthOwnershipReadTable<
   SqlTableModel<O>,
-  N,
-  SQL
+  N
 >;
 
 export type OAuthOwnershipTable<O extends Table, N> = Shared.OAuthOwnershipTable<
   SqlTableModel<O>,
-  N,
-  SQL
+  N
 >;
 
 export type OAuthCredentialReadTable<C extends Table> = Shared.OAuthCredentialReadTable<
@@ -65,51 +57,36 @@ export type OAuthAuthorityTable<C extends Table, N> = Shared.OAuthAuthorityTable
   SQL
 >;
 
-/** Both purposes may use the same physical table. Shared tables share module/flow
- * and module/command uniqueness. The snapshot has the exact purpose-specific core
- * codec; terminal writes erase it, while identity, claim and retention columns remain. */
 export type OAuthFlowTable<F extends Table> = Shared.OAuthFlowTable<SqlTableModel<F>>;
 
-export type OAuthTupleAuthorityTable<T extends Table, N> = Shared.OAuthTupleAuthorityTable<
-  SqlTableModel<T>,
-  N
->;
-
 export type OAuthRegistrationIntentTable<I extends Table> = Shared.OAuthRegistrationIntentTable<
   SqlTableModel<I>
 >;
 
-export type OAuthRegistrationCommandTable<
-  R extends Table,
-  Registration,
-> = Shared.OAuthRegistrationCommandTable<SqlTableModel<R>, Registration>;
-
-export type OAuthUnlinkCommandTable<U extends Table> = Shared.OAuthUnlinkCommandTable<
-  SqlTableModel<U>
->;
-
-/** Each descriptor reads only its own subject-scoped method rows. The native row
- * projector and SQL condition must express the same installed method eligibility.
- * All source/identifier/policy mutations advance subject securityRevision. D1 also
- * guards exact selected IDs/versions and absence/count assumptions, never just a
- * stale boolean. An over-limit graph fails closed rather than truncating. */
 export type OAuthEligibilityTable<T extends Table, N> = Shared.OAuthEligibilityTable<
   SqlTableModel<T>,
   N,
   SQL
 >;
 
-/** Authenticated command replay uses current subject status and this additional
- * nonconsuming SQL policy. It never consumes a fresh action factor. */
-export type OAuthMetadataPolicy<N> = Shared.OAuthMetadataPolicy<N, SQL>;
-
 export type OAuthCleanupTable<T extends Table, N> = Shared.OAuthCleanupTable<
   SqlTableModel<T>,
   N,
   SQL
 >;
 
-export type OAuthRegistrationEligibility<N> = Shared.OAuthRegistrationEligibility<N, SQL>;
+export type OAuthRegistrationGuardTable<
+  T extends Table,
+  Registration,
+  N,
+> = Shared.OAuthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>;
+
+export type OAuthRegistrationGuardDescriptor<Registration, N> =
+  Shared.OAuthRegistrationGuardDescriptor<Registration, N, SQL, Table>;
+
+export type OAuthEligibilityDescriptor<N> = Shared.OAuthEligibilityDescriptor<N, SQL, Table>;
+
+export type OAuthCleanupDescriptor<N> = Shared.OAuthCleanupDescriptor<N, SQL, Table>;
 
 export type OAuthSignInMapping<
   S extends Table,
@@ -128,64 +105,29 @@ export type OAuthSignInMapping<
   SQL
 >;
 
-export type OAuthOwnershipMutation<
-  T extends Table,
-  O extends Table,
-  N,
-> = Shared.OAuthOwnershipMutation<SqlTableModel<T>, SqlTableModel<O>, N, SQL>;
-
-export type OAuthRegistrationIntentMapping<
+export type OAuthAccountsMapping<
   S extends Table,
   O extends Table,
   C extends Table,
   AC extends Table,
   F extends Table,
-  T extends Table,
-  I extends Table,
   N,
-> = Shared.OAuthRegistrationIntentMapping<
+> = Shared.OAuthAccountsMapping<
   SqlTableModel<S>,
   SqlTableModel<O>,
   SqlTableModel<C>,
   SqlTableModel<AC>,
   SqlTableModel<F>,
-  SqlTableModel<T>,
-  SqlTableModel<I>,
-  N,
-  SQL
->;
-
-export type OAuthRegistrationBase<
-  Registration,
-  T extends Table,
-  O extends Table,
-  I extends Table,
-  R extends Table,
-  N,
-> = Shared.OAuthRegistrationBase<
-  Registration,
-  SqlTableModel<T>,
-  SqlTableModel<O>,
-  SqlTableModel<I>,
-  SqlTableModel<R>,
   N,
   SQL,
   Table
 >;
 
-export type OAuthRegistrationGuardTable<
-  T extends Table,
-  Registration,
+export type OAuthRegistrationIntentMapping<
+  O extends Table,
+  I extends Table,
   N,
-> = Shared.OAuthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>;
-
-export type OAuthRegistrationGuardDescriptor<Registration, N> =
-  Shared.OAuthRegistrationGuardDescriptor<Registration, N, SQL, Table>;
-
-export const oauthRegistrationGuardTable = <T extends Table, Registration, N>(
-  input: OAuthRegistrationGuardTable<T, Registration, N>,
-): OAuthRegistrationGuardDescriptor<Registration, N> =>
-  Shared.oauthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>(input);
+> = Shared.OAuthRegistrationIntentMapping<SqlTableModel<O>, SqlTableModel<I>, N, SQL>;
 
 export type OAuthRegistrationMapping<
   Registration,
@@ -193,9 +135,7 @@ export type OAuthRegistrationMapping<
   O extends Table,
   C extends Table,
   AC extends Table,
-  T extends Table,
   I extends Table,
-  R extends Table,
   N,
 > = Shared.OAuthRegistrationMapping<
   Registration,
@@ -203,61 +143,18 @@ export type OAuthRegistrationMapping<
   SqlTableModel<O>,
   SqlTableModel<C>,
   SqlTableModel<AC>,
-  SqlTableModel<T>,
   SqlTableModel<I>,
-  SqlTableModel<R>,
   N,
   SQL,
   Table
 >;
 
-/** Heterogeneous descriptors are made by typed factories and projected privately. */
-export type OAuthEligibilityDescriptor<N> = Shared.OAuthEligibilityDescriptor<N, SQL, Table>;
-
-export const oauthEligibilityTable = <T extends Table, N>(
-  input: OAuthEligibilityTable<T, N>,
-): OAuthEligibilityDescriptor<N> => Shared.oauthEligibilityTable<SqlTableModel<T>, N, SQL>(input);
-
-export type OAuthCleanupDescriptor<N> = Shared.OAuthCleanupDescriptor<N, SQL, Table>;
-
-export const oauthCleanupTable = <T extends Table, N>(
-  input: OAuthCleanupTable<T, N>,
-): OAuthCleanupDescriptor<N> => Shared.oauthCleanupTable<SqlTableModel<T>, N, SQL>(input);
-
-/** A stable application/reference lock acquired before an ownership target.
- * Missing rows retain ownership. Conditions use detached native IDs; every
- * writer of the guarded reference follows the same order. */
-export type OAuthReferenceGuardTable<T extends Table, N> = Shared.OAuthReferenceGuardTable<
-  SqlTableModel<T>,
-  N,
-  SQL
->;
-
-export type OAuthReferenceGuardDescriptor<N> = Shared.OAuthReferenceGuardDescriptor<N, SQL, Table>;
+export const oauthEligibilityTable = <T extends Table, N>(input: OAuthEligibilityTable<T, N>) =>
+  Shared.oauthEligibilityTable<SqlTableModel<T>, N, SQL>(input);
 
-export const oauthReferenceGuardTable = <T extends Table, N>(
-  input: OAuthReferenceGuardTable<T, N>,
-): OAuthReferenceGuardDescriptor<N> =>
-  Shared.oauthReferenceGuardTable<SqlTableModel<T>, N, SQL>(input);
+export const oauthCleanupTable = <T extends Table, N>(input: OAuthCleanupTable<T, N>) =>
+  Shared.oauthCleanupTable<SqlTableModel<T>, N, SQL>(input);
 
-export type OAuthAccountsMapping<
-  S extends Table,
-  O extends Table,
-  C extends Table,
-  AC extends Table,
-  F extends Table,
-  T extends Table,
-  U extends Table,
-  N,
-> = Shared.OAuthAccountsMapping<
-  SqlTableModel<S>,
-  SqlTableModel<O>,
-  SqlTableModel<C>,
-  SqlTableModel<AC>,
-  SqlTableModel<F>,
-  SqlTableModel<T>,
-  SqlTableModel<U>,
-  N,
-  SQL,
-  Table
->;
+export const oauthRegistrationGuardTable = <T extends Table, Registration, N>(
+  input: OAuthRegistrationGuardTable<T, Registration, N>,
+) => Shared.oauthRegistrationGuardTable<SqlTableModel<T>, Registration, N, SQL>(input);

package/src/internal/sql-persistence.ts

@@ -3,9 +3,7 @@ import { SqlClient } from "effect/sql";
 
 import { PersistenceConfigurationError, type PersistenceApi } from "./configuration";
 import { makeNativeSqlTables } from "./native-sql-table";
-import { makeComposedPasskeys } from "./passkeys";
 import { createPersistence } from "./persistence";
-import { makeSqlDatabase, sqlQueryOperations } from "./sql-query";
 import { Table } from "./sql-table";
 import type { StorageTable } from "./storage-tables";
 
@@ -23,9 +21,7 @@ export const AuthPersistence: PersistenceApi<Table> & { readonly table: typeof t
       ),
       unique: table.unique,
     }),
-    operations: sqlQueryOperations,
-    nativeTables: (client) => makeNativeSqlTables(client),
-    passkeys: makeComposedPasskeys(sqlQueryOperations),
+    nativeTables: makeNativeSqlTables,
     acquire: Effect.gen(function* () {
       const sql = yield* SqlClient.SqlClient;
 
@@ -40,7 +36,7 @@ export const AuthPersistence: PersistenceApi<Table> & { readonly table: typeof t
           reason: "Use an explicit adapter for this SQL dialect",
         });
 
-      return yield* makeSqlDatabase(dialect);
+      return sql;
     }),
   }),
   table,

package/src/internal/sql-storage-validation.ts

@@ -5,7 +5,6 @@ import { PersistenceMappingError } from "./mapping-error";
 import { Table } from "./sql-table";
 import { storageKeyPlans } from "./storage-plans";
 import { validateStorageBatch, type StorageValidation } from "./storage-validation";
-import { NativeDatabase } from "./transaction-kernel";
 
 /** Check declared mappings against physical keys before acquiring OAuth services. */
 export const validateSqlStorage = Effect.fnUntraced(function* (mapping: unknown) {
@@ -20,7 +19,7 @@ export const validateSqlStorage = Effect.fnUntraced(function* (mapping: unknown)
       PersistenceMappingError.make({ operation: "mapping", cause: "Invalid storage key mapping" }),
   });
 
-  const { $client: client } = yield* NativeDatabase;
+  const client = yield* SqlClient.SqlClient;
 
   const dialect = client.onDialectOrElse({
     pg: () => "pg" as const,