@yielded/auth-persistence 0.1.0-beta.10

package/dist/internal/email-kernel.d.mts

@@ -0,0 +1,275 @@
+import { QueryFailure, QueryOperations, SqlColumn, SqlFragment } from "./query-operations.mjs";
+import { PersistenceMappingError } from "./mapping-error.mjs";
+import { AnyEmailAddressMapping, AnyEmailSignInMapping } from "./models/email-model.mjs";
+import { ProofSqlConfiguration, makeProofKernel } from "./proof-kernel.mjs";
+import { Context, DateTime, Effect, Option } from "effect";
+import { LifecycleHooks, PreparedCommit } from "@yielded/auth/Hooks";
+import { AuthenticationRevision, SecurityRevision } from "@yielded/auth/Sessions";
+import { EmailAddressMutation, EmailCredentialSnapshot, EmailUnavailable } from "@yielded/auth/Email";
+import { ProofCompletionInput } from "@yielded/auth/Proofs";
+import { LoginIdentifier } from "@yielded/auth/Identity";
+import * as SqlError$1 from "effect/unstable/sql/SqlError";
+//#region src/internal/email-kernel.d.ts
+type AdapterFailure = QueryFailure | PersistenceMappingError | SqlError$1.SqlError;
+type SignInMapping = AnyEmailSignInMapping;
+export interface EmailSqlQuery<A = ReadonlyArray<any>> extends Effect.Effect<A, AdapterFailure> {
+  readonly getSQL: () => ReturnType<QueryOperations["sql"]>;
+  readonly from: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly where: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly limit: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly orderBy: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly for: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly set: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly values: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly returning: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly innerJoin: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly onConflictDoNothing: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly onDuplicateKeyUpdate: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+  readonly $returningId: (...args: ReadonlyArray<any>) => EmailSqlQuery<A>;
+}
+export interface EmailSqlDatabase {
+  readonly select: (...args: ReadonlyArray<any>) => EmailSqlQuery;
+  readonly insert: (...args: ReadonlyArray<any>) => EmailSqlQuery;
+  readonly update: (...args: ReadonlyArray<any>) => EmailSqlQuery;
+  readonly delete: (...args: ReadonlyArray<any>) => EmailSqlQuery;
+  readonly transaction: <A, E, R>(body: (transaction: EmailSqlDatabase) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError$1.SqlError, R>;
+}
+declare const CurrentEmailSql_base: Context.ServiceClass<CurrentEmailSql, "effect-auth/CurrentEmailSql", EmailSqlDatabase>;
+export declare class CurrentEmailSql extends CurrentEmailSql_base {}
+export interface EmailSqlConfiguration {
+  readonly mode: "interactive" | "synchronous";
+  readonly locking: boolean;
+  readonly standaloneGuard: Effect.Effect<void, EmailUnavailable>;
+  readonly coordinated?: boolean;
+  readonly proof?: {
+    readonly mapping: any;
+    readonly configuration: ProofSqlConfiguration;
+  };
+}
+export interface CurrentAddress {
+  readonly nativeSubjectId: unknown;
+  readonly subject: any;
+  readonly revision: AuthenticationRevision;
+  readonly source?: {
+    readonly credential: any;
+    readonly identifier: any;
+    readonly snapshot: EmailCredentialSnapshot;
+  };
+  readonly targetIdentifier?: any;
+  readonly targetCredential?: any;
+  readonly targetIdentifierRevision?: SecurityRevision;
+  readonly eligible: boolean;
+}
+export declare const makeEmailKernel: <Fragment extends SqlFragment = SqlFragment, Column extends SqlColumn = SqlColumn>(operations: QueryOperations<Fragment, Column>, proofs: Pick<ReturnType<typeof makeProofKernel>, "completeProofPlanIn">) => {
+  validEmailSignInConstraints: (mapping: SignInMapping) => boolean;
+  emailLookupQuery: (mapping: SignInMapping, moduleId: string, identifier: LoginIdentifier) => {
+    fields: {
+      subject: any;
+      identifier: any;
+      credential: any;
+    };
+    from: any;
+    subjectTable: any;
+    subjectJoin: Fragment;
+    credentialTable: any;
+    credentialJoin: Fragment | undefined;
+    predicate: Fragment | undefined;
+    limit: number;
+  };
+  decodeEmailSnapshot: (mapping: AnyEmailSignInMapping, moduleId: string, requested: LoginIdentifier, row: any) => Effect.Effect<Readonly<{
+    moduleId: string;
+    identifierRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+    verifiedAtMillis: number;
+    credentialId: string;
+    credentialRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+    identifier: Readonly<LoginIdentifier>;
+    revision: {
+      readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+      readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      readonly credentials: readonly {
+        readonly credentialId: string;
+        readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      }[];
+    };
+  }> | undefined, EmailUnavailable | PersistenceMappingError, never>;
+  makeSqlEmailSignInTargets: (database: EmailSqlDatabase, mapping: AnyEmailSignInMapping, configuration: EmailSqlConfiguration) => Effect.Effect<{
+    readonly lookup: (input: {
+      readonly moduleId: string;
+      readonly identifier: LoginIdentifier;
+    }) => Effect.Effect<Option.Option<EmailCredentialSnapshot>, EmailUnavailable>;
+  }, never, never>;
+  currentAddress: (mapping: AnyEmailAddressMapping<Fragment>, input: {
+    readonly moduleId: string;
+    readonly subjectId: string;
+    readonly target: LoginIdentifier;
+    readonly sourceCredentialId?: string;
+  }, locking: boolean) => Effect.Effect<{
+    nativeSubjectId: unknown;
+    subject: any;
+    revision: {
+      readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+      readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      readonly credentials: readonly {
+        readonly credentialId: string;
+        readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      }[];
+    };
+    source?: {
+      readonly credential: any;
+      readonly identifier: any;
+      readonly snapshot: EmailCredentialSnapshot;
+    } | undefined;
+    targetIdentifier?: any;
+    targetCredential?: any;
+    targetIdentifierRevision?: any;
+    eligible: boolean;
+  } | undefined, EmailUnavailable | QueryFailure, CurrentEmailSql>;
+  sameEmailRevision: (left: AuthenticationRevision, right: AuthenticationRevision) => boolean;
+  snapshotEmailMutation: (input: EmailAddressMutation) => Effect.Effect<Readonly<{
+    moduleId: string;
+    commandId: import("@yielded/auth/Email").EmailCommandId;
+    completion: import("@yielded/auth/Proofs").ProofCompletionPlan;
+    invalidation?: Readonly<{
+      trigger: "all-session-revocation" | "credential-change" | "factor-reset" | "identifier-change" | "password-reset" | "subject-delete" | "subject-disable";
+      existingSessions: "immediate" | "original-absolute-expiry";
+      maximumExposureMillis: number;
+      oldAuthenticationEvidence: "rejected";
+    }> | undefined;
+    target: Readonly<{
+      namespace: string;
+      value: string;
+    }>;
+    captured: Readonly<{
+      eligible: boolean;
+      revision: {
+        readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+        readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        readonly credentials: readonly {
+          readonly credentialId: string;
+          readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        }[];
+      };
+      targetIdentifierRevision?: (string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">) | undefined;
+      source?: Readonly<{
+        moduleId: string;
+        identifierRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        verifiedAtMillis: number;
+        credentialId: string;
+        credentialRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+        identifier: Readonly<LoginIdentifier>;
+        revision: {
+          readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+          readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+          readonly credentials: readonly {
+            readonly credentialId: string;
+            readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+          }[];
+        };
+      }> | undefined;
+    }>;
+    authorization: Readonly<{
+      challenge: Readonly<{
+        moduleId: string;
+        action: "change-address" | "verify-address";
+        commandId: string & import("effect/Brand").Brand<"effect-auth/EmailCommandId">;
+        sourceCredentialId?: string | undefined;
+        targetIdentifierRevision?: (string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">) | undefined;
+        bindingDigest: string & import("effect/Brand").Brand<"effect-auth/TokenDigest">;
+        target: Readonly<{
+          namespace: string;
+          value: string;
+        }>;
+        revision: {
+          readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+          readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+          readonly credentials: readonly {
+            readonly credentialId: string;
+            readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+          }[];
+        };
+      }>;
+      evidence: Readonly<{
+        flowId: string & import("effect/Brand").Brand<"effect-auth/AuthenticationFlowId">;
+        bindingDigest: string & import("effect/Brand").Brand<"effect-auth/TokenDigest">;
+        revision: Readonly<{
+          subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+          securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+          credentials: readonly Readonly<{
+            credentialId: string;
+            revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+          }>[];
+        }>;
+        proofs: readonly [Readonly<{
+          method: string;
+          credentialId: string;
+          userVerified: boolean;
+          phishingResistant: boolean;
+          factors: readonly ("inherence" | "knowledge" | "possession")[];
+          verifiedAt: DateTime.Utc;
+        }>, ...Readonly<{
+          method: string;
+          credentialId: string;
+          userVerified: boolean;
+          phishingResistant: boolean;
+          factors: readonly ("inherence" | "knowledge" | "possession")[];
+          verifiedAt: DateTime.Utc;
+        }>[]];
+      }>;
+      requirement: Readonly<{
+        maximumAgeMillis: number;
+        alternatives: readonly [Readonly<{
+          userVerified: boolean;
+          phishingResistant: boolean;
+          minimumCredentials: number;
+          factors: readonly ("inherence" | "knowledge" | "possession")[];
+        }>, ...Readonly<{
+          userVerified: boolean;
+          phishingResistant: boolean;
+          minimumCredentials: number;
+          factors: readonly ("inherence" | "knowledge" | "possession")[];
+        }>[]];
+      }>;
+    }>;
+  }>, EmailUnavailable, never>;
+  validateEmailAuthority: (mapping: AnyEmailAddressMapping<Fragment>, configuration: EmailSqlConfiguration, input: EmailAddressMutation, action: "change-address" | "verify-address") => Effect.Effect<{
+    nativeSubjectId: unknown;
+    subject: any;
+    revision: {
+      readonly subjectId: string & import("effect/Brand").Brand<"effect-auth/SubjectId">;
+      readonly securityRevision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      readonly credentials: readonly {
+        readonly credentialId: string;
+        readonly revision: string & import("effect/Brand").Brand<"effect-auth/SecurityRevision">;
+      }[];
+    };
+    source?: {
+      readonly credential: any;
+      readonly identifier: any;
+      readonly snapshot: EmailCredentialSnapshot;
+    } | undefined;
+    targetIdentifier?: any;
+    targetCredential?: any;
+    targetIdentifierRevision?: any;
+    eligible: boolean;
+  } | undefined, EmailUnavailable | QueryFailure, CurrentEmailSql>;
+  makeSqlEmailAddressPersistence: (database: EmailSqlDatabase, mapping: AnyEmailAddressMapping<Fragment>, configuration: EmailSqlConfiguration) => Effect.Effect<{
+    readonly target: (input: {
+      readonly moduleId: string;
+      readonly subjectId: import("@yielded/auth/Schema").SubjectId;
+      readonly target: LoginIdentifier;
+      readonly sourceCredentialId?: string;
+    }) => Effect.Effect<import("@yielded/auth/Email").EmailAddressTarget, EmailUnavailable>;
+    readonly checkCompletion: (input: ProofCompletionInput) => Effect.Effect<boolean, EmailUnavailable>;
+    readonly verifyWithProof: <A>(input: EmailAddressMutation, prepare: import("@yielded/auth/Email").PrepareEmailCommit<import("@yielded/auth/Email").EmailAddressDecision, A>) => Effect.Effect<PreparedCommit<A>, EmailUnavailable>;
+    readonly changeWithProof: <A>(input: EmailAddressMutation, prepare: import("@yielded/auth/Email").PrepareEmailCommit<import("@yielded/auth/Email").EmailAddressDecision, A>) => Effect.Effect<PreparedCommit<A>, EmailUnavailable>;
+    readonly cleanup: <A>(input: {
+      readonly moduleId: string;
+      readonly limit: number;
+    }, prepare: import("@yielded/auth/Email").PrepareEmailCommit<{
+      readonly removed: number;
+      readonly hasMore: boolean;
+    }, A>) => Effect.Effect<PreparedCommit<A>, EmailUnavailable>;
+  }, never, LifecycleHooks>;
+};
+//#endregion
+//# sourceMappingURL=email-kernel.d.mts.map