monday-cli 0.2.0

package/dist/api/column-values.d.ts

@@ -0,0 +1,446 @@
+/**
+ * Column-value writer (`cli-design.md` §5.3, `v0.1-plan.md` §3 M5a).
+ *
+ * The write half of the column-value abstraction: takes a resolved
+ * column + a raw user-supplied string and produces the Monday wire
+ * payload Monday's `change_simple_column_value` /
+ * `change_column_value` / `change_multiple_column_values` mutations
+ * accept.
+ *
+ * **Two entry points.** Nine of the ten allowlisted types translate
+ * purely locally — no network, no clock dependency beyond the date
+ * module's injectable clock — and live behind the sync
+ * `translateColumnValue`. `people` is the exception: email→ID
+ * resolution can hit the network. Rather than forcing a
+ * `Promise<TranslatedColumnValue>` on every call site for the nine
+ * sync types, `translateColumnValueAsync` is the unified async entry
+ * point the command layer always calls. It delegates to the sync
+ * version for non-people types and dispatches to `parsePeopleInput`
+ * for `people`. M5b's write surface goes through async exclusively
+ * (people may appear in any `--set` bundle).
+ *
+ * **Scope.** All ten allowlisted types translate:
+ * `text` / `long_text` / `numbers` (simple-string payloads, M5a
+ * skeleton); `status` / `dropdown` (rich-object payloads); `date`
+ * (rich, with relative-token resolution against the profile
+ * timezone); `people` (rich, with `me`-token + email resolution via
+ * the M3 `userByEmail` directory cache); and the M8 firm additions
+ * `link` / `email` / `phone` (pipe-form parsers in `links.ts` /
+ * `emails.ts` / `phones.ts`; same `change_column_value` wire path
+ * as the v0.1 rich types).
+ *
+ * **Date resolution context** (cli-design §5.3 step 3 + the
+ * "Relative dates and timezone" subsection). Relative tokens
+ * (`today`, `+3d`, `+2h`) need a clock + a timezone; both come
+ * from `TranslateColumnValueInputs.dateResolution`. Defaults to
+ * the system clock + system tz when omitted — M5b's command
+ * layer plumbs `MONDAY_TIMEZONE` env override through this slot.
+ * Tests inject a deterministic clock for DST-boundary coverage.
+ * The actual resolution machinery lives in `dates.ts`; this
+ * module just delegates and packages the result alongside the
+ * other column types.
+ *
+ * **People resolution context** (cli-design §5.3 step 3 line
+ * 728-734 + the `me` token rule line 704-707). Email lookups +
+ * `me` resolution come through
+ * `TranslateColumnValueAsyncInputs.peopleResolution`, which
+ * carries `resolveMe` (mirroring `filters.ts`'s slot, so the
+ * same M5b wiring resolves `me` for both filter reads and
+ * `--set` writes) and `resolveEmail` (M5b wires this to
+ * `resolvers.userByEmail`). Required for people columns; ignored
+ * for everything else. The actual parsing machinery lives in
+ * `people.ts`.
+ *
+ * **Mutation selection** (`cli-design.md` §5.3 step 5) lives in
+ * `selectMutation` below — single simple → `change_simple_column_value`;
+ * single rich → `change_column_value`; N (any combo) →
+ * `change_multiple_column_values` (atomic on Monday's side). The
+ * multi form re-wraps `long_text`'s simple bare string as
+ * `{ text: <value> }` because Monday's per-column blob inside
+ * `change_multiple_column_values` requires the object form for
+ * `long_text` (a wire-shape divergence from
+ * `change_simple_column_value`'s bare-string acceptance — pinned
+ * via fixture in the unit suite, logged as a spec gap in
+ * `v0.1-plan.md` §3 M5a for cli-design backfill).
+ *
+ * **No CLI-side label-to-index lookup.** Per `cli-design.md` §5.3
+ * step 3: the CLI emits `{ "label": ... }` for label input and
+ * `{ "index": N }` for numeric input on `status`; it does *not*
+ * traverse `column.settings_str` to resolve labels to their stable
+ * indexes. Same shape for `dropdown` — `{ "labels": [...] }` for
+ * label input, `{ "ids": [...] }` for all-numeric input. Monday is
+ * the validator of last resort; the translator's contract is
+ * "produce the documented wire shape, let Monday reject typos as
+ * `validation_failed`".
+ *
+ * **Monday `JSON` scalar discipline** (`cli-design.md` §5.3 step 4).
+ * Every payload is a plain JS value (string for the simple form,
+ * plain object for the rich form). The SDK / fetch layer is
+ * responsible for stringifying at the wire boundary — this module
+ * never `JSON.stringify`s. The unit tests in
+ * `tests/unit/api/column-values.test.ts` pin the exact wire shape
+ * per type as a fixture so M5b and v0.2's bulk surface inherit the
+ * rule unchanged.
+ *
+ * **`--set-raw` escape hatch (M8).** v0.1 had no escape hatch;
+ * v0.2's M8 milestone added `--set-raw <col>=<json>` (see
+ * `src/api/raw-write.ts`) for column types that don't have a
+ * friendly translator yet. Non-allowlisted column types still
+ * surface `unsupported_column_type` keyed by roadmap category per
+ * `column-types.ts getColumnRoadmapCategory`: tentative writer-
+ * expansion types (`tags` / `board_relation` / `dependency`) slipped
+ * to v0.3 at M18 close — they get `deferred_to: "v0.3"` plus a
+ * `--set-raw` hint, read-only-forever types get
+ * `read_only: true`, anything else gets `deferred_to: "future"`
+ * with a `--set-raw` hint when the underlying mutation is shaped
+ * like `change_column_value`. The M8 contract is "we translate the
+ * ten allowlisted types and reject everything else with
+ * category-accurate guidance, pointing tentative + future-shaped
+ * targets at `--set-raw`."
+ */
+import { ApiError } from '../utils/errors.js';
+import type { JsonObject } from '../types/json.js';
+import { type WritableColumnType } from './column-types.js';
+import { type DateResolution, type DateResolutionContext } from './dates.js';
+import { type PeopleResolution, type PeopleResolutionContext } from './people.js';
+export type { DateResolution, DateResolutionContext } from './dates.js';
+export type { PeoplePayload, PeoplePayloadEntry, PeopleResolution, PeopleResolutionContext, PeopleResolutionToken, } from './people.js';
+export type { LinkPayload } from './links.js';
+export type { EmailPayload } from './emails.js';
+export type { PhonePayload } from './phones.js';
+/**
+ * Discriminator on the wire payload's *shape*, not the GraphQL
+ * mutation that consumes it (one mutation can accept either shape).
+ *
+ *   - `simple` — bare-string payload accepted by
+ *     `change_simple_column_value`. Used by `text`, `long_text`,
+ *     `numbers`. When bundled into `change_multiple_column_values`,
+ *     `long_text` is re-wrapped to `{ text: <value> }` by
+ *     `selectMutation`; the discriminator on the translated value
+ *     stays `simple` because that's the column-class fact, not
+ *     the per-mutation projection.
+ *   - `rich`   — plain-object payload accepted by
+ *     `change_column_value` and the per-column entry in
+ *     `change_multiple_column_values`. Used by `status`,
+ *     `dropdown`, `date`, and `people`. The slot type is
+ *     `JsonObject` (R-JsonValue refactor) so non-JSON values
+ *     (`undefined`, symbols, functions) can't sneak past the
+ *     type system into the wire payload.
+ */
+export type ColumnValuePayload = {
+    readonly format: 'simple';
+    readonly value: string;
+} | {
+    readonly format: 'rich';
+    readonly value: JsonObject;
+};
+export interface TranslatedColumnValue {
+    /** The resolved column ID — echoed in M5b's mutation envelope. */
+    readonly columnId: string;
+    /** The resolved column's type — narrowed to `WRITABLE_COLUMN_TYPES`. */
+    readonly columnType: WritableColumnType;
+    /** The wire payload + format discriminator. */
+    readonly payload: ColumnValuePayload;
+    /** The raw input the caller passed, preserved for the dry-run diff. */
+    readonly rawInput: string;
+    /**
+     * Echo of the resolution context for relative-token date
+     * inputs — populated by the `date` translator when the input
+     * was a relative token (`today`, `+3d`, `+2h`) so the
+     * dry-run engine can render `details.resolved_from` per
+     * cli-design §6.4. `null` for explicit ISO inputs (where
+     * the raw input *is* the resolved value) and for
+     * non-`date` columns. cli-design §5.3 line 783-786 pins
+     * the shape.
+     */
+    readonly resolvedFrom: DateResolution | null;
+    /**
+     * Echo of the per-token resolution for the `people` translator —
+     * one entry per input token, pairing the verbatim input with the
+     * resolved Monday user ID. Populated by the people translator;
+     * `null` for every other type. The dry-run engine renders this
+     * as `details.resolved_from` on people-column diff cells.
+     *
+     * **Why a parallel slot rather than widening `resolvedFrom`** —
+     * the date echo and people echo are structurally different
+     * (`{input, timezone, now}` vs `{tokens: [{input, resolved_id},
+     * ...]}`). One slot per kind keeps existing `resolvedFrom`
+     * consumers untouched and lets each translator's tests assert on
+     * its own shape without an `if kind === 'date'` discriminator
+     * dance. v0.2 may widen — extending the union is always
+     * available later. The shape itself is a v0.1-plan §3 M5a spec
+     * gap for cli-design backfill (the §6.4 sample only shows the
+     * date case).
+     */
+    readonly peopleResolution: PeopleResolution | null;
+}
+export interface TranslateColumnValueInputs {
+    /**
+     * The resolved column. Only `id` and `type` are read; the full
+     * `BoardColumn` is fine but not required, so the bulk path can
+     * project a slim shape.
+     */
+    readonly column: {
+        readonly id: string;
+        readonly type: string;
+    };
+    /** The raw user-supplied value (post-`--set` parsing). */
+    readonly value: string;
+    /**
+     * Resolution context for the `date` translator's relative
+     * tokens (`today`, `+3d`, `+2h`). Ignored for non-`date`
+     * columns. Defaults to system clock + system tz when omitted;
+     * M5b's command layer plumbs `MONDAY_TIMEZONE` env override
+     * through this slot per cli-design §5.3 line 765.
+     */
+    readonly dateResolution?: DateResolutionContext;
+}
+/**
+ * Async-entry inputs — superset of `TranslateColumnValueInputs`
+ * with the people-resolution slot. Required for people columns;
+ * ignored for everything else. The async entry point delegates
+ * to the sync version when `column.type !== 'people'`, so the
+ * `peopleResolution` slot can be omitted in callers that know
+ * they're never targeting a people column.
+ *
+ * In M5b's command layer, the slot is always passed (the layer
+ * doesn't know in advance which column types appear in a
+ * multi-`--set` bundle).
+ */
+export interface TranslateColumnValueAsyncInputs extends TranslateColumnValueInputs {
+    /**
+     * Resolution context for the `people` translator's `me` token
+     * + email lookups. Required for people columns; ignored for
+     * non-people types. cli-design §5.3 step 3 line 728-734 +
+     * line 704-707 pin the grammar.
+     */
+    readonly peopleResolution?: PeopleResolutionContext;
+}
+/**
+ * Translates a single `<column>=<value>` pair into the Monday wire
+ * payload. **Sync entry point — handles the nine types whose
+ * translation is purely local computation** (`text` / `long_text` /
+ * `numbers` / `status` / `dropdown` / `date` / `link` / `email` /
+ * `phone`). For `people` columns, use `translateColumnValueAsync`:
+ * people resolution can hit the network (email→ID lookup) and is
+ * therefore async-only.
+ *
+ * **Throws** `ApiError`:
+ *   - `unsupported_column_type` — type not in the friendly
+ *     allowlist. Carries `column_id` + `type` plus per-category
+ *     details: `deferred_to: "v0.3"` for the tentative writer-
+ *     expansion row that slipped from v0.2 (`tags` /
+ *     `board_relation` / `dependency`), `read_only: true` for
+ *     read-only-forever types (mirror / formula / auto_number /
+ *     creation_log / last_updated / item_id), `deferred_to:
+ *     "future"` for anything else. The `--set-raw` escape hatch
+ *     (M8) accepts most non-allowlisted types.
+ *   - `internal_error` — sync entry was called on a `people`
+ *     column. Programmer error: the write surface always uses
+ *     `translateColumnValueAsync`. The check exists so a future
+ *     contributor doesn't accidentally regress to a sync code
+ *     path that silently mis-translates people input.
+ *
+ * **Throws** `UsageError`:
+ *   - `usage_error` — for status / dropdown numeric input that
+ *     exceeds `Number.MAX_SAFE_INTEGER`, dropdown input that
+ *     contains no labels and no IDs after trim + filter, `date`
+ *     input that does not match any supported form (ISO date,
+ *     ISO date+time, or relative token), invalid URL / email /
+ *     phone in the link / email / phone translators, or
+ *     pipe-form input with empty leader/trailer in those types.
+ *     See `unsafeIntegerError`, the dropdown empty-input branch,
+ *     `dates.parseDateInput`, `links.parseLinkInput`,
+ *     `emails.parseEmailInput`, and `phones.parsePhoneInput` for
+ *     the documented messages.
+ */
+export declare const translateColumnValue: (inputs: TranslateColumnValueInputs) => TranslatedColumnValue;
+/**
+ * Async entry point — handles every type in `WRITABLE_COLUMN_TYPES`.
+ * Delegates to `translateColumnValue` (sync) for non-people columns;
+ * dispatches to `parsePeopleInput` for `people`.
+ *
+ * The `peopleResolution` slot is required when `column.type ===
+ * 'people'`. Omitting it for a people column raises `internal_error`
+ * (programmer wiring bug) — agents see this as a loud failure
+ * rather than a silent fallback to the unsupported-type path.
+ *
+ * **Throws** every error `translateColumnValue` throws (delegated
+ * unchanged for non-people types), plus:
+ *   - `ApiError(user_not_found)` — bubbled from `peopleResolution.
+ *     resolveEmail` for unknown emails. cli-design.md §5.3 step 3
+ *     line 733 pins the contract.
+ *   - `UsageError(usage_error)` — empty / numeric people input.
+ *     See `parsePeopleInput` for the per-branch messages.
+ *   - `ApiError(internal_error)` — `peopleResolution` was omitted
+ *     for a people column.
+ */
+/**
+ * Builds the per-type "clear" payload for `monday item clear`. The
+ * dedicated verb keeps `--set <col>=<value>` and the clear path
+ * non-overlapping (cli-design §5.3 step 3 explicitly notes that
+ * empty-string input on `status` is `{label: ""}`, NOT a clear; the
+ * translator is value-shaping, not intent-disambiguating).
+ *
+ * Per-type clear shapes:
+ *   - `text` / `long_text` / `numbers` → simple bare empty string
+ *     (`change_simple_column_value(value: "")` clears the cell).
+ *   - `status` / `dropdown` / `date` / `people` → empty JSON object
+ *     `{}` via `change_column_value(value: JSON!)`. Monday's
+ *     official "clear all column values" pattern.
+ *
+ * **Throws** `unsupported_column_type` for types outside the v0.1
+ * writable allowlist — same code path the value translator uses,
+ * keyed by roadmap category (`deferred_to: "v0.3"` /
+ * `read_only: true` / `deferred_to: "future"`). Agents see the
+ * same per-category surface across `item set` / `item update` /
+ * `item clear`, so a wrapper that triages on the error details
+ * doesn't need a per-verb branch.
+ *
+ * Sync entry — `people` clear doesn't need email resolution (the
+ * payload is `{}` regardless of who's currently assigned). Reused
+ * by the `item clear` dry-run + live paths.
+ */
+export declare const translateColumnClear: (column: {
+    readonly id: string;
+    readonly type: string;
+}) => TranslatedColumnValue;
+export declare const translateColumnValueAsync: (inputs: TranslateColumnValueAsyncInputs) => Promise<TranslatedColumnValue>;
+/**
+ * The wire shape `change_multiple_column_values` accepts for one
+ * column inside its `column_values` map: either a bare string (for
+ * the simple types Monday accepts as a string) or a plain JSON
+ * object (for rich types — and for `long_text`, see below).
+ */
+export type MultiColumnValue = string | JsonObject;
+/**
+ * Discriminated union over the three v0.1 mutation paths that
+ * `cli-design.md` §5.3 step 5 enumerates. The variant carries
+ * exactly the fields M5b's command layer threads into the GraphQL
+ * SDK — no extra projection at the call site.
+ *
+ *   - `change_simple_column_value` — single simple type. The
+ *     `value` field is the bare string Monday's
+ *     `change_simple_column_value(value: String!)` mutation
+ *     accepts. `text` / `long_text` / `numbers` only.
+ *   - `change_column_value` — single rich type. The `value` field
+ *     is the plain-object payload Monday's
+ *     `change_column_value(value: JSON!)` mutation accepts —
+ *     the SDK / fetch layer JSON-stringifies at the wire boundary.
+ *     Used by `status` / `dropdown` / `date` / `people`.
+ *   - `change_multiple_column_values` — N (any combo). The
+ *     `columnValues` map carries one entry per column; per-column
+ *     value is `string | object` per `MultiColumnValue` above.
+ *     **`long_text` re-wrap**: simple-form `long_text`'s bare
+ *     string is wrapped to `{ text: <value> }` for this mutation
+ *     because Monday's per-column blob inside the multi mutation
+ *     requires the object form for `long_text` (a wire-shape
+ *     divergence from `change_simple_column_value`'s bare-string
+ *     acceptance — see selectMutation source comment for the spec
+ *     gap).
+ */
+export type SelectedMutation = {
+    readonly kind: 'change_simple_column_value';
+    readonly columnId: string;
+    readonly value: string;
+} | {
+    readonly kind: 'change_column_value';
+    readonly columnId: string;
+    readonly value: JsonObject;
+} | {
+    readonly kind: 'change_multiple_column_values';
+    readonly columnValues: Readonly<Record<string, MultiColumnValue>>;
+};
+/**
+ * Picks the right Monday mutation for a list of translated column
+ * values per `cli-design.md` §5.3 step 5.
+ *
+ * Dispatch:
+ *   - 1 translated value, simple → `change_simple_column_value`
+ *     (bare-string `value`).
+ *   - 1 translated value, rich → `change_column_value` (object
+ *     `value`).
+ *   - N translated values (any combo of simple / rich) →
+ *     `change_multiple_column_values`. Atomic on Monday's side —
+ *     either every column update lands or none do.
+ *
+ * **Duplicate column IDs throw `usage_error`.** Bundling two
+ * `--set status=Done --set status=Doing` would have last-write-wins
+ * semantics inside `change_multiple_column_values`'s map and the
+ * agent has no way to know which one won. Surfacing as a typed
+ * error at the bundling boundary keeps mutations deterministic;
+ * the command layer (M5b) can catch + reframe with the literal
+ * `--set` flags it received.
+ *
+ * **Empty input throws `usage_error`.** Defensive — the command
+ * layer is supposed to validate `--set` was supplied, but the
+ * helper shouldn't return a malformed `change_multiple_column_values`
+ * with an empty map.
+ *
+ * **`long_text` re-wrap, spec gap.** Monday's
+ * `change_multiple_column_values(column_values: JSON!)` accepts a
+ * map where each value is either a string or a per-type object.
+ * For `long_text` specifically, the per-type object is `{text:
+ * <value>}` — so the bare string that `change_simple_column_value`
+ * accepts is *not* the right shape inside the multi mutation.
+ * `text` / `numbers` stay as bare strings. This wire-shape
+ * divergence isn't called out in cli-design.md §5.3 step 5; logged
+ * as a spec gap in v0.1-plan.md §3 M5a for backfill. Pinned via
+ * fixture in the unit suite.
+ */
+export declare const selectMutation: (translated: readonly TranslatedColumnValue[]) => SelectedMutation;
+/**
+ * Bundles a list of translated column values into Monday's
+ * `column_values: JSON!` map shape — the input parameter
+ * `change_multiple_column_values`, `create_item`, and `create_subitem`
+ * all accept. Per-column projection routes through `projectForMulti`,
+ * so the `long_text` re-wrap (`{ text: <value> }` inside the map)
+ * applies uniformly across every wire surface that takes a
+ * `column_values` map.
+ *
+ * **Why a shared helper.** `selectMutation` builds this map for the
+ * multi-update case (M5b); M9's `item create` needs the same shape
+ * to bundle `--set` values into `create_item.column_values` /
+ * `create_subitem.column_values`. The single-round-trip exit gate
+ * (cli-design §5.8) requires the create payload bundles every
+ * translated value into one map — and the shape rule should not
+ * drift between update and create. The fixture pin in
+ * `tests/unit/api/column-values.test.ts` covers both consumers.
+ *
+ * **Duplicate-column-ID throws `usage_error`.** Same rule as
+ * `selectMutation`'s multi case — bundling two values for the same
+ * column would silently keep one. The cli-design §5.3 step 2
+ * mutual-exclusion contract enforces this resolution-time; the
+ * helper duplicates the gate so misuse from a non-command caller
+ * still surfaces a typed error.
+ */
+export declare const bundleColumnValues: (translated: readonly TranslatedColumnValue[]) => Readonly<Record<string, MultiColumnValue>>;
+/**
+ * Builds the canonical `unsupported_column_type` error (`cli-design.md`
+ * §5.3 step 4 + §6.5). Branches on the type's roadmap category so
+ * agents get accurate guidance instead of a blanket "wait for the
+ * next version" hint.
+ *
+ * Three categories per `column-types.ts getColumnRoadmapCategory`:
+ *
+ *   - **v0.3 writer-expansion candidates** (`tags` / `board_relation`
+ *     / `dependency` — slipped from v0.2 tentative at M18 close)
+ *     get `deferred_to: "v0.3"`. The M8 firm row (`link` / `email`
+ *     / `phone`) shipped friendly translators in v0.2 and goes
+ *     through the writable-allowlist branch, not this error path.
+ *   - **read-only forever** (`mirror` / `formula` / `auto_number` /
+ *     `creation_log` / `last_updated` / `item_id`) — Monday-computed
+ *     columns that are not writable via the API regardless of CLI
+ *     version. `read_only: true`, hint points at the underlying
+ *     source column. cli-design.md §5.3 writer-expansion roadmap
+ *     "read-only forever" row says this explicitly.
+ *   - **future** (anything else) — `deferred_to: "future"`, generic
+ *     message. Examples include `battery`, `item_assignees`,
+ *     `time_tracking`, `files`, `rating`. The roadmap doesn't
+ *     promise these for v0.2 or v0.3, so over-promising would be
+ *     the same drift Codex M5b cleanup re-review caught.
+ *
+ * Exported for unit coverage.
+ */
+export declare const unsupportedColumnTypeError: (columnId: string, type: string) => ApiError;
+//# sourceMappingURL=column-values.d.ts.map

package/dist/api/column-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-values.d.ts","sourceRoot":"","sources":["../../src/api/column-values.ts"],"names":[],"mappings":"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"}