@fire-spark/cli 0.0.0-stage → 0.13.3

package/src/commands/doctor/client/order.ts

@@ -0,0 +1,261 @@
+import { randomUUID } from "node:crypto";
+
+import type { Locale } from "../../../core/i18n";
+import { translate } from "../../../core/i18n";
+import type { Redactor } from "../../../core/redact";
+import type { FetchLike } from "../live/http";
+import type { LiveConfig } from "../live/live.session";
+import { createLiveSession } from "../live/live.session";
+import type { RealtimeToken } from "../live/live.session";
+import { buildOrderBody, doctorOrderId, pickProduct } from "../live/order";
+import type { OrderChanged, WebSocketFactory } from "../live/realtime";
+import { subscribe } from "../live/realtime";
+import type { Subscription } from "../live/realtime";
+import { REASONS, fail } from "../live/result";
+import type { CheckFail, CheckSkip } from "../live/result";
+import { channelLabel, paymentOf } from "./config";
+import { COPY } from "./copy";
+import type { YamlChannel } from "./yaml";
+
+/** Sheet check: place an order on the channel. Not a CLI flag. */
+export const ORDER_CHECK_ID = "ORD-01";
+
+const PLACE_STATUSES = ["ACCEPTED", "IN_PROGRESS", "EXISTS"];
+const AUTH_URL = "https://identitytoolkit.googleapis.com";
+const HTTP_TIMEOUT_MS = 15000;
+const RELEASE_TIMEOUT_MS = 120000;
+
+const nativeSocket = (): WebSocketFactory | undefined => {
+  const Socket = globalThis.WebSocket;
+  if (!Socket) return undefined;
+  return url => new Socket(url) as unknown as ReturnType<WebSocketFactory>;
+};
+
+export interface OrderInput {
+  locale: Locale;
+  env: NodeJS.ProcessEnv;
+  channels: YamlChannel[];
+  channelId?: string;
+  redactor: Redactor;
+  fetch?: FetchLike;
+}
+
+const textOf = (value: string | null | undefined) => {
+  return value?.trim() ?? "";
+};
+
+/** First missing field the test order needs. Empty string means ready. */
+export const orderFieldGap = (channel: YamlChannel, env: NodeJS.ProcessEnv) => {
+  const payment = channel.payment ? paymentOf(channel.payment) : null;
+  if (!payment) return "payment";
+  if (!textOf(channel.merchant_id)) return "merchant_id";
+  if (!textOf(channel.api_url)) return "api_url";
+  if (!textOf(channel.store_id)) return "store_id";
+  if (!textOf(channel.channel_id)) return "channel_id";
+  if (!textOf(channel.fulfillment_id)) return "fulfillment_id";
+  const email = textOf(env.FIRESPARK_DOCTOR_CUSTOMER_EMAIL);
+  if (!email) return "FIRESPARK_DOCTOR_CUSTOMER_EMAIL";
+  const password = textOf(env.FIRESPARK_DOCTOR_CUSTOMER_PASSWORD);
+  if (!password) return "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD";
+  const key = textOf(env.FIRESPARK_DOCTOR_FIREBASE_API_KEY);
+  if (!key) return "FIRESPARK_DOCTOR_FIREBASE_API_KEY";
+  return "";
+};
+
+const channelOf = (channels: YamlChannel[], channelId: string | undefined) => {
+  if (channelId) {
+    return channels.find(channel => channel.channel_id === channelId) ?? null;
+  }
+  if (channels.length !== 1) return null;
+  return channels[0] ?? null;
+};
+
+const missing = (locale: Locale, channel: string, field: string) => {
+  const vars = { channel, field };
+  const detail = translate(locale, COPY.orderMissing, vars);
+  return { status: "fail" as const, detail };
+};
+
+const detailOf = (locale: Locale, result: CheckFail | CheckSkip) => {
+  const message = translate(locale, result.reason.copy, result.reason.vars);
+  if (result.status === "fail") return `${result.hop}: ${message}`;
+  return message;
+};
+
+const msOf = (value: string | undefined, fallback: number) => {
+  const parsed = Number(value);
+  if (!value || !Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+};
+
+export const liveConfigOf = (channel: YamlChannel, env: NodeJS.ProcessEnv) => {
+  const apiUrl = textOf(channel.api_url);
+  const firebaseApiKey = textOf(env.FIRESPARK_DOCTOR_FIREBASE_API_KEY);
+  const firebaseAuthUrl = textOf(env.FIRESPARK_DOCTOR_FIREBASE_AUTH_URL);
+  const customerEmail = textOf(env.FIRESPARK_DOCTOR_CUSTOMER_EMAIL);
+  const customerPassword = textOf(env.FIRESPARK_DOCTOR_CUSTOMER_PASSWORD);
+  const storeId = textOf(channel.store_id);
+  const channelId = textOf(channel.channel_id);
+  const fulfillmentId = textOf(channel.fulfillment_id);
+  const rawCurrency = textOf(env.FIRESPARK_DOCTOR_CURRENCY) || "USD";
+  const currency = rawCurrency.toUpperCase();
+  const httpName = env.FIRESPARK_DOCTOR_HTTP_TIMEOUT_MS;
+  const httpTimeoutMs = msOf(httpName, HTTP_TIMEOUT_MS);
+  const b1 = { apiUrl, firebaseApiKey };
+  const b2 = { firebaseAuthUrl: firebaseAuthUrl || AUTH_URL };
+  const b3 = { customerEmail, customerPassword, storeId, channelId };
+  const b4 = { fulfillmentId, currency, httpTimeoutMs };
+  const config: LiveConfig = { ...b1, ...b2, ...b3, ...b4 };
+  return config;
+};
+
+const placeBodyOf = () => {
+  const payment = { type: "CASH" };
+  return { payment };
+};
+
+const tokenGap = (token: RealtimeToken) => {
+  const fields = ["url", "key", "customer_topic", "access_token"] as const;
+  return fields.find(field => !token[field]);
+};
+
+const settled = (id: string, event: OrderChanged) => {
+  if (event.order_id !== id) return false;
+  if (event.checkout_state === "released") return true;
+  return event.checkout_state === "failed";
+};
+
+const joinFail = (locale: Locale, error: unknown) => {
+  const detail = error instanceof Error ? error.message : String(error);
+  const vars = { target: "realtime", detail };
+  const reason = fail("realtime-join", REASONS.network, vars);
+  return { status: "fail" as const, detail: detailOf(locale, reason) };
+};
+
+const releaseOf = (
+  locale: Locale,
+  event: OrderChanged | undefined,
+  seconds: number
+) => {
+  if (event?.checkout_state === "released") {
+    return { status: "pass" as const };
+  }
+  if (event?.checkout_state === "failed") {
+    const detail = event.error?.message?.trim() || "failed";
+    const reason = fail("checkout-release", REASONS.checkoutFailed, { detail });
+    return { status: "fail" as const, detail: detailOf(locale, reason) };
+  }
+  const last = event?.checkout_state || "—";
+  const vars = { seconds, last };
+  const reason = fail("checkout-release", REASONS.timeout, vars);
+  return { status: "fail" as const, detail: detailOf(locale, reason) };
+};
+
+/** Cash and sandbox both place a cash tender. Anything else never places. */
+export const runOrder = async (input: OrderInput) => {
+  const { locale, env, channels, channelId } = input;
+  const chosen = channelOf(channels, channelId);
+  if (!chosen) {
+    const detail = translate(locale, COPY.orderNoChannel);
+    return { status: "fail" as const, detail };
+  }
+  const field = orderFieldGap(chosen, env);
+  if (field) return missing(locale, channelLabel(chosen), field);
+  const config = liveConfigOf(chosen, env);
+  const fetchImpl = input.fetch ?? fetch;
+  const deps = { fetch: fetchImpl };
+  const live = createLiveSession(config, deps, input.redactor);
+  const menus = await live.menus();
+  if (!menus.ok) {
+    const detail = detailOf(locale, menus.result);
+    return { status: "fail" as const, detail };
+  }
+  const product = pickProduct(menus.value, env.FIRESPARK_DOCTOR_PRODUCT_ID);
+  if (!product?.id) {
+    const vars = { what: "menus[].products" };
+    const reason = fail("menu-fetch", REASONS.emptyList, vars);
+    return { status: "fail" as const, detail: detailOf(locale, reason) };
+  }
+  const id = doctorOrderId();
+  const menu = menus.value.find(item => item.products?.includes(product));
+  const lineUid = randomUUID();
+  const menuId = menu?.id;
+  const bodyArgs = { id, config, product, menuId, lineUid };
+  const built = buildOrderBody(bodyArgs);
+  const codes = [201, 202];
+  const createArgs = ["order-create", "POST", "/orders", codes, built] as const;
+  const created = await live.storefront<{ id?: string }>(...createArgs);
+  if (!created.ok) {
+    const detail = detailOf(locale, created.result);
+    return { status: "fail" as const, detail };
+  }
+  if (created.value.id !== id) {
+    const vars = { expected: id, actual: String(created.value.id) };
+    const reason = fail("order-create", REASONS.mismatch, vars);
+    return { status: "fail" as const, detail: detailOf(locale, reason) };
+  }
+  const token = await live.realtimeToken();
+  if (!token.ok) {
+    const detail = detailOf(locale, token.result);
+    return { status: "fail" as const, detail };
+  }
+  const createSocket = nativeSocket();
+  if (!createSocket) {
+    const field = "WebSocket";
+    const reason = fail("realtime-join", REASONS.badShape, { field });
+    return { status: "fail" as const, detail: detailOf(locale, reason) };
+  }
+  const absent = tokenGap(token.value);
+  if (absent) {
+    const reason = fail("realtime-token", REASONS.badShape, { field: absent });
+    return { status: "fail" as const, detail: detailOf(locale, reason) };
+  }
+  const url = token.value.url ?? "";
+  const key = token.value.key ?? "";
+  const topic = token.value.customer_topic ?? "";
+  const accessToken = token.value.access_token ?? "";
+  const joinTimeoutMs = config.httpTimeoutMs;
+  const b1 = { url, key, topic, accessToken };
+  const b2 = { joinTimeoutMs, createSocket };
+  const subscription = subscribe({ ...b1, ...b2 });
+  const joined = await openChannel(locale, subscription);
+  if (joined.status === "fail") return joined;
+  const placePath = `/orders/${encodeURIComponent(id)}/place`;
+  const pay = placeBodyOf();
+  const placeArgs = ["order-place", "POST", placePath, codes, pay] as const;
+  const placed = await live.storefront<{ status?: string }>(...placeArgs);
+  if (!placed.ok) {
+    subscription.close();
+    const detail = detailOf(locale, placed.result);
+    return { status: "fail" as const, detail };
+  }
+  const status = placed.value.status ?? "";
+  if (!PLACE_STATUSES.includes(status)) {
+    subscription.close();
+    const vars = { expected: PLACE_STATUSES.join(" | "), actual: status };
+    const reason = fail("order-place", REASONS.mismatch, vars);
+    return { status: "fail" as const, detail: detailOf(locale, reason) };
+  }
+  const timeoutMs = msOf(env.FIRESPARK_DOCTOR_TIMEOUT_MS, RELEASE_TIMEOUT_MS);
+  const match = (item: OrderChanged) => settled(id, item);
+  const event = await subscription.waitFor(match, timeoutMs);
+  subscription.close();
+  const seconds = Math.round(timeoutMs / 1000);
+  return releaseOf(locale, event, seconds);
+};
+
+const openChannel = async (locale: Locale, subscription: Subscription) => {
+  try {
+    await subscription.joined;
+    return { status: "pass" as const };
+  } catch (error) {
+    subscription.close();
+    return joinFail(locale, error);
+  }
+};
+
+/** `--fix` must not invent ids or place an order. */
+export const fixOrder = (locale: Locale) => {
+  const detail = translate(locale, COPY.orderNoFix);
+  return { status: "fail" as const, detail };
+};