@voyant-travel/auth 0.135.0 → 0.136.0

package/dist/node-runtime.js

@@ -10,13 +10,16 @@
  */
 import { openNodeDatabase } from "@voyant-travel/db/runtime";
 import { authUser, cloudAuthUserLinks, userProfilesTable, } from "@voyant-travel/db/schema/iam";
+import { parseJsonBody, } from "@voyant-travel/hono";
 import { handleApiError, reportException, requestId, } from "@voyant-travel/hono/middleware/error-boundary";
 import { getRequestId } from "@voyant-travel/hono/observability";
 import { accessCatalogScopesForRole, isFullAccessRole } from "@voyant-travel/types/member-roles";
 import { eq, sql } from "drizzle-orm";
 import { Hono } from "hono";
+import { z } from "zod";
 import { createVoyantCloudAdminAuthPlugin, revalidateVoyantCloudAdminAuthSession, revalidateVoyantCloudAdminAuthUser, } from "./cloud-admin-session.js";
 import { buildClearCloudAdminAuthStateCookie, createCloudAdminAuthStart } from "./cloud-broker.js";
+import { createDrizzleCustomerBuyerAccountStore, listCustomerBuyerAccounts, normalizeCustomerBuyerAccountPolicy, repairCustomerPersonalBuyerAccountEntitlement, resolveActiveCustomerBuyerContext, selectCustomerBuyerAccount, } from "./customer-buyer-accounts.js";
 import { createAdminBetterAuth, createCustomerBetterAuth, handleApiTokenManagementRequest, handleOrganizationMembersRequest, } from "./server.js";
 import { ensureCurrentUserProfile } from "./workspace.js";
 function classifyOperatorApiAuthSurface(requestUrl) {
@@ -292,6 +295,7 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
                 facebook: { enabled: false, credentialRef: null },
                 apple: { enabled: false, credentialRef: null },
             },
+            accountPolicy: normalizeCustomerBuyerAccountPolicy(),
         };
         const raw = env.VOYANT_CUSTOMER_AUTH_CONFIG_JSON?.trim();
         if (!raw)
@@ -321,11 +325,11 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
                     facebook: social(methods.facebook),
                     apple: social(methods.apple),
                 },
+                accountPolicy: normalizeCustomerBuyerAccountPolicy(parsed.accountPolicy),
             };
         }
-        catch {
-            console.error("[auth/customer] Invalid VOYANT_CUSTOMER_AUTH_CONFIG_JSON; failing social auth closed");
-            return fallback;
+        catch (error) {
+            throw new Error("Invalid VOYANT_CUSTOMER_AUTH_CONFIG_JSON", { cause: error });
         }
     }
     function defaultCustomerAuthContext(env, policy) {
@@ -373,6 +377,7 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
                         : {}),
                 },
             },
+            accountPolicy: policy.accountPolicy,
         };
     }
     async function resolveCustomerAuthContext(env, request) {
@@ -423,7 +428,8 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
         return parsed.toString().replace(/\/$/, "");
     }
     async function publicCustomerAuthConfiguration(env, request) {
-        const methods = (await resolveCustomerAuthContext(env, request)).methods;
+        const context = await resolveCustomerAuthContext(env, request);
+        const methods = context.methods;
         const providers = methods.socialProviders ?? {};
         return {
             methods: {
@@ -433,6 +439,7 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
                 facebook: Boolean(providers.facebook),
                 apple: Boolean(providers.apple),
             },
+            accountPolicy: normalizeCustomerBuyerAccountPolicy(context.accountPolicy),
         };
     }
     function buildAdminBetterAuth(env, db) {
@@ -492,9 +499,9 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
             },
         });
     }
-    async function buildCustomerBetterAuth(env, db, request) {
+    async function buildCustomerBetterAuth(env, db, request, resolvedContext) {
         const emailSender = runtimeOptions.resolveEmailSender?.(env);
-        const context = await resolveCustomerAuthContext(env, request);
+        const context = resolvedContext ?? (await resolveCustomerAuthContext(env, request));
         const publicApiBaseURL = context.publicApiBaseURL ?? getPublicApiBaseUrl(env);
         const authDb = db;
         return createCustomerBetterAuth({
@@ -504,6 +511,7 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
             basePath: "/auth/customer",
             trustedOrigins: context.trustedOrigins,
             methods: withCustomerSocialRedirectUris(context.methods, publicApiBaseURL),
+            accountPolicy: context.accountPolicy,
             sendResetPassword: async ({ user, url }) => {
                 const publicUrl = withCustomerPublicResetPasswordUrl(url, publicApiBaseURL);
                 if (!emailSender) {
@@ -581,8 +589,11 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
         }
         const { db, dispose } = openDatabase(env);
         try {
+            const customerContext = customerSurface
+                ? await resolveCustomerAuthContext(env, request)
+                : null;
             const auth = customerSurface
-                ? await buildCustomerBetterAuth(env, db, request)
+                ? await buildCustomerBetterAuth(env, db, request, customerContext ?? undefined)
                 : buildAdminBetterAuth(env, db);
             const session = await auth.api.getSession({ headers: request.headers });
             if (!session) {
@@ -609,9 +620,25 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
                 }
             }
             if (customerSurface) {
-                return {
+                await repairCustomerPersonalBuyerAccountEntitlement(db, session.user.id);
+                const buyerStore = createDrizzleCustomerBuyerAccountStore(db);
+                const relationshipPersonId = await buyerStore.getRelationshipPersonId(session.user.id);
+                const activeAuthOrganizationId = session.session.activeOrganizationId ?? null;
+                const buyer = await resolveActiveCustomerBuyerContext({
+                    identity: {
+                        userId: session.user.id,
+                        name: session.user.name ?? null,
+                        email: session.user.email ?? null,
+                    },
+                    activeAuthOrganizationId,
+                    policy: customerContext?.accountPolicy,
+                    store: buyerStore,
+                });
+                const customerIdentity = {
                     userId: session.user.id,
                     sessionId: session.session.id,
+                    // Existing organizationId is staff/workspace context. Customer buyer
+                    // scoping uses the explicit discriminated buyer fields below.
                     organizationId: null,
                     callerType: "session",
                     actor: "customer",
@@ -619,6 +646,22 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
                     scopes: [],
                     email: session.user.email ?? null,
                 };
+                if (!buyer) {
+                    return {
+                        ...customerIdentity,
+                        relationshipPersonId,
+                    };
+                }
+                return {
+                    ...customerIdentity,
+                    buyerAccountId: buyer.id,
+                    buyerAccountKind: buyer.kind,
+                    authOrganizationId: buyer.authOrganizationId,
+                    relationshipOrganizationId: buyer.relationshipOrganizationId,
+                    relationshipPersonId,
+                    buyerMembershipId: buyer.membershipId,
+                    buyerMembershipRole: buyer.membershipRole,
+                };
             }
             return {
                 userId: session.user.id,
@@ -951,8 +994,10 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
         }
     });
     auth.get("/auth/customer/config", async (c) => {
+        c.header("Cache-Control", "no-store");
         if (c.env.VOYANT_CUSTOMER_AUTH_MODE?.trim() === "disabled") {
             return c.json({
+                disabled: true,
                 methods: {
                     emailCode: false,
                     emailPassword: false,
@@ -964,6 +1009,88 @@ export function createOperatorAuthNodeRuntime(runtimeOptions) {
         }
         return c.json(await publicCustomerAuthConfiguration(c.env, c.req.raw));
     });
+    const selectBuyerAccountSchema = z.object({ accountId: z.string().min(1) });
+    auth.get("/auth/customer/buyer-accounts", async (c) => {
+        c.header("Cache-Control", "no-store");
+        if (c.env.VOYANT_CUSTOMER_AUTH_MODE?.trim() === "disabled") {
+            return c.json({ error: "Customer auth is disabled" }, 404);
+        }
+        const { db, dispose } = openDatabase(c.env);
+        try {
+            const context = await resolveCustomerAuthContext(c.env, c.req.raw);
+            const betterAuth = await buildCustomerBetterAuth(c.env, db, c.req.raw, context);
+            const session = await betterAuth.api.getSession({ headers: c.req.raw.headers });
+            if (!session)
+                return c.json({ error: "Unauthorized" }, 401);
+            await repairCustomerPersonalBuyerAccountEntitlement(db, session.user.id);
+            return c.json(await listCustomerBuyerAccounts({
+                identity: {
+                    userId: session.user.id,
+                    name: session.user.name ?? null,
+                    email: session.user.email ?? null,
+                },
+                activeAuthOrganizationId: session.session.activeOrganizationId ??
+                    null,
+                policy: context.accountPolicy,
+                store: createDrizzleCustomerBuyerAccountStore(db),
+            }));
+        }
+        finally {
+            c.executionCtx.waitUntil(dispose());
+        }
+    });
+    auth.post("/auth/customer/buyer-accounts/active", async (c) => {
+        c.header("Cache-Control", "no-store");
+        if (c.env.VOYANT_CUSTOMER_AUTH_MODE?.trim() === "disabled") {
+            return c.json({ error: "Customer auth is disabled" }, 404);
+        }
+        const body = await parseJsonBody(c, selectBuyerAccountSchema);
+        const { db, dispose } = openDatabase(c.env);
+        try {
+            const context = await resolveCustomerAuthContext(c.env, c.req.raw);
+            const betterAuth = await buildCustomerBetterAuth(c.env, db, c.req.raw, context);
+            const session = await betterAuth.api.getSession({ headers: c.req.raw.headers });
+            if (!session)
+                return c.json({ error: "Unauthorized" }, 401);
+            await repairCustomerPersonalBuyerAccountEntitlement(db, session.user.id);
+            const selected = await selectCustomerBuyerAccount({
+                accountId: body.accountId,
+                identity: {
+                    userId: session.user.id,
+                    name: session.user.name ?? null,
+                    email: session.user.email ?? null,
+                },
+                activeAuthOrganizationId: session.session.activeOrganizationId ??
+                    null,
+                policy: context.accountPolicy,
+                store: createDrizzleCustomerBuyerAccountStore(db),
+            });
+            if (!selected) {
+                return c.json({ error: "Buyer account is unavailable" }, 403);
+            }
+            const activationUrl = new URL(c.req.url);
+            activationUrl.pathname = "/auth/customer/organization/set-active";
+            activationUrl.search = "";
+            const activationHeaders = new Headers(c.req.raw.headers);
+            activationHeaders.delete("content-length");
+            activationHeaders.set("content-type", "application/json");
+            const activationResponse = await betterAuth.handler(new Request(activationUrl, {
+                method: "POST",
+                headers: activationHeaders,
+                body: JSON.stringify({ organizationId: selected.authOrganizationId }),
+            }));
+            if (!activationResponse.ok)
+                return activationResponse;
+            const headers = new Headers(activationResponse.headers);
+            headers.delete("content-length");
+            headers.set("cache-control", "no-store");
+            headers.set("content-type", "application/json; charset=UTF-8");
+            return new Response(JSON.stringify({ activeAccount: selected }), { status: 200, headers });
+        }
+        finally {
+            c.executionCtx.waitUntil(dispose());
+        }
+    });
     auth.all("/auth/customer/*", async (c) => {
         if (c.env.VOYANT_CUSTOMER_AUTH_MODE?.trim() === "disabled") {
             return c.json({ error: "Customer auth is disabled" }, 404);