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

package/src/drizzle/oauth-target.ts

@@ -1,48 +1,265 @@
-import type { OAuthKernel } from "@yielded/auth-persistence/Adapter";
+import {
+  captureOAuthMapping,
+  makeNativeOAuthSignInServices,
+  makeNativeOAuthAccountsServices,
+  makeNativeOAuthRegistrationIntentServices,
+  makeNativeOAuthRegistrationServices,
+  makeNativeOAuthConnectedServices,
+  makeNativeOAuthRevocationServices,
+  type OAuthNativeReadMapping,
+  type OAuthNativeAccountsMapping,
+  type OAuthNativeRegistrationIntentMapping,
+  type OAuthNativeRegistrationMapping,
+  type OAuthNativeConnectedMapping,
+  type OAuthNativeRevocationMapping,
+} from "@yielded/auth-persistence/Adapter";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import { OAuthUnavailable } from "@yielded/auth/OAuth";
+import { Effect } from "effect";
+
+import type { D1BatchStatements } from "./D1BatchStatements";
+import type { NativeDatabaseHandle } from "./native-database";
+import {
+  nativeTarget,
+  coordinateNativeTarget,
+  type NativeTargetConfiguration,
+} from "./native-target";
+import { validateDrizzleStorage } from "./storage-validation";
 
-import { oauthKernel } from "./oauth-kernel";
+export {
+  oauthAccountsPersistenceLayer,
+  oauthSignInPersistenceLayer,
+  oauthRegistrationIntentsLayer,
+  oauthRegistrationAuthorityLayer,
+  oauthConnectedPersistenceLayer,
+  oauthConnectedRevocationsLayer,
+} from "@yielded/auth-persistence/Adapter";
 
-export const sqlClientOAuthStandaloneGuard: OAuthKernel["target"]["sqlClientOAuthStandaloneGuard"] =
-  oauthKernel.target.sqlClientOAuthStandaloneGuard;
+export type OAuthTargetConfiguration = NativeTargetConfiguration;
 
-export const makeTargetOAuthSignInServices: OAuthKernel["target"]["makeTargetOAuthSignInServices"] =
-  oauthKernel.target.makeTargetOAuthSignInServices;
+export type OAuthCoordinatorError<E> = E | OAuthUnavailable;
+const unavailable = () => OAuthUnavailable.make({});
 
-export const makeTargetOAuthRegistrationIntentServices: OAuthKernel["target"]["makeTargetOAuthRegistrationIntentServices"] =
-  oauthKernel.target.makeTargetOAuthRegistrationIntentServices;
+const mapped = Effect.fnUntraced(function* (
+  original: unknown,
+  configuration: OAuthTargetConfiguration,
+) {
+  const mapping = captureOAuthMapping(original);
 
-export const makeTargetOAuthRegistrationServices: OAuthKernel["target"]["makeTargetOAuthRegistrationServices"] =
-  oauthKernel.target.makeTargetOAuthRegistrationServices;
+  yield* validateDrizzleStorage(mapping).pipe(Effect.mapError(unavailable));
+  if (
+    configuration.mode === "batch" &&
+    !(
+      typeof mapping === "object" &&
+      mapping !== null &&
+      "d1" in mapping &&
+      typeof mapping.d1 === "object" &&
+      mapping.d1 !== null &&
+      "primary" in mapping.d1 &&
+      mapping.d1.primary === true
+    )
+  )
+    return yield* unavailable();
 
-export const coordinateTargetOAuthRegistration: OAuthKernel["target"]["coordinateTargetOAuthRegistration"] =
-  oauthKernel.target.coordinateTargetOAuthRegistration;
+  return { mapping, ...(yield* nativeTarget(configuration)) };
+});
 
-export const coordinateTargetOAuthSignIn: OAuthKernel["target"]["coordinateTargetOAuthSignIn"] =
-  oauthKernel.target.coordinateTargetOAuthSignIn;
+export const makeTargetOAuthSignInServices = (
+  source: unknown,
+  configuration: OAuthTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* mapped(source, configuration);
 
-export const coordinateTargetOAuthRegistrationIntents: OAuthKernel["target"]["coordinateTargetOAuthRegistrationIntents"] =
-  oauthKernel.target.coordinateTargetOAuthRegistrationIntents;
+    return yield* target.provide(
+      makeNativeOAuthSignInServices(
+        target.tables,
+        target.mapping as OAuthNativeReadMapping,
+        target.batch,
+      ),
+    );
+  });
 
-export const coordinateTargetOAuthAccounts: OAuthKernel["target"]["coordinateTargetOAuthAccounts"] =
-  oauthKernel.target.coordinateTargetOAuthAccounts;
+export const makeTargetOAuthAccountsServices = (
+  source: unknown,
+  configuration: OAuthTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* mapped(source, configuration);
 
-export const makeTargetOAuthAccountsServices: OAuthKernel["target"]["makeTargetOAuthAccountsServices"] =
-  oauthKernel.target.makeTargetOAuthAccountsServices;
+    return yield* target.provide(
+      makeNativeOAuthAccountsServices(
+        target.tables,
+        target.mapping as OAuthNativeAccountsMapping,
+        target.batch,
+      ),
+    );
+  });
 
-export const oauthAccountsPersistenceLayer: OAuthKernel["target"]["oauthAccountsPersistenceLayer"] =
-  oauthKernel.target.oauthAccountsPersistenceLayer;
+export const makeTargetOAuthRegistrationIntentServices = (
+  source: unknown,
+  configuration: OAuthTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* mapped(source, configuration);
 
-export const oauthSignInPersistenceLayer: OAuthKernel["target"]["oauthSignInPersistenceLayer"] =
-  oauthKernel.target.oauthSignInPersistenceLayer;
+    return yield* target.provide(
+      makeNativeOAuthRegistrationIntentServices(
+        target.tables,
+        target.mapping as OAuthNativeRegistrationIntentMapping,
+        target.batch,
+      ),
+    );
+  });
 
-export const oauthRegistrationIntentsLayer: OAuthKernel["target"]["oauthRegistrationIntentsLayer"] =
-  oauthKernel.target.oauthRegistrationIntentsLayer;
+export const makeTargetOAuthConnectedServices = (
+  source: unknown,
+  configuration: OAuthTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* mapped(source, configuration);
 
-export const oauthRegistrationAuthorityLayer: OAuthKernel["target"]["oauthRegistrationAuthorityLayer"] =
-  oauthKernel.target.oauthRegistrationAuthorityLayer;
+    return yield* target.provide(
+      makeNativeOAuthConnectedServices(
+        target.tables,
+        target.mapping as OAuthNativeConnectedMapping,
+        target.batch,
+      ),
+    );
+  });
 
-export type {
-  OAuthTargetConfiguration,
-  OAuthCoordinatorError,
-  OAuthExecution,
-} from "@yielded/auth-persistence/Adapter";
+export const makeTargetOAuthConnectedRevocationServices = (
+  source: unknown,
+  configuration: OAuthTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* mapped(source, configuration);
+
+    return yield* target.provide(
+      makeNativeOAuthRevocationServices(
+        target.tables,
+        target.mapping as OAuthNativeRevocationMapping,
+        target.batch,
+      ),
+    );
+  });
+
+export const makeTargetOAuthRegistrationServices = <Registration>(
+  source: unknown,
+  configuration: OAuthTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* mapped(source, configuration);
+
+    return yield* target.provide(
+      makeNativeOAuthRegistrationServices(
+        target.tables,
+        target.mapping as OAuthNativeRegistrationMapping<Registration>,
+        target.batch,
+      ),
+    );
+  });
+
+const coordinateOwner = <Services, Transaction, A, E, R, ES, RS>(
+  database: NativeDatabaseHandle,
+  configuration: OAuthTargetConfiguration,
+  make: Effect.Effect<Services, ES, RS>,
+  body: (transaction: Transaction, services: Services) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | OAuthUnavailable, Exclude<R, D1BatchStatements> | RS | LifecycleHooks> =>
+  coordinateNativeTarget(unavailable, database, configuration, make, body);
+
+export const coordinateTargetOAuthSignIn = <Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  mapping: unknown,
+  configuration: OAuthTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetOAuthSignInServices>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinateOwner(
+    database,
+    configuration,
+    makeTargetOAuthSignInServices(mapping, configuration),
+    body,
+  );
+
+export const coordinateTargetOAuthAccounts = <Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  mapping: unknown,
+  configuration: OAuthTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetOAuthAccountsServices>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinateOwner(
+    database,
+    configuration,
+    makeTargetOAuthAccountsServices(mapping, configuration),
+    body,
+  );
+
+export const coordinateTargetOAuthRegistrationIntents = <Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  mapping: unknown,
+  configuration: OAuthTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetOAuthRegistrationIntentServices>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinateOwner(
+    database,
+    configuration,
+    makeTargetOAuthRegistrationIntentServices(mapping, configuration),
+    body,
+  );
+
+export const coordinateTargetOAuthConnected = <Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  mapping: unknown,
+  configuration: OAuthTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetOAuthConnectedServices>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinateOwner(
+    database,
+    configuration,
+    makeTargetOAuthConnectedServices(mapping, configuration),
+    body,
+  );
+
+export const coordinateTargetOAuthConnectedRevocations = <Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  mapping: unknown,
+  configuration: OAuthTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetOAuthConnectedRevocationServices>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinateOwner(
+    database,
+    configuration,
+    makeTargetOAuthConnectedRevocationServices(mapping, configuration),
+    body,
+  );
+
+export const coordinateTargetOAuthRegistration = <Registration, Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  mapping: unknown,
+  configuration: OAuthTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetOAuthRegistrationServices<Registration>>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinateOwner(
+    database,
+    configuration,
+    makeTargetOAuthRegistrationServices<Registration>(mapping, configuration),
+    body,
+  );

package/src/drizzle/passkey/target.ts

@@ -0,0 +1,205 @@
+import {
+  type SqlBatchCommit,
+  makeBatchPasskeyServices,
+  makeNativePasskeyCeremonyServices,
+  makeNativePasskeyCredentialServices,
+  makeNativePasskeyServices,
+  type NativeSqlTables,
+  type NativePasskeyCeremonyMapping,
+  type PasskeyNativeMapping,
+  type PasskeyNativeRead,
+} from "@yielded/auth-persistence/Adapter";
+import { LifecycleHooks } from "@yielded/auth/Hooks";
+import { PasskeyConfigurationError, PasskeyUnavailable } from "@yielded/auth/Passkey";
+import { type Crypto, Effect } from "effect";
+import type { SqlClient } from "effect/sql";
+
+import type { D1BatchStatements } from "../D1BatchStatements";
+import type { PersistenceMappingError } from "../model";
+import {
+  NativeDatabase,
+  type NativeDatabaseHandle,
+  type NativePhysicalDatabase,
+} from "../native-database";
+import {
+  nativeTarget,
+  coordinateNativeTarget,
+  type NativeTargetConfiguration,
+} from "../native-target";
+import type { PasskeyPersistenceServices, PasskeyMappingSource } from "../passkey-model";
+import { validateDrizzleStorage } from "../storage-validation";
+export type PasskeyTargetConfiguration = NativeTargetConfiguration;
+
+export type PasskeyCoordinatorError<E> =
+  | E
+  | PasskeyUnavailable
+  | PasskeyConfigurationError
+  | PersistenceMappingError;
+
+const unavailable = () => PasskeyUnavailable.make({});
+
+const emptyHooks: LifecycleHooks["Service"] = {
+  before: () => Effect.void,
+  after: () => Effect.succeed([]),
+};
+
+// Mapped table/SQL generics end here. Persisted values are decoded by shared schemas.
+export const capturePasskeyMapping = <M, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+) =>
+  Effect.flatMap(Effect.isEffect(source) ? source : Effect.succeed(source), (mapping) =>
+    validateDrizzleStorage(mapping).pipe(
+      Effect.andThen(
+        Effect.try({
+          try: () => {
+            if (
+              configuration.mode === "batch" &&
+              !(
+                typeof mapping === "object" &&
+                mapping !== null &&
+                "d1" in mapping &&
+                typeof mapping.d1 === "object" &&
+                mapping.d1 !== null &&
+                "primary" in mapping.d1 &&
+                mapping.d1.primary === true
+              )
+            )
+              throw PasskeyConfigurationError.make({});
+
+            return mapping;
+          },
+          catch: () => PasskeyConfigurationError.make({}),
+        }),
+      ),
+    ),
+  );
+
+type NativePasskeyServices = Effect.Success<ReturnType<typeof makeNativePasskeyServices>>;
+
+interface PasskeyMapped<M> {
+  readonly mapping: M;
+  readonly database: NativePhysicalDatabase;
+  readonly tables: NativeSqlTables;
+  readonly batch: SqlBatchCommit["Service"] | undefined;
+  readonly provide: <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, Exclude<Exclude<R, SqlClient.SqlClient>, SqlBatchCommit>>;
+  readonly base: () => Effect.Effect<NativePasskeyServices, never, Crypto.Crypto | LifecycleHooks>;
+}
+
+export const makePasskeyMapped = Effect.fnUntraced(function* <M, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+): Effect.fn.Return<
+  PasskeyMapped<M>,
+  PasskeyConfigurationError | PersistenceMappingError,
+  R | NativeDatabase
+> {
+  const mapping = yield* capturePasskeyMapping(source, configuration);
+  const database = yield* NativeDatabase;
+  const { tables, batch, provide } = yield* nativeTarget(configuration);
+  const native = mapping as unknown as PasskeyNativeMapping;
+
+  return {
+    mapping,
+    database,
+    tables,
+    batch,
+    provide,
+    base: () =>
+      provide(
+        configuration.mode === "batch"
+          ? makeBatchPasskeyServices(tables, native)
+          : makeNativePasskeyServices(tables, native),
+      ),
+  };
+});
+
+export const makeTargetPasskeyCredentials = <M, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* makePasskeyMapped(source, configuration);
+
+    return yield* target
+      .provide(
+        makeNativePasskeyCredentialServices(
+          target.tables,
+          target.mapping as unknown as PasskeyNativeRead,
+        ),
+      )
+      .pipe(Effect.provideService(LifecycleHooks, emptyHooks));
+  }).pipe(Effect.catchDefect(() => Effect.fail(PasskeyConfigurationError.make({}))));
+
+export const makeTargetPasskeyPersistence = <M, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* makePasskeyMapped(source, configuration);
+
+    const base = yield* target.base();
+
+    return { passkeyPersistence: base.passkeyPersistence } satisfies PasskeyPersistenceServices;
+  });
+
+export const makeTargetPasskeyRegistration = <M, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* makePasskeyMapped(source, configuration);
+
+    return yield* target.provide(
+      makeNativePasskeyCeremonyServices(
+        target.tables,
+        target.mapping as unknown as NativePasskeyCeremonyMapping,
+        configuration.mode === "batch" ? target.batch : undefined,
+      ),
+    );
+  });
+
+export const coordinatePasskeyOwner = <S, Transaction, A, E, R, ESetup, RSetup>(
+  database: NativeDatabaseHandle,
+  configuration: PasskeyTargetConfiguration,
+  make: Effect.Effect<S, ESetup, RSetup>,
+  body: (transaction: Transaction, services: S) => Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | PasskeyUnavailable,
+  Exclude<R, D1BatchStatements> | RSetup | LifecycleHooks
+> => coordinateNativeTarget(unavailable, database, configuration, make, body);
+
+export const coordinateTargetPasskey = <M, RSetup, Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  source: PasskeyMappingSource<M, RSetup>,
+  configuration: PasskeyTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetPasskeyPersistence>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinatePasskeyOwner(
+    database,
+    configuration,
+    makeTargetPasskeyPersistence(source, configuration),
+    body,
+  );
+
+export const coordinateTargetPasskeyRegistration = <M, RSetup, Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  source: PasskeyMappingSource<M, RSetup>,
+  configuration: PasskeyTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: Effect.Success<ReturnType<typeof makeTargetPasskeyRegistration>>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinatePasskeyOwner(
+    database,
+    configuration,
+    makeTargetPasskeyRegistration(source, configuration),
+    body,
+  );

package/src/drizzle/passkey/write-target.ts

@@ -0,0 +1,91 @@
+import {
+  makePasskeyNativeManagement,
+  makePasskeyNativeRegistration,
+  type NativePasskeyManagementMapping,
+  type NativePasskeyRegistrationMapping,
+} from "@yielded/auth-persistence/Adapter";
+import { PasskeyManagementPersistence } from "@yielded/auth/Passkey";
+import { Effect, Layer } from "effect";
+
+import type { NativeDatabaseHandle } from "../native-database";
+import type { PasskeyMappingSource } from "../passkey-model";
+import type {
+  PasskeyManagementServices,
+  PasskeyRegistrationServices,
+} from "../passkey-write-model";
+import {
+  coordinatePasskeyOwner,
+  makePasskeyMapped,
+  type PasskeyTargetConfiguration,
+} from "./target";
+
+export const passkeyManagementPersistenceLayer = <E, R>(
+  services: Effect.Effect<PasskeyManagementServices, E, R>,
+) =>
+  Layer.effect(
+    PasskeyManagementPersistence,
+    Effect.map(services, (value) => value.passkeyManagementPersistence),
+  );
+
+export const makeTargetPasskeyManagement = <M, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* makePasskeyMapped(source, configuration);
+    const base = yield* target.base();
+
+    return {
+      passkeyPersistence: base.passkeyPersistence,
+      ...makePasskeyNativeManagement(
+        base,
+        target.mapping as unknown as NativePasskeyManagementMapping,
+      ),
+    };
+  });
+
+export const makeTargetPasskeyRegistrationWriter = <M, Value, R>(
+  source: PasskeyMappingSource<M, R>,
+  configuration: PasskeyTargetConfiguration,
+) =>
+  Effect.gen(function* () {
+    const target = yield* makePasskeyMapped(source, configuration);
+    const base = yield* target.base();
+
+    return {
+      passkeyPersistence: base.passkeyPersistence,
+      ...makePasskeyNativeRegistration(
+        base,
+        target.mapping as unknown as NativePasskeyRegistrationMapping<Value>,
+      ),
+    };
+  });
+
+export const coordinateTargetPasskeyManagement = <M, RSetup, Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  source: PasskeyMappingSource<M, RSetup>,
+  configuration: PasskeyTargetConfiguration,
+  body: (transaction: Transaction, services: PasskeyManagementServices) => Effect.Effect<A, E, R>,
+) =>
+  coordinatePasskeyOwner(
+    database,
+    configuration,
+    makeTargetPasskeyManagement(source, configuration),
+    body,
+  );
+
+export const coordinateTargetPasskeyRegistrationWriter = <M, Value, RSetup, Transaction, A, E, R>(
+  database: NativeDatabaseHandle,
+  source: PasskeyMappingSource<M, RSetup>,
+  configuration: PasskeyTargetConfiguration,
+  body: (
+    transaction: Transaction,
+    services: PasskeyRegistrationServices<Value>,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  coordinatePasskeyOwner(
+    database,
+    configuration,
+    makeTargetPasskeyRegistrationWriter<M, Value, RSetup>(source, configuration),
+    body,
+  );