@fire-spark/cli 0.13.2 → 0.13.3

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

@@ -0,0 +1,400 @@
+import { randomUUID } from "node:crypto";
+
+import type { Copy } from "../../../core/i18n";
+import type { Menu } from "../live/live.session";
+import { buildOrderBody, doctorOrderId, pickProduct } from "../live/order";
+import { paymentOf } from "./config";
+import { fromLive, isOutcome, isRecord, namedOrderSkip } from "./flow";
+import { openLive, prepare, queryOf, rowsOf, say, textOf } from "./flow";
+import { trpcCall, withSafeFix } from "./flow";
+import { liveConfigOf } from "./order";
+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 = {
+  channel: line(
+    "{id} no aplica al canal {template}.",
+    "{id} does not apply to the {template} channel.",
+    "{id} não se aplica ao canal {template}."
+  ),
+  list: line(
+    "El menú no es una lista.",
+    "The menu is not a list.",
+    "O cardápio não é uma lista."
+  ),
+  search: line(
+    "La búsqueda del menú no devolvió el producto ni el estado vacío.",
+    "Menu search did not return the product or the empty state.",
+    "A busca do cardápio não devolveu o produto nem o estado vazio."
+  ),
+  language: line(
+    "MEN-14 se omite: el menú no tiene textos en más de un idioma.",
+    "MEN-14 is skipped: the menu has no text in more than one language.",
+    "MEN-14 é omitido: o cardápio não tem textos em mais de um idioma."
+  ),
+  modifiers: line(
+    "MEN-15 se omite: falta menus[].products[].modifiers.",
+    "MEN-15 is skipped: menus[].products[].modifiers is missing.",
+    "MEN-15 é omitido: falta menus[].products[].modifiers."
+  ),
+  scope: line(
+    "MEN-16 se omite: falta menus[].scope.",
+    "MEN-16 is skipped: menus[].scope is missing.",
+    "MEN-16 é omitido: falta menus[].scope."
+  ),
+  recommendations: line(
+    "MEN-17 se omite: ningún producto tiene recomendaciones.",
+    "MEN-17 is skipped: no product has recommendations.",
+    "MEN-17 é omitido: nenhum produto tem recomendações."
+  ),
+  rules: line(
+    "CHK-03 se omite: no hay reglas de pedido distintas del default.",
+    "CHK-03 is skipped: there are no order rules beyond the default.",
+    "CHK-03 é omitido: não há regras de pedido além do padrão."
+  ),
+  orderId: line(
+    "Falta FIRESPARK_DOCTOR_ORDER_ID.",
+    "FIRESPARK_DOCTOR_ORDER_ID is missing.",
+    "Falta FIRESPARK_DOCTOR_ORDER_ID."
+  ),
+  anonymous: line(
+    "CHK-04 se omite: este canal no acepta pedidos anónimos.",
+    "CHK-04 is skipped: this channel does not accept anonymous orders.",
+    "CHK-04 é omitido: este canal não aceita pedidos anônimos."
+  ),
+  validate: line(
+    "La validación del carrito no respondió ok.",
+    "Cart validation did not respond ok.",
+    "A validação do carrinho não respondeu ok."
+  ),
+  notCash: line(
+    "El pago del canal no es cash ni sandbox. No hice place.",
+    "The channel payment is not cash or sandbox. Place was not called.",
+    "O pagamento do canal não é cash nem sandbox. Place não foi chamado."
+  ),
+  placeStatus: line(
+    "Place respondió {status}. Esperaba ACCEPTED o IN_PROGRESS.",
+    "Place returned {status}. Expected ACCEPTED or IN_PROGRESS.",
+    "Place respondeu {status}. Esperava ACCEPTED ou IN_PROGRESS."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+const PLACE = new Set(["ACCEPTED", "IN_PROGRESS"]);
+const DEFAULT_MAX_ITEMS = 99;
+const DEFAULT_MAX_TOTAL = 999999;
+
+const applies = (ctx: RunCtx, id: string, allowed: ReadonlySet<string>) => {
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const template = textOf(ready.template);
+  if (allowed.has(template)) return null;
+  return say(ctx.locale, "skip", COPY.channel, { id, template });
+};
+
+const menusOf = async (ctx: RunCtx, channel: YamlChannel) => {
+  const live = openLive(ctx, channel);
+  const path = queryOf("/menus", { channel_id: textOf(channel.channel_id) });
+  const step = await live.storefront<unknown>("menus", "GET", path, [200]);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!Array.isArray(step.value)) return say(ctx.locale, "fail", COPY.list);
+  return { live, menus: step.value };
+};
+
+const productsOf = (menus: unknown[]) => {
+  return rowsOf(menus).flatMap(menu => rowsOf(menu.products));
+};
+
+const namesOf = (menus: unknown[]) => {
+  return productsOf(menus)
+    .map(item => String(item.name ?? ""))
+    .filter(Boolean);
+};
+
+const searchMenus = async (ctx: RunCtx, channel: YamlChannel, q: string) => {
+  const live = openLive(ctx, channel);
+  const path = queryOf("/menus", {
+    channel_id: textOf(channel.channel_id),
+    q
+  });
+  const step = await live.storefront<unknown>("search", "GET", path, [200]);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (!Array.isArray(step.value)) return say(ctx.locale, "fail", COPY.list);
+  return namesOf(step.value);
+};
+
+const runMen13 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const name = namesOf(loaded.menus)[0] ?? "";
+  if (!name) return say(ctx.locale, "fail", COPY.search);
+  const hit = await searchMenus(ctx, ready, name);
+  if (!Array.isArray(hit)) return hit;
+  const miss = await searchMenus(ctx, ready, "zzzz-doctor-miss");
+  if (!Array.isArray(miss)) return miss;
+  if (!hit.includes(name) || miss.length !== 0) {
+    return say(ctx.locale, "fail", COPY.search);
+  }
+  return { status: "pass" };
+};
+
+const runMen14 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const multi = productsOf(loaded.menus).some(item => {
+    const bag = item.translations ?? item.names;
+    if (!isRecord(bag)) return false;
+    const locales = Object.keys(bag).filter(key => {
+      const value = bag[key];
+      return typeof value === "string" && value.trim() !== "";
+    });
+    return locales.length >= 2;
+  });
+  if (!multi) return say(ctx.locale, "skip", COPY.language);
+  return { status: "pass" };
+};
+
+const runMen15 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MEN-15", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return say(ctx.locale, "skip", COPY.modifiers);
+  const dash = textOf(ready.dashboard_url);
+  if (!dash) return say(ctx.locale, "skip", COPY.modifiers);
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env)
+  };
+  const productsProc = "menuBuilder.products.selectByRange";
+  const products = await trpcCall(dash, cookie, productsProc, input);
+  const groupsProc = "menuBuilder.modifierGroups.selectByRange";
+  const groups = await trpcCall(dash, cookie, groupsProc, input);
+  if (products.status >= 400 || groups.status >= 400) {
+    return say(ctx.locale, "fail", COPY.list);
+  }
+  if (!products.text.includes("id") || !groups.text.includes("id")) {
+    return say(ctx.locale, "skip", COPY.modifiers);
+  }
+  return { status: "pass" };
+};
+
+const runMen16 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MEN-16", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const found = rowsOf(loaded.menus).some(menu => {
+    const golden = typeof menu.golden_menu_id === "string";
+    const stale = Array.isArray(menu.outdated_entities) || menu.stale === true;
+    return golden && stale;
+  });
+  if (!found) return say(ctx.locale, "skip", COPY.scope);
+  return { status: "pass" };
+};
+
+const runMen17 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const types = new Set<string>();
+  for (const item of productsOf(loaded.menus)) {
+    const recs = item.recommendations ?? item.recommendation_types;
+    if (!Array.isArray(recs)) continue;
+    for (const rec of recs) {
+      if (isRecord(rec) && typeof rec.type === "string") types.add(rec.type);
+      if (typeof rec === "string") types.add(rec);
+    }
+  }
+  if (types.size === 0) return say(ctx.locale, "skip", COPY.recommendations);
+  return { status: "pass" };
+};
+
+const rulesAreDefault = (value: unknown) => {
+  if (!isRecord(value)) return true;
+  const rules = value.order_rules;
+  if (!isRecord(rules) || !isRecord(rules.order)) return true;
+  const order = rules.order;
+  const minItems = order.min_items;
+  const minTotal = order.min_total;
+  const maxItems = order.max_items;
+  const maxTotal = order.max_total;
+  if (typeof minItems === "number" && minItems !== 0) return false;
+  if (typeof minTotal === "number" && minTotal !== 0) return false;
+  if (typeof maxItems === "number" && maxItems !== DEFAULT_MAX_ITEMS) {
+    return false;
+  }
+  if (typeof maxTotal === "number" && maxTotal !== DEFAULT_MAX_TOTAL) {
+    return false;
+  }
+  return true;
+};
+
+const preferencesOf = async (ctx: RunCtx, channel: YamlChannel) => {
+  const live = openLive(ctx, channel);
+  const codes = [200];
+  const args = ["preferences", "GET", "/preferences", codes] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return step.value;
+};
+
+const CODES = new Set([
+  "TOTAL_BELOW_MINIMUM",
+  "TOTAL_ABOVE_MAXIMUM",
+  "ITEMS_BELOW_MINIMUM",
+  "ITEMS_ABOVE_MAXIMUM",
+  "DAILY_ORDER_LIMIT_REACHED"
+]);
+
+const runChk03 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  if (rulesAreDefault(prefs)) return say(ctx.locale, "skip", COPY.rules);
+  const live = openLive(ctx, ready);
+  const body = { items: [], total: "0" };
+  const codes = [200, 400, 422];
+  const args = ["rules", "POST", "/orders/validate", codes, body] as const;
+  const step = await live.probe(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  const raw = JSON.stringify(step.value.json ?? "");
+  const hit = [...CODES].some(code => raw.includes(code));
+  if (!hit) return say(ctx.locale, "fail", COPY.validate);
+  return { status: "pass" };
+};
+
+const runChk04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const prefs = await preferencesOf(ctx, ready);
+  if (isOutcome(prefs)) return prefs;
+  const fields = guestFields(prefs);
+  if (!fields) return say(ctx.locale, "skip", COPY.anonymous);
+  const modes = Object.values(fields);
+  if (modes.length === 0) return say(ctx.locale, "skip", COPY.anonymous);
+  const known = new Set(["required", "optional", "hidden"]);
+  const ok = modes.every(mode => typeof mode === "string" && known.has(mode));
+  if (!ok) return say(ctx.locale, "fail", COPY.anonymous);
+  return { status: "pass" };
+};
+
+const runChk05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "CHK-05", new Set(["kiosk"]));
+  if (skipped) return skipped;
+  const named = namedOrderSkip(ctx, "CHK-05");
+  if (named) return named;
+  const id = textOf(ctx.env.FIRESPARK_DOCTOR_ORDER_ID);
+  if (!id) return say(ctx.locale, "fail", COPY.orderId);
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const codes = [200];
+  const args = ["cancel", "POST", `/orders/${id}/cancel`, codes, {}] as const;
+  const step = await live.storefront<unknown>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  return { status: "pass" };
+};
+
+const guestFields = (value: unknown) => {
+  if (!isRecord(value) || !isRecord(value.checkout)) return null;
+  const guest = value.checkout.anonymous_customer;
+  if (!isRecord(guest) || !isRecord(guest.fields)) return null;
+  return guest.fields;
+};
+
+const runChk02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const fields = [...LIVE, "store_id", "fulfillment_id"] as const;
+  const ready = prepare(ctx, fields);
+  if (isOutcome(ready)) return ready;
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const menus = loaded.menus as Menu[];
+  const wanted = ctx.env.FIRESPARK_DOCTOR_PRODUCT_ID;
+  const product = pickProduct(menus, wanted);
+  if (!product?.id) return say(ctx.locale, "fail", COPY.list);
+  const config = liveConfigOf(ready, ctx.env);
+  const lineUid = randomUUID();
+  const id = "validate-only";
+  const b1 = { id, config, product, lineUid };
+  const built = buildOrderBody(b1);
+  const store_id = textOf(ready.store_id);
+  const channel_id = textOf(ready.channel_id);
+  const fulfillment_id = textOf(ready.fulfillment_id);
+  const scope = { store_id, channel_id, fulfillment_id };
+  const body = { ...scope, lines: built.lines, totals: built.totals };
+  const codes = [200];
+  const args = ["validate", "POST", "/orders/validate", codes, body] as const;
+  const step = await loaded.live.storefront<{ ok?: boolean }>(...args);
+  if (!step.ok) return fromLive(ctx.locale, step.result);
+  if (step.value.ok !== true) return say(ctx.locale, "fail", COPY.validate);
+  return { status: "pass" };
+};
+
+const runChk01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = namedOrderSkip(ctx, "CHK-01");
+  if (skipped) return skipped;
+  const fields = [...LIVE, "store_id", "fulfillment_id", "payment"] as const;
+  const ready = prepare(ctx, fields);
+  if (isOutcome(ready)) return ready;
+  if (!paymentOf(textOf(ready.payment))) {
+    return say(ctx.locale, "fail", COPY.notCash);
+  }
+  const loaded = await menusOf(ctx, ready);
+  if (isOutcome(loaded)) return loaded;
+  const product = pickProduct(loaded.menus as Menu[]);
+  if (!product?.id) return say(ctx.locale, "fail", COPY.list);
+  const id = doctorOrderId();
+  const config = liveConfigOf(ready, ctx.env);
+  const lineUid = randomUUID();
+  const built = buildOrderBody({ id, config, product, lineUid });
+  const codes = [201, 202];
+  const create = ["order-create", "POST", "/orders", codes, built] as const;
+  const created = await loaded.live.storefront<{ id?: string }>(...create);
+  if (!created.ok) return fromLive(ctx.locale, created.result);
+  const payment = { type: "CASH" };
+  const placePath = `/orders/${encodeURIComponent(id)}/place`;
+  const p1 = ["order-place", "POST", placePath] as const;
+  const placeArgs = [...p1, codes, { payment }] as const;
+  const place = loaded.live.storefront<{ status?: string }>;
+  const placed = await place(...placeArgs);
+  if (!placed.ok) return fromLive(ctx.locale, placed.result);
+  const status = placed.value.status ?? "";
+  if (!PLACE.has(status)) {
+    return say(ctx.locale, "fail", COPY.placeStatus, { status: status || "—" });
+  }
+  return { status: "pass" };
+};
+
+export const CHECKOUT_BINDINGS: Record<string, CheckBinding> = {
+  "MEN-13": withSafeFix(runMen13),
+  "MEN-14": withSafeFix(runMen14),
+  "MEN-15": withSafeFix(runMen15),
+  "MEN-16": withSafeFix(runMen16),
+  "MEN-17": withSafeFix(runMen17),
+  "CHK-01": withSafeFix(runChk01),
+  "CHK-02": withSafeFix(runChk02),
+  "CHK-03": withSafeFix(runChk03),
+  "CHK-04": withSafeFix(runChk04),
+  "CHK-05": withSafeFix(runChk05)
+};