@yielded/auth-persistence-drizzle 0.1.0-beta.24 → 0.1.0-beta.26

package/src/drizzle/d1-phone.ts

@@ -1,103 +0,0 @@
-import type { D1Client } from "@effect/sql-d1/D1Client";
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-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 { type Crypto, Context, Effect } 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 { 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<DatabaseService, Database, Table, D1PhoneMapping>(
-  DatabaseService,
-  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>
-  | Crypto.Crypto
-  | LifecycleHooks
-  | RSetup
-  | DatabaseRequirements
-> =>
-  Effect.flatMap(nativeDatabase(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));
-        }),
-    ).pipe(Effect.provideService(NativeDatabase, database)),
-  );

package/src/drizzle/d1-planning.ts

@@ -1,104 +0,0 @@
-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))),
-        );
-      },
-    };
-  });