@12-apps/discounts 1.11.0 → 1.13.0

package/src/react/schedule-builder.tsx

@@ -0,0 +1,253 @@
+"use client";
+
+import type { JSX } from "react";
+
+import { Button } from "@12-apps/ui/form/Button";
+import { FormControl, FormLabel, FormMessage } from "@12-apps/ui/form/Form";
+import { Input } from "@12-apps/ui/form/Input";
+import { Box } from "@12-apps/ui/mui/Box";
+import { Stack } from "@12-apps/ui/mui/Stack";
+import { Text } from "@12-apps/ui/typography/Text";
+
+import { MAX_SCHEDULE_WINDOWS, type DiscountSchedule, type DiscountScheduleWindow } from "../engine/schedule";
+
+import { fill, type DiscountsWebCopy } from "./copy";
+import { formatScheduleWindow } from "./schedule-summary";
+
+/**
+ * "Toda sexta, das 16:00 às 20:00" — the weekly schedule editor (FUT-996).
+ *
+ * The shape is chosen from how a merchant DESCRIBES a promotion, not from how
+ * a week is stored. Three decisions carry it:
+ *
+ * **Day chips, not checkboxes.** Seven chips in a row read as a week at a
+ * glance; seven checkboxes read as a list you have to parse. Monday-first,
+ * because that is the axis `WeekHours` and every hours screen already uses, and
+ * a promotions screen starting on Sunday next to an hours screen starting on
+ * Monday is its own bug report.
+ *
+ * **A LIST of rows, each with its own days and hours** — not a per-weekday
+ * hours grid. One row covers "toda sexta das 16 às 20" and "segunda e terça à
+ * tarde" alike; a second covers "sexta 16–20 e sábado 12–16". The grid shape
+ * (what `openingHours` uses) asks seven questions to answer one, and a
+ * promotion is a sentence, not a business week.
+ *
+ * **A live read-back.** See `./schedule-summary` — it is the only thing on this
+ * screen the operator can check against what they meant.
+ *
+ * Presets WRITE INTO the chips rather than being a mode: after "Seg a Sex" the
+ * operator can still deselect Wednesday, which is what makes them a shortcut
+ * instead of a fourth thing to understand.
+ */
+
+/** Monday-first, 0..6 — the axis the engine and every hours surface share. */
+const WEEK = [0, 1, 2, 3, 4, 5, 6];
+const WEEKDAY_PRESET = [0, 1, 2, 3, 4];
+const WEEKEND_PRESET = [5, 6];
+
+/** A new row: the most common promotion, so an operator edits rather than fills. */
+export function blankWindow(): DiscountScheduleWindow {
+  return { days: [], from: "16:00", to: "20:00" };
+}
+
+function toggleDay(days: readonly number[], day: number): number[] {
+  return days.includes(day) ? days.filter((d) => d !== day) : [...days, day].sort((a, b) => a - b);
+}
+
+/** One day chip. A button rather than a checkbox — see the header. */
+function DayChip({
+  label,
+  index,
+  selected,
+  onClick,
+}: {
+  label: string;
+  /** The ROW this chip belongs to — test ids must be unique across rows. */
+  index: number;
+  selected: boolean;
+  onClick: () => void;
+}): JSX.Element {
+  return (
+    <Button
+      type="button"
+      variant={selected ? "solid" : "outline"}
+      size="sm"
+      onClick={onClick}
+      aria-pressed={selected}
+      data-testid={`schedule-day-${index}-${label}`}
+    >
+      {label}
+    </Button>
+  );
+}
+
+/** One "these days, these hours" row. */
+function WindowRow({
+  window,
+  index,
+  copy,
+  canRemove,
+  onChange,
+  onRemove,
+}: {
+  window: DiscountScheduleWindow;
+  index: number;
+  copy: DiscountsWebCopy;
+  canRemove: boolean;
+  onChange: (next: DiscountScheduleWindow) => void;
+  onRemove: () => void;
+}): JSX.Element {
+  const sentence = formatScheduleWindow(window, copy);
+  return (
+    <Stack
+      spacing={1}
+      sx={{ border: 1, borderColor: "divider", borderRadius: 1, p: 1.5 }}
+      data-testid={`schedule-window-${index}`}
+    >
+      <Box sx={{ display: "flex", gap: 0.5, flexWrap: "wrap", alignItems: "center" }}>
+        {WEEK.map((day) => (
+          <DayChip
+            key={day}
+            label={copy.schedule.dayShort[day] ?? String(day)}
+            index={index}
+            selected={window.days.includes(day)}
+            onClick={() => onChange({ ...window, days: toggleDay(window.days, day) })}
+          />
+        ))}
+        {canRemove && (
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            onClick={onRemove}
+            aria-label={copy.schedule.removeWindow}
+            data-testid={`schedule-remove-${index}`}
+          >
+            ✕
+          </Button>
+        )}
+      </Box>
+      <Box sx={{ display: "flex", gap: 1, alignItems: "center", flexWrap: "wrap" }}>
+        <Text variant="caption">{copy.schedule.fromLabel}</Text>
+        <Input
+          type="time"
+          value={window.from}
+          onChange={(event) => onChange({ ...window, from: event.target.value })}
+          aria-label={copy.schedule.fromLabel}
+          data-testid={`schedule-from-${index}`}
+        />
+        <Text variant="caption">{copy.schedule.toLabel}</Text>
+        <Input
+          type="time"
+          value={window.to}
+          onChange={(event) => onChange({ ...window, to: event.target.value })}
+          aria-label={copy.schedule.toLabel}
+          data-testid={`schedule-to-${index}`}
+        />
+      </Box>
+      {sentence !== null && (
+        <Text variant="caption" data-testid={`schedule-summary-${index}`}>
+          {sentence}
+        </Text>
+      )}
+    </Stack>
+  );
+}
+
+/** The three shortcuts. They write into the chips; they are not a mode. */
+function Presets({
+  copy,
+  onApply,
+}: {
+  copy: DiscountsWebCopy;
+  onApply: (days: number[]) => void;
+}): JSX.Element {
+  const presets: [string, number[]][] = [
+    [copy.schedule.presetEveryDay, WEEK],
+    [copy.schedule.presetWeekdays, WEEKDAY_PRESET],
+    [copy.schedule.presetWeekend, WEEKEND_PRESET],
+  ];
+  return (
+    <Box sx={{ display: "flex", gap: 0.5, flexWrap: "wrap" }}>
+      {presets.map(([label, days]) => (
+        <Button
+          key={label}
+          type="button"
+          variant="ghost"
+          size="sm"
+          onClick={() => onApply([...days])}
+          data-testid={`schedule-preset-${label}`}
+        >
+          {label}
+        </Button>
+      ))}
+    </Box>
+  );
+}
+
+export function ScheduleBuilder({
+  schedule,
+  copy,
+  timezone,
+  error,
+  onChange,
+}: {
+  schedule: DiscountSchedule;
+  copy: DiscountsWebCopy;
+  /** Whose clock these times are in — a merchant setting 16:00 must know. */
+  timezone: string;
+  error?: string | null;
+  onChange: (next: DiscountSchedule) => void;
+}): JSX.Element {
+  const { windows } = schedule;
+  const replace = (index: number, next: DiscountScheduleWindow): void =>
+    onChange({ windows: windows.map((w, i) => (i === index ? next : w)) });
+
+  return (
+    <FormControl>
+      <FormLabel>{copy.schedule.builderTitle}</FormLabel>
+      <Stack spacing={1} data-testid="schedule-builder">
+        <Presets
+          copy={copy}
+          onApply={(days) =>
+            onChange({
+              windows:
+                windows.length === 0
+                  ? [{ ...blankWindow(), days }]
+                  : windows.map((w, i) => (i === 0 ? { ...w, days } : w)),
+            })
+          }
+        />
+        {windows.map((window, index) => (
+          <WindowRow
+            // Index is the identity here: rows have no id, and the list is
+            // edited by position — which is also the order the sentence reads.
+            key={index}
+            window={window}
+            index={index}
+            copy={copy}
+            canRemove={windows.length > 1}
+            onChange={(next) => replace(index, next)}
+            onRemove={() => onChange({ windows: windows.filter((_, i) => i !== index) })}
+          />
+        ))}
+        {windows.length < MAX_SCHEDULE_WINDOWS && (
+          <Box>
+            <Button
+              type="button"
+              variant="outline"
+              size="sm"
+              onClick={() => onChange({ windows: [...windows, blankWindow()] })}
+              data-testid="schedule-add-window"
+            >
+              {copy.schedule.addWindow}
+            </Button>
+          </Box>
+        )}
+        <Text variant="caption">{fill(copy.schedule.timezoneNote, { timezone })}</Text>
+        <Text variant="caption">{copy.schedule.guaranteeNote}</Text>
+        {error != null && error !== "" && <FormMessage error>{error}</FormMessage>}
+      </Stack>
+    </FormControl>
+  );
+}

package/src/react/schedule-copy.ts

@@ -0,0 +1,74 @@
+/**
+ * The weekly schedule editor and the sentence it reads back (FUT-996).
+ *
+ * The read-back is the highest-value thing on this screen — a grid of chips and
+ * two clocks is data, and "Toda sexta, das 16:00 às 20:00" is the promise the
+ * operator is actually making. It follows the free-units builder's rule: the
+ * sentence appears only once the values make a real offer, so it is never
+ * confirmation of something that cannot be saved.
+ *
+ * Day names are three separate records because Portuguese needs them to be.
+ * `dayShort` is a chip ("Seg"), `dayLong` is a list item ("segunda"), and
+ * `dayEvery` is a sentence opener whose article follows the day's GENDER
+ * ("Toda segunda", "Todo sábado"). Deriving the third from the second would
+ * mean encoding Portuguese grammar in a package that must not know which
+ * language it is rendering.
+ */
+export interface DiscountsScheduleCopy {
+  /** Section heading over the period and the repetition. */
+  readonly sectionTitle: string;
+  readonly periodTitle: string;
+  readonly periodHint: string;
+  readonly repetitionTitle: string;
+  /** The two repetition choices. */
+  readonly always: string;
+  readonly specific: string;
+  /** The builder. */
+  readonly builderTitle: string;
+  readonly addWindow: string;
+  readonly removeWindow: string;
+  readonly fromLabel: string;
+  readonly toLabel: string;
+  /** Preset buttons that write into the chips rather than replacing them. */
+  readonly presetEveryDay: string;
+  readonly presetWeekdays: string;
+  readonly presetWeekend: string;
+  /** Monday-first, 0..6. */
+  readonly dayShort: readonly string[];
+  readonly dayLong: readonly string[];
+  readonly dayEvery: readonly string[];
+  /** Joining a day list: "segunda, terça e quarta". */
+  readonly listSeparator: string;
+  readonly listLast: string;
+  /** Collapsed day sets, so a common week reads as a phrase not a list. */
+  readonly allDays: string;
+  readonly weekdays: string;
+  readonly weekend: string;
+  /** The read-back. `{days}`, `{from}`, `{to}`. */
+  readonly summary: string;
+  /** The same, when the window runs past midnight. */
+  readonly summaryOvernight: string;
+  /** Whose clock these times are in. `{timezone}`. */
+  readonly timezoneNote: string;
+  /**
+   * What the shopper is promised — stated where the merchant promises it.
+   * FUT-996 decision 2: the price follows the moment the item entered the cart.
+   */
+  readonly guaranteeNote: string;
+  /**
+   * The ORDER-scope asymmetry, shown ONLY for that combination because it is
+   * otherwise invisible: an order-wide rule has no line to anchor to, so it is
+   * judged at checkout while every other scope is judged per line.
+   */
+  readonly orderScopeNote: string;
+  /** Grid: the campaign window and the schedule in one cell. `{window}`, `{schedule}`. */
+  readonly windowWithSchedule: string;
+  /** Grid: a compact schedule, plus "+N" when there are more rows. `{count}`. */
+  readonly moreWindows: string;
+  /** Grid + card: this rule's hours are running at this moment. */
+  readonly activeNow: string;
+  /** Refusals. */
+  readonly daysRequired: string;
+  readonly timesRequired: string;
+  readonly windowsRequired: string;
+}

package/src/react/schedule-summary.ts

@@ -0,0 +1,100 @@
+import type { DiscountSchedule, DiscountScheduleWindow } from "../engine/schedule";
+import { toMinutes } from "../engine/schedule";
+
+import { fill, type DiscountsWebCopy } from "./copy";
+
+/**
+ * The read-back sentence: "Toda sexta, das 16:00 às 20:00." (FUT-996)
+ *
+ * The highest-value thing on the schedule editor. A row of day chips and two
+ * clocks is DATA; this is the promise the operator is actually making, in the
+ * words they would use to describe it out loud, and it is the only thing on the
+ * screen they can check against what they meant.
+ *
+ * It follows `summaryOf` in the free-units builder exactly: **nothing is
+ * rendered until the values make a real offer.** A sentence over a half-built
+ * window would read as confirmation of something the validator is about to
+ * refuse, which is worse than no sentence at all.
+ *
+ * Its own module because it is pure string assembly the builder, the grid cell
+ * and the card all want, and a copy of it in each is how three surfaces start
+ * describing one promotion three ways.
+ */
+
+const ALL_DAYS = [0, 1, 2, 3, 4, 5, 6];
+const WEEKDAYS = [0, 1, 2, 3, 4];
+const WEEKEND = [5, 6];
+
+function sameDays(days: readonly number[], expected: readonly number[]): boolean {
+  const unique = [...new Set(days)].sort((a, b) => a - b);
+  return unique.length === expected.length && unique.every((day, i) => day === expected[i]);
+}
+
+/**
+ * The day set as a phrase.
+ *
+ * Collapsed sets come first so a common week reads as a phrase rather than a
+ * list — "De segunda a sexta" beats "segunda, terça, quarta, quinta e sexta",
+ * which is the same fact spelled at four times the length.
+ *
+ * A SINGLE day uses the pack's `dayEvery` form ("Toda sexta", "Todo sábado")
+ * rather than the bare name, because that is how a merchant says it. The
+ * article follows the day's gender in Portuguese, which is why the pack carries
+ * all seven rather than the code prefixing a word.
+ */
+function formatDays(days: readonly number[], copy: DiscountsWebCopy): string | null {
+  const unique = [...new Set(days)].sort((a, b) => a - b);
+  if (unique.length === 0) return null;
+  if (unique.some((day) => day < 0 || day > 6)) return null;
+  const { schedule } = copy;
+  if (sameDays(unique, ALL_DAYS)) return schedule.allDays;
+  if (sameDays(unique, WEEKDAYS)) return schedule.weekdays;
+  if (sameDays(unique, WEEKEND)) return schedule.weekend;
+  if (unique.length === 1) return schedule.dayEvery[unique[0] as number] ?? null;
+  const names = unique.map((day) => schedule.dayLong[day] ?? String(day));
+  const last = names[names.length - 1] as string;
+  return names.slice(0, -1).join(schedule.listSeparator) + schedule.listLast + last;
+}
+
+/**
+ * One window as a sentence, or null when it is not yet an offer.
+ *
+ * An overnight window gets its OWN sentence rather than the same one, because
+ * "das 22:00 às 02:00" is ambiguous on a screen and unambiguous only once it
+ * says which day the 02:00 belongs to. An operator who typed it by mistake sees
+ * it; one who meant it gets confirmation.
+ */
+export function formatScheduleWindow(
+  window: DiscountScheduleWindow,
+  copy: DiscountsWebCopy,
+): string | null {
+  const days = formatDays(window.days, copy);
+  const from = toMinutes(window.from);
+  const to = toMinutes(window.to);
+  if (days === null || from === null || to === null || from === to) return null;
+  const template = to < from ? copy.schedule.summaryOvernight : copy.schedule.summary;
+  return fill(template, { days, from: window.from, to: window.to });
+}
+
+/**
+ * The COMPACT form for a grid cell: "sex 16:00–20:00", plus "+N" when the rule
+ * has more windows than the column can show.
+ *
+ * Short day names rather than the sentence, because a table cell is read in a
+ * column of forty and the sentence is read once, deliberately, in a form.
+ */
+export function formatScheduleCell(
+  schedule: DiscountSchedule | null | undefined,
+  copy: DiscountsWebCopy,
+): string | null {
+  if (schedule === null || schedule === undefined) return null;
+  const [first, ...rest] = schedule.windows;
+  if (first === undefined) return null;
+  const days = [...new Set(first.days)]
+    .sort((a, b) => a - b)
+    .map((day) => copy.schedule.dayShort[day] ?? String(day))
+    .join(" ");
+  const head = `${days} ${first.from}–${first.to}`;
+  if (rest.length === 0) return head;
+  return `${head} ${fill(copy.schedule.moreWindows, { count: rest.length })}`;
+}

package/src/react/screen-bindings.ts

@@ -0,0 +1,57 @@
+"use client";
+
+import { useServerDataViews } from "@12-apps/app-shell/react";
+
+import type { DiscountsPagination, WireTargetGroup } from "./api";
+import type { MenuBinding, DiscountsScreenProps } from "./discounts-screen";
+import { discountsQueryToParams } from "./table-config";
+
+/**
+ * The two bindings {@link DiscountsScreen} hands down — pagination and the row
+ * menu — lifted out of it.
+ *
+ * Neither is a second concern; they live here because that component is at both
+ * the size and the complexity ceilings, and these are the parts of it that are
+ * pure plumbing rather than layout.
+ */
+
+/**
+ * The grid's server-side pagination binding, with the defaults a page that has
+ * not loaded yet needs.
+ *
+ * Its own hook so the three `??` fallbacks are not branches inside
+ * {@link DiscountsScreen}, which sits at the complexity ceiling.
+ */
+export function usePagedServer(
+  pagination: DiscountsPagination | undefined,
+): ReturnType<typeof useServerDataViews> {
+  return useServerDataViews({
+    totalCount: pagination?.total ?? 0,
+    page: pagination?.page ?? 1,
+    pageSize: pagination?.pageSize ?? 20,
+    toParams: discountsQueryToParams,
+  });
+}
+
+/**
+ * The binding every row menu, tile and card receives — built once so an edit
+ * opened from any of the three offers the same pickers.
+ *
+ * A helper rather than an inline literal: the optional `timezoneLabel` is a
+ * conditional spread, and {@link DiscountsScreen} is at the complexity ceiling.
+ */
+export function toMenuBinding(
+  props: DiscountsScreenProps,
+  groups: readonly WireTargetGroup[] | undefined,
+): MenuBinding {
+  const { api, copy, formatters, currencyField, onError, timezoneLabel } = props;
+  return {
+    api,
+    copy,
+    formatters,
+    currencyField,
+    groups,
+    onError,
+    ...(timezoneLabel ? { timezoneLabel } : {}),
+  };
+}

package/src/react/table-config.ts

@@ -76,6 +76,21 @@ export function discountColumns(copy: DiscountsWebCopy): DataViewColumn<Discount
       searchable: true,
     },
     { id: "window", header: copy.screen.columns.window, accessor: (row) => row.windowLabel },
+    {
+      // The live answer to "is my happy hour on right now?" (FUT-996).
+      //
+      // Its own column rather than a widening of the vigência pill beside it:
+      // those three values are resolved by a store-side SQL predicate, and a
+      // recurrence predicate is not expressible there. This one is computed in
+      // the browser from the store's timezone, so it can be SHOWN but not
+      // FILTERED — and a cell is honest about that in a way a pill would not be.
+      //
+      // Blank, not "Não", for a rule with no schedule: there is nothing
+      // intermittent to report, and a column of "Não" would read as a fault.
+      id: "activeNow",
+      header: copy.schedule.activeNow,
+      accessor: (row) => (row.activeNow ? copy.schedule.activeNow : EMPTY),
+    },
     {
       id: "usageCount",
       header: copy.screen.columns.usageCount,

package/src/server/copy.ts

@@ -34,6 +34,8 @@ export interface DiscountsServerCopy {
   readonly invalidDate: string;
   /** 422 — the window closes at or before it opens, so it is never open. */
   readonly endsBeforeStarts: string;
+  /** The weekly schedule is not one the engine can act on (FUT-996). */
+  readonly invalidSchedule: string;
   /** 422 — a minimum-basket threshold of zero or less. */
   readonly invalidMinSubtotal: string;
   /** 422 — a global redemption cap of zero or less. */
@@ -79,6 +81,7 @@ const COPY_KEYS: readonly (keyof DiscountsServerCopy)[] = [
   "itemTargetRequired",
   "invalidDate",
   "endsBeforeStarts",
+  "invalidSchedule",
   "invalidMinSubtotal",
   "invalidUsageLimit",
   "invalidPerBuyerLimit",

package/src/server/en-US.ts

@@ -23,6 +23,7 @@ export const EN_US_DISCOUNTS_SERVER_COPY: DiscountsServerCopy = {
   // would send an operator to type something the endpoint rejects.
   invalidDate: "Invalid date. Use the format YYYY-MM-DD.",
   endsBeforeStarts: "The end date must be after the start date.",
+  invalidSchedule: "Invalid promotion schedule. Pick at least one day, and a start and end time that differ.",
   invalidMinSubtotal: "The minimum order must be greater than zero (or left blank).",
   invalidUsageLimit: "The usage limit must be greater than zero (or left blank).",
   invalidPerBuyerLimit: "The per-customer limit must be greater than zero (or left blank).",

package/src/server/mcp.ts

@@ -17,6 +17,7 @@ import {
   MAX_COMBO_SLOT_QUANTITY,
   MAX_PERCENT_OFF_BP,
 } from "../engine/kinds";
+import { MAX_SCHEDULE_WINDOWS } from "../engine/schedule";
 import { discountSearchConfig } from "./search";
 
 /**
@@ -66,6 +67,35 @@ export const comboRequirementSchema = z.object({
   quantity: z.number().int().min(1).max(MAX_COMBO_SLOT_QUANTITY),
 });
 
+/**
+ * A `HH:MM` clock time, 24-hour — the schedule's own wire format (FUT-996).
+ *
+ * A string rather than minutes-since-midnight because it is what an operator
+ * typed and what a card reads back; converting at the edge would mean two
+ * representations of one fact and a conversion to get wrong in each direction.
+ */
+const clockTimeSchema = z
+  .string()
+  .regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use HH:MM, 24-hour");
+
+/**
+ * One "these days, these hours" row. `days` is **Monday-first, 0..6** — the
+ * same axis every hours surface uses, and NOT `Date#getDay()`'s Sunday-first.
+ *
+ * `to` earlier than `from` is legal and means the window runs past midnight: a
+ * bar shutting at 02:00 is the most common happy hour there is.
+ */
+const scheduleWindowSchema = z.object({
+  days: z.array(z.number().int().min(0).max(6)).min(1).max(7),
+  from: clockTimeSchema,
+  to: clockTimeSchema,
+});
+
+/** The weekly schedule. Null = always, within the campaign window. */
+const discountScheduleSchema = z.object({
+  windows: z.array(scheduleWindowSchema).min(1).max(MAX_SCHEDULE_WINDOWS),
+});
+
 /**
  * A discount as the API returns it (JSON-serialized: dates become ISO
  * strings). The two join tables are flattened into id arrays.
@@ -93,6 +123,7 @@ export const discountSchema = z.object({
   code: z.string().nullable(),
   startsAt: z.string().nullable(),
   endsAt: z.string().nullable(),
+  schedule: discountScheduleSchema.nullable().optional(),
   minSubtotalCents: z.number().int().nullable(),
   usageLimit: z.number().int().nullable(),
   perBuyerLimit: z.number().int().nullable(),
@@ -150,6 +181,7 @@ const discountWriteShape = {
   code: z.string().min(1).max(64).nullable().optional(),
   startsAt: calendarDateSchema.nullable().optional(),
   endsAt: calendarDateSchema.nullable().optional(),
+  schedule: discountScheduleSchema.nullable().optional(),
   minSubtotalCents: z.number().int().positive().nullable().optional(),
   usageLimit: z.number().int().positive().nullable().optional(),
   perBuyerLimit: z.number().int().positive().nullable().optional(),

package/src/server/pt-BR.ts

@@ -20,6 +20,7 @@ export const PT_BR_DISCOUNTS_SERVER_COPY: DiscountsServerCopy = {
   itemTargetRequired: "Selecione ao menos um produto para este desconto.",
   invalidDate: "Data inválida. Use o formato AAAA-MM-DD.",
   endsBeforeStarts: "A data de término deve ser posterior à data de início.",
+  invalidSchedule: "Horários da promoção inválidos. Escolha ao menos um dia e um horário de início e fim diferentes.",
   invalidMinSubtotal: "O pedido mínimo deve ser maior que zero (ou deixe em branco).",
   invalidUsageLimit: "O limite de usos deve ser maior que zero (ou deixe em branco).",
   invalidPerBuyerLimit: "O limite por cliente deve ser maior que zero (ou deixe em branco).",

package/src/server/store.ts

@@ -1,6 +1,7 @@
 import type { PaginatedResult, ParsedSearchInput } from "@12-apps/shared-helpers/search";
 
 import type { DiscountScope, DiscountTrigger, DiscountType } from "../engine/kinds";
+import type { DiscountSchedule } from "../engine/schedule";
 import type { ComboRequirement } from "../engine/types";
 import type { DiscountScalars, DiscountTargets } from "./validate";
 
@@ -33,6 +34,13 @@ export interface DiscountRecord {
   code: string | null;
   startsAt: Date | null;
   endsAt: Date | null;
+  /**
+   * The WEEKLY schedule (FUT-996), OPTIONAL for the reason the combo columns
+   * below are: a host that has not added the column keeps compiling and keeps
+   * answering the record it always did. Null or absent = always, within the
+   * campaign window.
+   */
+  schedule?: DiscountSchedule | null;
   minSubtotalCents: number | null;
   usageLimit: number | null;
   perBuyerLimit: number | null;