@fire-spark/cli 0.0.0-stage → 0.13.3

package/src/commands/doctor/client/ord.flow.ts

@@ -0,0 +1,445 @@
+import { createHmac } from "node:crypto";
+
+import type { Copy } from "../../../core/i18n";
+import type { LiveSession } from "../live/live.session";
+import { channelLabel } from "./config";
+import { COPY as SHARED } from "./copy";
+import { fromLive, isOutcome, isRecord, namedOrderSkip } from "./flow";
+import { openLive, prepare, queryOf, rowsOf, say, textOf } from "./flow";
+import { trpcCall, withSafeFix } from "./flow";
+import type { CheckBinding, Outcome, RunCtx } from "./runner";
+import type { YamlChannel } from "./yaml";
+
+const line = (es: string, en: string, pt: string): Copy => {
+  return { "es-EC": es, "en-US": en, "pt-BR": pt };
+};
+
+const COPY = {
+  overlay: line(
+    "El overlay no distingue released, failed y el timeout de 60 s.",
+    "The overlay does not distinguish released, failed, and the 60s timeout.",
+    "O overlay não distingue released, failed e o timeout de 60 s."
+  ),
+  token: line(
+    "El token de realtime no trae {field}.",
+    "The realtime token is missing {field}.",
+    "O token de realtime não traz {field}."
+  ),
+  list: line(
+    "El listado de órdenes no es una lista.",
+    "The order list is not a list.",
+    "A lista de pedidos não é uma lista."
+  ),
+  drifted: line(
+    "El carrito cambió entre dos lecturas de la misma sesión.",
+    "The cart changed between two reads of the same session.",
+    "O carrinho mudou entre duas leituras da mesma sessão."
+  ),
+  notDashboard: line(
+    "{id} no aplica al canal {template}. El editor está en el dashboard.",
+    "{id} does not apply to the {template} channel. The editor is on the dashboard.",
+    "{id} não se aplica ao canal {template}. O editor está no dashboard."
+  ),
+  notServer: line(
+    "ORD-11 no aplica al canal {template}. Solo el canal server firma webhooks.",
+    "ORD-11 does not apply to the {template} channel. Only the server channel signs webhooks.",
+    "ORD-11 não se aplica ao canal {template}. Só o canal server assina webhooks."
+  ),
+  unsigned: line(
+    "Una request sin firma respondió {status}. Esperaba 401.",
+    "A request without a signature returned {status}. Expected 401.",
+    "Uma request sem assinatura respondeu {status}. Esperava 401."
+  ),
+  signed: line(
+    "Con firma válida, el receptor respondió {status}. Esperaba {expected}.",
+    "With a valid signature, the receiver returned {status}. Expected {expected}.",
+    "Com assinatura válida, o receptor respondeu {status}. Esperava {expected}."
+  ),
+  orderId: line(
+    "Falta FIRESPARK_DOCTOR_ORDER_ID. No inventé una orden.",
+    "FIRESPARK_DOCTOR_ORDER_ID is missing. No order was invented.",
+    "Falta FIRESPARK_DOCTOR_ORDER_ID. Nenhum pedido foi inventado."
+  ),
+  need: line(
+    "ORD-06 se omite: falta {field}.",
+    "ORD-06 is skipped: {field} is missing.",
+    "ORD-06 é omitido: falta {field}."
+  ),
+  gap: line(
+    "{id} se omite: falta {field}.",
+    "{id} is skipped: {field} is missing.",
+    "{id} é omitido: falta {field}."
+  ),
+  http: line(
+    "{id} respondió {status}.",
+    "{id} responded {status}.",
+    "{id} respondeu {status}."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+const sign = (secret: string, body: string) => {
+  const hex = createHmac("sha256", secret).update(body).digest("hex");
+  return `sha256=${hex}`;
+};
+
+type Opened = { channel: YamlChannel; live: LiveSession };
+
+const open = async (
+  ctx: RunCtx,
+  fields: readonly string[]
+): Promise<Opened | Outcome> => {
+  const ready = prepare(ctx, fields);
+  if (isOutcome(ready)) return ready;
+  return { channel: ready, live: openLive(ctx, ready) };
+};
+
+const orderPath = (channel: YamlChannel) => {
+  const channelId = textOf(channel.channel_id);
+  const storeId = textOf(channel.store_id);
+  const query = { channel_id: channelId, store_id: storeId };
+  return queryOf("/orders", query);
+};
+
+const orderList = async (opened: Opened, ctx: RunCtx) => {
+  const path = orderPath(opened.channel);
+  const codes = [200];
+  const listArgs = ["orders", "GET", path, codes] as const;
+  const step = await opened.live.storefront<unknown>(...listArgs);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!Array.isArray(step.value)) return say(ctx.locale, "fail", COPY.list);
+  return rowsOf(step.value);
+};
+
+const gap = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.gap, { id, field });
+};
+
+const orderIdOf = (ctx: RunCtx, rows: Record<string, unknown>[]) => {
+  const named = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (named) return named;
+  const row = rows.find(item => typeof item.id === "string");
+  return row && typeof row.id === "string" ? row.id : "";
+};
+
+const runOrd02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const opened = await open(ctx, LIVE);
+  if (isOutcome(opened)) return opened;
+  const rows = await orderList(opened, ctx);
+  if (!Array.isArray(rows)) return rows;
+  const id = orderIdOf(ctx, rows);
+  if (!id) return gap(ctx, "ORD-02", "FIRESPARK_DOCTOR_ORDER_ID");
+  const path = `/orders/${encodeURIComponent(id)}/fulfillment`;
+  const codes = [200];
+  const args = ["fulfillment", "GET", path, codes] as const;
+  const step = await opened.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value)) return say(ctx.locale, "fail", COPY.overlay);
+  const state = step.value.checkout_state;
+  const known =
+    state === "pending" || state === "released" || state === "failed";
+  if (!known) return gap(ctx, "ORD-02", "orders.fulfillment.checkout_state");
+  return { status: "pass" };
+};
+
+const runOrd03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const fields = [...LIVE, "store_id"] as const;
+  const opened = await open(ctx, fields);
+  if (isOutcome(opened)) return opened;
+  const rows = await orderList(opened, ctx);
+  if (!Array.isArray(rows)) return rows;
+  const id = orderIdOf(ctx, rows);
+  if (!id) return gap(ctx, "ORD-03", "FIRESPARK_DOCTOR_ORDER_ID");
+  const path = `/orders/${encodeURIComponent(id)}/fulfillment`;
+  const codes = [200];
+  const args = ["tracking", "GET", path, codes] as const;
+  const step = await opened.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value)) return say(ctx.locale, "fail", COPY.list);
+  if (typeof step.value.status !== "string") {
+    return gap(ctx, "ORD-03", "orders.fulfillment.status");
+  }
+  const states = step.value.current_states ?? step.value.entered_node_ids;
+  if (!Array.isArray(states)) {
+    return gap(ctx, "ORD-03", "orders.fulfillment.current_states");
+  }
+  return { status: "pass" };
+};
+
+const runOrd04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  if (ready.template !== "dashboard") {
+    const template = textOf(ready.template);
+    return say(ctx.locale, "skip", COPY.notDashboard, {
+      id: "ORD-04",
+      template
+    });
+  }
+  const opened = await open(ctx, LIVE);
+  if (isOutcome(opened)) return opened;
+  const codes = [200];
+  const args = ["workflow", "GET", "/fulfillment", codes] as const;
+  const step = await opened.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const rows = rowsOf(step.value);
+  const graph =
+    rows.find(isRecord) ?? (isRecord(step.value) ? step.value : null);
+  if (!graph) return gap(ctx, "ORD-04", "fulfillment.checkout_release");
+  if (!("checkout_release" in graph)) {
+    return gap(ctx, "ORD-04", "fulfillment.checkout_release");
+  }
+  const states = graph.states ?? graph.nodes;
+  if (!Array.isArray(states) || states.length === 0) {
+    return gap(ctx, "ORD-04", "fulfillment.states");
+  }
+  return { status: "pass" };
+};
+
+const runOrd05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "ORD-05");
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ["receiver"]);
+  if (isOutcome(ready)) return ready;
+  const id = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (!id) return say(ctx.locale, "fail", COPY.orderId);
+  const base = textOf(ready.receiver).replace(/\/$/, "");
+  const url = `${base}/api/injection`;
+  const data = { order_id: id, status: "open" };
+  const head = { id: "doctor-injection", type: "order.changed" };
+  const body = JSON.stringify({ ...head, data });
+  let status = 0;
+  try {
+    status = await postJson(url, body);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { status: "fail", detail };
+  }
+  if (status < 200 || status >= 300) {
+    return say(ctx.locale, "fail", COPY.signed, { status, expected: 200 });
+  }
+  return { status: "pass" };
+};
+
+const runOrd06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "ORD-06");
+  if (skipped) return skipped;
+  const id = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (!id) return say(ctx.locale, "fail", COPY.orderId);
+  const uid = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_UID);
+  if (!uid)
+    return say(ctx.locale, "skip", COPY.need, {
+      field: "FIRESPARK_DOCTOR_DEVICE_UID"
+    });
+  const secret = textOf(ctx.env.FIRESPARK_DOCTOR_DEVICE_SECRET);
+  if (!secret) {
+    return say(ctx.locale, "skip", COPY.need, {
+      field: "FIRESPARK_DOCTOR_DEVICE_SECRET"
+    });
+  }
+  const session = textOf(ctx.env.FIRESPARK_DOCTOR_SESSION_UID);
+  if (!session) {
+    return say(ctx.locale, "skip", COPY.need, {
+      field: "FIRESPARK_DOCTOR_SESSION_UID"
+    });
+  }
+  const fields = [...LIVE, "store_id"] as const;
+  const opened = await open(ctx, fields);
+  if (isOutcome(opened)) return opened;
+  const operator = textOf(ctx.env.FIRESPARK_DOCTOR_OPERATOR_ID);
+  const version = Number(ctx.env.FIRESPARK_DOCTOR_SESSION_VERSION ?? "0");
+  const body = {
+    device_uid: uid,
+    device_secret: secret,
+    operator_id: operator,
+    session_uid: session,
+    expected_version: version,
+    order_id: id
+  };
+  const codes = [200];
+  const path = "/pos/kiosk-orders/settle";
+  const args = ["settle", "POST", path, codes, body] as const;
+  const step = await opened.live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const openOrders = async (ctx: RunCtx) => {
+  const fields = [...LIVE, "store_id"] as const;
+  const opened = await open(ctx, fields);
+  if (isOutcome(opened)) return opened;
+  const channelId = textOf(opened.channel.channel_id);
+  const storeId = textOf(opened.channel.store_id);
+  const query = { channel_id: channelId, store_id: storeId, status: "OPEN" };
+  const path = queryOf("/orders", query);
+  const codes = [200];
+  const args = ["open-orders", "GET", path, codes] as const;
+  const step = await opened.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!Array.isArray(step.value)) return say(ctx.locale, "fail", COPY.list);
+  return { opened, rows: rowsOf(step.value) };
+};
+
+const runOrd07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const first = await openOrders(ctx);
+  if (isOutcome(first)) return first;
+  const id = first.rows.find(row => typeof row.id === "string")?.id;
+  if (typeof id !== "string" || !id) {
+    return gap(ctx, "ORD-07", "orders.status=OPEN");
+  }
+  const second = await openOrders(ctx);
+  if (isOutcome(second)) return second;
+  const again = second.rows.some(row => row.id === id);
+  if (!again) return say(ctx.locale, "fail", COPY.drifted);
+  return { status: "pass" };
+};
+
+const runOrd08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const fields = [...LIVE, "store_id"] as const;
+  const opened = await open(ctx, fields);
+  if (isOutcome(opened)) return opened;
+  const rows = await orderList(opened, ctx);
+  if (!Array.isArray(rows)) return rows;
+  const id = orderIdOf(ctx, rows);
+  if (!id) return gap(ctx, "ORD-08", "orders.id");
+  const codes = [200];
+  const args = [
+    "order",
+    "GET",
+    `/orders/${encodeURIComponent(id)}`,
+    codes
+  ] as const;
+  const step = await opened.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!isRecord(step.value)) return say(ctx.locale, "fail", COPY.list);
+  const lines = step.value.lines ?? step.value.items;
+  if (!Array.isArray(lines)) return gap(ctx, "ORD-08", "orders.lines");
+  return { status: "pass" };
+};
+
+const runOrd09 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "ORD-09");
+  if (skipped) return skipped;
+  const id = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (!id) return say(ctx.locale, "fail", COPY.orderId);
+  const fields = [...LIVE, "store_id"] as const;
+  const opened = await open(ctx, fields);
+  if (isOutcome(opened)) return opened;
+  const path = `/orders/${encodeURIComponent(id)}/reorder`;
+  const body = { strategy: "replace" };
+  const codes = [200, 201];
+  const args = ["reorder", "POST", path, codes, body] as const;
+  const step = await opened.live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const runOrd10 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "ORD-10");
+  if (skipped) return skipped;
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return gap(ctx, "ORD-10", "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  const id = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (!id) return gap(ctx, "ORD-10", "FIRESPARK_DOCTOR_ORDER_ID");
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return gap(ctx, "ORD-10", "dashboard_url");
+  const merchant = textOf(ready.merchant_id);
+  if (!merchant) return gap(ctx, "ORD-10", "merchant_id");
+  const env = textOf(ready.env);
+  if (!env) return gap(ctx, "ORD-10", "env");
+  const input = {
+    merchant_id: merchant,
+    env,
+    id,
+    fulfillment_status: "PREPARING"
+  };
+  const step = await trpcCall(dash, cookie, "orders.advanceFulfillment", input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "ORD-10",
+      status: step.status
+    });
+  }
+  return { status: "pass" };
+};
+
+const postJson = async (url: string, body: string, signature?: string) => {
+  const headers: Record<string, string> = {
+    "content-type": "application/json"
+  };
+  if (signature) headers["x-firespark-signature"] = signature;
+  const signal = AbortSignal.timeout(15000);
+  const init = { method: "POST", headers, body, signal };
+  const response = await fetch(url, init);
+  return response.status;
+};
+
+const runOrd11 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, ["channel_id", "receiver"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (template !== "server") {
+    return say(ctx.locale, "skip", COPY.notServer, { template });
+  }
+  const base = textOf(ready.receiver).replace(/\/$/, "");
+  const url = `${base}/api/injection`;
+  let unsigned = 0;
+  try {
+    unsigned = await postJson(url, "{}");
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { status: "fail", detail };
+  }
+  if (unsigned !== 401) {
+    return say(ctx.locale, "fail", COPY.unsigned, { status: unsigned });
+  }
+  const secret = textOf(ctx.env.FIRESPARK_DOCTOR_WEBHOOK_SECRET);
+  if (!secret) {
+    const channel = channelLabel(ready);
+    const field = "FIRESPARK_DOCTOR_WEBHOOK_SECRET";
+    const vars = { channel, field };
+    return say(ctx.locale, "fail", SHARED.flowMissing, vars);
+  }
+  const bad = "{";
+  const odd = JSON.stringify({ hello: 1 });
+  let invalid = 0;
+  let envelope = 0;
+  try {
+    invalid = await postJson(url, bad, sign(secret, bad));
+    envelope = await postJson(url, odd, sign(secret, odd));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { status: "fail", detail };
+  }
+  if (invalid !== 400) {
+    const badStatus = { status: invalid, expected: 400 };
+    return say(ctx.locale, "fail", COPY.signed, badStatus);
+  }
+  if (envelope !== 422) {
+    const oddStatus = { status: envelope, expected: 422 };
+    return say(ctx.locale, "fail", COPY.signed, oddStatus);
+  }
+  return { status: "pass" };
+};
+
+export const ORD_BINDINGS: Record<string, CheckBinding> = {
+  "ORD-02": withSafeFix(runOrd02),
+  "ORD-03": withSafeFix(runOrd03),
+  "ORD-04": withSafeFix(runOrd04),
+  "ORD-05": withSafeFix(runOrd05),
+  "ORD-06": withSafeFix(runOrd06),
+  "ORD-07": withSafeFix(runOrd07),
+  "ORD-08": withSafeFix(runOrd08),
+  "ORD-09": withSafeFix(runOrd09),
+  "ORD-10": withSafeFix(runOrd10),
+  "ORD-11": withSafeFix(runOrd11)
+};