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

package/src/drizzle/standalone-guard.ts

@@ -1,13 +1,13 @@
 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<
+export type TransactionService = Context.Key<
   SqlClient.TransactionConnection,
   SqlClient.TransactionConnection.Service
 >;
 
-const transactionService = (database: unknown): TransactionService | undefined => {
+export const transactionService = (database: unknown): TransactionService | undefined => {
   if (
     !Predicate.hasProperty(database, "$client") ||
     !Predicate.hasProperty(database.$client, "transactionService") ||
@@ -19,14 +19,26 @@ const transactionService = (database: unknown): TransactionService | undefined =
   return database.$client.transactionService;
 };
 
+/** Capture the foreign client's marker while acquiring standalone services. */
+export const acquireTransactionService = <Id, Database>(service: Context.Key<Id, Database>) =>
+  Effect.map(Effect.service(service), (database): TransactionService | undefined => {
+    if (
+      !Predicate.hasProperty(database, "$client") ||
+      !Predicate.hasProperty(database.$client, "transactionService") ||
+      !Context.isKey(database.$client.transactionService)
+    ) {
+      return undefined;
+    }
+
+    return database.$client.transactionService;
+  });
+
 /** Bind the client-specific transaction marker at foreign adapter construction. */
 export const sqlClientStandaloneGuard = <Failure>(
-  database: unknown,
+  service: TransactionService | undefined,
   unavailable: () => Failure,
 ): Effect.Effect<void, Failure> => {
-  const service = transactionService(database);
-
   if (service === undefined) return Effect.suspend(() => Effect.fail(unavailable()));
 
-  return requireStandalone(unavailable, { transactionService: service });
+  return requireStandalone(unavailable, service);
 };

package/src/drizzle/totp-target.ts

@@ -1,4 +1,5 @@
 import { randomId } from "@yielded/auth-crypto";
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import { LifecycleHooks } from "@yielded/auth/Hooks";
 import {
   TotpConfigurationError,
@@ -10,9 +11,10 @@ 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 { nativeDatabase } from "./native-database";
 import type { SuppliedService } from "./SuppliedService";
 import {
   type TotpMapping,
@@ -44,8 +46,8 @@ export type TotpCoordinatorError<E> =
   | PersistenceMappingError;
 
 export const sqlClientTotpStandaloneGuard = (
-  database: Parameters<typeof sqlClientTransactionStandaloneGuard>[1],
-) => sqlClientTransactionStandaloneGuard(unavailable, database);
+  service: Parameters<typeof sqlClientTransactionStandaloneGuard>[1],
+) => sqlClientTransactionStandaloneGuard(unavailable, service);
 
 const validateMapping = <M>(original: M, configuration: TotpTargetConfiguration): M => {
   const mapping = original as any;
@@ -66,55 +68,58 @@ const validateMapping = <M>(original: M, configuration: TotpTargetConfiguration)
   });
 };
 
-const services = (
+const services = Effect.fnUntraced(function* (
   mapping: any,
   execution: TransactionExecution<TotpUnavailable, CurrentTotpTransaction>,
-  hooks: LifecycleHooks["Service"],
-): TotpPersistenceServices => ({
-  totpPersistence: TotpPersistence.of({
-    snapshot: Effect.fn("TotpNative.snapshot")(
-      function* (input) {
-        const captured = { ...input };
+): Effect.fn.Return<TotpPersistenceServices, never, LifecycleHooks> {
+  const hooks = yield* LifecycleHooks;
 
-        invariant(captured.moduleId === mapping.moduleId);
-        yield* execution.admit;
+  return {
+    totpPersistence: TotpPersistence.of({
+      snapshot: Effect.fn("TotpNative.snapshot")(
+        function* (input) {
+          const captured = { ...input };
+
+          invariant(captured.moduleId === mapping.moduleId);
+          yield* execution.admit;
 
-        return yield* execution
-          .run(
-            Effect.map(captureTotp(mapping, captured.subjectId), (value) => value?.snapshot),
-            false,
-          )
-          .pipe(Effect.provideService(LifecycleHooks, hooks));
-      },
-      Effect.catchDefect(() => Effect.fail(unavailable())),
-    ),
-    mutate: (original, prepare) =>
-      Effect.suspend(() => {
-        // Detach caller-owned payloads before any driver or hook can suspend.
-        const codec = Schema.toCodecIso(TotpMutation);
-        const input = Schema.decodeSync(codec)(Schema.encodeSync(codec)(original));
+          return yield* execution
+            .run(
+              Effect.map(captureTotp(mapping, captured.subjectId), (value) => value?.snapshot),
+              false,
+            )
+            .pipe(Effect.provideService(LifecycleHooks, hooks));
+        },
+        Effect.catchDefect(() => Effect.fail(unavailable())),
+      ),
+      mutate: (original, prepare) =>
+        Effect.suspend(() => {
+          // Detach caller-owned payloads before any driver or hook can suspend.
+          const codec = Schema.toCodecIso(TotpMutation);
+          const input = Schema.decodeSync(codec)(Schema.encodeSync(codec)(original));
 
-        return execution.admit.pipe(
-          Effect.andThen(
-            execution.run(
-              Effect.gen(function* () {
-                const decision = yield* mutateTotp(mapping, input),
-                  owner = yield* CurrentTotpTransaction;
+          return execution.admit.pipe(
+            Effect.andThen(
+              execution.run(
+                Effect.gen(function* () {
+                  const decision = yield* mutateTotp(mapping, input),
+                    owner = yield* CurrentTotpTransaction;
 
-                owner.guards.push(owner.journal.prepare(undefined));
-                const receipt = prepare(decision, owner.journal);
+                  owner.guards.push(owner.journal.prepare(undefined));
+                  const receipt = prepare(decision, owner.journal);
 
-                invariant(receipt?._tag === "PreparedCommit" && Effect.isEffect(receipt.read));
-                owner.guards.push(receipt as any);
+                  invariant(receipt?._tag === "PreparedCommit" && Effect.isEffect(receipt.read));
+                  owner.guards.push(receipt as any);
 
-                return receipt;
-              }),
+                  return receipt;
+                }),
+              ),
             ),
-          ),
-          Effect.provideService(LifecycleHooks, hooks),
-        );
-      }).pipe(Effect.catchDefect(() => Effect.fail(unavailable()))),
-  }),
+            Effect.provideService(LifecycleHooks, hooks),
+          );
+        }).pipe(Effect.catchDefect(() => Effect.fail(unavailable()))),
+    }),
+  };
 });
 
 export const makeTargetTotpPersistence = <
@@ -124,12 +129,10 @@ export const makeTargetTotpPersistence = <
   N,
   RSetup = never,
 >(
-  database: TransactionNativeDatabase,
   source: TotpMappingSource<TotpMapping<S, F, C, N>, RSetup>,
   configuration: TotpTargetConfiguration,
 ) =>
   Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
     const original = yield* Effect.isEffect(source) ? source : Effect.succeed(source);
 
     const mapping = yield* Effect.try({
@@ -137,15 +140,14 @@ export const makeTargetTotpPersistence = <
       catch: () => TotpConfigurationError.make({}),
     });
 
-    const execution = makeTransactionExecution(
+    const execution = yield* makeTransactionExecution(
       CurrentTotpTransaction,
-      database,
       configuration,
       unavailable,
       randomId,
     );
 
-    return services(mapping, execution, hooks);
+    return yield* services(mapping, execution);
   });
 
 export const coordinateTargetTotp = <M, A, E, R, RSetup = never>(
@@ -159,7 +161,6 @@ export const coordinateTargetTotp = <M, A, E, R, RSetup = never>(
   ) => Effect.Effect<A, E, R>,
 ): Effect.Effect<A, TotpCoordinatorError<E>, R | RSetup | LifecycleHooks> =>
   Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
     const original = yield* Effect.isEffect(source) ? source : Effect.succeed(source);
 
     const mapping = yield* Effect.try({
@@ -174,8 +175,11 @@ export const coordinateTargetTotp = <M, A, E, R, RSetup = never>(
       Effect.void,
       unavailable,
       randomId,
-      (execution) => services(mapping, execution, hooks),
-      body,
+      (execution) => services(mapping, execution),
+      (transaction, acquireServices, append) =>
+        Effect.flatMap(acquireServices, (boundServices) =>
+          body(transaction, boundServices, append),
+        ),
     );
   });
 
@@ -185,11 +189,13 @@ type TransactionOf<D> = D extends { readonly transaction: (...args: any[]) => an
 
 /** Concrete driver wrappers select transaction mode; cryptography always precedes these owners. */
 export const makeTotpTarget = <
+  DatabaseId,
   D extends { readonly transaction: any },
   T extends Table,
   Extra = unknown,
   Synchronous extends boolean = false,
 >(
+  databaseService: Context.Service<DatabaseId, D>,
   configuration: TotpTargetConfiguration,
 ) => {
   function coordinateTotpPersistence<
@@ -292,17 +298,12 @@ export const makeTotpTarget = <
   }
 
   return {
-    makeTotpPersistenceServices: <
-      Database extends D,
-      S extends T,
-      F extends T,
-      C extends T,
-      N,
-      RSetup = never,
-    >(
-      database: Database,
+    makeTotpPersistenceServices: <S extends T, F extends T, C extends T, N, RSetup = never>(
       mapping: TotpMappingSource<TotpMapping<S, F, C, N> & Extra, RSetup>,
-    ) => makeTargetTotpPersistence(database as any, mapping, configuration),
+    ) =>
+      makeTargetTotpPersistence(mapping, configuration).pipe(
+        Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService)),
+      ),
     coordinateTotpPersistence,
   };
 };

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/d1-identity.d.mts

@@ -1,30 +0,0 @@
-import { D1ExternalIdentityMapping, D1SubjectProvisioningMapping } from "./model.mjs";
-import { ExternalIdentity, IdentityConflict, IdentityUnavailable, SubjectProvisioningInput } from "@yielded/auth/Identity";
-import { SubjectId } from "@yielded/auth/Schema";
-import { AnyRelations } from "drizzle-orm";
-import { Effect } from "effect";
-import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { D1Client } from "@effect/sql-d1/D1Client";
-import { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
-//#region src/drizzle/d1-identity.d.ts
-/**
- * D1 provisioning is an ordered atomic batch. The receipt captures the
- * database-generated subject id from the first insert via last_insert_rowid;
- * the optional identifier then reads that stable id from the receipt.
- */
-export declare const makeD1SubjectProvisioningServices: <Subject extends AnySQLiteTable, Identifier extends AnySQLiteTable, Request extends AnySQLiteTable, NativeId>(database: EffectSQLiteD1Database<AnyRelations> & {
-  readonly $client: D1Client;
-}, mapping: D1SubjectProvisioningMapping<Subject, Identifier, Request, NativeId>) => {
-  readonly subjectProvisioner: {
-    readonly provision: (input: SubjectProvisioningInput) => Effect.Effect<import("@yielded/auth/Identity").ProvisioningResult, IdentityConflict | IdentityUnavailable>;
-  };
-};
-export declare const makeD1ExternalIdentityServices: <Subject extends AnySQLiteTable, External extends AnySQLiteTable, NativeId>(database: EffectSQLiteD1Database<AnyRelations> & {
-  readonly $client: D1Client;
-}, mapping: D1ExternalIdentityMapping<Subject, External, NativeId>) => {
-  readonly externalIdentityMutation: {
-    readonly bind: (subjectId: SubjectId, identity: ExternalIdentity) => Effect.Effect<void, IdentityConflict | IdentityUnavailable>;
-  };
-};
-//#endregion
-//# sourceMappingURL=d1-identity.d.mts.map

package/dist/drizzle/mysql-identity.d.mts

@@ -1,21 +0,0 @@
-import { ExternalIdentityTables, SubjectProvisioningTables } from "./model.mjs";
-import { ExternalIdentity, IdentityConflict, IdentityUnavailable, SubjectProvisioningInput } from "@yielded/auth/Identity";
-import { SubjectId } from "@yielded/auth/Schema";
-import { AnyRelations } from "drizzle-orm";
-import { Effect } from "effect";
-import { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
-import { AnyMySqlTable } from "drizzle-orm/mysql-core";
-//#region src/drizzle/mysql-identity.d.ts
-type Database = EffectMysql2Database<AnyRelations>;
-export declare const makeMysqlSubjectProvisioningServices: <Subject extends AnyMySqlTable, Identifier extends AnyMySqlTable, Request extends AnyMySqlTable, NativeId>(database: Database, mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>) => {
-  readonly subjectProvisioner: {
-    readonly provision: (input: SubjectProvisioningInput) => Effect.Effect<import("@yielded/auth/Identity").ProvisioningResult, IdentityConflict | IdentityUnavailable>;
-  };
-};
-export declare const makeMysqlExternalIdentityServices: <Subject extends AnyMySqlTable, External extends AnyMySqlTable, NativeId>(database: Database, mapping: ExternalIdentityTables<Subject, External, NativeId>) => {
-  readonly externalIdentityMutation: {
-    readonly bind: (subjectId: SubjectId, identity: ExternalIdentity) => Effect.Effect<void, IdentityConflict | IdentityUnavailable>;
-  };
-};
-//#endregion
-//# sourceMappingURL=mysql-identity.d.mts.map

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