@voyant-travel/storefront 0.120.1

package/dist/verification/service.d.ts

@@ -0,0 +1,114 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ConfirmEmailVerificationChallengeInput, ConfirmSmsVerificationChallengeInput, StartEmailVerificationChallengeInput, StartSmsVerificationChallengeInput } from "./validation.js";
+export interface StorefrontVerificationServiceOptions {
+    codeLength?: number;
+    expiresInSeconds?: number;
+    maxAttempts?: number;
+    now?: () => Date;
+}
+export interface StorefrontVerificationDeliveryResult {
+    id?: string;
+    provider?: string;
+}
+export type StorefrontVerificationNotificationChannel = "email" | "sms" | (string & {});
+export interface StorefrontVerificationNotificationPayload {
+    to: string;
+    channel: StorefrontVerificationNotificationChannel;
+    provider?: string;
+    template: string;
+    data?: unknown;
+    subject?: string;
+    text?: string;
+}
+export interface StorefrontVerificationNotificationResult {
+    id?: string;
+    provider: string;
+}
+export interface StorefrontVerificationNotificationProvider {
+    readonly name: string;
+    readonly channels: ReadonlyArray<StorefrontVerificationNotificationChannel>;
+    send(payload: StorefrontVerificationNotificationPayload): Promise<StorefrontVerificationNotificationResult>;
+}
+export interface StorefrontVerificationEmailSendInput {
+    email: string;
+    code: string;
+    purpose: string;
+    locale?: string | null;
+    expiresAt: Date;
+    metadata?: Record<string, unknown> | null;
+}
+export interface StorefrontVerificationSmsSendInput {
+    phone: string;
+    code: string;
+    purpose: string;
+    locale?: string | null;
+    expiresAt: Date;
+    metadata?: Record<string, unknown> | null;
+}
+export interface StorefrontVerificationSenders {
+    sendEmailChallenge?: (input: StorefrontVerificationEmailSendInput) => Promise<StorefrontVerificationDeliveryResult | undefined>;
+    sendSmsChallenge?: (input: StorefrontVerificationSmsSendInput) => Promise<StorefrontVerificationDeliveryResult | undefined>;
+}
+export interface StorefrontVerificationProviderOptions {
+    email?: {
+        provider?: string;
+        template?: string;
+        subject?: string | ((input: StorefrontVerificationEmailSendInput) => string);
+    };
+    sms?: {
+        provider?: string;
+        template?: string;
+    };
+}
+export declare class StorefrontVerificationError extends Error {
+    readonly code: "sender_not_configured" | "challenge_not_found" | "challenge_expired" | "challenge_invalid" | "challenge_failed";
+    constructor(message: string, code: "sender_not_configured" | "challenge_not_found" | "challenge_expired" | "challenge_invalid" | "challenge_failed");
+}
+export declare function createStorefrontVerificationSendersFromProviders(providers: ReadonlyArray<StorefrontVerificationNotificationProvider>, options?: StorefrontVerificationProviderOptions): StorefrontVerificationSenders;
+export declare function createStorefrontVerificationService(options?: StorefrontVerificationServiceOptions): {
+    startEmailChallenge(db: PostgresJsDatabase, input: StartEmailVerificationChallengeInput, senders: StorefrontVerificationSenders): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "failed" | "pending" | "cancelled" | "expired" | "verified";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    startSmsChallenge(db: PostgresJsDatabase, input: StartSmsVerificationChallengeInput, senders: StorefrontVerificationSenders): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "failed" | "pending" | "cancelled" | "expired" | "verified";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    confirmEmailChallenge(db: PostgresJsDatabase, input: ConfirmEmailVerificationChallengeInput): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "failed" | "pending" | "cancelled" | "expired" | "verified";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    confirmSmsChallenge(db: PostgresJsDatabase, input: ConfirmSmsVerificationChallengeInput): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "failed" | "pending" | "cancelled" | "expired" | "verified";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/verification/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/verification/service.ts"],"names":[],"mappings":"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"}

package/dist/verification/service.js

@@ -0,0 +1,283 @@
+import { and, desc, eq } from "drizzle-orm";
+import { storefrontVerificationChallenges } from "./schema.js";
+export class StorefrontVerificationError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "StorefrontVerificationError";
+    }
+}
+function normalizeEmail(value) {
+    return value.trim().toLowerCase();
+}
+function normalizePhone(value) {
+    return value.trim();
+}
+function generateVerificationCode(length) {
+    const chars = "0123456789";
+    const bytes = new Uint8Array(length);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => chars[byte % chars.length]).join("");
+}
+async function hashVerificationCode(code) {
+    const bytes = new TextEncoder().encode(code);
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function toChallengeRecord(row) {
+    return {
+        id: row.id,
+        channel: row.channel,
+        destination: row.destination,
+        purpose: row.purpose,
+        status: row.status,
+        expiresAt: row.expiresAt,
+        verifiedAt: row.verifiedAt ?? null,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function requireChallengeRow(row, operation) {
+    if (!row) {
+        throw new Error(`Storefront verification ${operation} did not return a challenge row`);
+    }
+    return row;
+}
+async function getLatestChallenge(db, channel, destination, purpose) {
+    const [row] = await db
+        .select()
+        .from(storefrontVerificationChallenges)
+        .where(and(eq(storefrontVerificationChallenges.channel, channel), eq(storefrontVerificationChallenges.destination, destination), eq(storefrontVerificationChallenges.purpose, purpose)))
+        .orderBy(desc(storefrontVerificationChallenges.updatedAt), desc(storefrontVerificationChallenges.createdAt))
+        .limit(1);
+    return row ?? null;
+}
+async function startChallenge(db, channel, destination, purpose, metadata, options) {
+    const now = options?.now?.() ?? new Date();
+    const codeLength = Math.max(4, Math.min(8, options?.codeLength ?? 6));
+    const maxAttempts = Math.max(1, options?.maxAttempts ?? 5);
+    const expiresInSeconds = Math.max(60, options?.expiresInSeconds ?? 600);
+    const expiresAt = new Date(now.getTime() + expiresInSeconds * 1000);
+    const code = generateVerificationCode(codeLength);
+    const codeHash = await hashVerificationCode(code);
+    const existing = await getLatestChallenge(db, channel, destination, purpose);
+    if (existing && existing.status === "pending" && existing.expiresAt > now) {
+        const [updated] = await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            codeHash,
+            attemptCount: 0,
+            maxAttempts,
+            expiresAt,
+            lastSentAt: now,
+            failedAt: null,
+            verifiedAt: null,
+            metadata: metadata ?? null,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, existing.id))
+            .returning();
+        return { challenge: requireChallengeRow(updated, "update"), code };
+    }
+    if (existing && existing.status === "pending" && existing.expiresAt <= now) {
+        await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            status: "expired",
+            failedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, existing.id));
+    }
+    const [created] = await db
+        .insert(storefrontVerificationChallenges)
+        .values({
+        channel,
+        destination,
+        purpose,
+        codeHash,
+        status: "pending",
+        attemptCount: 0,
+        maxAttempts,
+        expiresAt,
+        lastSentAt: now,
+        metadata: metadata ?? null,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .returning();
+    return { challenge: requireChallengeRow(created, "insert"), code };
+}
+async function confirmChallenge(db, channel, destination, purpose, code, options) {
+    const now = options?.now?.() ?? new Date();
+    const row = await getLatestChallenge(db, channel, destination, purpose);
+    if (!row || row.status !== "pending") {
+        throw new StorefrontVerificationError("Verification challenge not found", "challenge_not_found");
+    }
+    if (row.expiresAt <= now) {
+        await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            status: "expired",
+            failedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, row.id));
+        throw new StorefrontVerificationError("Verification challenge expired", "challenge_expired");
+    }
+    if (row.codeHash !== (await hashVerificationCode(code))) {
+        const nextAttemptCount = row.attemptCount + 1;
+        const terminal = nextAttemptCount >= row.maxAttempts;
+        await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            attemptCount: nextAttemptCount,
+            status: terminal ? "failed" : row.status,
+            failedAt: terminal ? now : row.failedAt,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, row.id));
+        throw new StorefrontVerificationError(terminal ? "Verification challenge failed" : "Invalid verification code", terminal ? "challenge_failed" : "challenge_invalid");
+    }
+    const [verified] = await db
+        .update(storefrontVerificationChallenges)
+        .set({
+        status: "verified",
+        verifiedAt: now,
+        updatedAt: now,
+    })
+        .where(eq(storefrontVerificationChallenges.id, row.id))
+        .returning();
+    return requireChallengeRow(verified, "confirm");
+}
+export function createStorefrontVerificationSendersFromProviders(providers, options = {}) {
+    const byChannel = new Map();
+    const byName = new Map();
+    for (const provider of providers) {
+        byName.set(provider.name, provider);
+        for (const channel of provider.channels) {
+            byChannel.set(channel, provider);
+        }
+    }
+    async function send(payload) {
+        const provider = payload.provider
+            ? byName.get(payload.provider)
+            : byChannel.get(payload.channel);
+        if (!provider) {
+            throw new StorefrontVerificationError(`No verification notification provider registered for channel "${payload.channel}"`, "sender_not_configured");
+        }
+        return provider.send(payload);
+    }
+    return {
+        async sendEmailChallenge(input) {
+            const subject = typeof options.email?.subject === "function"
+                ? options.email.subject(input)
+                : options.email?.subject;
+            const result = await send({
+                to: input.email,
+                channel: "email",
+                provider: options.email?.provider,
+                template: options.email?.template ?? "storefront-verification-email",
+                subject,
+                data: {
+                    code: input.code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: input.expiresAt.toISOString(),
+                    metadata: input.metadata ?? null,
+                },
+            });
+            return { id: result.id, provider: result.provider };
+        },
+        async sendSmsChallenge(input) {
+            const result = await send({
+                to: input.phone,
+                channel: "sms",
+                provider: options.sms?.provider,
+                template: options.sms?.template ?? "storefront-verification-sms",
+                data: {
+                    code: input.code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: input.expiresAt.toISOString(),
+                    metadata: input.metadata ?? null,
+                },
+                text: `${input.code} is your verification code.`,
+            });
+            return { id: result.id, provider: result.provider };
+        },
+    };
+}
+export function createStorefrontVerificationService(options) {
+    return {
+        async startEmailChallenge(db, input, senders) {
+            const email = normalizeEmail(input.email);
+            const { challenge, code } = await startChallenge(db, "email", email, input.purpose, input.metadata, options);
+            if (!senders.sendEmailChallenge) {
+                throw new StorefrontVerificationError("Email verification sender not configured", "sender_not_configured");
+            }
+            try {
+                await senders.sendEmailChallenge({
+                    email,
+                    code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: challenge.expiresAt,
+                    metadata: input.metadata,
+                });
+            }
+            catch (error) {
+                const now = options?.now?.() ?? new Date();
+                await db
+                    .update(storefrontVerificationChallenges)
+                    .set({
+                    status: "failed",
+                    failedAt: now,
+                    updatedAt: now,
+                })
+                    .where(eq(storefrontVerificationChallenges.id, challenge.id));
+                throw error;
+            }
+            return toChallengeRecord(challenge);
+        },
+        async startSmsChallenge(db, input, senders) {
+            const phone = normalizePhone(input.phone);
+            const { challenge, code } = await startChallenge(db, "sms", phone, input.purpose, input.metadata, options);
+            if (!senders.sendSmsChallenge) {
+                throw new StorefrontVerificationError("SMS verification sender not configured", "sender_not_configured");
+            }
+            try {
+                await senders.sendSmsChallenge({
+                    phone,
+                    code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: challenge.expiresAt,
+                    metadata: input.metadata,
+                });
+            }
+            catch (error) {
+                const now = options?.now?.() ?? new Date();
+                await db
+                    .update(storefrontVerificationChallenges)
+                    .set({
+                    status: "failed",
+                    failedAt: now,
+                    updatedAt: now,
+                })
+                    .where(eq(storefrontVerificationChallenges.id, challenge.id));
+                throw error;
+            }
+            return toChallengeRecord(challenge);
+        },
+        async confirmEmailChallenge(db, input) {
+            const verified = await confirmChallenge(db, "email", normalizeEmail(input.email), input.purpose, input.code, options);
+            return toChallengeRecord(verified);
+        },
+        async confirmSmsChallenge(db, input) {
+            const verified = await confirmChallenge(db, "sms", normalizePhone(input.phone), input.purpose, input.code, options);
+            return toChallengeRecord(verified);
+        },
+    };
+}

package/dist/verification/validation.d.ts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export declare const storefrontVerificationChannelSchema: z.ZodEnum<{
+    email: "email";
+    sms: "sms";
+}>;
+export declare const storefrontVerificationStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    pending: "pending";
+    cancelled: "cancelled";
+    expired: "expired";
+    verified: "verified";
+}>;
+export declare const startEmailVerificationChallengeSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    purpose: z.ZodDefault<z.ZodString>;
+    locale: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const startSmsVerificationChallengeSchema: z.ZodObject<{
+    phone: z.ZodString;
+    purpose: z.ZodDefault<z.ZodString>;
+    locale: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const confirmEmailVerificationChallengeSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    code: z.ZodString;
+    purpose: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const confirmSmsVerificationChallengeSchema: z.ZodObject<{
+    phone: z.ZodString;
+    code: z.ZodString;
+    purpose: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const storefrontVerificationChallengeRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        email: "email";
+        sms: "sms";
+    }>;
+    destination: z.ZodString;
+    purpose: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        cancelled: "cancelled";
+        expired: "expired";
+        verified: "verified";
+    }>;
+    expiresAt: z.ZodDate;
+    verifiedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const storefrontVerificationStartResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        email: "email";
+        sms: "sms";
+    }>;
+    destination: z.ZodString;
+    purpose: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        cancelled: "cancelled";
+        expired: "expired";
+        verified: "verified";
+    }>;
+    expiresAt: z.ZodDate;
+    verifiedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const storefrontVerificationConfirmResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        email: "email";
+        sms: "sms";
+    }>;
+    destination: z.ZodString;
+    purpose: z.ZodString;
+    expiresAt: z.ZodDate;
+    verifiedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    status: z.ZodLiteral<"verified">;
+}, z.core.$strip>;
+export type StorefrontVerificationChannel = z.infer<typeof storefrontVerificationChannelSchema>;
+export type StorefrontVerificationStatus = z.infer<typeof storefrontVerificationStatusSchema>;
+export type StartEmailVerificationChallengeInput = z.infer<typeof startEmailVerificationChallengeSchema>;
+export type StartSmsVerificationChallengeInput = z.infer<typeof startSmsVerificationChallengeSchema>;
+export type ConfirmEmailVerificationChallengeInput = z.infer<typeof confirmEmailVerificationChallengeSchema>;
+export type ConfirmSmsVerificationChallengeInput = z.infer<typeof confirmSmsVerificationChallengeSchema>;
+export type StorefrontVerificationChallengeRecord = z.infer<typeof storefrontVerificationChallengeRecordSchema>;
+export type StorefrontVerificationStartResult = z.infer<typeof storefrontVerificationStartResultSchema>;
+export type StorefrontVerificationConfirmResult = z.infer<typeof storefrontVerificationConfirmResultSchema>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/verification/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/verification/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mCAAmC;;;EAA2B,CAAA;AAC3E,eAAO,MAAM,kCAAkC;;;;;;EAM7C,CAAA;AAKF,eAAO,MAAM,qCAAqC;;;;;iBAKhD,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;iBAK9C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;iBAOlD,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;iBAOhD,CAAA;AAEF,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;iBAUtD,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;iBAA8C,CAAA;AAElG,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;iBAGlD,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,qCAAqC,CAC7C,CAAA;AACD,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,qCAAqC,CAC7C,CAAA;AACD,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAA;AACD,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA"}

package/dist/verification/validation.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const storefrontVerificationChannelSchema = z.enum(["email", "sms"]);
+export const storefrontVerificationStatusSchema = z.enum([
+    "pending",
+    "verified",
+    "expired",
+    "failed",
+    "cancelled",
+]);
+const purposeSchema = z.string().trim().min(1).max(100).default("contact_confirmation");
+const metadataSchema = z.record(z.string(), z.unknown()).optional().nullable();
+export const startEmailVerificationChallengeSchema = z.object({
+    email: z.email(),
+    purpose: purposeSchema,
+    locale: z.string().trim().min(2).max(16).optional().nullable(),
+    metadata: metadataSchema,
+});
+export const startSmsVerificationChallengeSchema = z.object({
+    phone: z.string().trim().min(6).max(32),
+    purpose: purposeSchema,
+    locale: z.string().trim().min(2).max(16).optional().nullable(),
+    metadata: metadataSchema,
+});
+export const confirmEmailVerificationChallengeSchema = z.object({
+    email: z.email(),
+    code: z
+        .string()
+        .trim()
+        .regex(/^\d{4,8}$/),
+    purpose: purposeSchema,
+});
+export const confirmSmsVerificationChallengeSchema = z.object({
+    phone: z.string().trim().min(6).max(32),
+    code: z
+        .string()
+        .trim()
+        .regex(/^\d{4,8}$/),
+    purpose: purposeSchema,
+});
+export const storefrontVerificationChallengeRecordSchema = z.object({
+    id: z.string(),
+    channel: storefrontVerificationChannelSchema,
+    destination: z.string(),
+    purpose: z.string(),
+    status: storefrontVerificationStatusSchema,
+    expiresAt: z.date(),
+    verifiedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export const storefrontVerificationStartResultSchema = storefrontVerificationChallengeRecordSchema;
+export const storefrontVerificationConfirmResultSchema = storefrontVerificationChallengeRecordSchema.extend({
+    status: z.literal("verified"),
+});