@yielded/auth-persistence 0.1.0-beta.7

package/src/drizzle/d1-phone.ts

@@ -0,0 +1,96 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import {
+  PhoneOtpUnavailable as PhoneUnavailable,
+  PhoneAdmission,
+  PhonePersistence,
+  PhoneSignInTargets,
+} from "@yielded/auth/PhoneOtp";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import { Context, Effect } from "effect";
+
+import { makeD1Owner } from "./d1-planning";
+import { D1BatchStatements } from "./D1BatchStatements";
+import type { D1PhoneMapping, PhoneMapping, PhoneMappingSource } from "./phone-model";
+import { coordinateTargetPhone, makePhoneTarget, type PhoneCoordinatorError } from "./phone-target";
+type Database = EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client };
+type Table = AnySQLiteTable;
+
+const configuration = {
+  mode: "batch" as const,
+  dialect: "sqlite" as const,
+  locking: false,
+  standaloneGuard: () => Effect.void,
+};
+
+/** Reads use a primary D1 session; observations and expiry are asserted in the same batch. */
+const target = makePhoneTarget<Database, Table, D1PhoneMapping>(configuration);
+
+export const { makePhonePersistenceServices } = target;
+
+export const coordinatePhonePersistence = <
+  D extends Database,
+  S extends Table,
+  I extends Table,
+  F extends Table,
+  C extends Table,
+  N,
+  A,
+  E,
+  R,
+  RSetup = never,
+  DatabaseError = never,
+  DatabaseRequirements = never,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: {
+    readonly mapping: PhoneMappingSource<PhoneMapping<S, I, C, F, N> & D1PhoneMapping, RSetup>;
+  },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  PhoneCoordinatorError<E> | DatabaseError,
+  | Exclude<R, PhonePersistence | PhoneAdmission | PhoneSignInTargets | D1BatchStatements>
+  | LifecycleHooks
+  | RSetup
+  | DatabaseRequirements
+> =>
+  Effect.flatMap(acquire, (database) =>
+    coordinateTargetPhone(
+      database,
+      options.mapping,
+      configuration,
+      (_transaction, services, append) =>
+        Effect.gen(function* () {
+          const original = services.phonePersistence;
+
+          const nativeCollector = D1BatchStatements.of({
+            append: (statement) => Effect.sync(() => append(statement)),
+          });
+
+          const owner = yield* makeD1Owner(PhoneUnavailable.make({})).pipe(
+            Effect.provideService(D1BatchStatements, nativeCollector),
+          );
+
+          const service: PhonePersistence["Service"] = {
+            target: (input) => owner.run(original.target(input)),
+            mutate: (input, prepare) => owner.run(original.mutate(input, prepare)),
+          };
+
+          const provided = Context.make(PhonePersistence, service).pipe(
+            Context.add(D1BatchStatements, owner.collector),
+            Context.add(PhoneAdmission, {
+              admit: (input) => owner.run(services.phoneAdmission.admit(input)),
+              cleanup: (input) => owner.run(services.phoneAdmission.cleanup(input)),
+            }),
+            Context.add(PhoneSignInTargets, {
+              lookup: (input) => owner.run(services.phoneSignInTargets.lookup(input)),
+            }),
+          );
+
+          return yield* owner.close(Effect.provideContext(body, provided));
+        }),
+    ),
+  );

package/src/drizzle/d1-planning.ts

@@ -0,0 +1,104 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import { HookConfigurationError } from "@yielded/auth/Hooks";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import { type Option, Context, Effect } from "effect";
+
+import { D1BatchStatements } from "./D1BatchStatements";
+
+export type D1PlanningDatabase = EffectSQLiteD1Database<AnyRelations> & {
+  readonly $client: D1Client;
+};
+
+export class CurrentD1PlanningDatabase extends Context.Service<
+  CurrentD1PlanningDatabase,
+  D1PlanningDatabase
+>()("effect-auth/drizzle/CurrentD1PlanningDatabase") {}
+
+export interface D1Owner<Closed> {
+  readonly collector: D1BatchStatements["Service"];
+  readonly check: Effect.Effect<void, Closed>;
+  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | Closed, R>;
+  readonly close: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | Closed, R>;
+}
+
+const closedCollector = () =>
+  HookConfigurationError.make({ reason: "closed-journal", contribution: "d1-batch" });
+
+export const makeD1Owner = <Closed>(
+  closed: Closed,
+): Effect.Effect<D1Owner<Closed>, never, D1BatchStatements> =>
+  Effect.map(D1BatchStatements, (nativeCollector) => {
+    let accepting = true;
+    let active = 0;
+    let collector: D1BatchStatements["Service"];
+
+    const valid = (current: Option.Option<D1BatchStatements["Service"]>) =>
+      accepting && current._tag === "Some" && current.value === collector;
+
+    const checkWith = <Failure>(failure: Failure): Effect.Effect<void, Failure> =>
+      Effect.serviceOption(D1BatchStatements).pipe(
+        Effect.flatMap((current) => (valid(current) ? Effect.void : Effect.fail(failure))),
+      );
+
+    const enterWith = <Failure>(failure: Failure): Effect.Effect<void, Failure> =>
+      Effect.serviceOption(D1BatchStatements).pipe(
+        Effect.flatMap((current) => {
+          if (!valid(current)) return Effect.fail(failure);
+          active++;
+
+          return Effect.void;
+        }),
+      );
+
+    const runWith = <A, E, R, Failure>(
+      failure: Failure,
+      effect: Effect.Effect<A, E, R>,
+    ): Effect.Effect<A, E | Failure, R> =>
+      Effect.uninterruptibleMask((restore) =>
+        enterWith(failure).pipe(
+          Effect.flatMap(() =>
+            restore(effect).pipe(
+              Effect.flatMap((value) => checkWith(failure).pipe(Effect.as(value))),
+              Effect.ensuring(
+                Effect.sync(() => {
+                  active--;
+                }),
+              ),
+            ),
+          ),
+        ),
+      );
+
+    const check = checkWith(closed);
+
+    const run = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | Closed, R> =>
+      runWith(closed, effect);
+
+    collector = D1BatchStatements.of({
+      append: (statement) =>
+        runWith(
+          closedCollector(),
+          Effect.suspend(() => nativeCollector.append(statement)),
+        ).pipe(Effect.orDie),
+    });
+
+    return {
+      collector,
+      check,
+      run,
+      close: (effect) => {
+        let activeAtClose = false;
+
+        return effect.pipe(
+          Effect.ensuring(
+            Effect.sync(() => {
+              accepting = false;
+              activeAtClose = active !== 0;
+            }),
+          ),
+          Effect.flatMap((value) => (activeAtClose ? Effect.fail(closed) : Effect.succeed(value))),
+        );
+      },
+    };
+  });