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

package/src/SqliteDo.ts

@@ -1,24 +1,39 @@
-import { OAuthStateDecisions } from "@yielded/auth/OAuth";
-import { AuthStoreDecisions } from "@yielded/auth/Persistence";
+import { SqliteClient } from "@effect/sql-sqlite-do/SqliteClient";
+import { NativeDatabase, PersistenceConfigurationError } from "@yielded/auth-persistence/Adapter";
 import type { AnyRelations } from "drizzle-orm";
-import type { EffectSQLiteDoDatabase } from "drizzle-orm/effect-sqlite-do";
+import { type EffectSQLiteDoDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-do";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { Context, Effect } from "effect";
-import type { SqlError } from "effect/unstable/sql/SqlError";
+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, EffectSQLiteDoDatabase<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/SqliteDo/Database",
+) {}
+
+/** The SQL-client Layer must configure storage so Drizzle owns transactionSync. */
+export const databaseLayer = Layer.effect(
+  Database,
+  Effect.gen(function* () {
+    const client = yield* SqliteClient;
+    const storage = client.config.storage;
+
+    if (storage === undefined)
+      return yield* PersistenceConfigurationError.make({
+        reason:
+          "SqliteDo requires a SQL client configured with storage for synchronous transactions",
+      });
+
+    return yield* makeWithDefaults({ storage });
+  }),
+);
 
 import type {
-  AuthStoreTables,
-  AuthTables,
   ExternalIdentityTables,
   IdentityTables,
-  OAuthStateTables,
   SubjectProvisioningTables,
 } from "./drizzle/model";
-import {
-  makeSqliteAuthServices,
-  makeSqliteAuthStoreServices,
-  makeSqliteOAuthStateServices,
-} from "./drizzle/sqlite";
 import { makeSqliteEmailTarget, sqliteEmailConfiguration } from "./drizzle/sqlite-emails";
 import {
   makeSqliteExternalIdentityServices,
@@ -28,21 +43,25 @@ import {
 import { makeSqlitePasswordTarget, sqlitePasswordConfiguration } from "./drizzle/sqlite-passwords";
 import { makeSqliteProofTarget, sqliteProofConfiguration } from "./drizzle/sqlite-proofs";
 import { makeSqliteSessionTarget, sqliteSessionConfiguration } from "./drizzle/sqlite-sessions";
-import type { SuppliedService } from "./drizzle/SuppliedService";
 
-const sessionTarget = makeSqliteSessionTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
+const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteDoDatabase<AnyRelations>, true>(
+  Database,
   sqliteSessionConfiguration("synchronous", Effect.void),
 );
 
-const proofTarget = makeSqliteProofTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
+const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteDoDatabase<AnyRelations>, true>(
+  Database,
   sqliteProofConfiguration("synchronous", Effect.void),
 );
 
-const passwordTarget = makeSqlitePasswordTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
-  sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void),
-);
+const passwordTarget = makeSqlitePasswordTarget<
+  Database,
+  EffectSQLiteDoDatabase<AnyRelations>,
+  true
+>(Database, sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void));
 
-const emailTarget = makeSqliteEmailTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
+const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteDoDatabase<AnyRelations>, true>(
+  Database,
   sqliteEmailConfiguration("synchronous", Effect.void, Effect.void),
 );
 
@@ -100,249 +119,6 @@ export const {
 
 export const commitMode = "synchronous" as const;
 
-export const makeAuthStoreServices = <C extends AnySQLiteTable, R extends AnySQLiteTable>(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
-  mapping: AuthStoreTables<C, R>,
-) => makeSqliteAuthStoreServices(database, mapping);
-
-export const makeOAuthStateServices = <S extends AnySQLiteTable>(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
-  mapping: OAuthStateTables<S>,
-) => makeSqliteOAuthStateServices(database, mapping);
-
-export const makeAuthServices = <
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  S extends AnySQLiteTable,
->(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
-  mapping: AuthTables<C, R, S>,
-) => makeSqliteAuthServices(database, mapping);
-
-type TransactionOf<D extends EffectSQLiteDoDatabase<AnyRelations>> = Parameters<
-  Parameters<D["transaction"]>[0]
->[0];
-
-export function coordinateAuthStoreTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  A,
-  E,
-  DatabaseError,
-  DatabaseRequirements,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: { readonly mapping: AuthStoreTables<C, R>; readonly transaction?: never },
-  body: Effect.Effect<A, E, NoInfer<AuthStoreDecisions>>,
-): Effect.Effect<A, E | DatabaseError | SqlError, DatabaseRequirements>;
-
-export function coordinateAuthStoreTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  A,
-  E,
-  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, NoInfer<AuthStoreDecisions | TxId>>,
-): Effect.Effect<A, E | DatabaseError | SqlError, DatabaseRequirements>;
-
-export function coordinateAuthStoreTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  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>,
-) {
-  return Effect.flatMap(acquire, (database) =>
-    database.transaction<A, E, Exclude<Requirements, AuthStoreDecisions>>((transaction) => {
-      const decisions = makeSqliteAuthStoreServices(transaction, options.mapping).decisions;
-      const provided = Context.make(AuthStoreDecisions, decisions);
-      const work = Effect.provideContext(body, provided);
-
-      return options.transaction === undefined
-        ? work
-        : Effect.provideService(
-            work,
-            options.transaction,
-            options.transaction.of(transaction as TransactionOf<D>),
-          );
-    }),
-  );
-}
-
-export function coordinateOAuthStateTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  S extends AnySQLiteTable,
-  A,
-  E,
-  DatabaseError,
-  DatabaseRequirements,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: { readonly mapping: OAuthStateTables<S>; readonly transaction?: never },
-  body: Effect.Effect<A, E, NoInfer<OAuthStateDecisions>>,
-): Effect.Effect<A, E | DatabaseError | SqlError, DatabaseRequirements>;
-
-export function coordinateOAuthStateTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  S extends AnySQLiteTable,
-  A,
-  E,
-  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, NoInfer<OAuthStateDecisions | TxId>>,
-): Effect.Effect<A, E | DatabaseError | SqlError, DatabaseRequirements>;
-
-export function coordinateOAuthStateTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  S extends AnySQLiteTable,
-  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>,
-) {
-  return Effect.flatMap(acquire, (database) =>
-    database.transaction<A, E, Exclude<Requirements, OAuthStateDecisions>>((transaction) => {
-      const decisions = makeSqliteOAuthStateServices(transaction, options.mapping).decisions;
-      const provided = Context.make(OAuthStateDecisions, decisions);
-      const work = Effect.provideContext(body, provided);
-
-      return options.transaction === undefined
-        ? work
-        : Effect.provideService(
-            work,
-            options.transaction,
-            options.transaction.of(transaction as TransactionOf<D>),
-          );
-    }),
-  );
-}
-
-/**
- * Supported composition boundary for Durable Objects. The owner must return
- * decisions as values and translate rejection only after this root
- * transactionSync commit. Its body may contain only runSync-compatible Effects;
- * the installed driver rejects suspension and rolls back. Owner failure rolls
- * back synchronously, so no retry is performed inside this boundary.
- */
-export function coordinateAuthTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  S extends AnySQLiteTable,
-  A,
-  E,
-  DatabaseError,
-  DatabaseRequirements,
->(
-  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
-  options: { readonly mapping: AuthTables<C, R, S>; readonly transaction?: never },
-  body: Effect.Effect<A, E, NoInfer<AuthStoreDecisions | OAuthStateDecisions>>,
-): Effect.Effect<A, E | DatabaseError | SqlError, DatabaseRequirements>;
-
-export function coordinateAuthTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  S extends AnySQLiteTable,
-  A,
-  E,
-  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, NoInfer<AuthStoreDecisions | OAuthStateDecisions | TxId>>,
-): Effect.Effect<A, E | DatabaseError | SqlError, DatabaseRequirements>;
-
-export function coordinateAuthTransaction<
-  D extends EffectSQLiteDoDatabase<AnyRelations>,
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  S extends AnySQLiteTable,
-  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>,
-) {
-  return Effect.flatMap(acquire, (database) =>
-    database.transaction<A, E, Exclude<Requirements, AuthStoreDecisions | OAuthStateDecisions>>(
-      (transaction) => {
-        const decisions = makeSqliteAuthServices(transaction, options.mapping).decisions;
-
-        const provided = Context.make(AuthStoreDecisions, decisions).pipe(
-          Context.add(OAuthStateDecisions, decisions),
-        );
-
-        const work = Effect.provideContext(body, provided);
-
-        return options.transaction === undefined
-          ? work
-          : Effect.provideService(
-              work,
-              options.transaction,
-              options.transaction.of(transaction as TransactionOf<D>),
-            );
-      },
-    ),
-  );
-}
-
 export const makeIdentityServices = <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
@@ -350,9 +126,11 @@ export const makeIdentityServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
   mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => makeSqliteIdentityServices(database, mapping, "synchronous");
+) =>
+  makeSqliteIdentityServices(mapping, "synchronous").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeSubjectProvisioningServices = <
   Subject extends AnySQLiteTable,
@@ -360,25 +138,30 @@ export const makeSubjectProvisioningServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
   mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => makeSqliteSubjectProvisioningServices(database, mapping, "synchronous");
+) =>
+  makeSqliteSubjectProvisioningServices(mapping, "synchronous").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeExternalIdentityServices = <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteDoDatabase<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,
   EffectSQLiteDoDatabase<AnyRelations>,
   true
->(sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void));
+>(Database, sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void));
 
 export const { makePasswordPreparedPersistenceServices, coordinatePasswordPreparedPersistence } =
   passwordPreparedTarget;
@@ -388,10 +171,11 @@ export { passwordPreparedPersistenceLayer } from "./drizzle/password-prepared-ta
 import { makeOAuthTarget } from "./drizzle/oauth-drivers";
 
 const oauthTarget = makeOAuthTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,
@@ -416,11 +200,12 @@ export const {
 import { makePasskeyTarget } from "./drizzle/passkey-drivers";
 
 const passkeyTarget = makePasskeyTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   unknown,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,
@@ -443,11 +228,12 @@ export const {
 import { makeTotpTarget } from "./drizzle/totp-target";
 
 const totpTarget = makeTotpTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   unknown,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,
@@ -459,11 +245,12 @@ export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTa
 import { makePhoneTarget } from "./drizzle/phone-target";
 
 const phoneTarget = makePhoneTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   unknown,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,

package/src/SqliteNode.ts

@@ -1,32 +1,25 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { AnyRelations } from "drizzle-orm";
 import { type EffectSQLiteNodeDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-node";
 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, EffectSQLiteNodeDatabase<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/SqliteNode/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<EffectSQLiteNodeDatabase<AnyRelations>>((database) =>
-  sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(database)),
+const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(service)),
 );
 
-const proofTarget = makeSqliteProofTarget<EffectSQLiteNodeDatabase<AnyRelations>>((database) =>
-  sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(database)),
+const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(service)),
 );
 
-const passwordTarget = makeSqlitePasswordTarget<EffectSQLiteNodeDatabase<AnyRelations>>(
-  (database) =>
+const passwordTarget = makeSqlitePasswordTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) =>
     sqlitePasswordConfiguration(
       "interactive",
-      sqlClientPasswordStandaloneGuard(database),
-      sqlClientProofStandaloneGuard(database),
+      sqlClientPasswordStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
     ),
 );
 
-const emailTarget = makeSqliteEmailTarget<EffectSQLiteNodeDatabase<AnyRelations>>((database) =>
-  sqliteEmailConfiguration(
-    "interactive",
-    sqlClientEmailStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
-  ),
+const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteNodeDatabase<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: EffectSQLiteNodeDatabase<AnyRelations>,
-  mapping: AuthStoreTables<C, R>,
-) => makeSqliteAuthStoreServices(database, mapping);
-
-export const makeOAuthStateServices = <S extends AnySQLiteTable>(
-  database: EffectSQLiteNodeDatabase<AnyRelations>,
-  mapping: OAuthStateTables<S>,
-) => makeSqliteOAuthStateServices(database, mapping);
-
-export const makeAuthServices = <
-  C extends AnySQLiteTable,
-  R extends AnySQLiteTable,
-  S extends AnySQLiteTable,
->(
-  database: EffectSQLiteNodeDatabase<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: EffectSQLiteNodeDatabase<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: EffectSQLiteNodeDatabase<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: EffectSQLiteNodeDatabase<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,
   EffectSQLiteNodeDatabase<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,
   EffectSQLiteNodeDatabase<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,
   EffectSQLiteNodeDatabase<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,
   EffectSQLiteNodeDatabase<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,
   EffectSQLiteNodeDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,