@fire-spark/cli 0.13.2 → 0.13.3

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

@@ -0,0 +1,412 @@
+import { Big } from "big.js";
+
+import type { Copy } from "../../../core/i18n";
+import type { LiveSession } from "../live/live.session";
+import { fromLive, isOutcome, isRecord, openLive, prepare } from "./flow";
+import { queryOf, rowsOf, say, textOf, trpcCall, withSafeFix } from "./flow";
+import { readSources } from "./repo.scan";
+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."
+  ),
+  empty: line(
+    "El menú no tiene productos.",
+    "The menu has no products.",
+    "O cardápio não tem produtos."
+  ),
+  drifted: line(
+    "El menú cambió entre dos lecturas de la misma sesión.",
+    "The menu changed between two reads of the same session.",
+    "O cardápio mudou entre duas leituras da mesma sessão."
+  ),
+  noDiscount: line(
+    "MEN-08 se omite: el menú no tiene un producto con precio anterior.",
+    "MEN-08 is skipped: the menu has no product with a previous price.",
+    "MEN-08 é omitido: o cardápio não tem um produto com preço anterior."
+  ),
+  discount: line(
+    "El descuento no cuadra con el precio anterior.",
+    "The discount does not match the previous price.",
+    "O desconto não fecha com o preço anterior."
+  ),
+  noStock: line(
+    "MEN-09 se omite: el menú no tiene un producto agotado.",
+    "MEN-09 is skipped: the menu has no out-of-stock product.",
+    "MEN-09 é omitido: o cardápio não tem um produto esgotado."
+  ),
+  noHours: line(
+    "MEN-10 se omite: el menú no tiene un producto oculto o fuera de horario.",
+    "MEN-10 is skipped: the menu has no hidden or out-of-hours product.",
+    "MEN-10 é omitido: o cardápio não tem um produto oculto ou fora do horário."
+  ),
+  noVariant: line(
+    "MEN-11 se omite: el menú no tiene un producto con variantes.",
+    "MEN-11 is skipped: the menu has no product with variants.",
+    "MEN-11 é omitido: o cardápio não tem um produto com variantes."
+  ),
+  noModifier: line(
+    "MEN-12 se omite: falta modifier_groups.min.",
+    "MEN-12 is skipped: modifier_groups.min is missing.",
+    "MEN-12 é omitido: falta modifier_groups.min."
+  ),
+  named: line(
+    "{id} solo corre cuando lo nombras. No cambié el menú.",
+    "{id} runs only when you name it. The menu was not changed.",
+    "{id} só roda quando você o nomeia. O cardápio não foi alterado."
+  ),
+  need: 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}."
+  ),
+  listener: line(
+    "MEN-07 el canal se suscribe a menu.changed.",
+    "MEN-07 the channel subscribes to menu.changed.",
+    "MEN-07 o canal assina menu.changed."
+  ),
+  soldOut: line(
+    "MEN-09 el producto agotado no se renderiza en gris con Agotado o Sold out.",
+    "MEN-09 the out-of-stock product is not rendered grey with Agotado or Sold out.",
+    "MEN-09 o produto esgotado não renderiza em cinza com Agotado ou Sold out."
+  )
+};
+
+const LIVE = [
+  "api_url",
+  "channel_id",
+  "FIRESPARK_DOCTOR_CUSTOMER_EMAIL",
+  "FIRESPARK_DOCTOR_CUSTOMER_PASSWORD",
+  "FIRESPARK_DOCTOR_FIREBASE_API_KEY"
+] as const;
+
+type Row = Record<string, unknown>;
+
+type Loaded = { channel: YamlChannel; live: LiveSession; menus: unknown[] };
+
+const numberOf = (value: unknown) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+};
+
+const productsOf = (menus: unknown[]) => {
+  return rowsOf(menus).flatMap(menu => rowsOf(menu.products));
+};
+
+const idsOf = (products: Row[]) => {
+  return products.map(product => String(product.id ?? "")).join(",");
+};
+
+const load = async (ctx: RunCtx): Promise<Loaded | Outcome> => {
+  const ready = prepare(ctx, LIVE);
+  if (isOutcome(ready)) return ready;
+  const live = openLive(ctx, ready);
+  const path = queryOf("/menus", { channel_id: textOf(ready.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 { channel: ready, live, menus: step.value };
+};
+
+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 namedOnly = (ctx: RunCtx, id: string) => {
+  if (ctx.named.has(id)) return null;
+  return say(ctx.locale, "skip", COPY.named, { id });
+};
+
+const need = (ctx: RunCtx, id: string, field: string) => {
+  return say(ctx.locale, "skip", COPY.need, { id, field });
+};
+
+const dashOf = (ctx: RunCtx, id: string, channel: YamlChannel) => {
+  const cookie = textOf(ctx.env.FIRESPARK_DOCTOR_DASHBOARD_COOKIE);
+  if (!cookie) return need(ctx, id, "FIRESPARK_DOCTOR_DASHBOARD_COOKIE");
+  if (!textOf(channel.dashboard_url)) return need(ctx, id, "dashboard_url");
+  if (!textOf(channel.merchant_id)) return need(ctx, id, "merchant_id");
+  if (!textOf(channel.env)) return need(ctx, id, "env");
+  return cookie;
+};
+
+const runMen01 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MEN-01", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const named = namedOnly(ctx, "MEN-01");
+  if (named) return named;
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const cookie = dashOf(ctx, "MEN-01", ready);
+  if (typeof cookie !== "string") return cookie;
+  const dash = textOf(ready.dashboard_url);
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env),
+    name: "doctor-menu"
+  };
+  const step = await trpcCall(dash, cookie, "menus.insert", input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "MEN-01",
+      status: step.status
+    });
+  }
+  return { status: "pass" };
+};
+
+const runMen02 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MEN-02", new Set(["dashboard"]));
+  if (skipped) return skipped;
+  const named = namedOnly(ctx, "MEN-02");
+  if (named) return named;
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const cookie = dashOf(ctx, "MEN-02", ready);
+  if (typeof cookie !== "string") return cookie;
+  const dash = textOf(ready.dashboard_url);
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env)
+  };
+  const step = await trpcCall(dash, cookie, "menuSyncs.selectLatest", input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "MEN-02",
+      status: step.status
+    });
+  }
+  const keys = ["draft", "publish", "cancel", "rollback"];
+  const found = keys.some(key => step.text.toLowerCase().includes(key));
+  if (!found) return need(ctx, "MEN-02", "menu_syncs");
+  return { status: "pass" };
+};
+
+const runMen04 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["kiosk", "dashboard"]);
+  const skipped = applies(ctx, "MEN-04", allowed);
+  if (skipped) return skipped;
+  const named = namedOnly(ctx, "MEN-04");
+  if (named) return named;
+  const ready = prepare(ctx, ["channel_id"]);
+  if (isOutcome(ready)) return ready;
+  const cookie = dashOf(ctx, "MEN-04", ready);
+  if (typeof cookie !== "string") return cookie;
+  const dash = textOf(ready.dashboard_url);
+  const input = {
+    merchant_id: textOf(ready.merchant_id),
+    env: textOf(ready.env),
+    name: "doctor-product",
+    pricing: { price: "1.00" }
+  };
+  const proc = "menuBuilder.products.insert";
+  const step = await trpcCall(dash, cookie, proc, input);
+  if (step.status < 200 || step.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "MEN-04",
+      status: step.status
+    });
+  }
+  return { status: "pass" };
+};
+
+const stable = async (ctx: RunCtx): Promise<Outcome> => {
+  const first = await load(ctx);
+  if (isOutcome(first)) return first;
+  const second = await load(ctx);
+  if (isOutcome(second)) return second;
+  const left = idsOf(productsOf(first.menus));
+  const right = idsOf(productsOf(second.menus));
+  if (left !== right) return say(ctx.locale, "fail", COPY.drifted);
+  if (!left) return say(ctx.locale, "fail", COPY.empty);
+  return { status: "pass" };
+};
+
+const runMen05 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MEN-05", new Set(["kiosk"]));
+  if (skipped) return skipped;
+  const named = namedOnly(ctx, "MEN-05");
+  if (named) return named;
+  const first = await load(ctx);
+  if (isOutcome(first)) return first;
+  const before = idsOf(productsOf(first.menus));
+  const cookie = dashOf(ctx, "MEN-05", first.channel);
+  if (typeof cookie !== "string") return cookie;
+  const dash = textOf(first.channel.dashboard_url);
+  const input = {
+    merchant_id: textOf(first.channel.merchant_id),
+    env: textOf(first.channel.env),
+    name: "doctor-dirty"
+  };
+  const wrote = await trpcCall(dash, cookie, "menus.update", input);
+  if (wrote.status < 200 || wrote.status >= 300) {
+    return say(ctx.locale, "fail", COPY.http, {
+      id: "MEN-05",
+      status: wrote.status
+    });
+  }
+  const second = await load(ctx);
+  if (isOutcome(second)) return second;
+  const after = idsOf(productsOf(second.menus));
+  if (before === after && before !== "") {
+    return say(ctx.locale, "fail", COPY.drifted);
+  }
+  return { status: "pass" };
+};
+
+const runMen06 = async (ctx: RunCtx): Promise<Outcome> => {
+  const skipped = applies(ctx, "MEN-06", new Set(["pos"]));
+  if (skipped) return skipped;
+  return stable(ctx);
+};
+
+const runMen07 = async (ctx: RunCtx): Promise<Outcome> => {
+  const allowed = new Set(["web", "app", "chat", "call-center"]);
+  const skipped = applies(ctx, "MEN-07", allowed);
+  if (skipped) return skipped;
+  const files = await readSources(ctx.cwd);
+  const listen = files.filter(file => file.body.includes("listenOrder"));
+  if (listen.length === 0) return need(ctx, "MEN-07", "listenOrder");
+  const changed = listen.some(file => {
+    return (
+      file.body.includes("menu.changed") || file.body.includes("menuChanged")
+    );
+  });
+  if (changed) return say(ctx.locale, "fail", COPY.listener);
+  return { status: "pass" };
+};
+
+const pricingOf = (product: Row) => {
+  return isRecord(product.pricing) ? product.pricing : null;
+};
+
+const runMen08 = async (ctx: RunCtx): Promise<Outcome> => {
+  const loaded = await load(ctx);
+  if (isOutcome(loaded)) return loaded;
+  const priced = productsOf(loaded.menus).flatMap(product => {
+    const pricing = pricingOf(product);
+    if (!pricing) return [];
+    const price = numberOf(pricing.price);
+    const anchor = numberOf(pricing.anchor_price);
+    if (price === null || anchor === null) return [];
+    return [{ price, anchor }];
+  });
+  const sample = priced[0];
+  if (!sample) return say(ctx.locale, "skip", COPY.noDiscount);
+  const price = new Big(String(sample.price));
+  const anchor = new Big(String(sample.anchor));
+  if (!anchor.gt(price)) return say(ctx.locale, "fail", COPY.discount);
+  const saved = anchor.minus(price);
+  if (!saved.plus(price).eq(anchor)) {
+    return say(ctx.locale, "fail", COPY.discount);
+  }
+  return { status: "pass" };
+};
+
+const statusOf = (product: Row) => {
+  const availability = product.availability;
+  if (!isRecord(availability)) return "";
+  const status = availability.status;
+  return typeof status === "string" ? status : "";
+};
+
+const runMen09 = async (ctx: RunCtx): Promise<Outcome> => {
+  const loaded = await load(ctx);
+  if (isOutcome(loaded)) return loaded;
+  const found = productsOf(loaded.menus).some(product => {
+    return statusOf(product) === "OUT_OF_STOCK";
+  });
+  if (!found) return say(ctx.locale, "skip", COPY.noStock);
+  const files = await readSources(ctx.cwd);
+  const label = files.some(file => {
+    const sold =
+      file.body.includes("Agotado") || file.body.includes("Sold out");
+    const grey = file.body.includes("grey") || file.body.includes("gray");
+    return sold && grey;
+  });
+  if (!label) return say(ctx.locale, "fail", COPY.soldOut);
+  return { status: "pass" };
+};
+
+const runMen10 = async (ctx: RunCtx): Promise<Outcome> => {
+  const loaded = await load(ctx);
+  if (isOutcome(loaded)) return loaded;
+  const found = productsOf(loaded.menus).some(product => {
+    if (!Array.isArray(product.schedules)) return false;
+    return product.schedules.some(isRecord);
+  });
+  if (!found) return need(ctx, "MEN-10", "schedules");
+  const files = await readSources(ctx.cwd);
+  const label = files.some(file => {
+    if (file.body.includes("Fuera de horario")) return true;
+    return file.body.includes("OUTSIDE_HOURS");
+  });
+  if (!label) return need(ctx, "MEN-10", "OUTSIDE_HOURS");
+  return { status: "pass" };
+};
+
+const runMen11 = async (ctx: RunCtx): Promise<Outcome> => {
+  const loaded = await load(ctx);
+  if (isOutcome(loaded)) return loaded;
+  const found = productsOf(loaded.menus).some(product => {
+    const pricing = pricingOf(product);
+    const groups = product.variant_groups ?? product.variants;
+    if (!Array.isArray(groups) || groups.length === 0) return false;
+    if (!pricing || numberOf(pricing.starting_price) === null) return false;
+    return groups.filter(isRecord).some(group => {
+      const status = group.status ?? group.availability;
+      return status === "OUT_OF_STOCK" || status === "SOLD_OUT";
+    });
+  });
+  if (!found) return need(ctx, "MEN-11", "variant_groups");
+  return { status: "pass" };
+};
+
+const runMen12 = async (ctx: RunCtx): Promise<Outcome> => {
+  const loaded = await load(ctx);
+  if (isOutcome(loaded)) return loaded;
+  const found = productsOf(loaded.menus).some(product => {
+    if (!Array.isArray(product.modifiers)) return false;
+    return product.modifiers.filter(isRecord).some(group => {
+      return typeof group.min === "number" && typeof group.max === "number";
+    });
+  });
+  if (!found) return say(ctx.locale, "skip", COPY.noModifier);
+  return { status: "pass" };
+};
+
+export const MEN_BINDINGS: Record<string, CheckBinding> = {
+  "MEN-01": withSafeFix(runMen01),
+  "MEN-02": withSafeFix(runMen02),
+  "MEN-04": withSafeFix(runMen04),
+  "MEN-05": withSafeFix(runMen05),
+  "MEN-06": withSafeFix(runMen06),
+  "MEN-07": withSafeFix(runMen07),
+  "MEN-08": withSafeFix(runMen08),
+  "MEN-09": withSafeFix(runMen09),
+  "MEN-10": withSafeFix(runMen10),
+  "MEN-11": withSafeFix(runMen11),
+  "MEN-12": withSafeFix(runMen12)
+};