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

package/src/SqliteWasm.ts

@@ -1,32 +1,25 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { AnyRelations } from "drizzle-orm";
 import { type EffectSQLiteWasmDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { Effect } from "effect";
+import { Context, Effect, Layer } from "effect";
 
+import { nativeDatabase } from "./drizzle/native-database";
+
+/** The application-owned Drizzle database used to construct persistence services. */
+export class Database extends Context.Service<Database, EffectSQLiteWasmDatabase<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/SqliteWasm/Database",
+) {}
+
+/** Construct Drizzle from the driver's SQL-client Layer. */
+export const databaseLayer = Layer.effect(Database, makeWithDefaults({}));
+
+import { sqlClientEmailStandaloneGuard } from "./drizzle/email-target";
 import type {
-  AuthStoreTables,
-  AuthTables,
   ExternalIdentityTables,
   IdentityTables,
-  OAuthStateTables,
   SubjectProvisioningTables,
 } from "./drizzle/model";
-import {
-  coordinateSqliteAuthStoreTransaction,
-  coordinateSqliteAuthTransaction,
-  coordinateSqliteOAuthStateTransaction,
-  makeSqliteAuthServices,
-  makeSqliteAuthStoreServices,
-  makeSqliteOAuthStateServices,
-} from "./drizzle/sqlite";
-
-export {
-  coordinateSqliteAuthStoreTransaction as coordinateAuthStoreTransaction,
-  coordinateSqliteAuthTransaction as coordinateAuthTransaction,
-  coordinateSqliteOAuthStateTransaction as coordinateOAuthStateTransaction,
-};
-
-import { sqlClientEmailStandaloneGuard } from "./drizzle/email-target";
 import { sqlClientPasswordStandaloneGuard } from "./drizzle/password-target";
 import { sqlClientProofStandaloneGuard } from "./drizzle/proof-target";
 import { sqlClientSessionStandaloneGuard } from "./drizzle/session-target";
@@ -40,29 +33,34 @@ import { makeSqlitePasswordTarget, sqlitePasswordConfiguration } from "./drizzle
 import { makeSqliteProofTarget, sqliteProofConfiguration } from "./drizzle/sqlite-proofs";
 import { makeSqliteSessionTarget, sqliteSessionConfiguration } from "./drizzle/sqlite-sessions";
 
-const sessionTarget = makeSqliteSessionTarget<EffectSQLiteWasmDatabase<AnyRelations>>((database) =>
-  sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(database)),
+const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(service)),
 );
 
-const proofTarget = makeSqliteProofTarget<EffectSQLiteWasmDatabase<AnyRelations>>((database) =>
-  sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(database)),
+const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(service)),
 );
 
-const passwordTarget = makeSqlitePasswordTarget<EffectSQLiteWasmDatabase<AnyRelations>>(
-  (database) =>
+const passwordTarget = makeSqlitePasswordTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) =>
     sqlitePasswordConfiguration(
       "interactive",
-      sqlClientPasswordStandaloneGuard(database),
-      sqlClientProofStandaloneGuard(database),
+      sqlClientPasswordStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
     ),
 );
 
-const emailTarget = makeSqliteEmailTarget<EffectSQLiteWasmDatabase<AnyRelations>>((database) =>
-  sqliteEmailConfiguration(
-    "interactive",
-    sqlClientEmailStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
-  ),
+const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) =>
+    sqliteEmailConfiguration(
+      "interactive",
+      sqlClientEmailStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
+    ),
 );
 
 export const {
@@ -97,25 +95,6 @@ export const {
 
 export const commitMode = "interactive" as const;
 
-export const makeAuthStoreServices = <C extends AnySQLiteTable, R extends AnySQLiteTable>(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
-  mapping: AuthStoreTables<C, R>,
-) => makeSqliteAuthStoreServices(database, mapping);
-
-export const makeOAuthStateServices = <S extends AnySQLiteTable>(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
-  mapping: OAuthStateTables<S>,
-) => makeSqliteOAuthStateServices(database, mapping);
-
-export const makeAuthServices = <
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  S extends AnySQLiteTable,
->(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
-  mapping: AuthTables<C, R, S>,
-) => makeSqliteAuthServices(database, mapping);
-
 export const makeIdentityServices = <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
@@ -123,9 +102,11 @@ export const makeIdentityServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
   mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => makeSqliteIdentityServices(database, mapping, "interactive");
+) =>
+  makeSqliteIdentityServices(mapping, "interactive").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeSubjectProvisioningServices = <
   Subject extends AnySQLiteTable,
@@ -133,28 +114,33 @@ export const makeSubjectProvisioningServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
   mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => makeSqliteSubjectProvisioningServices(database, mapping, "interactive");
+) =>
+  makeSqliteSubjectProvisioningServices(mapping, "interactive").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeExternalIdentityServices = <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
   mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => makeSqliteExternalIdentityServices(database, mapping);
+) =>
+  makeSqliteExternalIdentityServices(mapping).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 import { makeSqlitePasswordPreparedTarget } from "./drizzle/sqlite-password-prepared";
 
 const passwordPreparedTarget = makeSqlitePasswordPreparedTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>
->((database) =>
+>(Database, (service) =>
   sqlitePasswordConfiguration(
     "interactive",
-    sqlClientPasswordStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
+    sqlClientPasswordStandaloneGuard(service),
+    sqlClientProofStandaloneGuard(service),
   ),
 );
 
@@ -167,9 +153,10 @@ import { makeOAuthTarget } from "./drizzle/oauth-drivers";
 import { sqlClientOAuthStandaloneGuard } from "./drizzle/oauth-target";
 
 const oauthTarget = makeOAuthTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -195,9 +182,10 @@ import { makePasskeyTarget } from "./drizzle/passkey-drivers";
 import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
 
 const passkeyTarget = makePasskeyTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -220,9 +208,10 @@ export const {
 import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
 
 const totpTarget = makeTotpTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -234,9 +223,10 @@ export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTa
 import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
 
 const phoneTarget = makePhoneTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,

package/src/drizzle/D1BatchStatements.ts

@@ -1,5 +1,5 @@
 import { Context, type Effect } from "effect";
-import type { Statement } from "effect/unstable/sql/Statement";
+import type { Statement } from "effect/sql/Statement";
 
 /** Appends application statements to the current coordinator's single atomic batch. */
 export class D1BatchStatements extends Context.Service<

package/src/drizzle/d1-database.ts

@@ -0,0 +1,10 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import { Context } from "effect";
+
+/** Application-owned D1 database, including the client that owns native batches. */
+export class Database extends Context.Service<
+  Database,
+  EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client }
+>()("effect-auth/persistence-drizzle/D1/Database") {}

package/src/drizzle/d1-emails.ts

@@ -35,8 +35,9 @@ import type { EffectDrizzleQueryError } from "drizzle-orm/effect-core";
 import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Schema, Cause, DateTime, Effect, Option, Context } from "effect";
-import type { Statement } from "effect/unstable/sql/Statement";
+import type { Statement } from "effect/sql/Statement";
 
+import { Database as DatabaseService } from "./d1-database";
 import { CurrentD1PlanningDatabase, makeD1Owner } from "./d1-planning";
 import { compileD1ProofCompletionPlan } from "./d1-proofs";
 import { D1BatchStatements } from "./D1BatchStatements";
@@ -1268,10 +1269,9 @@ export const makeD1EmailSignInServices = <
   C extends AnySQLiteTable,
   NativeId,
 >(
-  database: Database,
   mapping: EmailSignInMapping<S, I, C, NativeId>,
 ) =>
-  Effect.succeed({
+  Effect.map(DatabaseService, (database) => ({
     emailSignInTargets: EmailSignInTargets.of({
       lookup: (input) => {
         if (!validEmailSignInConstraints(mapping as any)) return Effect.fail(unavailable());
@@ -1293,9 +1293,9 @@ export const makeD1EmailSignInServices = <
         );
       },
     }),
-  });
+  }));
 
-export const makeD1EmailAddressServices = <
+export const makeD1EmailAddressServices = Effect.fnUntraced(function* <
   S extends AnySQLiteTable,
   I extends AnySQLiteTable,
   C extends AnySQLiteTable,
@@ -1315,7 +1315,6 @@ export const makeD1EmailAddressServices = <
   PCr extends AnySQLiteTable,
   PNativeId,
 >(
-  database: Database,
   mapping: D1EmailAddressMapping<S, I, C, AC, M, NativeId>,
   proofMapping: D1ProofPersistenceMapping<
     PRq,
@@ -1331,56 +1330,57 @@ export const makeD1EmailAddressServices = <
     PCr,
     PNativeId
   >,
-) =>
-  Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
+) {
+  const database = yield* DatabaseService;
 
-    const plans = makeAddressPlans(
-      mapping as unknown as AddressMapping,
-      proofMapping as unknown as ProofMapping,
-    );
+  const hooks = yield* LifecycleHooks;
 
-    const run = <Out, Err, Env>(plan: Effect.Effect<Planned<Out>, Err, Env>) =>
-      Effect.gen(function* () {
-        if (yield* hasCommitScope) return yield* unavailable();
+  const plans = makeAddressPlans(
+    mapping as unknown as AddressMapping,
+    proofMapping as unknown as ProofMapping,
+  );
 
-        return yield* executeStandalone(plan, 2);
-      }).pipe(
-        Effect.provideService(CurrentD1PlanningDatabase, database),
-        Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
-        Effect.provideService(LifecycleHooks, hooks),
-      );
+  const run = <Out, Err, Env>(plan: Effect.Effect<Planned<Out>, Err, Env>) =>
+    Effect.gen(function* () {
+      if (yield* hasCommitScope) return yield* unavailable();
 
-    const service: EmailAddressPersistence["Service"] = {
-      target: (input) =>
-        plans
-          .target(input)
-          .pipe(
-            Effect.provideService(CurrentD1PlanningDatabase, database),
-            Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
-            Effect.provideService(LifecycleHooks, hooks),
-            translateFailure,
-          ),
-      checkCompletion: (input) =>
-        plans
-          .checkCompletion(input)
-          .pipe(
-            Effect.provideService(CurrentD1PlanningDatabase, database),
-            Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
-            Effect.provideService(LifecycleHooks, hooks),
-            translateFailure,
-          ),
-      verifyWithProof: (input, prepare) =>
-        run(plans.verifyWithProof(input, prepare)).pipe(translateFailure),
-      changeWithProof: (input, prepare) =>
-        run(plans.changeWithProof(input, prepare)).pipe(translateFailure),
-      cleanup: (input, prepare) => run(plans.cleanup(input, prepare)).pipe(translateFailure),
-    };
-
-    return { emailAddressPersistence: service };
-  });
+      return yield* executeStandalone(plan, 2);
+    }).pipe(
+      Effect.provideService(CurrentD1PlanningDatabase, database),
+      Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
+      Effect.provideService(LifecycleHooks, hooks),
+    );
+
+  const service: EmailAddressPersistence["Service"] = {
+    target: (input) =>
+      plans
+        .target(input)
+        .pipe(
+          Effect.provideService(CurrentD1PlanningDatabase, database),
+          Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
+          Effect.provideService(LifecycleHooks, hooks),
+          translateFailure,
+        ),
+    checkCompletion: (input) =>
+      plans
+        .checkCompletion(input)
+        .pipe(
+          Effect.provideService(CurrentD1PlanningDatabase, database),
+          Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
+          Effect.provideService(LifecycleHooks, hooks),
+          translateFailure,
+        ),
+    verifyWithProof: (input, prepare) =>
+      run(plans.verifyWithProof(input, prepare)).pipe(translateFailure),
+    changeWithProof: (input, prepare) =>
+      run(plans.changeWithProof(input, prepare)).pipe(translateFailure),
+    cleanup: (input, prepare) => run(plans.cleanup(input, prepare)).pipe(translateFailure),
+  };
 
-export const makeD1EmailRegistrationServices = <
+  return { emailAddressPersistence: service };
+});
+
+export const makeD1EmailRegistrationServices = Effect.fnUntraced(function* <
   Registration,
   S extends AnySQLiteTable,
   I extends AnySQLiteTable,
@@ -1401,7 +1401,6 @@ export const makeD1EmailRegistrationServices = <
   PCr extends AnySQLiteTable,
   PNativeId,
 >(
-  database: Database,
   mapping: D1EmailRegistrationMapping<Registration, S, I, C, AC, Rq, NativeId>,
   proofMapping: D1ProofPersistenceMapping<
     PRq,
@@ -1417,44 +1416,45 @@ export const makeD1EmailRegistrationServices = <
     PCr,
     PNativeId
   >,
-) =>
-  Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
+) {
+  const database = yield* DatabaseService;
 
-    const plans = makeRegistrationPlans(
-      mapping as unknown as RegistrationMapping<Registration> & {
-        readonly d1: AddressMapping["d1"];
-      },
-      proofMapping as unknown as ProofMapping,
-    );
+  const hooks = yield* LifecycleHooks;
 
-    const run = <Out, Err, Env>(plan: Effect.Effect<Planned<Out>, Err, Env>) =>
-      Effect.gen(function* () {
-        if (yield* hasCommitScope) return yield* unavailable();
+  const plans = makeRegistrationPlans(
+    mapping as unknown as RegistrationMapping<Registration> & {
+      readonly d1: AddressMapping["d1"];
+    },
+    proofMapping as unknown as ProofMapping,
+  );
 
-        return yield* executeStandalone(plan, 2);
-      }).pipe(
-        Effect.provideService(CurrentD1PlanningDatabase, database),
-        Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
-        Effect.provideService(LifecycleHooks, hooks),
-      );
+  const run = <Out, Err, Env>(plan: Effect.Effect<Planned<Out>, Err, Env>) =>
+    Effect.gen(function* () {
+      if (yield* hasCommitScope) return yield* unavailable();
 
-    const service: EmailRegistrationAuthority<Registration> = {
-      inspect: (input) =>
-        plans
-          .inspect(input)
-          .pipe(
-            Effect.provideService(CurrentD1PlanningDatabase, database),
-            Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
-            Effect.provideService(LifecycleHooks, hooks),
-            translateFailure,
-          ),
-      registerWithProof: (input, prepare) =>
-        run(plans.registerWithProof(input, prepare)).pipe(translateFailure),
-    };
+      return yield* executeStandalone(plan, 2);
+    }).pipe(
+      Effect.provideService(CurrentD1PlanningDatabase, database),
+      Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
+      Effect.provideService(LifecycleHooks, hooks),
+    );
 
-    return { registrationAuthority: service };
-  });
+  const service: EmailRegistrationAuthority<Registration> = {
+    inspect: (input) =>
+      plans
+        .inspect(input)
+        .pipe(
+          Effect.provideService(CurrentD1PlanningDatabase, database),
+          Effect.provideService(CurrentEmailSql, database as unknown as EmailSqlDatabase),
+          Effect.provideService(LifecycleHooks, hooks),
+          translateFailure,
+        ),
+    registerWithProof: (input, prepare) =>
+      run(plans.registerWithProof(input, prepare)).pipe(translateFailure),
+  };
+
+  return { registrationAuthority: service };
+});
 
 type CoordinatorError<E> = E | EmailUnavailable | HookConfigurationError;
 
@@ -1797,9 +1797,7 @@ const executeStandalone = <A, E, R>(
   retries = 2,
 ): Effect.Effect<
   A,
-  | E
-  | import("@yielded/auth/Hooks").HookConfigurationError
-  | import("effect/unstable/sql/SqlError").SqlError,
+  E | import("@yielded/auth/Hooks").HookConfigurationError | import("effect/sql/SqlError").SqlError,
   Exclude<R, CurrentCommitJournal> | CurrentD1PlanningDatabase | LifecycleHooks
 > =>
   Effect.suspend(() => {

package/src/drizzle/d1-generated-statement.ts

@@ -1,6 +1,6 @@
 import { sql, type SQL } from "drizzle-orm";
 import { Schema } from "effect";
-import type { Statement } from "effect/unstable/sql/Statement";
+import type { Statement } from "effect/sql/Statement";
 
 // oxlint-disable-next-line no-restricted-properties -- Statement.compile exposes untyped native SQL parameters.
 const valuesJson = Schema.encodeUnknownSync(

package/src/drizzle/d1-identity.ts

@@ -18,7 +18,6 @@ import {
   is,
   sql,
   SQL,
-  type AnyRelations,
   type InferInsertModel,
   type Table,
 } from "drizzle-orm";
@@ -26,6 +25,7 @@ import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
 import type { AnySQLiteTable, SQLiteColumn } from "drizzle-orm/sqlite-core";
 import { Cause, Effect, Schema } from "effect";
 
+import { Database as DatabaseService } from "./d1-database";
 import {
   column,
   isMappedConstraintConflict,
@@ -92,15 +92,14 @@ const selectFields = <T extends Table>(
  * database-generated subject id from the first insert via last_insert_rowid;
  * the optional identifier then reads that stable id from the receipt.
  */
-export const makeD1SubjectProvisioningServices = <
+export const makeD1SubjectProvisioningServices = Effect.fnUntraced(function* <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
   Request extends AnySQLiteTable,
   NativeId,
->(
-  database: EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client },
-  mapping: D1SubjectProvisioningMapping<Subject, Identifier, Request, NativeId>,
-) => {
+>(mapping: D1SubjectProvisioningMapping<Subject, Identifier, Request, NativeId>) {
+  const database = yield* DatabaseService;
+
   const db = database as RuntimeDatabase;
   const requestTable = mapping.provisioningRequest.table;
 
@@ -254,16 +253,15 @@ export const makeD1SubjectProvisioningServices = <
   }, mapUnavailable);
 
   return { subjectProvisioner: SubjectProvisioner.of({ provision }) } as const;
-};
+});
 
-export const makeD1ExternalIdentityServices = <
+export const makeD1ExternalIdentityServices = Effect.fnUntraced(function* <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
->(
-  database: EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client },
-  mapping: D1ExternalIdentityMapping<Subject, External, NativeId>,
-) => {
+>(mapping: D1ExternalIdentityMapping<Subject, External, NativeId>) {
+  const database = yield* DatabaseService;
+
   const db = database as RuntimeDatabase;
   const externalTable = mapping.externalIdentity.table;
 
@@ -358,18 +356,17 @@ export const makeD1ExternalIdentityServices = <
   }, mapUnavailable);
 
   return { externalIdentityMutation: ExternalIdentityMutation.of({ bind }) } as const;
-};
+});
 
-export const makeD1IdentityServices = <
+export const makeD1IdentityServices = Effect.fnUntraced(function* <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
   External extends AnySQLiteTable,
   Request extends AnySQLiteTable,
   NativeId,
->(
-  database: EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client },
-  mapping: D1GeneratedIdentityMapping<Subject, Identifier, External, Request, NativeId>,
-) => ({
-  ...makeD1SubjectProvisioningServices(database, mapping),
-  ...makeD1ExternalIdentityServices(database, mapping),
+>(mapping: D1GeneratedIdentityMapping<Subject, Identifier, External, Request, NativeId>) {
+  return {
+    ...(yield* makeD1SubjectProvisioningServices(mapping)),
+    ...(yield* makeD1ExternalIdentityServices(mapping)),
+  };
 });

package/src/drizzle/d1-oauth.ts

@@ -1,4 +1,5 @@
 import type { D1Client } from "@effect/sql-d1/D1Client";
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { LifecycleHooks } from "@yielded/auth/Hooks";
 import {
   OAuthAccountsPersistence,
@@ -11,8 +12,10 @@ import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
 
+import { Database as DatabaseService } from "./d1-database";
 import { makeD1Owner } from "./d1-planning";
 import { D1BatchStatements } from "./D1BatchStatements";
+import { nativeDatabase } from "./native-database";
 import type {
   OAuthAccountsMapping,
   OAuthD1Mapping,
@@ -54,9 +57,11 @@ export const makeD1OAuthAccountsServices = <
   U extends SQLiteTable,
   N,
 >(
-  database: Database,
   mapping: OAuthAccountsMapping<S, O, C, AC, F, T, U, N> & OAuthD1Mapping,
-) => makeTargetOAuthAccountsServices(database, mapping, configuration);
+) =>
+  makeTargetOAuthAccountsServices(mapping, configuration).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
+  );
 
 export const makeD1OAuthSignInServices = <
   S extends SQLiteTable,
@@ -66,9 +71,11 @@ export const makeD1OAuthSignInServices = <
   F extends SQLiteTable,
   N,
 >(
-  database: Database,
   mapping: OAuthSignInMapping<S, O, C, AC, F, N> & OAuthD1Mapping,
-) => makeTargetOAuthSignInServices(database, mapping, configuration);
+) =>
+  makeTargetOAuthSignInServices(mapping, configuration).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
+  );
 
 export const makeD1OAuthRegistrationIntentServices = <
   S extends SQLiteTable,
@@ -80,9 +87,11 @@ export const makeD1OAuthRegistrationIntentServices = <
   I extends SQLiteTable,
   N,
 >(
-  database: Database,
   mapping: OAuthRegistrationIntentMapping<S, O, C, AC, F, T, I, N> & OAuthD1Mapping,
-) => makeTargetOAuthRegistrationIntentServices(database, mapping, configuration);
+) =>
+  makeTargetOAuthRegistrationIntentServices(mapping, configuration).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
+  );
 
 export const makeD1OAuthRegistrationServices = <
   Registration,
@@ -95,9 +104,11 @@ export const makeD1OAuthRegistrationServices = <
   R extends SQLiteTable,
   N,
 >(
-  database: Database,
   mapping: OAuthRegistrationMapping<Registration, S, O, C, AC, T, I, R, N> & OAuthD1Mapping,
-) => makeTargetOAuthRegistrationServices<Registration>(database, mapping, configuration);
+) =>
+  makeTargetOAuthRegistrationServices<Registration>(mapping, configuration).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(DatabaseService)),
+  );
 
 export function coordinateD1OAuthSignIn<
   S extends SQLiteTable,

package/src/drizzle/d1-passkey.ts

@@ -10,6 +10,7 @@ import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Effect, Context } from "effect";
 
+import { Database as DatabaseService } from "./d1-database";
 import { makeD1Owner } from "./d1-planning";
 import { D1BatchStatements } from "./D1BatchStatements";
 import { makePasskeyTarget } from "./passkey-drivers";
@@ -38,7 +39,10 @@ const configuration = {
   standaloneGuard: () => Effect.void,
 };
 
-const target = makePasskeyTarget<Database, Table, D1PasskeyMapping>(configuration);
+const target = makePasskeyTarget<DatabaseService, Database, Table, D1PasskeyMapping>(
+  DatabaseService,
+  configuration,
+);
 
 export const {
   makePasskeyCredentialServices,