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

package/src/drizzle/sqlite-proofs.ts

@@ -10,12 +10,19 @@ import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
 import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type { ProofPersistenceMapping } from "./proof-model";
+import { CurrentProofSql } from "./proof-sql";
 import {
   coordinateTargetProofPersistence,
   makeTargetProofPersistenceServices,
   type ProofTargetConfiguration,
 } from "./proof-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database =
@@ -52,11 +59,25 @@ export const sqliteProofConfiguration = (
   ...(coordinatorGuard === undefined ? {} : { coordinatorGuard }),
 });
 
-export const makeSqliteProofTarget = <D extends Database, Synchronous extends boolean = false>(
-  configuration: ProofTargetConfiguration | ((database: D) => ProofTargetConfiguration),
+export const makeSqliteProofTarget = <
+  DatabaseId,
+  D extends Database,
+  Synchronous extends boolean = false,
+>(
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | ProofTargetConfiguration
+    | ((service: TransactionService | undefined) => ProofTargetConfiguration),
 ) => {
   const configurationFor = (database: D) =>
-    typeof configuration === "function" ? configuration(database) : configuration;
+    typeof configuration === "function"
+      ? configuration(transactionService(database))
+      : configuration;
+
+  const standaloneConfiguration =
+    typeof configuration === "function"
+      ? Effect.map(acquireTransactionService(databaseService), configuration)
+      : Effect.succeed(configuration);
 
   function coordinateProofPersistence<
     Database extends D,
@@ -194,9 +215,11 @@ export const makeSqliteProofTarget = <D extends Database, Synchronous extends bo
       Cr extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: Mapping<Rq, S, G, Cn, Rs, A, F, C, Sub, I, Cr, NativeId>,
-    ) => makeTargetProofPersistenceServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeTargetProofPersistenceServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentProofSql, nativeDatabase(databaseService))),
     coordinateProofPersistence,
   };
 };

package/src/drizzle/sqlite-sessions.ts

@@ -18,12 +18,14 @@ import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Context, Effect } from "effect";
 import type { SqlError } from "effect/sql/SqlError";
 
+import { nativeDatabase } from "./native-database";
 import type {
   AuthenticationAuthorityMapping,
   PendingAuthenticationMapping,
   SignedSessionValidityMapping,
   StatefulSessionMapping,
 } from "./session-model";
+import { CurrentSessionSql } from "./session-sql";
 import {
   coordinateTargetAuthenticationAuthority,
   coordinateTargetPendingAuthentication,
@@ -37,6 +39,11 @@ import {
   makeTargetSessionStepUpServices,
   coordinateTargetSessionStepUp,
 } from "./session-target";
+import {
+  type TransactionService,
+  acquireTransactionService,
+  transactionService,
+} from "./standalone-guard";
 import type { SuppliedService } from "./SuppliedService";
 
 type Database =
@@ -66,10 +73,9 @@ export const makeSqliteAuthenticationAuthorityServices = <
   P extends AnySQLiteTable,
   NativeId,
 >(
-  database: Database,
   mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetAuthenticationAuthorityServices<Claims>(database, mapping, configuration);
+) => makeTargetAuthenticationAuthorityServices<Claims>(mapping, configuration);
 
 export const makeSqlitePendingAuthenticationServices = <
   Claims,
@@ -79,10 +85,9 @@ export const makeSqlitePendingAuthenticationServices = <
   F extends AnySQLiteTable,
   NativeId,
 >(
-  database: Database,
   mapping: PendingAuthenticationMapping<Claims, S, C, P, F, NativeId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetPendingAuthenticationServices<Claims>(database, mapping, configuration);
+) => makeTargetPendingAuthenticationServices<Claims>(mapping, configuration);
 
 export const makeSqliteStatefulSessionServices = <
   Claims,
@@ -94,10 +99,9 @@ export const makeSqliteStatefulSessionServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: StatefulSessionMapping<Claims, S, C, Session, F, P, NativeId, NativeSessionId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetStatefulSessionServices<Claims>(database, mapping, configuration);
+) => makeTargetStatefulSessionServices<Claims>(mapping, configuration);
 
 export const makeSqliteSignedSessionValidityServices = <
   S extends AnySQLiteTable,
@@ -105,10 +109,9 @@ export const makeSqliteSignedSessionValidityServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>,
   configuration: SessionTargetConfiguration,
-) => makeTargetSignedSessionValidityServices(database, mapping, configuration);
+) => makeTargetSignedSessionValidityServices(mapping, configuration);
 
 export const coordinateSqliteAuthenticationAuthority = <
   Claims,
@@ -221,11 +224,25 @@ export const coordinateSqliteSignedSessionValidity = <
     owner,
   );
 
-export const makeSqliteSessionTarget = <D extends Database, Synchronous extends boolean = false>(
-  configuration: SessionTargetConfiguration | ((database: D) => SessionTargetConfiguration),
+export const makeSqliteSessionTarget = <
+  DatabaseId,
+  D extends Database,
+  Synchronous extends boolean = false,
+>(
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration:
+    | SessionTargetConfiguration
+    | ((service: TransactionService | undefined) => SessionTargetConfiguration),
 ) => {
   const configurationFor = (database: D) =>
-    typeof configuration === "function" ? configuration(database) : configuration;
+    typeof configuration === "function"
+      ? configuration(transactionService(database))
+      : configuration;
+
+  const standaloneConfiguration =
+    typeof configuration === "function"
+      ? Effect.map(acquireTransactionService(databaseService), configuration)
+      : Effect.succeed(configuration);
 
   function coordinateSessionStepUp<
     Database extends D,
@@ -854,7 +871,6 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       NativeId,
       NativeSessionId,
     >(
-      database: D,
       mapping: SessionStepUpMapping<
         NoInfer<Claims>,
         S,
@@ -866,7 +882,10 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
         NativeSessionId
       >,
       target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
-    ) => makeSqliteSessionStepUpServices(database, mapping, target, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteSessionStepUpServices(mapping, target, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     coordinateSessionStepUp,
     makeAuthenticationAuthorityServices: <
       Claims,
@@ -876,9 +895,11 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       P extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: AuthenticationAuthorityMapping<Claims, S, C, F, P, NativeId>,
-    ) => makeSqliteAuthenticationAuthorityServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteAuthenticationAuthorityServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     makePendingAuthenticationServices: <
       Claims,
       S extends AnySQLiteTable,
@@ -887,9 +908,11 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       F extends AnySQLiteTable,
       NativeId,
     >(
-      database: D,
       mapping: PendingAuthenticationMapping<Claims, S, C, P, F, NativeId>,
-    ) => makeSqlitePendingAuthenticationServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqlitePendingAuthenticationServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     makeStatefulSessionServices: <
       Claims,
       S extends AnySQLiteTable,
@@ -900,18 +923,22 @@ export const makeSqliteSessionTarget = <D extends Database, Synchronous extends
       NativeId,
       NativeSessionId,
     >(
-      database: D,
       mapping: StatefulSessionMapping<Claims, S, C, Session, F, P, NativeId, NativeSessionId>,
-    ) => makeSqliteStatefulSessionServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteStatefulSessionServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     makeSignedSessionValidityServices: <
       S extends AnySQLiteTable,
       T extends AnySQLiteTable,
       NativeId,
       NativeSessionId,
     >(
-      database: D,
       mapping: SignedSessionValidityMapping<S, T, NativeId, NativeSessionId>,
-    ) => makeSqliteSignedSessionValidityServices(database, mapping, configurationFor(database)),
+    ) =>
+      Effect.flatMap(standaloneConfiguration, (configuration) =>
+        makeSqliteSignedSessionValidityServices(mapping, configuration),
+      ).pipe(Effect.provideServiceEffect(CurrentSessionSql, nativeDatabase(databaseService))),
     coordinateAuthenticationAuthority,
     coordinatePendingAuthentication,
     coordinateStatefulSessions,
@@ -932,11 +959,10 @@ export const makeSqliteSessionStepUpServices = <
   NativeId,
   NativeSessionId,
 >(
-  database: Database,
   mapping: SessionStepUpMapping<NoInfer<Claims>, S, C, I, Session, T, NativeId, NativeSessionId>,
   target: Context.Service<Id, SessionStepUpPersistence<Claims>>,
   configuration: SessionTargetConfiguration,
-) => makeTargetSessionStepUpServices(database, mapping, target, configuration);
+) => makeTargetSessionStepUpServices(mapping, target, configuration);
 
 export const coordinateSqliteSessionStepUp = <
   Claims,

package/src/drizzle/standalone-guard.ts

@@ -2,12 +2,12 @@ import { requireStandalone } from "@yielded/auth-persistence/Adapter";
 import { Context, Effect, Predicate } from "effect";
 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,
@@ -13,6 +14,7 @@ import { Context, Effect, Schema } from "effect";
 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/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 { AnyRelations } from "drizzle-orm";
-import { Effect } from "effect";
-import { SubjectId } from "@yielded/auth/Schema";
-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 { AnyRelations } from "drizzle-orm";
-import { Effect } from "effect";
-import { SubjectId } from "@yielded/auth/Schema";
-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/pg-identity.d.mts

@@ -1,22 +0,0 @@
-import { ExternalIdentityTables, SubjectProvisioningTables } from "./model.mjs";
-import { ExternalIdentity, IdentityConflict, IdentityUnavailable, SubjectProvisioningInput } from "@yielded/auth/Identity";
-import { AnyRelations } from "drizzle-orm";
-import { Effect } from "effect";
-import { SubjectId } from "@yielded/auth/Schema";
-import { EffectPgDatabase } from "drizzle-orm/effect-pglite";
-import { AnyPgTable } from "drizzle-orm/pg-core";
-import { EffectPgDatabase as EffectPgDatabase$1 } from "drizzle-orm/effect-postgres";
-//#region src/drizzle/pg-identity.d.ts
-type Database = EffectPgDatabase$1<AnyRelations> | EffectPgDatabase<AnyRelations>;
-export declare const makePgSubjectProvisioningServices: <Subject extends AnyPgTable, Identifier extends AnyPgTable, Request extends AnyPgTable, 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 makePgExternalIdentityServices: <Subject extends AnyPgTable, External extends AnyPgTable, NativeId>(database: Database, mapping: ExternalIdentityTables<Subject, External, NativeId>) => {
-  readonly externalIdentityMutation: {
-    readonly bind: (subjectId: SubjectId, identity: ExternalIdentity) => Effect.Effect<void, IdentityConflict | IdentityUnavailable>;
-  };
-};
-//#endregion
-//# sourceMappingURL=pg-identity.d.mts.map