@yielded/auth-persistence-drizzle 0.1.0-beta.0 → 0.1.0-beta.1

package/src/drizzle/password-target.ts

@@ -7,7 +7,7 @@ import {
 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 type * as SqlError from "effect/unstable/sql/SqlError";
+import type * as SqlError from "effect/sql/SqlError";
 
 import {
   makeSqlPasswordRegistrationAuthority,

package/src/drizzle/pg-emails.ts

@@ -6,7 +6,7 @@ import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pgli
 import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
 import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   EmailAddressMapping,

package/src/drizzle/pg-identity.ts

@@ -0,0 +1,301 @@
+import {
+  ExternalIdentityMutation,
+  IdentityConflict,
+  IdentityUnavailable,
+  SubjectProvisioned,
+  type ExternalIdentity,
+  SubjectProvisioner,
+  type SubjectProvisioningInput,
+} from "@yielded/auth/Identity";
+import { reportPersistenceFailure } from "@yielded/auth/Persistence";
+import type { SubjectId } from "@yielded/auth/Schema";
+/* oxlint-disable no-explicit-any -- Drizzle's generic query builders lose the concrete consumer table through a runtime column map. Assertions stay in this adapter. */
+import { and, eq, type AnyRelations } from "drizzle-orm";
+import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pglite";
+import type { EffectPgDatabase as PgDatabase } from "drizzle-orm/effect-postgres";
+import { type AnyPgTable, type PgColumn } from "drizzle-orm/pg-core";
+import { Cause, Effect, Schema } from "effect";
+
+import {
+  column,
+  PersistenceMappingError,
+  isMappedConstraintConflict,
+  provisioningFingerprint,
+  type ExternalIdentityTables,
+  type IdentityTables,
+  type SubjectProvisioningTables,
+} from "./model";
+
+type Database = PgDatabase<AnyRelations> | PgliteDatabase<AnyRelations>;
+type RuntimeDatabase = PgDatabase<any>;
+
+const identityUnavailable = () => IdentityUnavailable.make();
+const isIdentityFailure = Schema.is(Schema.Union([IdentityConflict, IdentityUnavailable]));
+
+const mapIdentityFailure = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  reportPersistenceFailure(effect, isIdentityFailure).pipe(
+    Effect.catchCause((cause) =>
+      Effect.failCause(
+        Cause.map(cause, (error) => (isIdentityFailure(error) ? error : identityUnavailable())),
+      ),
+    ),
+  );
+
+export const makePgSubjectProvisioningServices = <
+  Subject extends AnyPgTable,
+  Identifier extends AnyPgTable,
+  Request extends AnyPgTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
+) => {
+  const db = database as RuntimeDatabase;
+  const requestTable = mapping.provisioningRequest.table;
+  const requestIdColumn = column(requestTable, mapping.provisioningRequest.requestId);
+  const requestFingerprintColumn = column(requestTable, mapping.provisioningRequest.fingerprint);
+  const requestSubjectColumn = column(requestTable, mapping.provisioningRequest.subjectId);
+  const identifierTable = mapping.identifier.table;
+  const identifierNamespaceColumn = column(identifierTable, mapping.identifier.namespace);
+  const identifierValueColumn = column(identifierTable, mapping.identifier.value);
+
+  const findReceipt = Effect.fn("DrizzlePgIdentity.findReceipt")(function* (requestId: string) {
+    const rows = yield* db
+      .select({
+        fingerprint: requestFingerprintColumn as PgColumn,
+        subjectId: requestSubjectColumn as PgColumn,
+      })
+      .from(requestTable as any)
+      .where(eq(requestIdColumn, requestId))
+      .limit(1);
+
+    return rows[0];
+  });
+
+  const provision = Effect.fn("DrizzlePgIdentity.provision")(function* (
+    input: SubjectProvisioningInput,
+  ) {
+    const fingerprint = provisioningFingerprint(input);
+    const existing = yield* findReceipt(input.requestId);
+
+    if (existing !== undefined) {
+      if (existing.fingerprint !== fingerprint) return yield* IdentityConflict.make();
+      const id = yield* mapping.subjectId.toSubject(existing.subjectId as NativeId);
+
+      return SubjectProvisioned.make({ subjectId: id });
+    }
+
+    const attempt = db.transaction((tx) =>
+      Effect.gen(function* () {
+        const allocated =
+          mapping.subject.allocateId === undefined ? undefined : yield* mapping.subject.allocateId;
+
+        const inserted = yield* tx
+          .insert(mapping.subject.table as any)
+          .values(mapping.subject.encodeInsert(input, allocated) as any)
+          .returning({ id: column(mapping.subject.table, mapping.subject.id) as PgColumn });
+
+        const nativeId = (inserted[0]?.id ?? allocated) as NativeId | undefined;
+
+        if (nativeId === undefined) {
+          return yield* PersistenceMappingError.make({
+            operation: "provisionSubject.generatedId",
+            cause: new Error("subject insert did not return its native id"),
+          });
+        }
+        if (input.identifier !== undefined) {
+          yield* tx
+            .insert(identifierTable as any)
+            .values(
+              mapping.identifier.encodeInsert(input.identifier, nativeId, input.verifiedAt) as any,
+            );
+        }
+        yield* tx
+          .insert(requestTable as any)
+          .values(
+            mapping.provisioningRequest.encodeInsert(input.requestId, fingerprint, nativeId) as any,
+          );
+
+        return nativeId;
+      }),
+    );
+
+    const nativeId = yield* attempt.pipe(
+      Effect.catchCause(
+        (
+          cause,
+        ): Effect.Effect<
+          NativeId,
+          | Effect.Error<typeof attempt>
+          | Effect.Error<ReturnType<typeof findReceipt>>
+          | IdentityConflict
+        > => {
+          if (
+            cause.reasons.length === 0 ||
+            !cause.reasons.every(
+              (reason) =>
+                Cause.isFailReason(reason) &&
+                isMappedConstraintConflict(mapping.isConstraintConflict, reason.error),
+            )
+          )
+            return Effect.failCause(cause);
+
+          return findReceipt(input.requestId).pipe(
+            Effect.flatMap((receipt) => {
+              if (receipt !== undefined && receipt.fingerprint === fingerprint) {
+                return Effect.succeed(receipt.subjectId as NativeId);
+              }
+              if (input.identifier === undefined) return IdentityConflict.make();
+
+              return db
+                .select({
+                  subjectId: column(identifierTable, mapping.identifier.subjectId) as PgColumn,
+                })
+                .from(identifierTable as any)
+                .where(
+                  and(
+                    eq(identifierNamespaceColumn, input.identifier.namespace),
+                    eq(identifierValueColumn, input.identifier.value),
+                  ),
+                )
+                .limit(1)
+                .pipe(Effect.flatMap(() => IdentityConflict.make()));
+            }),
+          );
+        },
+      ),
+    );
+
+    const subjectId = yield* mapping.subjectId.toSubject(nativeId);
+
+    return SubjectProvisioned.make({ subjectId });
+  }, mapIdentityFailure);
+
+  return {
+    subjectProvisioner: SubjectProvisioner.of({ provision }),
+  } as const;
+};
+
+export const makePgExternalIdentityServices = <
+  Subject extends AnyPgTable,
+  External extends AnyPgTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: ExternalIdentityTables<Subject, External, NativeId>,
+) => {
+  const db = database as RuntimeDatabase;
+  const externalTable = mapping.externalIdentity.table;
+
+  const externalProviderColumn = column(
+    externalTable,
+    mapping.externalIdentity.provider,
+  ) as PgColumn;
+
+  const externalIssuerColumn = column(externalTable, mapping.externalIdentity.issuer) as PgColumn;
+  const externalSubjectColumn = column(externalTable, mapping.externalIdentity.subject) as PgColumn;
+
+  const externalSubjectIdColumn = column(
+    externalTable,
+    mapping.externalIdentity.subjectId,
+  ) as PgColumn;
+
+  const subjectIdColumn = column(mapping.subject.table, mapping.subject.id) as PgColumn;
+  const subjectStatusColumn = column(mapping.subject.table, mapping.subject.status) as PgColumn;
+
+  const bind = Effect.fn("DrizzlePgIdentity.bindExternalIdentity")(function* (
+    subjectId: SubjectId,
+    identity: ExternalIdentity,
+  ) {
+    const nativeId = yield* mapping.subjectId.toNative(subjectId);
+
+    const decision = yield* db
+      .transaction((tx) =>
+        Effect.gen(function* () {
+          const subjects = yield* tx
+            .select({ status: subjectStatusColumn })
+            .from(mapping.subject.table as any)
+            .where(eq(subjectIdColumn, nativeId))
+            .for("update")
+            .limit(1);
+
+          if (subjects[0] === undefined || !mapping.subject.isActiveStatus(subjects[0].status))
+            return { _tag: "conflict" } as const;
+
+          const links = yield* tx
+            .select({ subjectId: externalSubjectIdColumn })
+            .from(externalTable as any)
+            .where(
+              and(
+                eq(externalProviderColumn, identity.provider),
+                eq(externalIssuerColumn, identity.issuer),
+                eq(externalSubjectColumn, identity.subject),
+              ),
+            )
+            .for("update")
+            .limit(1);
+
+          if (links[0] !== undefined)
+            return mapping.subjectId.equals(links[0].subjectId as NativeId, nativeId)
+              ? ({ _tag: "bound" } as const)
+              : ({ _tag: "conflict" } as const);
+          yield* tx
+            .insert(externalTable as any)
+            .values(mapping.externalIdentity.encodeInsert(identity, nativeId) as any);
+
+          return { _tag: "bound" } as const;
+        }),
+      )
+      .pipe(
+        Effect.catchCause((cause) => {
+          if (
+            cause.reasons.length === 0 ||
+            !cause.reasons.every(
+              (reason) =>
+                Cause.isFailReason(reason) &&
+                isMappedConstraintConflict(mapping.isConstraintConflict, reason.error),
+            )
+          )
+            return Effect.failCause(cause);
+
+          return db
+            .select({ subjectId: externalSubjectIdColumn })
+            .from(externalTable as any)
+            .where(
+              and(
+                eq(externalProviderColumn, identity.provider),
+                eq(externalIssuerColumn, identity.issuer),
+                eq(externalSubjectColumn, identity.subject),
+              ),
+            )
+            .limit(1)
+            .pipe(
+              Effect.map((rows) =>
+                rows[0] !== undefined &&
+                mapping.subjectId.equals(rows[0].subjectId as NativeId, nativeId)
+                  ? ({ _tag: "bound" } as const)
+                  : ({ _tag: "conflict" } as const),
+              ),
+            );
+        }),
+      );
+
+    if (decision._tag === "conflict") return yield* IdentityConflict.make();
+  }, mapIdentityFailure);
+
+  return { externalIdentityMutation: ExternalIdentityMutation.of({ bind }) } as const;
+};
+
+export const makePgIdentityServices = <
+  Subject extends AnyPgTable,
+  Identifier extends AnyPgTable,
+  External extends AnyPgTable,
+  Request extends AnyPgTable,
+  NativeId,
+>(
+  database: Database,
+  mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
+) => ({
+  ...makePgSubjectProvisioningServices(database, mapping),
+  ...makePgExternalIdentityServices(database, mapping),
+});

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

@@ -5,7 +5,7 @@ import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pgli
 import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
 import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   PasswordPreparedPersistenceMapping,

package/src/drizzle/pg-passwords.ts

@@ -6,7 +6,7 @@ import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pgli
 import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
 import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model";
 import type { PasswordRegistrationAuthority } from "./password-registration";

package/src/drizzle/pg-proofs.ts

@@ -5,7 +5,7 @@ import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pgli
 import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
 import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type { ProofPersistenceMapping } from "./proof-model";
 import type { ProofSqlQuery } from "./proof-sql";

package/src/drizzle/pg-sessions.ts

@@ -13,7 +13,7 @@ import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pgli
 import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
 import type { AnyPgTable } from "drizzle-orm/pg-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   AuthenticationAuthorityMapping,

package/src/drizzle/phone-target.ts

@@ -16,7 +16,7 @@ import { ProofBinding } from "@yielded/auth/Proofs";
 import { sql, type Table } from "drizzle-orm";
 /* oxlint-disable no-explicit-any -- shared native implementation; driver entrypoints retain exact database and table types. */
 import { Context, Effect, Schema } from "effect";
-import type { Statement } from "effect/unstable/sql/Statement";
+import type { Statement } from "effect/sql/Statement";
 
 import { CurrentD1PlanningDatabase } from "./d1-planning";
 import { compileD1ProofCompletionPlan } from "./d1-proofs";

package/src/drizzle/proof-target.ts

@@ -7,7 +7,7 @@ import {
 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/unstable/sql/SqlError";
+import type * as SqlError from "effect/sql/SqlError";
 
 import {
   makeSqlProofPersistence,

package/src/drizzle/session-target.ts

@@ -15,7 +15,7 @@ import {
 } 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/unstable/sql/SqlError";
+import type * as SqlError from "effect/sql/SqlError";
 
 import {
   makeSqlAuthenticationAuthority,

package/src/drizzle/sqlite-emails.ts

@@ -9,7 +9,7 @@ import type { EffectSQLiteNodeDatabase as NodeDatabase } from "drizzle-orm/effec
 import type { EffectSQLiteWasmDatabase as WasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   EmailAddressMapping,

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

@@ -2,7 +2,7 @@ import type { LifecycleHooks, HookConfigurationError } from "@yielded/auth/Hooks
 import type { PasswordUnavailable, PasswordPreparedPersistence } from "@yielded/auth/Password";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   PasswordPreparedPersistenceMapping,

package/src/drizzle/sqlite-passwords.ts

@@ -9,7 +9,7 @@ import type { EffectSQLiteNodeDatabase as NodeDatabase } from "drizzle-orm/effec
 import type { EffectSQLiteWasmDatabase as WasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type { PasswordPersistenceMapping, PasswordRegistrationMapping } from "./password-model";
 import type { PasswordRegistrationAuthority } from "./password-registration";

package/src/drizzle/sqlite-proofs.ts

@@ -8,7 +8,7 @@ import type { EffectSQLiteNodeDatabase } from "drizzle-orm/effect-sqlite-node";
 import type { EffectSQLiteWasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type { ProofPersistenceMapping } from "./proof-model";
 import {

package/src/drizzle/sqlite-sessions.ts

@@ -16,7 +16,7 @@ import type { EffectSQLiteNodeDatabase } from "drizzle-orm/effect-sqlite-node";
 import type { EffectSQLiteWasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Context, Effect } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { SqlError } from "effect/sql/SqlError";
 
 import type {
   AuthenticationAuthorityMapping,

package/src/drizzle/standalone-guard.ts

@@ -1,6 +1,6 @@
 import { requireStandalone } from "@yielded/auth-persistence/Adapter";
 import { Context, Effect, Predicate } from "effect";
-import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import type * as SqlClient from "effect/sql/SqlClient";
 
 type TransactionService = Context.Key<
   SqlClient.TransactionConnection,

package/src/drizzle/totp-target.ts

@@ -10,7 +10,7 @@ import {
 import type { Table } from "drizzle-orm";
 /* oxlint-disable no-explicit-any -- shared native implementation; driver entrypoints retain exact database and table types. */
 import { Context, Effect, Schema } from "effect";
-import type { Statement } from "effect/unstable/sql/Statement";
+import type { Statement } from "effect/sql/Statement";
 
 import type { PersistenceMappingError } from "./model";
 import type { SuppliedService } from "./SuppliedService";

package/src/drizzle/transaction-mysql.ts

@@ -1,7 +1,7 @@
 /* oxlint-disable no-explicit-any -- this private acquisition preserves the installed native transaction; public wrappers retain its exact type. */
 import { EffectMysql2Transaction } from "drizzle-orm/effect-mysql2";
 import { Effect } from "effect";
-import { makeWithTransaction, type SqlClient } from "effect/unstable/sql/SqlClient";
+import { makeWithTransaction, type SqlClient } from "effect/sql/SqlClient";
 
 /** Locking discovery and later SQL policy predicates must see the same current
  * authority. MySQL's default repeatable-read snapshot is unsuitable after a

package/src/index.ts

@@ -105,15 +105,7 @@ export {
 } from "./drizzle/proof-model";
 
 export {
-  type AuthStoreTables,
-  type AuthTables,
-  type ChallengeColumns,
-  type ChallengeConsumeDecision,
-  type ChallengeInput,
-  type ChallengeRecord,
-  type ChallengeTableMapping,
   type CommitMode,
-  type ConsumeDecision,
   type D1ExternalIdentityMapping,
   type D1GeneratedIdentityMapping,
   type D1SubjectProvisioningMapping,
@@ -121,31 +113,17 @@ export {
   type ExternalIdentityTables,
   type IdentityTables,
   type InstantCodec,
-  type OAuthStateColumns,
-  type OAuthStateTableMapping,
-  type OAuthStateTables,
-  type RegistrationColumns,
-  type RegistrationRecord,
-  type RegistrationTableMapping,
-  type RequiredAuthConstraints,
-  type RequiredAuthStoreConstraints,
   type RequiredExternalIdentityConstraints,
   type RequiredIdentityConstraints,
-  type RequiredOAuthStateConstraints,
   type RequiredSubjectProvisioningConstraints,
   type SubjectIdCodec,
   type SubjectProvisioningTables,
-  authServicesLayer,
   column,
   identityServicesLayer,
   isMappedConstraintConflict,
   provisioningFingerprint,
-  requireStandaloneConsume,
-  requiredAuthConstraints,
-  requiredAuthStoreConstraints,
   requiredExternalIdentityConstraints,
   requiredIdentityConstraints,
-  requiredOAuthStateConstraints,
   requiredSubjectProvisioningConstraints,
   updateValues,
 } from "./drizzle/model";
@@ -334,7 +312,6 @@ export {
 export { passwordPersistenceLayer, passwordRegistrationLayer } from "./drizzle/password-target";
 export { passwordPreparedPersistenceLayer } from "./drizzle/password-prepared-target";
 export { proofPersistenceLayer } from "./drizzle/proof-target";
-export { AuthStoreDecisions } from "@yielded/auth/Persistence";
 
 export {
   type TotpMapping,
@@ -346,7 +323,6 @@ export {
 } from "./drizzle/totp-model";
 
 export { encodeTotpRecord, decodeTotpRecord } from "./drizzle/totp-state";
-export { OAuthStateDecisions } from "@yielded/auth/OAuth";
 
 export {
   type PasskeyCredentialInsert,

package/src/internal/drizzle-postgres.ts

@@ -15,7 +15,7 @@ import {
   type PgTable,
 } from "drizzle-orm/pg-core";
 import type { Effect } from "effect";
-import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { SqlClient } from "effect/sql/SqlClient";
 
 import { drizzleQueryOperations } from "../drizzle/query-operations";
 

package/src/internal/drizzle-sqlite.ts

@@ -14,7 +14,7 @@ import {
   type SQLiteTable,
 } from "drizzle-orm/sqlite-core";
 import type { Effect } from "effect";
-import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { SqlClient } from "effect/sql/SqlClient";
 
 import { drizzleQueryOperations } from "../drizzle/query-operations";
 

package/dist/drizzle/mysql.d.mts

@@ -1,69 +0,0 @@
-import { AuthStoreTables, AuthTables, ChallengeConsumeDecision, ConsumeDecision, OAuthStateTables } from "./model.mjs";
-import { SuppliedService } from "./SuppliedService.mjs";
-import { EmailOtpRejected } from "@yielded/auth/AuthStore";
-import { AuthStoreError, InvalidRegistration } from "@yielded/auth/Errors";
-import { InvalidOAuthState, OAuthState, OAuthStateDecisions } from "@yielded/auth/OAuth";
-import { ConsumeChallenge, ConsumeRegistration, NewChallenge, NewRegistration, TokenDigest, VerifiedEmail } from "@yielded/auth/Schema";
-import { AnyRelations } from "drizzle-orm";
-import { Effect } from "effect";
-import { AuthStoreDecisions } from "@yielded/auth/Persistence";
-import { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
-import { SqlError } from "effect/unstable/sql/SqlError";
-import { AnyMySqlTable } from "drizzle-orm/mysql-core";
-//#region src/drizzle/mysql.d.ts
-type Database = EffectMysql2Database<AnyRelations>;
-type TransactionOf<D extends Database> = Parameters<Parameters<D["transaction"]>[0]>[0];
-/** MySQL/InnoDB implementation. Multi-step decisions stay values until commit. */
-export declare const makeMysqlAuthStoreServices: <C extends AnyMySqlTable, R extends AnyMySqlTable>(database: Database, mapping: AuthStoreTables<C, R>) => {
-  readonly authStore: {
-    readonly issueChallenge: (input: NewChallenge) => Effect.Effect<void, import("@yielded/auth/AuthStore").IssueChallengeError>;
-    readonly consumeChallenge: (input: ConsumeChallenge) => Effect.Effect<VerifiedEmail, EmailOtpRejected | AuthStoreError>;
-    readonly issueRegistration: (input: NewRegistration) => Effect.Effect<void, AuthStoreError>;
-    readonly inspectRegistration: (tokenDigest: TokenDigest) => Effect.Effect<import("@yielded/auth/Schema").PendingRegistration, InvalidRegistration | AuthStoreError>;
-    readonly consumeRegistration: (input: ConsumeRegistration) => Effect.Effect<void, InvalidRegistration | AuthStoreError>;
-  };
-  readonly decisions: {
-    readonly consumeChallenge: (input: ConsumeChallenge) => Effect.Effect<ChallengeConsumeDecision, AuthStoreError, never>;
-    readonly consumeRegistration: (input: ConsumeRegistration) => Effect.Effect<ConsumeDecision<void>, AuthStoreError, never>;
-  };
-};
-export declare const makeMysqlOAuthStateServices: <S extends AnyMySqlTable>(database: Database, mapping: OAuthStateTables<S>) => {
-  readonly oauthStateStore: {
-    readonly issue: (state: OAuthState) => Effect.Effect<void, AuthStoreError>;
-    readonly consume: (stateDigest: TokenDigest) => Effect.Effect<OAuthState, InvalidOAuthState | AuthStoreError>;
-  };
-  readonly decisions: {
-    readonly consumeOAuthState: (digest: string & import("effect/Brand").Brand<"effect-auth/TokenDigest">) => Effect.Effect<ConsumeDecision<OAuthState>, AuthStoreError, never>;
-  };
-};
-/**
- * Owns the native outer commit. Keep rejection as a decision value inside the
- * owner; interruption before commit rolls back. This adapter never retries a
- * deadlock inside the caller's transaction.
- */
-export declare function coordinateMysqlAuthStoreTransaction<D extends Database, C extends AnyMySqlTable, R extends AnyMySqlTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
-  readonly mapping: AuthStoreTables<C, R>;
-  readonly transaction?: never;
-}, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions> | DatabaseRequirements>;
-export declare function coordinateMysqlAuthStoreTransaction<D extends Database, C extends AnyMySqlTable, R extends AnyMySqlTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
-  readonly mapping: AuthStoreTables<C, R>;
-  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-}, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions | TxId> | DatabaseRequirements>;
-export declare function coordinateMysqlOAuthStateTransaction<D extends Database, S extends AnyMySqlTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
-  readonly mapping: OAuthStateTables<S>;
-  readonly transaction?: never;
-}, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, OAuthStateDecisions> | DatabaseRequirements>;
-export declare function coordinateMysqlOAuthStateTransaction<D extends Database, S extends AnyMySqlTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
-  readonly mapping: OAuthStateTables<S>;
-  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-}, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, OAuthStateDecisions | TxId> | DatabaseRequirements>;
-export declare function coordinateMysqlAuthTransaction<D extends Database, C extends AnyMySqlTable, R extends AnyMySqlTable, S extends AnyMySqlTable, A, E, Requirements, DatabaseError, DatabaseRequirements>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
-  readonly mapping: AuthTables<C, R, S>;
-  readonly transaction?: never;
-}, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions | OAuthStateDecisions> | DatabaseRequirements>;
-export declare function coordinateMysqlAuthTransaction<D extends Database, C extends AnyMySqlTable, R extends AnyMySqlTable, S extends AnyMySqlTable, A, E, Requirements, DatabaseError, DatabaseRequirements, TxId, TxShape>(acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>, options: {
-  readonly mapping: AuthTables<C, R, S>;
-  readonly transaction: SuppliedService<TxId, NoInfer<TransactionOf<D>>, TxShape>;
-}, body: Effect.Effect<A, E, Requirements>): Effect.Effect<A, E | DatabaseError | SqlError, Exclude<Requirements, AuthStoreDecisions | OAuthStateDecisions | TxId> | DatabaseRequirements>;
-//#endregion
-//# sourceMappingURL=mysql.d.mts.map