@yielded/auth-persistence-drizzle 0.1.0-beta.21 → 0.1.0-beta.23

package/src/drizzle/mysql-password-prepared.ts

@@ -30,8 +30,6 @@ export const makeMySqlPasswordPreparedPersistenceServices = <
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   T extends AnyMySqlTable,
   B extends AnyMySqlTable,
@@ -44,7 +42,7 @@ export const makeMySqlPasswordPreparedPersistenceServices = <
   PCr extends AnyMySqlTable = AnyMySqlTable,
   PNativeId = unknown,
 >(
-  mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>,
+  mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>,
   proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>,
 ) =>
   Effect.flatMap(
@@ -64,8 +62,6 @@ export function coordinateMySqlPasswordPreparedPersistence<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   T extends AnyMySqlTable,
   B extends AnyMySqlTable,
@@ -85,7 +81,7 @@ export function coordinateMySqlPasswordPreparedPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>;
     readonly proofMapping?:
       | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
       | undefined;
@@ -107,8 +103,6 @@ export function coordinateMySqlPasswordPreparedPersistence<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   T extends AnyMySqlTable,
   B extends AnyMySqlTable,
@@ -130,7 +124,7 @@ export function coordinateMySqlPasswordPreparedPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>;
     readonly proofMapping?:
       | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
       | undefined;
@@ -152,8 +146,6 @@ export function coordinateMySqlPasswordPreparedPersistence<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   T extends AnyMySqlTable,
   B extends AnyMySqlTable,
@@ -175,7 +167,7 @@ export function coordinateMySqlPasswordPreparedPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>;
     readonly proofMapping?:
       | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
       | undefined;

package/src/drizzle/mysql-passwords.ts

@@ -56,11 +56,9 @@ type Mapping<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   NativeId,
-> = PasswordPersistenceMapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+> = PasswordPersistenceMapping<S, I, C, AC, A, M, NativeId>;
 
 export const makeMysqlPasswordPersistenceServices = <
   S extends AnyMySqlTable,
@@ -68,12 +66,10 @@ export const makeMysqlPasswordPersistenceServices = <
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   NativeId,
 >(
-  mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>,
+  mapping: Mapping<S, I, C, AC, A, M, NativeId>,
   proofMapping?: ProofPersistenceMapping<
     any,
     any,
@@ -104,8 +100,6 @@ export function coordinateMysqlPasswordPersistence<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   NativeId,
   PM extends
@@ -119,7 +113,7 @@ export function coordinateMysqlPasswordPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+    readonly mapping: Mapping<S, I, C, AC, A, M, NativeId>;
     readonly proofMapping?: PM;
     readonly transaction?: never;
   },
@@ -137,8 +131,6 @@ export function coordinateMysqlPasswordPersistence<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   NativeId,
   PM extends
@@ -154,7 +146,7 @@ export function coordinateMysqlPasswordPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+    readonly mapping: Mapping<S, I, C, AC, A, M, NativeId>;
     readonly proofMapping?: PM;
     readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
   },
@@ -172,8 +164,6 @@ export function coordinateMysqlPasswordPersistence<
   C extends AnyMySqlTable,
   AC extends AnyMySqlTable,
   A extends AnyMySqlTable,
-  RS extends AnyMySqlTable,
-  CE extends AnyMySqlTable,
   M extends AnyMySqlTable,
   NativeId,
   PM extends
@@ -189,7 +179,7 @@ export function coordinateMysqlPasswordPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: Mapping<S, I, C, AC, A, RS, CE, M, NativeId>;
+    readonly mapping: Mapping<S, I, C, AC, A, M, NativeId>;
     readonly proofMapping?: PM;
     readonly transaction?: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
   },

package/src/drizzle/native-sql-table.ts

@@ -0,0 +1,229 @@
+import {
+  PersistenceMappingError,
+  makeNativeSqlTables,
+  nativeSqlAlias,
+  type NativeSqlTables,
+  type SqlTable,
+} from "@yielded/auth-persistence/Adapter";
+import {
+  getTableColumns,
+  is,
+  Param,
+  Placeholder,
+  type SQL,
+  Table,
+  sql,
+  type BuildQueryConfig,
+  type SQLWrapper,
+} from "drizzle-orm";
+import { Predicate } from "effect";
+import type { SqlClient } from "effect/sql/SqlClient";
+import * as Statement from "effect/sql/Statement";
+
+type CapturedDialect = Pick<BuildQueryConfig, "escapeName" | "escapeString" | "codecs">;
+
+/** Foreign compiler boundary only: builders are used to materialize SQL, never
+ * executed. The select builder exposes the original dialect even through the
+ * Durable Object database projection, which retains bound query methods. */
+interface CapturedDatabase {
+  readonly select: () => { readonly dialect: CapturedDialect };
+  readonly insert: (table: Table) => {
+    readonly values: (values: Record<string, unknown>) => SQLWrapper;
+  };
+  readonly update: (table: Table) => {
+    readonly set: (values: Record<string, unknown>) => SQLWrapper;
+  };
+}
+
+const invalid = (cause: string): never => {
+  throw PersistenceMappingError.make({ operation: "mapping", cause });
+};
+
+const capture = (
+  database: object,
+): { readonly database: CapturedDatabase; readonly dialect: CapturedDialect } => {
+  if (
+    !Predicate.hasProperty(database, "select") ||
+    typeof database.select !== "function" ||
+    !Predicate.hasProperty(database, "insert") ||
+    typeof database.insert !== "function" ||
+    !Predicate.hasProperty(database, "update") ||
+    typeof database.update !== "function"
+  )
+    return invalid("Expected a captured Drizzle database");
+
+  const selection: unknown = database.select();
+
+  if (!Predicate.hasProperty(selection, "dialect"))
+    return invalid("Expected a captured Drizzle dialect");
+  const dialect = selection.dialect;
+
+  if (
+    !Predicate.hasProperty(dialect, "escapeName") ||
+    typeof dialect.escapeName !== "function" ||
+    !Predicate.hasProperty(dialect, "escapeString") ||
+    typeof dialect.escapeString !== "function"
+  )
+    return invalid("Expected Drizzle dialect escaping methods");
+
+  if (
+    Predicate.hasProperty(dialect, "codecs") &&
+    dialect.codecs !== undefined &&
+    (!Predicate.hasProperty(dialect.codecs, "apply") || typeof dialect.codecs.apply !== "function")
+  )
+    return invalid("Expected Drizzle dialect codecs");
+
+  // Drizzle's private dialect and generic query builders are erased only here.
+  return { database: database as CapturedDatabase, dialect: dialect as CapturedDialect };
+};
+
+const compileWith =
+  (dialect: CapturedDialect) =>
+  (expression: SQL): Statement.Fragment => {
+    const slots: string[] = [];
+
+    const query = expression.toQuery({
+      escapeName: (name) => {
+        if (name.includes("\0")) return invalid("NUL in SQL identifier");
+
+        return dialect.escapeName(name);
+      },
+      escapeString: (value) => {
+        if (value.includes("\0")) return invalid("NUL in SQL literal");
+
+        return dialect.escapeString(value);
+      },
+      escapeParam: (index) => {
+        if (index !== slots.length) return invalid("Invalid Drizzle parameter order");
+        const slot = `yielded_parameter_${index}`;
+
+        slots.push(slot);
+
+        return `\0${slot}\0`;
+      },
+      ...(dialect.codecs === undefined ? {} : { codecs: dialect.codecs }),
+    });
+
+    // Only compiler-emitted slots are translated. Native Statement parameters
+    // receive their final positions when composed; SQL literals containing $1 or
+    // ? are never inspected or rewritten. NUL is reserved for this compilation.
+    const parts = query.sql.split("\0");
+
+    if (parts.length !== slots.length * 2 + 1 || query.params.length !== slots.length)
+      return invalid("NUL or parameter marker collision in Drizzle SQL");
+
+    const segments: Statement.Segment[] = [];
+    const consumed = new Set<number>();
+
+    for (let offset = 0; offset < parts.length; offset += 2) {
+      segments.push(Statement.literal(parts[offset]));
+      if (offset + 1 === parts.length) break;
+      const index = slots.indexOf(parts[offset + 1]);
+
+      if (index < 0 || consumed.has(index))
+        return invalid("NUL or parameter marker collision in Drizzle SQL");
+      consumed.add(index);
+      const value: unknown = query.params[index];
+
+      if (is(value, Placeholder) || is(value, Param)) return invalid("Unbound Drizzle placeholder");
+      if (Statement.isFragment(value)) segments.push(...value.segments);
+      else segments.push(Statement.parameter(value));
+    }
+
+    return Statement.fragment(segments);
+  };
+
+/** Preserve native Statement expressions in writes without applying a column
+ * codec to them. Ordinary values still pass through Drizzle's own builders. */
+const writeValues = (values: Readonly<Record<string, unknown>>) =>
+  Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [
+      key,
+      Statement.isFragment(value) ? sql`${sql.param(value)}` : value,
+    ]),
+  );
+
+/** Capture the root database's compiler, not a later transaction object's
+ * client. Call insert/update inside the operation to materialize hooks once. */
+export const makeDrizzleSqlTables = (
+  client: SqlClient,
+  capturedDatabase: object,
+): NativeSqlTables => {
+  const { database, dialect } = capture(capturedDatabase);
+  const compile = compileWith(dialect);
+
+  return makeNativeSqlTables(client, (_client, physical): SqlTable => {
+    if (!is(physical, Table)) return invalid("Expected a Drizzle table");
+    const columns = getTableColumns(physical);
+    const entries = Object.entries(columns);
+
+    const getColumn = (key: string) => {
+      const column = Object.hasOwn(columns, key) ? columns[key] : undefined;
+
+      if (column === undefined) return invalid("Missing Drizzle column");
+
+      return column;
+    };
+
+    const bind = (alias?: string): SqlTable => {
+      const reference = (key: string) => {
+        const column = getColumn(key);
+
+        return alias === undefined
+          ? sql`${column}`
+          : sql`${sql.identifier(alias)}.${sql.identifier(column.name)}`;
+      };
+
+      return {
+        name: compile(
+          alias === undefined ? sql`${physical}` : sql`${physical} AS ${sql.identifier(alias)}`,
+        ),
+        as: bind,
+        column: (key) => compile(reference(key)),
+        fields: (prefix) =>
+          compile(
+            sql.join(
+              entries.map(([key, column], index) => {
+                const selection =
+                  dialect.codecs === undefined
+                    ? reference(key)
+                    : dialect.codecs.apply(column, "cast", reference(key));
+
+                return sql`${selection} as ${sql.identifier(nativeSqlAlias(prefix, index))}`;
+              }),
+              sql`, `,
+            ),
+          ),
+        decode: (row, prefix) =>
+          Object.fromEntries(
+            entries.map(([key, column], index) => {
+              const alias = nativeSqlAlias(prefix, index);
+
+              if (!Object.hasOwn(row, alias)) return invalid("Missing SQL projection field");
+              const value = row[alias];
+
+              return [
+                key,
+                value === null
+                  ? null
+                  : column.mapFromDriverValue(
+                      dialect.codecs === undefined
+                        ? value
+                        : dialect.codecs.apply(column, "normalize", value),
+                    ),
+              ];
+            }),
+          ),
+        value: (key, value) => {
+          const column = getColumn(key);
+
+          return Statement.isFragment(value) ? value : compile(sql`${sql.param(value, column)}`);
+        },
+        insert: (values) => compile(database.insert(physical).values(writeValues(values)).getSQL()),
+        update: (values) => compile(database.update(physical).set(writeValues(values)).getSQL()),
+      };
+    };
+
+    return bind();
+  });
+};

package/src/drizzle/password-model.ts

@@ -6,8 +6,6 @@ import type { DrizzleTableModel } from "./table-model";
 export {
   type PasswordAttemptAction,
   type PasswordAttemptState,
-  type PasswordRateScopeKind,
-  type PasswordScopeKeys,
   type PasswordAttemptRecord,
   type RequiredPasswordConstraints,
   requiredPasswordConstraints,
@@ -51,14 +49,6 @@ export type PasswordAttemptTable<
   NativeSubjectId,
 > = Shared.PasswordAttemptTable<DrizzleTableModel<Attempt>, NativeSubjectId>;
 
-export type PasswordRateScopeTable<RateScope extends Table> = Shared.PasswordRateScopeTable<
-  DrizzleTableModel<RateScope>
->;
-
-export type PasswordChargeTable<Charge extends Table> = Shared.PasswordChargeTable<
-  DrizzleTableModel<Charge>
->;
-
 export type PasswordCommandTable<Command extends Table> = Shared.PasswordCommandTable<
   DrizzleTableModel<Command>
 >;
@@ -71,8 +61,6 @@ export type PasswordPersistenceMapping<
   Credential extends Table,
   AuthorityCredential extends Table,
   Attempt extends Table,
-  RateScope extends Table,
-  Charge extends Table,
   Command extends Table,
   NativeSubjectId,
 > = Shared.PasswordPersistenceMapping<
@@ -81,8 +69,6 @@ export type PasswordPersistenceMapping<
   DrizzleTableModel<Credential>,
   DrizzleTableModel<AuthorityCredential>,
   DrizzleTableModel<Attempt>,
-  DrizzleTableModel<RateScope>,
-  DrizzleTableModel<Charge>,
   DrizzleTableModel<Command>,
   NativeSubjectId,
   SQL
@@ -94,8 +80,6 @@ export type D1PasswordPersistenceMapping<
   Credential extends Table,
   AuthorityCredential extends Table,
   Attempt extends Table,
-  RateScope extends Table,
-  Charge extends Table,
   Command extends Table,
   NativeSubjectId,
 > = Shared.D1PasswordPersistenceMapping<
@@ -104,8 +88,6 @@ export type D1PasswordPersistenceMapping<
   DrizzleTableModel<Credential>,
   DrizzleTableModel<AuthorityCredential>,
   DrizzleTableModel<Attempt>,
-  DrizzleTableModel<RateScope>,
-  DrizzleTableModel<Charge>,
   DrizzleTableModel<Command>,
   NativeSubjectId,
   SQL
@@ -153,8 +135,6 @@ export type AnyPasswordPersistenceMapping = PasswordPersistenceMapping<
   Table,
   Table,
   Table,
-  Table,
-  Table,
   unknown
 >;
 

package/src/drizzle/password-prepared-model.ts

@@ -87,8 +87,6 @@ export interface PasswordPreparedPersistenceMapping<
   Credential extends Table,
   AuthorityCredential extends Table,
   Attempt extends Table,
-  RateScope extends Table,
-  Charge extends Table,
   Command extends Table,
   Intent extends Table,
   Admission extends Table,
@@ -100,8 +98,6 @@ export interface PasswordPreparedPersistenceMapping<
     Credential,
     AuthorityCredential,
     Attempt,
-    RateScope,
-    Charge,
     Command,
     NativeSubjectId
   >;
@@ -119,8 +115,6 @@ export type D1PasswordPreparedPersistenceMapping<
   Credential extends Table,
   AuthorityCredential extends Table,
   Attempt extends Table,
-  RateScope extends Table,
-  Charge extends Table,
   Command extends Table,
   Intent extends Table,
   Admission extends Table,
@@ -131,8 +125,6 @@ export type D1PasswordPreparedPersistenceMapping<
   Credential,
   AuthorityCredential,
   Attempt,
-  RateScope,
-  Charge,
   Command,
   Intent,
   Admission,
@@ -146,8 +138,6 @@ export type D1PasswordPreparedPersistenceMapping<
     Credential,
     AuthorityCredential,
     Attempt,
-    RateScope,
-    Charge,
     Command,
     NativeSubjectId
   >;
@@ -253,7 +243,5 @@ export type AnyPasswordPreparedPersistenceMapping = PasswordPreparedPersistenceM
   Table,
   Table,
   Table,
-  Table,
-  Table,
   unknown
 >;

package/src/drizzle/password-sql.ts

@@ -1,13 +1,16 @@
 import { makePasswordKernel } from "@yielded/auth-persistence/Adapter";
 
+import { makeDrizzleSqlTables } from "./native-sql-table";
 import { completeProofPlanIn } from "./proof-sql";
 import { drizzleQueryOperations } from "./query-operations";
 export type { PasswordSqlQuery } from "@yielded/auth-persistence/Adapter";
 export type { PasswordSqlDatabase } from "@yielded/auth-persistence/Adapter";
 export { CurrentPasswordSql } from "@yielded/auth-persistence/Adapter";
+
 export type { PasswordSqlConfiguration } from "@yielded/auth-persistence/Adapter";
 
 export const { makeSqlPasswordPersistence, passwordSqlKernel } = makePasswordKernel(
   drizzleQueryOperations,
   { completeProofPlanIn },
+  makeDrizzleSqlTables,
 );

package/src/drizzle/password-target.ts

@@ -1,4 +1,9 @@
-import type { NativeDatabase } from "@yielded/auth-persistence/Adapter";
+import {
+  CurrentPasswordPreparedTransaction,
+  type NativeDatabase,
+  type PasswordPreparedPostcondition,
+  PasswordPreparedPostconditions,
+} from "@yielded/auth-persistence/Adapter";
 import {
   coordinateCommit,
   hasCommitScope,
@@ -7,7 +12,7 @@ import {
 } from "@yielded/auth/Hooks";
 import { PasswordUnavailable, PasswordPersistence } from "@yielded/auth/Password";
 /* oxlint-disable no-explicit-any -- public driver wrappers restore concrete Drizzle generics. */
-import { type Context, Effect, Layer } from "effect";
+import { Cause, type Context, Effect, Layer } from "effect";
 import type * as SqlError from "effect/sql/SqlError";
 
 import {
@@ -154,7 +159,10 @@ export const coordinateTargetPasswordPersistence = <Transaction, A, E, R>(
       () =>
         database.transaction((transaction) =>
           Effect.gen(function* () {
-            return yield* owner(transaction, {
+            const postconditions: Array<PasswordPreparedPostcondition> = [];
+            let acceptingPostconditions = true;
+
+            const value = yield* owner(transaction, {
               passwordPersistence: yield* makeSqlPasswordPersistence(
                 mapping,
                 passwordOptions(configuration, proofMapping, true),
@@ -164,7 +172,36 @@ export const coordinateTargetPasswordPersistence = <Transaction, A, E, R>(
                   transaction as unknown as PasswordSqlDatabase,
                 ),
               ),
-            });
+            }).pipe(
+              Effect.provideService(PasswordPreparedPostconditions, {
+                register: (check) => {
+                  if (!acceptingPostconditions) return false;
+                  postconditions.push(check);
+
+                  return true;
+                },
+              }),
+              Effect.ensuring(
+                Effect.sync(() => {
+                  acceptingPostconditions = false;
+                }),
+              ),
+            );
+
+            // Application work in this transaction must not change what the
+            // password mutations committed to; a failure here rolls back both.
+            for (const check of postconditions)
+              yield* check.pipe(
+                Effect.provideService(
+                  CurrentPasswordPreparedTransaction,
+                  transaction as unknown as PasswordSqlDatabase,
+                ),
+                Effect.catchCause((cause) =>
+                  Effect.failCause(Cause.map(cause, () => PasswordUnavailable.make({}))),
+                ),
+              );
+
+            return value;
           }),
         ),
       { mode: configuration.mode },

package/src/drizzle/pg-password-prepared.ts

@@ -31,8 +31,6 @@ export const makePgPasswordPreparedPersistenceServices = <
   C extends AnyPgTable,
   AC extends AnyPgTable,
   A extends AnyPgTable,
-  RS extends AnyPgTable,
-  CE extends AnyPgTable,
   M extends AnyPgTable,
   T extends AnyPgTable,
   B extends AnyPgTable,
@@ -45,7 +43,7 @@ export const makePgPasswordPreparedPersistenceServices = <
   PCr extends AnyPgTable = AnyPgTable,
   PNativeId = unknown,
 >(
-  mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>,
+  mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>,
   proofMapping?: PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>,
 ) =>
   Effect.flatMap(
@@ -65,8 +63,6 @@ export function coordinatePgPasswordPreparedPersistence<
   C extends AnyPgTable,
   AC extends AnyPgTable,
   A extends AnyPgTable,
-  RS extends AnyPgTable,
-  CE extends AnyPgTable,
   M extends AnyPgTable,
   T extends AnyPgTable,
   B extends AnyPgTable,
@@ -86,7 +82,7 @@ export function coordinatePgPasswordPreparedPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>;
     readonly proofMapping?:
       | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
       | undefined;
@@ -108,8 +104,6 @@ export function coordinatePgPasswordPreparedPersistence<
   C extends AnyPgTable,
   AC extends AnyPgTable,
   A extends AnyPgTable,
-  RS extends AnyPgTable,
-  CE extends AnyPgTable,
   M extends AnyPgTable,
   T extends AnyPgTable,
   B extends AnyPgTable,
@@ -131,7 +125,7 @@ export function coordinatePgPasswordPreparedPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>;
     readonly proofMapping?:
       | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
       | undefined;
@@ -153,8 +147,6 @@ export function coordinatePgPasswordPreparedPersistence<
   C extends AnyPgTable,
   AC extends AnyPgTable,
   A extends AnyPgTable,
-  RS extends AnyPgTable,
-  CE extends AnyPgTable,
   M extends AnyPgTable,
   T extends AnyPgTable,
   B extends AnyPgTable,
@@ -176,7 +168,7 @@ export function coordinatePgPasswordPreparedPersistence<
 >(
   acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
   options: {
-    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, RS, CE, M, T, B, NativeId>;
+    readonly mapping: PasswordPreparedPersistenceMapping<S, I, C, AC, A, M, T, B, NativeId>;
     readonly proofMapping?:
       | PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>
       | undefined;