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

package/src/SqliteWasm.ts

@@ -1,12 +1,13 @@
-import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
-export { OAuthProxyPersistence } from "./internal/drizzle-sqlite-oauth-proxy";
-
 import type { AnyRelations } from "drizzle-orm";
-import { type EffectSQLiteWasmDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-wasm";
+import {
+  EffectSQLiteWasmTransaction as PasskeyTransaction,
+  type EffectSQLiteWasmDatabase,
+  makeWithDefaults,
+} from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 import { Context, Effect, Layer } from "effect";
 
-import { nativeDatabase } from "./drizzle/native-database";
+import { NativeDatabase, nativeDatabase } from "./drizzle/native-database";
 
 /** The application-owned Drizzle database used to construct persistence services. */
 export class Database extends Context.Service<Database, EffectSQLiteWasmDatabase<AnyRelations>>()(
@@ -16,62 +17,44 @@ export class Database extends Context.Service<Database, EffectSQLiteWasmDatabase
 /** Construct Drizzle from the driver's SQL-client Layer. */
 export const databaseLayer = Layer.effect(Database, makeWithDefaults({}));
 
-import { sqlClientEmailStandaloneGuard } from "./drizzle/email-target";
 import type {
   ExternalIdentityTables,
   IdentityTables,
   SubjectProvisioningTables,
 } from "./drizzle/model";
-import { sqlClientPasswordStandaloneGuard } from "./drizzle/password-target";
-import { sqlClientProofStandaloneGuard } from "./drizzle/proof-target";
-import { sqlClientSessionStandaloneGuard } from "./drizzle/session-target";
-import { makeSqliteEmailTarget, sqliteEmailConfiguration } from "./drizzle/sqlite-emails";
+import { makePasswordTarget } from "./drizzle/password-drivers";
+import { makeProofTarget } from "./drizzle/proof-drivers";
 import {
   makeSqliteExternalIdentityServices,
   makeSqliteIdentityServices,
   makeSqliteSubjectProvisioningServices,
 } from "./drizzle/sqlite-identity";
-import { makeSqlitePasswordTarget, sqlitePasswordConfiguration } from "./drizzle/sqlite-passwords";
-import { makeSqliteProofTarget, sqliteProofConfiguration } from "./drizzle/sqlite-proofs";
-import { makeSqliteSessionTarget, sqliteSessionConfiguration } from "./drizzle/sqlite-sessions";
-
-const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
-  Database,
-  (service) => sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(service)),
-);
 
-const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
-  Database,
-  (service) => sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(service)),
-);
+const proofTarget = makeProofTarget(Database, {
+  mode: "native",
+  dialect: "sqlite",
+  transactionConstructor: PasskeyTransaction,
+});
 
-const passwordTarget = makeSqlitePasswordTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
-  Database,
-  (service) =>
-    sqlitePasswordConfiguration(
-      "interactive",
-      sqlClientPasswordStandaloneGuard(service),
-      sqlClientProofStandaloneGuard(service),
-    ),
-);
+const passwordTarget = makePasswordTarget(Database, {
+  mode: "native",
+  dialect: "sqlite",
+  transactionConstructor: PasskeyTransaction,
+});
 
-const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
-  Database,
-  (service) =>
-    sqliteEmailConfiguration(
-      "interactive",
-      sqlClientEmailStandaloneGuard(service),
-      sqlClientProofStandaloneGuard(service),
-    ),
-);
+import { makeEmailTarget } from "./drizzle/email-drivers";
 
 export const {
-  coordinateEmailAddress,
-  coordinateEmailRegistration,
+  makeEmailSignInServices,
   makeEmailAddressServices,
   makeEmailRegistrationServices,
-  makeEmailSignInServices,
-} = emailTarget;
+  coordinateEmailAddress,
+  coordinateEmailRegistration,
+} = makeEmailTarget(Database, {
+  mode: "native",
+  dialect: "sqlite",
+  transactionConstructor: PasskeyTransaction,
+});
 
 export const {
   coordinatePasswordPersistence,
@@ -82,21 +65,6 @@ export const {
 
 export const { coordinateProofPersistence, makeProofPersistenceServices } = proofTarget;
 
-export const {
-  coordinateAuthenticationAuthority,
-  coordinatePendingAuthentication,
-  coordinateSignedSessionValidity,
-  coordinateStatefulSessions,
-  makeAuthenticationAuthorityServices,
-  makePendingAuthenticationServices,
-  makeSessionStepUpServices,
-  coordinateSessionStepUp,
-  makeSignedSessionValidityServices,
-  makeStatefulSessionServices,
-} = sessionTarget;
-
-export const commitMode = "interactive" as const;
-
 export const makeIdentityServices = <
   Subject extends AnySQLiteTable,
   Identifier extends AnySQLiteTable,
@@ -133,36 +101,16 @@ export const makeExternalIdentityServices = <
     Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
   );
 
-import { makeSqlitePasswordPreparedTarget } from "./drizzle/sqlite-password-prepared";
-
-const passwordPreparedTarget = makeSqlitePasswordPreparedTarget<
-  Database,
-  EffectSQLiteWasmDatabase<AnyRelations>
->(Database, (service) =>
-  sqlitePasswordConfiguration(
-    "interactive",
-    sqlClientPasswordStandaloneGuard(service),
-    sqlClientProofStandaloneGuard(service),
-  ),
-);
-
-export const { makePasswordPreparedPersistenceServices, coordinatePasswordPreparedPersistence } =
-  passwordPreparedTarget;
-
-export { passwordPreparedPersistenceLayer } from "./drizzle/password-prepared-target";
-
 import { makeOAuthTarget } from "./drizzle/oauth-drivers";
-import { sqlClientOAuthStandaloneGuard } from "./drizzle/oauth-target";
 
 const oauthTarget = makeOAuthTarget<
   Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
 >(Database, {
-  mode: "interactive",
+  mode: "native",
   dialect: "sqlite",
-  locking: false,
-  standaloneGuard: sqlClientOAuthStandaloneGuard,
+  transactionConstructor: PasskeyTransaction,
 });
 
 export const {
@@ -181,23 +129,20 @@ export const {
 } = oauthTarget;
 
 import { makePasskeyTarget } from "./drizzle/passkey-drivers";
-import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
 
 const passkeyTarget = makePasskeyTarget<
   Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
 >(Database, {
-  mode: "interactive",
+  transactionConstructor: PasskeyTransaction,
+  mode: "native",
   dialect: "sqlite",
-  locking: false,
-  standaloneGuard: sqlClientPasskeyStandaloneGuard,
 });
 
 export const {
   makePasskeyCredentialServices,
   makePasskeyPersistenceServices,
-  makePasskeyEnrollmentContextServices,
   makePasskeyRegistrationCeremonyServices,
   coordinatePasskeyPersistence,
   coordinatePasskeyRegistrationCeremony,
@@ -207,35 +152,12 @@ export const {
   coordinatePasskeyRegistration,
 } = passkeyTarget;
 
-import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
-
-const totpTarget = makeTotpTarget<
-  Database,
-  EffectSQLiteWasmDatabase<AnyRelations>,
-  AnySQLiteTable<{ dialect: "sqlite" }>
->(Database, {
-  mode: "interactive",
-  dialect: "sqlite",
-  locking: false,
-  standaloneGuard: sqlClientTotpStandaloneGuard,
-});
-
-export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTarget;
-
-import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
+import { makePhoneTarget } from "./drizzle/phone-drivers";
 
-const phoneTarget = makePhoneTarget<
+export const { makePhonePersistenceServices, coordinatePhonePersistence } = makePhoneTarget(
   Database,
-  EffectSQLiteWasmDatabase<AnyRelations>,
-  AnySQLiteTable<{ dialect: "sqlite" }>
->(Database, {
-  mode: "interactive",
-  dialect: "sqlite",
-  locking: false,
-  standaloneGuard: sqlClientPhoneStandaloneGuard,
-});
-
-export const { makePhonePersistenceServices, coordinatePhonePersistence } = phoneTarget;
+  { mode: "native", dialect: "sqlite", transactionConstructor: PasskeyTransaction },
+);
 
 import { drizzleMigrationsLayer } from "./internal/drizzle-migrations";
 import { sqlitePersistence } from "./internal/drizzle-sqlite";
@@ -253,3 +175,33 @@ export const AuthPersistence = {
       ),
     )(options),
 };
+
+export { OAuthProxyPersistence } from "./internal/drizzle-sqlite-oauth-proxy";
+
+import { makeSessionTarget } from "./drizzle/session-drivers";
+
+export const {
+  coordinateAuthenticationAuthority,
+  coordinatePendingAuthentication,
+  coordinateSignedSessionValidity,
+  coordinateStatefulSessions,
+  makeAuthenticationAuthorityServices,
+  makePendingAuthenticationServices,
+  makeSignedSessionValidityServices,
+  makeStatefulSessionServices,
+  makeSessionStepUpServices,
+  coordinateSessionStepUp,
+  makeSessionCleanupServices,
+} = makeSessionTarget(Database, {
+  mode: "native",
+  dialect: "sqlite",
+  transactionConstructor: PasskeyTransaction,
+});
+
+import { makeTotpTarget } from "./drizzle/totp-target";
+
+export const { makeTotpPersistenceServices, coordinateTotpPersistence } = makeTotpTarget(Database, {
+  mode: "native",
+  dialect: "sqlite",
+  transactionConstructor: PasskeyTransaction,
+});

package/src/drizzle/d1-identity.ts

@@ -1,5 +1,5 @@
 import type { D1Client } from "@effect/sql-d1/D1Client";
-import { withStorageValidation, NativeDatabase } from "@yielded/auth-persistence/Adapter";
+import { withStorageValidation } from "@yielded/auth-persistence/Adapter";
 import {
   ExternalIdentityMutation,
   type ExternalIdentity,
@@ -35,7 +35,7 @@ import {
   type D1GeneratedIdentityMapping,
   type D1SubjectProvisioningMapping,
 } from "./model";
-import { nativeDatabase } from "./native-database";
+import { NativeDatabase, nativeDatabase } from "./native-database";
 import { validateDrizzleStorage } from "./storage-validation";
 
 type RuntimeDatabase = EffectSQLiteD1Database<any> & { readonly $client: D1Client };

package/src/drizzle/driver-types.ts

@@ -0,0 +1,26 @@
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import type { EffectLibsqlDatabase } from "drizzle-orm/effect-libsql";
+import type { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import type { EffectPgDatabase as PgliteDatabase } from "drizzle-orm/effect-pglite";
+import type { EffectPgDatabase as PostgresDatabase } from "drizzle-orm/effect-postgres";
+import type { EffectSQLiteBunDatabase } from "drizzle-orm/effect-sqlite-bun";
+import type { EffectSQLiteNodeDatabase } from "drizzle-orm/effect-sqlite-node";
+import type { EffectSQLiteWasmDatabase } from "drizzle-orm/effect-sqlite-wasm";
+
+import type { DatabaseValue } from "./sqlite-do-database";
+
+export type NativeDriverDatabase =
+  | EffectSQLiteD1Database<AnyRelations>
+  | EffectLibsqlDatabase<AnyRelations>
+  | EffectMysql2Database<AnyRelations>
+  | PgliteDatabase<AnyRelations>
+  | PostgresDatabase<AnyRelations>
+  | EffectSQLiteBunDatabase<AnyRelations>
+  | EffectSQLiteNodeDatabase<AnyRelations>
+  | EffectSQLiteWasmDatabase<AnyRelations>
+  | DatabaseValue<AnyRelations>;
+
+export type NativeDriverTransaction<D extends NativeDriverDatabase> = Parameters<
+  Parameters<D["transaction"]>[0]
+>[0];

package/src/drizzle/email-drivers.ts

@@ -0,0 +1,320 @@
+import type { EmailRegistrationAuthority } from "@yielded/auth-persistence/Adapter";
+import { EmailAddressPersistence, type EmailUnavailable } from "@yielded/auth/Email";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import type { Table } from "drizzle-orm";
+import { type Context, Effect, type Crypto } from "effect";
+
+import type { NativeDriverDatabase, NativeDriverTransaction } from "./driver-types";
+import type {
+  AnyEmailAddressMapping,
+  EmailSignInMapping,
+  AnyEmailSignInMapping,
+  AnyEmailRegistrationMapping,
+  EmailAddressMapping,
+  EmailRegistrationMapping,
+} from "./email-model";
+import {
+  coordinateTargetEmailAddress,
+  coordinateTargetEmailRegistration,
+  makeTargetEmailAddressServices,
+  makeTargetEmailSignInServices,
+  makeTargetEmailRegistrationServices,
+} from "./email-target";
+import { NativeDatabase, nativeDatabase } from "./native-database";
+import type { NativeTargetConfiguration } from "./native-target";
+import type { AnyProofPersistenceMapping, ProofPersistenceMapping } from "./proof-model";
+import type { SuppliedService } from "./SuppliedService";
+
+type ProofOption<Proof extends Table, Subject extends Table, NativeId> = {
+  readonly proofMapping?: ProofPersistenceMapping<Proof, Subject, NativeId>;
+};
+
+/** Foreign table callback variance is erased only after these public signatures;
+ * the target validates physical metadata and the workflow invokes row codecs. */
+export const makeEmailTarget = <DatabaseId, D extends NativeDriverDatabase>(
+  databaseService: Context.Service<DatabaseId, D>,
+  configuration: NativeTargetConfiguration,
+) => {
+  function coordinateEmailAddress<
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: EmailAddressMapping<S, I, C, AC, N>;
+      readonly transaction?: never;
+    } & ProofOption<Proof, PS, PN>,
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | EmailUnavailable,
+    Exclude<R, EmailAddressPersistence> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinateEmailAddress<
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: EmailAddressMapping<S, I, C, AC, N>;
+      readonly transaction: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    } & ProofOption<Proof, PS, PN>,
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | EmailUnavailable,
+    Exclude<R, EmailAddressPersistence | TxId> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinateEmailAddress<
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: EmailAddressMapping<S, I, C, AC, N>;
+      readonly transaction?: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    } & ProofOption<Proof, PS, PN>,
+    body: Effect.Effect<A, E, R>,
+  ) {
+    return Effect.flatMap(nativeDatabase(acquire), (database) =>
+      coordinateTargetEmailAddress(
+        database,
+        options.mapping as unknown as AnyEmailAddressMapping,
+        configuration,
+        (transaction: NativeDriverTransaction<Database>, services) => {
+          const work = Effect.provideService(
+            body,
+            EmailAddressPersistence,
+            services.emailAddressPersistence,
+          );
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+        options.proofMapping as unknown as AnyProofPersistenceMapping | undefined,
+      ),
+    );
+  }
+
+  function coordinateEmailRegistration<
+    TargetId,
+    Registration,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, N>;
+      readonly proofMapping: ProofPersistenceMapping<Proof, PS, PN>;
+      readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+      readonly transaction?: never;
+    },
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | EmailUnavailable,
+    Exclude<R, TargetId> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinateEmailRegistration<
+    TargetId,
+    Registration,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, N>;
+      readonly proofMapping: ProofPersistenceMapping<Proof, PS, PN>;
+      readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+      readonly transaction: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    },
+    body: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | DE | EmailUnavailable,
+    Exclude<R, TargetId | TxId> | DR | LifecycleHooks | Crypto.Crypto
+  >;
+  function coordinateEmailRegistration<
+    TargetId,
+    Registration,
+    Proof extends Table,
+    PS extends Table,
+    PN,
+    Database extends D,
+    S extends Table,
+    I extends Table,
+    C extends Table,
+    AC extends Table,
+    N,
+    A,
+    E,
+    R,
+    DE,
+    DR,
+    TxId,
+    TxShape,
+  >(
+    acquire: Effect.Effect<Database, DE, DR>,
+    options: {
+      readonly mapping: EmailRegistrationMapping<NoInfer<Registration>, S, I, C, AC, N>;
+      readonly proofMapping: ProofPersistenceMapping<Proof, PS, PN>;
+      readonly target: SuppliedService<TargetId, EmailRegistrationAuthority<Registration>>;
+      readonly transaction?: SuppliedService<
+        TxId,
+        NoInfer<NativeDriverTransaction<Database>>,
+        TxShape
+      >;
+    },
+    body: Effect.Effect<A, E, R>,
+  ) {
+    return Effect.flatMap(nativeDatabase(acquire), (database) =>
+      coordinateTargetEmailRegistration(
+        database,
+        options.mapping as unknown as AnyEmailRegistrationMapping<Registration>,
+        configuration,
+        options.proofMapping as unknown as AnyProofPersistenceMapping,
+        (transaction: NativeDriverTransaction<Database>, services) => {
+          const work = Effect.provideService(body, options.target, services.registrationAuthority);
+
+          return options.transaction === undefined
+            ? work
+            : Effect.provideService(work, options.transaction, options.transaction.of(transaction));
+        },
+      ),
+    );
+  }
+
+  return {
+    makeEmailSignInServices: <
+      S extends Table,
+      I extends Table,
+      C extends Table,
+      AC extends Table,
+      N,
+    >(
+      mapping: EmailSignInMapping<S, I, C, AC, N>,
+    ) =>
+      makeTargetEmailSignInServices(
+        mapping as unknown as AnyEmailSignInMapping,
+        configuration,
+      ).pipe(Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService))),
+    makeEmailAddressServices: <
+      S extends Table,
+      I extends Table,
+      C extends Table,
+      AC extends Table,
+      N,
+      Proof extends Table,
+      PS extends Table,
+      PN,
+    >(
+      mapping: EmailAddressMapping<S, I, C, AC, N>,
+      proofMapping?: ProofPersistenceMapping<Proof, PS, PN>,
+    ) =>
+      makeTargetEmailAddressServices(
+        mapping as unknown as AnyEmailAddressMapping,
+        configuration,
+        proofMapping as unknown as AnyProofPersistenceMapping | undefined,
+      ).pipe(Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService))),
+    makeEmailRegistrationServices: <
+      Registration,
+      Proof extends Table,
+      PS extends Table,
+      PN,
+      S extends Table,
+      I extends Table,
+      C extends Table,
+      AC extends Table,
+      N,
+    >(
+      mapping: EmailRegistrationMapping<Registration, S, I, C, AC, N>,
+      proofs: ProofPersistenceMapping<Proof, PS, PN>,
+    ) =>
+      makeTargetEmailRegistrationServices(
+        mapping as unknown as AnyEmailRegistrationMapping<Registration>,
+        configuration,
+        proofs as unknown as AnyProofPersistenceMapping,
+      ).pipe(Effect.provideServiceEffect(NativeDatabase, nativeDatabase(databaseService))),
+    coordinateEmailAddress,
+    coordinateEmailRegistration,
+  };
+};