@voyant-travel/storefront 0.120.1

package/dist/verification/index.d.ts

@@ -0,0 +1,12 @@
+import type { HonoModule } from "@voyant-travel/hono/module";
+import { type StorefrontVerificationRoutesOptions } from "./routes-public.js";
+export type { StorefrontVerificationPublicRoutes, StorefrontVerificationRoutesOptions, } from "./routes-public.js";
+export { buildStorefrontVerificationSenders, createStorefrontVerificationPublicRoutes, STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, } from "./routes-public.js";
+export type { NewStorefrontVerificationChallenge, StorefrontVerificationChallenge, } from "./schema.js";
+export { storefrontVerificationChallenges, storefrontVerificationChannelEnum, storefrontVerificationLinkable, storefrontVerificationModule, storefrontVerificationStatusEnum, } from "./schema.js";
+export type { StorefrontVerificationDeliveryResult, StorefrontVerificationEmailSendInput, StorefrontVerificationNotificationChannel, StorefrontVerificationNotificationPayload, StorefrontVerificationNotificationProvider, StorefrontVerificationNotificationResult, StorefrontVerificationProviderOptions, StorefrontVerificationSenders, StorefrontVerificationServiceOptions, StorefrontVerificationSmsSendInput, } from "./service.js";
+export { createStorefrontVerificationSendersFromProviders, createStorefrontVerificationService, StorefrontVerificationError, } from "./service.js";
+export type { ConfirmEmailVerificationChallengeInput, ConfirmSmsVerificationChallengeInput, StartEmailVerificationChallengeInput, StartSmsVerificationChallengeInput, StorefrontVerificationChallengeRecord, StorefrontVerificationChannel, StorefrontVerificationConfirmResult, StorefrontVerificationStartResult, StorefrontVerificationStatus, } from "./validation.js";
+export { confirmEmailVerificationChallengeSchema, confirmSmsVerificationChallengeSchema, startEmailVerificationChallengeSchema, startSmsVerificationChallengeSchema, storefrontVerificationChallengeRecordSchema, storefrontVerificationChannelSchema, storefrontVerificationConfirmResultSchema, storefrontVerificationStartResultSchema, storefrontVerificationStatusSchema, } from "./validation.js";
+export declare function createStorefrontVerificationHonoModule(options?: StorefrontVerificationRoutesOptions): HonoModule;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/verification/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,EAIL,KAAK,mCAAmC,EACzC,MAAM,oBAAoB,CAAA;AAG3B,YAAY,EACV,kCAAkC,EAClC,mCAAmC,GACpC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,kCAAkC,EAClC,wCAAwC,EACxC,6CAA6C,GAC9C,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EACV,kCAAkC,EAClC,+BAA+B,GAChC,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,gCAAgC,EAChC,iCAAiC,EACjC,8BAA8B,EAC9B,4BAA4B,EAC5B,gCAAgC,GACjC,MAAM,aAAa,CAAA;AACpB,YAAY,EACV,oCAAoC,EACpC,oCAAoC,EACpC,yCAAyC,EACzC,yCAAyC,EACzC,0CAA0C,EAC1C,wCAAwC,EACxC,qCAAqC,EACrC,6BAA6B,EAC7B,oCAAoC,EACpC,kCAAkC,GACnC,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,gDAAgD,EAChD,mCAAmC,EACnC,2BAA2B,GAC5B,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,sCAAsC,EACtC,oCAAoC,EACpC,oCAAoC,EACpC,kCAAkC,EAClC,qCAAqC,EACrC,6BAA6B,EAC7B,mCAAmC,EACnC,iCAAiC,EACjC,4BAA4B,GAC7B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,uCAAuC,EACvC,qCAAqC,EACrC,qCAAqC,EACrC,mCAAmC,EACnC,2CAA2C,EAC3C,mCAAmC,EACnC,yCAAyC,EACzC,uCAAuC,EACvC,kCAAkC,GACnC,MAAM,iBAAiB,CAAA;AAExB,wBAAgB,sCAAsC,CACpD,OAAO,CAAC,EAAE,mCAAmC,GAC5C,UAAU,CAeZ"}

package/dist/verification/index.js

@@ -0,0 +1,18 @@
+import { buildStorefrontVerificationSenders, createStorefrontVerificationPublicRoutes, STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, } from "./routes-public.js";
+import { storefrontVerificationModule } from "./schema.js";
+export { buildStorefrontVerificationSenders, createStorefrontVerificationPublicRoutes, STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, } from "./routes-public.js";
+export { storefrontVerificationChallenges, storefrontVerificationChannelEnum, storefrontVerificationLinkable, storefrontVerificationModule, storefrontVerificationStatusEnum, } from "./schema.js";
+export { createStorefrontVerificationSendersFromProviders, createStorefrontVerificationService, StorefrontVerificationError, } from "./service.js";
+export { confirmEmailVerificationChallengeSchema, confirmSmsVerificationChallengeSchema, startEmailVerificationChallengeSchema, startSmsVerificationChallengeSchema, storefrontVerificationChallengeRecordSchema, storefrontVerificationChannelSchema, storefrontVerificationConfirmResultSchema, storefrontVerificationStartResultSchema, storefrontVerificationStatusSchema, } from "./validation.js";
+export function createStorefrontVerificationHonoModule(options) {
+    const module = {
+        ...storefrontVerificationModule,
+        bootstrap: ({ bindings, container }) => {
+            container.register(STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, buildStorefrontVerificationSenders(bindings, options));
+        },
+    };
+    return {
+        module,
+        publicRoutes: createStorefrontVerificationPublicRoutes(options),
+    };
+}

package/dist/verification/routes-public.d.ts

@@ -0,0 +1,121 @@
+import type { ModuleContainer } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type StorefrontVerificationNotificationProvider, type StorefrontVerificationProviderOptions, type StorefrontVerificationSenders, type StorefrontVerificationServiceOptions } from "./service.js";
+type Env = {
+    Bindings: Record<string, unknown>;
+    Variables: {
+        container: ModuleContainer;
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export interface StorefrontVerificationRoutesOptions extends StorefrontVerificationServiceOptions, StorefrontVerificationProviderOptions {
+    sendEmailChallenge?: StorefrontVerificationSenders["sendEmailChallenge"];
+    sendSmsChallenge?: StorefrontVerificationSenders["sendSmsChallenge"];
+    providers?: ReadonlyArray<StorefrontVerificationNotificationProvider>;
+    resolveProviders?: (bindings: Record<string, unknown>) => ReadonlyArray<StorefrontVerificationNotificationProvider>;
+}
+export declare const STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY = "providers.storefrontVerification.senders";
+export declare function buildStorefrontVerificationSenders(bindings: Record<string, unknown>, options?: StorefrontVerificationRoutesOptions): StorefrontVerificationSenders;
+export declare function createStorefrontVerificationPublicRoutes(options?: StorefrontVerificationRoutesOptions): import("hono/hono-base").HonoBase<Env, {
+    "/email/start": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/email/confirm": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                code: "sender_not_configured";
+            } | {
+                error: string;
+                code: "challenge_not_found";
+            } | {
+                error: string;
+                code: "challenge_expired";
+            } | {
+                error: string;
+                code: "challenge_invalid" | "challenge_failed";
+            } | {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404 | 400 | 409 | 410 | 501;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    channel: "email" | "sms";
+                    destination: string;
+                    purpose: string;
+                    status: "failed" | "pending" | "cancelled" | "expired" | "verified";
+                    expiresAt: string;
+                    verifiedAt: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/sms/start": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/sms/confirm": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                code: "sender_not_configured";
+            } | {
+                error: string;
+                code: "challenge_not_found";
+            } | {
+                error: string;
+                code: "challenge_expired";
+            } | {
+                error: string;
+                code: "challenge_invalid" | "challenge_failed";
+            } | {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404 | 400 | 409 | 410 | 501;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    channel: "email" | "sms";
+                    destination: string;
+                    purpose: string;
+                    status: "failed" | "pending" | "cancelled" | "expired" | "verified";
+                    expiresAt: string;
+                    verifiedAt: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/sms/confirm">;
+export type StorefrontVerificationPublicRoutes = ReturnType<typeof createStorefrontVerificationPublicRoutes>;
+export {};
+//# sourceMappingURL=routes-public.d.ts.map

package/dist/verification/routes-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../../src/verification/routes-public.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAIL,KAAK,0CAA0C,EAC/C,KAAK,qCAAqC,EAC1C,KAAK,6BAA6B,EAClC,KAAK,oCAAoC,EAC1C,MAAM,cAAc,CAAA;AAQrB,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,SAAS,EAAE,eAAe,CAAA;QAC1B,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,MAAM,WAAW,mCACf,SAAQ,oCAAoC,EAC1C,qCAAqC;IACvC,kBAAkB,CAAC,EAAE,6BAA6B,CAAC,oBAAoB,CAAC,CAAA;IACxE,gBAAgB,CAAC,EAAE,6BAA6B,CAAC,kBAAkB,CAAC,CAAA;IACpE,SAAS,CAAC,EAAE,aAAa,CAAC,0CAA0C,CAAC,CAAA;IACrE,gBAAgB,CAAC,EAAE,CACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,aAAa,CAAC,0CAA0C,CAAC,CAAA;CAC/D;AAED,eAAO,MAAM,6CAA6C,6CACd,CAAA;AAE5C,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,mCAAmC,GAC5C,6BAA6B,CAgB/B;AA2ED,wBAAgB,wCAAwC,CACtD,OAAO,CAAC,EAAE,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6D9C;AAED,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,OAAO,wCAAwC,CAChD,CAAA"}

package/dist/verification/routes-public.js

@@ -0,0 +1,125 @@
+import { clientIpKey, enforceRateLimit, parseJsonBody } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { createStorefrontVerificationSendersFromProviders, createStorefrontVerificationService, StorefrontVerificationError, } from "./service.js";
+import { confirmEmailVerificationChallengeSchema, confirmSmsVerificationChallengeSchema, startEmailVerificationChallengeSchema, startSmsVerificationChallengeSchema, } from "./validation.js";
+export const STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY = "providers.storefrontVerification.senders";
+export function buildStorefrontVerificationSenders(bindings, options) {
+    const senders = {
+        sendEmailChallenge: options?.sendEmailChallenge,
+        sendSmsChallenge: options?.sendSmsChallenge,
+    };
+    if (!senders.sendEmailChallenge || !senders.sendSmsChallenge) {
+        const providers = options?.resolveProviders?.(bindings) ?? options?.providers;
+        if (providers?.length) {
+            const providerSenders = createStorefrontVerificationSendersFromProviders(providers, options);
+            senders.sendEmailChallenge ??= providerSenders.sendEmailChallenge;
+            senders.sendSmsChallenge ??= providerSenders.sendSmsChallenge;
+        }
+    }
+    return senders;
+}
+function getSenders(bindings, options, resolveFromContainer) {
+    if (resolveFromContainer) {
+        try {
+            return resolveFromContainer(STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY);
+        }
+        catch {
+            // Fall back to per-request sender construction when bootstrap has not run.
+        }
+    }
+    return buildStorefrontVerificationSenders(bindings, options);
+}
+function errorResponse(error) {
+    if (error instanceof StorefrontVerificationError) {
+        if (error.code === "sender_not_configured") {
+            return { status: 501, body: { error: error.message, code: error.code } };
+        }
+        if (error.code === "challenge_not_found") {
+            return { status: 404, body: { error: error.message, code: error.code } };
+        }
+        if (error.code === "challenge_expired") {
+            return { status: 410, body: { error: error.message, code: error.code } };
+        }
+        if (error.code === "challenge_invalid" || error.code === "challenge_failed") {
+            return { status: 409, body: { error: error.message, code: error.code } };
+        }
+    }
+    const message = error instanceof Error ? error.message : "Verification request failed";
+    return { status: 400, body: { error: message } };
+}
+function normalizeDestination(channel, destination) {
+    return channel === "email" ? destination.trim().toLowerCase() : destination.trim();
+}
+async function enforceVerificationStartLimits(c, channel, destination) {
+    const normalized = normalizeDestination(channel, destination);
+    return ((await enforceRateLimit(c, {
+        bucket: `storefront-verification:${channel}:destination-cooldown`,
+        max: 1,
+        windowSeconds: 30,
+        clientKey: () => normalized,
+    })) ??
+        (await enforceRateLimit(c, {
+            bucket: `storefront-verification:${channel}:destination-hour`,
+            max: channel === "sms" ? 5 : 10,
+            windowSeconds: 60 * 60,
+            clientKey: () => normalized,
+        })) ??
+        (await enforceRateLimit(c, {
+            bucket: `storefront-verification:${channel}:ip-hour`,
+            max: channel === "sms" ? 20 : 40,
+            windowSeconds: 60 * 60,
+            clientKey: clientIpKey,
+        })));
+}
+export function createStorefrontVerificationPublicRoutes(options) {
+    const service = createStorefrontVerificationService(options);
+    return new Hono()
+        .post("/email/start", async (c) => {
+        try {
+            const body = await parseJsonBody(c, startEmailVerificationChallengeSchema);
+            const limited = await enforceVerificationStartLimits(c, "email", body.email);
+            if (limited)
+                return limited;
+            const result = await service.startEmailChallenge(c.get("db"), body, getSenders(c.env, options, (key) => c.var.container.resolve(key)));
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    })
+        .post("/email/confirm", async (c) => {
+        try {
+            const result = await service.confirmEmailChallenge(c.get("db"), await parseJsonBody(c, confirmEmailVerificationChallengeSchema));
+            return c.json({ data: result });
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    })
+        .post("/sms/start", async (c) => {
+        try {
+            const body = await parseJsonBody(c, startSmsVerificationChallengeSchema);
+            const limited = await enforceVerificationStartLimits(c, "sms", body.phone);
+            if (limited)
+                return limited;
+            const result = await service.startSmsChallenge(c.get("db"), body, getSenders(c.env, options, (key) => c.var.container.resolve(key)));
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    })
+        .post("/sms/confirm", async (c) => {
+        try {
+            const result = await service.confirmSmsChallenge(c.get("db"), await parseJsonBody(c, confirmSmsVerificationChallengeSchema));
+            return c.json({ data: result });
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    });
+}

package/dist/verification/schema.d.ts

@@ -0,0 +1,273 @@
+import type { LinkableDefinition, Module } from "@voyant-travel/core";
+export declare const storefrontVerificationChannelEnum: import("drizzle-orm/pg-core").PgEnum<["email", "sms"]>;
+export declare const storefrontVerificationStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "verified", "expired", "failed", "cancelled"]>;
+export declare const storefrontVerificationChallenges: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "storefront_verification_challenges";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        channel: import("drizzle-orm/pg-core").PgColumn<{
+            name: "channel";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "email" | "sms";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["email", "sms"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        destination: import("drizzle-orm/pg-core").PgColumn<{
+            name: "destination";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        purpose: import("drizzle-orm/pg-core").PgColumn<{
+            name: "purpose";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        codeHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code_hash";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "failed" | "pending" | "cancelled" | "expired" | "verified";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "verified", "expired", "failed", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attemptCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt_count";
+            tableName: "storefront_verification_challenges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_attempts";
+            tableName: "storefront_verification_challenges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastSentAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_sent_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "verified_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "storefront_verification_challenges";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const storefrontVerificationChallengesRelations: import("drizzle-orm").Relations<"storefront_verification_challenges", {}>;
+export type StorefrontVerificationChallenge = typeof storefrontVerificationChallenges.$inferSelect;
+export type NewStorefrontVerificationChallenge = typeof storefrontVerificationChallenges.$inferInsert;
+export declare const storefrontVerificationLinkable: LinkableDefinition;
+export declare const storefrontVerificationModule: Module;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/verification/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAKrE,eAAO,MAAM,iCAAiC,wDAG5C,CAAA;AAEF,eAAO,MAAM,gCAAgC,iGAM3C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC5C,CAAA;AAED,eAAO,MAAM,yCAAyC,2EAGrD,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG,OAAO,gCAAgC,CAAC,YAAY,CAAA;AAClG,MAAM,MAAM,kCAAkC,GAC5C,OAAO,gCAAgC,CAAC,YAAY,CAAA;AAEtD,eAAO,MAAM,8BAA8B,EAAE,kBAK5C,CAAA;AAED,eAAO,MAAM,4BAA4B,EAAE,MAK1C,CAAA"}

package/dist/verification/schema.js

@@ -0,0 +1,50 @@
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { relations } from "drizzle-orm";
+import { index, integer, jsonb, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+export const storefrontVerificationChannelEnum = pgEnum("storefront_verification_channel", [
+    "email",
+    "sms",
+]);
+export const storefrontVerificationStatusEnum = pgEnum("storefront_verification_status", [
+    "pending",
+    "verified",
+    "expired",
+    "failed",
+    "cancelled",
+]);
+export const storefrontVerificationChallenges = pgTable("storefront_verification_challenges", {
+    id: typeId("storefront_verification_challenges"),
+    channel: storefrontVerificationChannelEnum("channel").notNull(),
+    destination: text("destination").notNull(),
+    purpose: text("purpose").notNull().default("contact_confirmation"),
+    codeHash: text("code_hash").notNull(),
+    status: storefrontVerificationStatusEnum("status").notNull().default("pending"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    maxAttempts: integer("max_attempts").notNull().default(5),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    lastSentAt: timestamp("last_sent_at", { withTimezone: true }).notNull().defaultNow(),
+    verifiedAt: timestamp("verified_at", { withTimezone: true }),
+    failedAt: timestamp("failed_at", { withTimezone: true }),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_storefront_verification_channel").on(table.channel),
+    index("idx_storefront_verification_destination").on(table.destination),
+    index("idx_storefront_verification_purpose").on(table.purpose),
+    index("idx_storefront_verification_status").on(table.status),
+    index("idx_storefront_verification_lookup").on(table.channel, table.destination, table.purpose, table.updatedAt, table.createdAt),
+]);
+export const storefrontVerificationChallengesRelations = relations(storefrontVerificationChallenges, () => ({}));
+export const storefrontVerificationLinkable = {
+    module: "storefront-verification",
+    entity: "storefrontVerificationChallenge",
+    table: "storefront_verification_challenges",
+    idPrefix: "svch",
+};
+export const storefrontVerificationModule = {
+    name: "storefront-verification",
+    linkable: {
+        storefrontVerificationChallenge: storefrontVerificationLinkable,
+    },
+};