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

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