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

package/src/drizzle/d1-emails.ts

@@ -37,6 +37,7 @@ import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Schema, Cause, DateTime, Effect, Option, Context } from "effect";
 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;
 

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,

package/src/drizzle/d1-password-prepared.ts

@@ -32,6 +32,7 @@ import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Cause, DateTime, Effect, Predicate, Redacted, Schema, Context } from "effect";
 import type { Statement } from "effect/sql/Statement";
 
+import { Database as DatabaseService } from "./d1-database";
 import { balancedD1And as and, compactD1GeneratedStatement } from "./d1-generated-statement";
 import { passwordD1Kernel as kernel } from "./d1-passwords";
 import { CurrentD1PlanningDatabase, makeD1Owner } from "./d1-planning";
@@ -964,7 +965,7 @@ const makePreparedPlans = (mapping: Mapping, proofMapping?: any) => {
   return services;
 };
 
-export const makeD1PasswordPreparedPersistenceServices = <
+export const makeD1PasswordPreparedPersistenceServices = Effect.fnUntraced(function* <
   S extends AnySQLiteTable,
   I extends AnySQLiteTable,
   C extends AnySQLiteTable,
@@ -984,47 +985,47 @@ export const makeD1PasswordPreparedPersistenceServices = <
   PCr extends AnySQLiteTable = AnySQLiteTable,
   PNativeId = unknown,
 >(
-  database: Database,
   mapping: D1PasswordPreparedPersistenceMapping<S, I, C, AC, At, RS, CE, M, T, B, NativeId>,
   proofMapping?: D1PasswordPreparedProofMapping<PS, PC, PM, PSub, PI, PCr, PNativeId>,
-) =>
-  Effect.gen(function* () {
-    const hooks = yield* LifecycleHooks;
-    const plans = makePreparedPlans(mapping as unknown as Mapping, proofMapping);
+) {
+  const database = yield* DatabaseService;
 
-    const run = <Out, Err, Env>(plan: Effect.Effect<Planned<Out>, Err, Env>) =>
-      Effect.gen(function* () {
-        if (yield* hasCommitScope) return yield* unavailable();
+  const hooks = yield* LifecycleHooks;
+  const plans = makePreparedPlans(mapping as unknown as Mapping, proofMapping);
 
-        return yield* executeStandalone(plan);
-      }).pipe(
-        Effect.provideService(CurrentD1PlanningDatabase, database),
-        Effect.provideService(CurrentPasswordSql, database as unknown as PasswordSqlDatabase),
-        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: PasswordPreparedPersistence = {
-      reserve: (input, prepare) => run(plans.reserve(input, prepare)).pipe(translateFailure),
-      publishReady: (input, prepare) =>
-        run(plans.publishReady(input, prepare)).pipe(translateFailure),
-      context: (input) =>
-        plans
-          .context(input)
-          .pipe(
-            Effect.provideService(CurrentD1PlanningDatabase, database),
-            Effect.provideService(CurrentPasswordSql, database as unknown as PasswordSqlDatabase),
-            Effect.provideService(LifecycleHooks, hooks),
-            translateContextFailure,
-          ),
-      complete: (input, prepare) => run(plans.complete(input, prepare)).pipe(translateFailure),
-      resetWithProof: (input, prepare) =>
-        run(plans.resetWithProof(input, prepare)).pipe(translateFailure),
-      cancel: (input, prepare) => run(plans.cancel(input, prepare)).pipe(translateFailure),
-      cleanup: (input, prepare) => run(plans.cleanup(input, prepare)).pipe(translateFailure),
-    };
-
-    return { passwordPreparedPersistence: service };
-  });
+      return yield* executeStandalone(plan);
+    }).pipe(
+      Effect.provideService(CurrentD1PlanningDatabase, database),
+      Effect.provideService(CurrentPasswordSql, database as unknown as PasswordSqlDatabase),
+      Effect.provideService(LifecycleHooks, hooks),
+    );
+
+  const service: PasswordPreparedPersistence = {
+    reserve: (input, prepare) => run(plans.reserve(input, prepare)).pipe(translateFailure),
+    publishReady: (input, prepare) =>
+      run(plans.publishReady(input, prepare)).pipe(translateFailure),
+    context: (input) =>
+      plans
+        .context(input)
+        .pipe(
+          Effect.provideService(CurrentD1PlanningDatabase, database),
+          Effect.provideService(CurrentPasswordSql, database as unknown as PasswordSqlDatabase),
+          Effect.provideService(LifecycleHooks, hooks),
+          translateContextFailure,
+        ),
+    complete: (input, prepare) => run(plans.complete(input, prepare)).pipe(translateFailure),
+    resetWithProof: (input, prepare) =>
+      run(plans.resetWithProof(input, prepare)).pipe(translateFailure),
+    cancel: (input, prepare) => run(plans.cancel(input, prepare)).pipe(translateFailure),
+    cleanup: (input, prepare) => run(plans.cleanup(input, prepare)).pipe(translateFailure),
+  };
+
+  return { passwordPreparedPersistence: service };
+});
 
 export function coordinateD1PasswordPreparedPersistence<
   TargetId,