@yielded/auth-persistence 0.1.0-beta.7

package/src/DrizzleLibsql.ts

@@ -0,0 +1,301 @@
+import { EmailUnavailable } from "@yielded/auth/Email";
+import { AuthStoreError } from "@yielded/auth/Errors";
+import { PasswordUnavailable } from "@yielded/auth/Password";
+import { ProofUnavailable } from "@yielded/auth/Proofs";
+import { SessionUnavailable } from "@yielded/auth/Sessions";
+import type { AnyRelations } from "drizzle-orm";
+import { type EffectLibsqlDatabase, makeWithDefaults } from "drizzle-orm/effect-libsql";
+import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import { Context, Effect, Option } from "effect";
+
+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 { makeSqliteEmailTarget, sqliteEmailConfiguration } from "./drizzle/sqlite-emails";
+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";
+
+// @effect/sql-libsql owns a driver-specific transaction context rather than
+// SqlClient.transactionService. This tag name is an upstream private detail
+// verified against 4.0.0-rc.112 and must be rechecked on driver upgrades;
+// Context's string-key identity makes the installed-version guard possible.
+const LibsqlTransaction = Context.Service<unknown>(
+  "@effect/sql-libsql/LibsqlClient/LibsqlTransaction",
+);
+
+const requireStandalone = Effect.serviceOption(LibsqlTransaction).pipe(
+  Effect.flatMap(
+    Option.match({
+      onNone: () => Effect.void,
+      onSome: () =>
+        AuthStoreError.make({
+          message: "Use the decision consume API inside an outer database transaction",
+        }),
+    }),
+  ),
+);
+
+const requireStandaloneSession = Effect.serviceOption(LibsqlTransaction).pipe(
+  Effect.flatMap(
+    Option.match({
+      onNone: () => Effect.void,
+      onSome: () => SessionUnavailable.make({}),
+    }),
+  ),
+);
+
+const requireStandaloneProof = Effect.serviceOption(LibsqlTransaction).pipe(
+  Effect.flatMap(
+    Option.match({
+      onNone: () => Effect.void,
+      onSome: () => ProofUnavailable.make({}),
+    }),
+  ),
+);
+
+const requireStandalonePassword = Effect.serviceOption(LibsqlTransaction).pipe(
+  Effect.flatMap(
+    Option.match({
+      onNone: () => Effect.void,
+      onSome: () => PasswordUnavailable.make({}),
+    }),
+  ),
+);
+
+const requireStandaloneEmail = Effect.serviceOption(LibsqlTransaction).pipe(
+  Effect.flatMap(
+    Option.match({
+      onNone: () => Effect.void,
+      onSome: () => EmailUnavailable.make({}),
+    }),
+  ),
+);
+
+const sessionTarget = makeSqliteSessionTarget<EffectLibsqlDatabase<AnyRelations>>(
+  sqliteSessionConfiguration("interactive", requireStandaloneSession),
+);
+
+const proofTarget = makeSqliteProofTarget<EffectLibsqlDatabase<AnyRelations>>(
+  sqliteProofConfiguration("interactive", requireStandaloneProof),
+);
+
+const passwordTarget = makeSqlitePasswordTarget<EffectLibsqlDatabase<AnyRelations>>(
+  sqlitePasswordConfiguration("interactive", requireStandalonePassword, requireStandaloneProof),
+);
+
+const emailTarget = makeSqliteEmailTarget<EffectLibsqlDatabase<AnyRelations>>(
+  sqliteEmailConfiguration("interactive", requireStandaloneEmail, requireStandaloneProof),
+);
+
+export const {
+  coordinateEmailAddress,
+  coordinateEmailRegistration,
+  makeEmailAddressServices,
+  makeEmailRegistrationServices,
+  makeEmailSignInServices,
+} = emailTarget;
+
+export const {
+  coordinatePasswordPersistence,
+  coordinatePasswordRegistration,
+  makePasswordPersistenceServices,
+  makePasswordRegistrationServices,
+} = passwordTarget;
+
+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 makeAuthStoreServices = <C extends AnySQLiteTable, R extends AnySQLiteTable>(
+  database: EffectLibsqlDatabase<AnyRelations>,
+  mapping: AuthStoreTables<C, R>,
+) => makeSqliteAuthStoreServices(database, mapping, requireStandalone);
+
+export const makeOAuthStateServices = <S extends AnySQLiteTable>(
+  database: EffectLibsqlDatabase<AnyRelations>,
+  mapping: OAuthStateTables<S>,
+) => makeSqliteOAuthStateServices(database, mapping, requireStandalone);
+
+export const makeAuthServices = <
+  C extends AnySQLiteTable,
+  R extends AnySQLiteTable,
+  S extends AnySQLiteTable,
+>(
+  database: EffectLibsqlDatabase<AnyRelations>,
+  mapping: AuthTables<C, R, S>,
+) => makeSqliteAuthServices(database, mapping, requireStandalone);
+
+export const makeIdentityServices = <
+  Subject extends AnySQLiteTable,
+  Identifier extends AnySQLiteTable,
+  External extends AnySQLiteTable,
+  Request extends AnySQLiteTable,
+  NativeId,
+>(
+  database: EffectLibsqlDatabase<AnyRelations>,
+  mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
+) => makeSqliteIdentityServices(database, mapping, "interactive");
+
+export const makeSubjectProvisioningServices = <
+  Subject extends AnySQLiteTable,
+  Identifier extends AnySQLiteTable,
+  Request extends AnySQLiteTable,
+  NativeId,
+>(
+  database: EffectLibsqlDatabase<AnyRelations>,
+  mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
+) => makeSqliteSubjectProvisioningServices(database, mapping, "interactive");
+
+export const makeExternalIdentityServices = <
+  Subject extends AnySQLiteTable,
+  External extends AnySQLiteTable,
+  NativeId,
+>(
+  database: EffectLibsqlDatabase<AnyRelations>,
+  mapping: ExternalIdentityTables<Subject, External, NativeId>,
+) => makeSqliteExternalIdentityServices(database, mapping);
+
+import { makeSqlitePasswordPreparedTarget } from "./drizzle/sqlite-password-prepared";
+
+const passwordPreparedTarget = makeSqlitePasswordPreparedTarget<EffectLibsqlDatabase<AnyRelations>>(
+  sqlitePasswordConfiguration("interactive", requireStandalonePassword, requireStandaloneProof),
+);
+
+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<
+  EffectLibsqlDatabase<AnyRelations>,
+  AnySQLiteTable<{ dialect: "sqlite" }>
+>({
+  mode: "interactive",
+  dialect: "sqlite",
+  locking: false,
+  standaloneGuard: sqlClientOAuthStandaloneGuard,
+});
+
+export const {
+  makeOAuthAccountsServices,
+  makeOAuthSignInServices,
+  makeOAuthRegistrationIntentServices,
+  makeOAuthRegistrationServices,
+  coordinateOAuthRegistration,
+  coordinateOAuthSignIn,
+  coordinateOAuthRegistrationIntents,
+  coordinateOAuthAccounts,
+  makeOAuthConnectedServices,
+  makeOAuthConnectedRevocationServices,
+  coordinateOAuthConnected,
+  coordinateOAuthConnectedRevocations,
+} = oauthTarget;
+
+import { makePasskeyTarget } from "./drizzle/passkey-drivers";
+import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
+
+const passkeyTarget = makePasskeyTarget<
+  EffectLibsqlDatabase<AnyRelations>,
+  AnySQLiteTable<{ dialect: "sqlite" }>
+>({
+  mode: "interactive",
+  dialect: "sqlite",
+  locking: false,
+  standaloneGuard: sqlClientPasskeyStandaloneGuard,
+});
+
+export const {
+  makePasskeyCredentialServices,
+  makePasskeyPersistenceServices,
+  makePasskeyEnrollmentContextServices,
+  makePasskeyRegistrationCeremonyServices,
+  coordinatePasskeyPersistence,
+  coordinatePasskeyRegistrationCeremony,
+  makePasskeyManagementServices,
+  makePasskeyRegistrationServices,
+  coordinatePasskeyManagement,
+  coordinatePasskeyRegistration,
+} = passkeyTarget;
+
+import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
+
+const totpTarget = makeTotpTarget<
+  EffectLibsqlDatabase<AnyRelations>,
+  AnySQLiteTable<{ dialect: "sqlite" }>
+>({
+  mode: "interactive",
+  dialect: "sqlite",
+  locking: false,
+  standaloneGuard: sqlClientTotpStandaloneGuard,
+});
+
+export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTarget;
+
+import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
+
+const phoneTarget = makePhoneTarget<
+  EffectLibsqlDatabase<AnyRelations>,
+  AnySQLiteTable<{ dialect: "sqlite" }>
+>({
+  mode: "interactive",
+  dialect: "sqlite",
+  locking: false,
+  standaloneGuard: sqlClientPhoneStandaloneGuard,
+});
+
+export const { makePhonePersistenceServices, coordinatePhonePersistence } = phoneTarget;
+
+import { drizzleMigrationsLayer } from "./internal/drizzle-migrations";
+import { sqlitePersistence } from "./internal/drizzle-sqlite";
+
+export const AuthPersistence = {
+  ...sqlitePersistence(makeWithDefaults({})),
+  migrationsLayer: drizzleMigrationsLayer(
+    makeWithDefaults({}),
+    Effect.promise(() => import("drizzle-orm/effect-libsql/migrator")).pipe(
+      Effect.map((module) => module.migrate),
+    ),
+  ),
+};

package/src/DrizzleMysql2.ts

@@ -0,0 +1,184 @@
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import type { AnyMySqlTable } from "drizzle-orm/mysql-core";
+
+import type { AuthTables, IdentityTables } from "./drizzle/model";
+import {
+  coordinateMysqlAuthStoreTransaction,
+  coordinateMysqlAuthTransaction,
+  coordinateMysqlOAuthStateTransaction,
+  makeMysqlAuthServices,
+  makeMysqlAuthStoreServices,
+  makeMysqlOAuthStateServices,
+} from "./drizzle/mysql";
+import {
+  makeMysqlExternalIdentityServices,
+  makeMysqlIdentityServices,
+  makeMysqlSubjectProvisioningServices,
+} from "./drizzle/mysql-identity";
+
+export {
+  coordinateMysqlAuthenticationAuthority as coordinateAuthenticationAuthority,
+  coordinateMysqlPendingAuthentication as coordinatePendingAuthentication,
+  coordinateMysqlSignedSessionValidity as coordinateSignedSessionValidity,
+  coordinateMysqlStatefulSessions as coordinateStatefulSessions,
+  makeMysqlAuthenticationAuthorityServices as makeAuthenticationAuthorityServices,
+  makeMysqlPendingAuthenticationServices as makePendingAuthenticationServices,
+  makeMysqlSignedSessionValidityServices as makeSignedSessionValidityServices,
+  makeMysqlStatefulSessionServices as makeStatefulSessionServices,
+} from "./drizzle/mysql-sessions";
+
+export {
+  coordinateMysqlProofPersistence as coordinateProofPersistence,
+  makeMysqlProofPersistenceServices as makeProofPersistenceServices,
+} from "./drizzle/mysql-proofs";
+
+export {
+  coordinateMysqlPasswordPersistence as coordinatePasswordPersistence,
+  coordinateMysqlPasswordRegistration as coordinatePasswordRegistration,
+  makeMysqlPasswordPersistenceServices as makePasswordPersistenceServices,
+  makeMysqlPasswordRegistrationServices as makePasswordRegistrationServices,
+} from "./drizzle/mysql-passwords";
+
+export {
+  coordinateMysqlEmailAddress as coordinateEmailAddress,
+  coordinateMysqlEmailRegistration as coordinateEmailRegistration,
+  makeMysqlEmailAddressServices as makeEmailAddressServices,
+  makeMysqlEmailRegistrationServices as makeEmailRegistrationServices,
+  makeMysqlEmailSignInServices as makeEmailSignInServices,
+} from "./drizzle/mysql-emails";
+
+export {
+  coordinateMysqlAuthStoreTransaction as coordinateAuthStoreTransaction,
+  coordinateMysqlAuthTransaction as coordinateAuthTransaction,
+  coordinateMysqlOAuthStateTransaction as coordinateOAuthStateTransaction,
+  makeMysqlAuthStoreServices as makeAuthStoreServices,
+  makeMysqlExternalIdentityServices as makeExternalIdentityServices,
+  makeMysqlOAuthStateServices as makeOAuthStateServices,
+  makeMysqlSubjectProvisioningServices as makeSubjectProvisioningServices,
+};
+
+export const commitMode = "interactive" as const;
+
+export const makeAuthServices = <
+  C extends AnyMySqlTable,
+  R extends AnyMySqlTable,
+  S extends AnyMySqlTable,
+>(
+  database: EffectMysql2Database<AnyRelations>,
+  mapping: AuthTables<C, R, S>,
+) => makeMysqlAuthServices(database, mapping);
+
+export const makeIdentityServices = <
+  Subject extends AnyMySqlTable,
+  Identifier extends AnyMySqlTable,
+  External extends AnyMySqlTable,
+  Request extends AnyMySqlTable,
+  NativeId,
+>(
+  database: EffectMysql2Database<AnyRelations>,
+  mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
+) => makeMysqlIdentityServices(database, mapping);
+
+export {
+  makeMysqlSessionStepUpServices as makeSessionStepUpServices,
+  coordinateMysqlSessionStepUp as coordinateSessionStepUp,
+} from "./drizzle/mysql-sessions";
+
+export {
+  makeMySqlPasswordPreparedPersistenceServices as makePasswordPreparedPersistenceServices,
+  coordinateMySqlPasswordPreparedPersistence as coordinatePasswordPreparedPersistence,
+} from "./drizzle/mysql-password-prepared";
+
+export { passwordPreparedPersistenceLayer } from "./drizzle/password-prepared-target";
+
+import { makeOAuthTarget } from "./drizzle/oauth-drivers";
+import { mysqlOAuthTransaction } from "./drizzle/oauth-mysql";
+import { sqlClientOAuthStandaloneGuard } from "./drizzle/oauth-target";
+
+const oauthTarget = makeOAuthTarget<
+  EffectMysql2Database<AnyRelations>,
+  AnyMySqlTable<{ dialect: "mysql" }>
+>({
+  mode: "interactive",
+  dialect: "mysql",
+  locking: true,
+  transaction: mysqlOAuthTransaction,
+  standaloneGuard: sqlClientOAuthStandaloneGuard,
+});
+
+export const {
+  makeOAuthAccountsServices,
+  makeOAuthSignInServices,
+  makeOAuthRegistrationIntentServices,
+  makeOAuthRegistrationServices,
+  coordinateOAuthRegistration,
+  coordinateOAuthSignIn,
+  coordinateOAuthRegistrationIntents,
+  coordinateOAuthAccounts,
+  makeOAuthConnectedServices,
+  makeOAuthConnectedRevocationServices,
+  coordinateOAuthConnected,
+  coordinateOAuthConnectedRevocations,
+} = oauthTarget;
+
+import { makePasskeyTarget } from "./drizzle/passkey-drivers";
+import { unavailable as passkeyUnavailable } from "./drizzle/passkey-state";
+import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
+import { mysqlTransaction } from "./drizzle/transaction-mysql";
+
+const passkeyTarget = makePasskeyTarget<
+  EffectMysql2Database<AnyRelations>,
+  AnyMySqlTable<{ dialect: "mysql" }>
+>({
+  mode: "interactive",
+  dialect: "mysql",
+  locking: true,
+  standaloneGuard: sqlClientPasskeyStandaloneGuard,
+  transaction: (database, body) => mysqlTransaction(passkeyUnavailable, database, body),
+});
+
+export const {
+  makePasskeyCredentialServices,
+  makePasskeyPersistenceServices,
+  makePasskeyEnrollmentContextServices,
+  makePasskeyRegistrationCeremonyServices,
+  coordinatePasskeyPersistence,
+  coordinatePasskeyRegistrationCeremony,
+  makePasskeyManagementServices,
+  makePasskeyRegistrationServices,
+  coordinatePasskeyManagement,
+  coordinatePasskeyRegistration,
+} = passkeyTarget;
+
+import { unavailable as totpUnavailable } from "./drizzle/totp-state";
+import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
+
+const totpTarget = makeTotpTarget<
+  EffectMysql2Database<AnyRelations>,
+  AnyMySqlTable<{ dialect: "mysql" }>
+>({
+  mode: "interactive",
+  dialect: "mysql",
+  locking: true,
+  standaloneGuard: sqlClientTotpStandaloneGuard,
+  transaction: (database, body) => mysqlTransaction(totpUnavailable, database, body),
+});
+
+export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTarget;
+
+import { unavailable as phoneUnavailable } from "./drizzle/phone-state";
+import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
+
+const phoneTarget = makePhoneTarget<
+  EffectMysql2Database<AnyRelations>,
+  AnyMySqlTable<{ dialect: "mysql" }>
+>({
+  mode: "interactive",
+  dialect: "mysql",
+  locking: true,
+  standaloneGuard: sqlClientPhoneStandaloneGuard,
+  transaction: (database, body) => mysqlTransaction(phoneUnavailable, database, body),
+});
+
+export const { makePhonePersistenceServices, coordinatePhonePersistence } = phoneTarget;

package/src/DrizzlePglite.ts

@@ -0,0 +1,174 @@
+import type { AnyRelations } from "drizzle-orm";
+import { type EffectPgDatabase, makeWithDefaults } from "drizzle-orm/effect-pglite";
+import type { AnyPgTable } from "drizzle-orm/pg-core";
+import { Effect } from "effect";
+
+import type { AuthTables, IdentityTables } from "./drizzle/model";
+import {
+  coordinatePgAuthStoreTransaction,
+  coordinatePgAuthTransaction,
+  coordinatePgOAuthStateTransaction,
+  makePgAuthServices,
+  makePgAuthStoreServices,
+  makePgExternalIdentityServices,
+  makePgIdentityServices,
+  makePgOAuthStateServices,
+  makePgSubjectProvisioningServices,
+} from "./drizzle/pg";
+
+export {
+  coordinatePgAuthenticationAuthority as coordinateAuthenticationAuthority,
+  coordinatePgPendingAuthentication as coordinatePendingAuthentication,
+  coordinatePgSignedSessionValidity as coordinateSignedSessionValidity,
+  coordinatePgStatefulSessions as coordinateStatefulSessions,
+  makePgAuthenticationAuthorityServices as makeAuthenticationAuthorityServices,
+  makePgPendingAuthenticationServices as makePendingAuthenticationServices,
+  makePgSignedSessionValidityServices as makeSignedSessionValidityServices,
+  makePgStatefulSessionServices as makeStatefulSessionServices,
+} from "./drizzle/pg-sessions";
+
+export {
+  coordinatePgProofPersistence as coordinateProofPersistence,
+  makePgProofPersistenceServices as makeProofPersistenceServices,
+} from "./drizzle/pg-proofs";
+
+export {
+  coordinatePgPasswordPersistence as coordinatePasswordPersistence,
+  coordinatePgPasswordRegistration as coordinatePasswordRegistration,
+  makePgPasswordPersistenceServices as makePasswordPersistenceServices,
+  makePgPasswordRegistrationServices as makePasswordRegistrationServices,
+} from "./drizzle/pg-passwords";
+
+export {
+  coordinatePgEmailAddress as coordinateEmailAddress,
+  coordinatePgEmailRegistration as coordinateEmailRegistration,
+  makePgEmailAddressServices as makeEmailAddressServices,
+  makePgEmailRegistrationServices as makeEmailRegistrationServices,
+  makePgEmailSignInServices as makeEmailSignInServices,
+} from "./drizzle/pg-emails";
+
+export {
+  coordinatePgAuthStoreTransaction as coordinateAuthStoreTransaction,
+  coordinatePgAuthTransaction as coordinateAuthTransaction,
+  coordinatePgOAuthStateTransaction as coordinateOAuthStateTransaction,
+  makePgAuthStoreServices as makeAuthStoreServices,
+  makePgExternalIdentityServices as makeExternalIdentityServices,
+  makePgOAuthStateServices as makeOAuthStateServices,
+  makePgSubjectProvisioningServices as makeSubjectProvisioningServices,
+};
+
+export const commitMode = "interactive" as const;
+
+export const makeAuthServices = <C extends AnyPgTable, R extends AnyPgTable, S extends AnyPgTable>(
+  database: EffectPgDatabase<AnyRelations>,
+  mapping: AuthTables<C, R, S>,
+) => makePgAuthServices(database, mapping);
+
+export const makeIdentityServices = <
+  Subject extends AnyPgTable,
+  Identifier extends AnyPgTable,
+  External extends AnyPgTable,
+  Request extends AnyPgTable,
+  NativeId,
+>(
+  database: EffectPgDatabase<AnyRelations>,
+  mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
+) => makePgIdentityServices(database, mapping);
+
+export {
+  makePgSessionStepUpServices as makeSessionStepUpServices,
+  coordinatePgSessionStepUp as coordinateSessionStepUp,
+} from "./drizzle/pg-sessions";
+
+export {
+  makePgPasswordPreparedPersistenceServices as makePasswordPreparedPersistenceServices,
+  coordinatePgPasswordPreparedPersistence as coordinatePasswordPreparedPersistence,
+} from "./drizzle/pg-password-prepared";
+
+export { passwordPreparedPersistenceLayer } from "./drizzle/password-prepared-target";
+
+import { makeOAuthTarget } from "./drizzle/oauth-drivers";
+import { sqlClientOAuthStandaloneGuard } from "./drizzle/oauth-target";
+
+const oauthTarget = makeOAuthTarget<EffectPgDatabase<AnyRelations>, AnyPgTable<{ dialect: "pg" }>>({
+  mode: "interactive",
+  dialect: "pg",
+  locking: true,
+  standaloneGuard: sqlClientOAuthStandaloneGuard,
+});
+
+export const {
+  makeOAuthAccountsServices,
+  makeOAuthSignInServices,
+  makeOAuthRegistrationIntentServices,
+  makeOAuthRegistrationServices,
+  coordinateOAuthRegistration,
+  coordinateOAuthSignIn,
+  coordinateOAuthRegistrationIntents,
+  coordinateOAuthAccounts,
+  makeOAuthConnectedServices,
+  makeOAuthConnectedRevocationServices,
+  coordinateOAuthConnected,
+  coordinateOAuthConnectedRevocations,
+} = oauthTarget;
+
+import { makePasskeyTarget } from "./drizzle/passkey-drivers";
+import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
+
+const passkeyTarget = makePasskeyTarget<
+  EffectPgDatabase<AnyRelations>,
+  AnyPgTable<{ dialect: "pg" }>
+>({
+  mode: "interactive",
+  dialect: "pg",
+  locking: true,
+  standaloneGuard: sqlClientPasskeyStandaloneGuard,
+});
+
+export const {
+  makePasskeyCredentialServices,
+  makePasskeyPersistenceServices,
+  makePasskeyEnrollmentContextServices,
+  makePasskeyRegistrationCeremonyServices,
+  coordinatePasskeyPersistence,
+  coordinatePasskeyRegistrationCeremony,
+  makePasskeyManagementServices,
+  makePasskeyRegistrationServices,
+  coordinatePasskeyManagement,
+  coordinatePasskeyRegistration,
+} = passkeyTarget;
+
+import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
+
+const totpTarget = makeTotpTarget<EffectPgDatabase<AnyRelations>, AnyPgTable<{ dialect: "pg" }>>({
+  mode: "interactive",
+  dialect: "pg",
+  locking: true,
+  standaloneGuard: sqlClientTotpStandaloneGuard,
+});
+
+export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTarget;
+
+import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
+
+const phoneTarget = makePhoneTarget<EffectPgDatabase<AnyRelations>, AnyPgTable<{ dialect: "pg" }>>({
+  mode: "interactive",
+  dialect: "pg",
+  locking: true,
+  standaloneGuard: sqlClientPhoneStandaloneGuard,
+});
+
+export const { makePhonePersistenceServices, coordinatePhonePersistence } = phoneTarget;
+
+import { drizzleMigrationsLayer } from "./internal/drizzle-migrations";
+import { postgresPersistence } from "./internal/drizzle-postgres";
+
+export const AuthPersistence = {
+  ...postgresPersistence(makeWithDefaults({})),
+  migrationsLayer: drizzleMigrationsLayer(
+    makeWithDefaults({}),
+    Effect.promise(() => import("drizzle-orm/effect-pglite/migrator")).pipe(
+      Effect.map((module) => module.migrate),
+    ),
+  ),
+};