@37signals/basecamp 0.12.0 → 0.14.0

package/dist/services/schedules-extensions.js

@@ -0,0 +1,268 @@
+import { SchedulesService as GeneratedSchedulesService } from "../generated/services/schedules.js";
+import { requireRecord, requiredWritableBoolean, requiredWritableString, writableBoolean, writableIdList, writableString, } from "./merge-safe.js";
+/** The deliberate-overwrite escape hatch named in this composite's error hints. */
+const ESCAPE = "replaceEntry()";
+/**
+ * How the guards name this record in their messages. Spelled with a space
+ * because {@link requireRecord} lowercases it into a sentence ("...where a
+ * schedule entry object was expected"); "ScheduleEntry" would read as
+ * "scheduleentry" there.
+ */
+const RECORD = "Schedule entry";
+const guardOptions = { record: RECORD, escape: ESCAPE };
+/** The carve-out members, keyed as they appear on {@link ScheduleEntryFields}. */
+const CARVE_OUTS = ["participantIds", "url", "highlighted", "notify"];
+/**
+ * SchedulesService with merge-safe `updateEntry` and read-modify-write
+ * `editEntry` on top of the generated surface (`getEntry`, `replaceEntry`,
+ * `createEntry`, `listEntries`, ...).
+ *
+ * `PUT /{accountId}/schedule_entries/{entryId}` is a full replace:
+ * `Schedules::EntriesController#update` rebuilds the recordable from the
+ * submitted params, so a sparse PUT that omits `description` erases it and one
+ * that omits `all_day` turns an all-day event into a midnight-to-midnight timed
+ * one. Neither is a 422 — both are a `200` that quietly clears, which is what
+ * these composites exist to prevent.
+ *
+ * Three writable fields are exempt. BC3 seeds `participant_ids`, `url` and
+ * `highlighted` from the existing recordable when the request does not address
+ * them, so the SDK's job for those is the opposite one: keep them **off** the
+ * wire unless the caller asked for them.
+ *
+ * Both composites compose the public `getEntry` and `replaceEntry`, so hooks
+ * observe the two wire operations under their native identities
+ * (`GetScheduleEntry` then `ReplaceScheduleEntry`) rather than a synthetic
+ * composite.
+ *
+ * **Non-recurring entries only.** `ensure_non_recurring_event` 302-redirects
+ * both `show` and `update` for a recurring entry, and the SDK follows neither:
+ * the GET surfaces as an unexpected body and the PUT as a redirect. Recurrence
+ * itself (`recurrence_schedule`, `recurs_until`, `time_zone_name`) is unmodeled
+ * — BC3 forces all three to nil for a non-recurring entry.
+ */
+export class SchedulesService extends GeneratedSchedulesService {
+    /**
+     * Sets the given fields on a schedule entry and preserves everything else:
+     * GETs the current entry, overlays the fields you addressed, and PUTs the
+     * full representation back.
+     *
+     * A key you leave off the request is not addressed. For the five full-state
+     * fields that means "keep what the server has"; for the four carve-outs it
+     * means the key never appears in the body, so BC3's own preservation applies.
+     * An explicitly-passed `""`, `false` or `[]` is an address and clears.
+     *
+     * Not atomic: there is no conditional-update signal on this endpoint, so a
+     * concurrent write between the GET and PUT is overwritten — last write wins
+     * for the full-state fields. The window is one round-trip. Use `replaceEntry`
+     * to overwrite deliberately.
+     *
+     * @param entryId - The entry ID
+     * @param req - Fields to set; unaddressed fields are preserved
+     * @returns The updated ScheduleEntry
+     * @throws {BasecampError} If the request fails, or if the read-back is malformed
+     *
+     * @example
+     * ```ts
+     * // Rename without erasing the description, times or all-day flag.
+     * await client.schedules.updateEntry(123, { summary: "Team Meeting & Kickoff" });
+     *
+     * // Drop the join link and the highlight; participants are left alone.
+     * await client.schedules.updateEntry(123, { url: "", highlighted: false });
+     * ```
+     */
+    async updateEntry(entryId, req) {
+        const current = await this.currentState(entryId);
+        const addressed = (key) => Object.prototype.hasOwnProperty.call(req, key);
+        // Full state: always sent. `??` covers the one degenerate presence case —
+        // a key set to `undefined` (or, from untyped JS, `null`). Neither can ride
+        // the wire, so honouring it as an address would drop the key and hand BC3
+        // the clear-by-omission this composite exists to prevent; the read-back
+        // value is the answer instead.
+        const state = {
+            summary: addressed("summary") ? (req.summary ?? current.summary) : current.summary,
+            startsAt: addressed("startsAt") ? (req.startsAt ?? current.startsAt) : current.startsAt,
+            endsAt: addressed("endsAt") ? (req.endsAt ?? current.endsAt) : current.endsAt,
+            description: addressed("description")
+                ? (req.description ?? current.description)
+                : current.description,
+            allDay: addressed("allDay") ? (req.allDay ?? current.allDay) : current.allDay,
+        };
+        // Addressed-only: never seeded, so presence alone decides. `false`, `""`
+        // and `[]` all pass, which is the point — they are clears, and BC3 would
+        // preserve rather than clear if the key went missing.
+        const carveOuts = {};
+        if (addressed("participantIds"))
+            carveOuts.participantIds = req.participantIds;
+        if (addressed("url"))
+            carveOuts.url = req.url;
+        if (addressed("highlighted"))
+            carveOuts.highlighted = req.highlighted;
+        if (addressed("notify"))
+            carveOuts.notify = req.notify;
+        return this.putEntry(entryId, state, carveOuts);
+    }
+    /**
+     * Applies a read-modify-write callback to a schedule entry: GETs the current
+     * entry, hands the callback its writable state, and PUTs the whole thing
+     * back. If the callback throws (or rejects), the edit aborts and nothing is
+     * written.
+     *
+     * The five full-state fields always ride back, so clearing one means setting
+     * it empty and an untouched one keeps its current value. The four carve-outs
+     * (`participantIds`, `url`, `highlighted`, `notify`) are seeded so you can
+     * read them, but they reach the wire only if the callback **assigns** to
+     * them. Assignment is tracked by invocation, not by comparing values:
+     * `e.url = e.url` is a write, because a caller who reassigns the value the
+     * read returned still means "write this", and no diff can recover that
+     * intent.
+     *
+     * Not atomic: there is no conditional-update signal on this endpoint, so a
+     * concurrent write between the GET and PUT is overwritten — last write wins
+     * for the full-state fields. The window is one round-trip. Use `replaceEntry`
+     * to overwrite deliberately.
+     *
+     * @param entryId - The entry ID
+     * @param fn - Callback that mutates the entry's writable fields in place
+     * @returns The updated ScheduleEntry
+     * @throws {BasecampError} If the request fails, or if the read-back is malformed
+     *
+     * @example
+     * ```ts
+     * await client.schedules.editEntry(123, (e) => {
+     *   e.summary = `🚨 ${e.summary}`;
+     *   e.description = ""; // clearing = setting empty on a full object
+     *   // participants, join link and highlight are untouched, so they stay off
+     *   // the wire and BC3 keeps them.
+     * });
+     * ```
+     */
+    async editEntry(entryId, fn) {
+        const fields = await this.currentFields(entryId);
+        // Setter-invocation dirty tracking. A snapshot diff would be wrong, not
+        // merely different: the callback that assigns exactly what the GET returned
+        // has still asked for a write, and dropping it hands the field back to
+        // BC3's preserve-on-omission.
+        const touched = new Set();
+        const view = new Proxy(fields, {
+            set(target, property, value) {
+                if (typeof property === "string")
+                    touched.add(property);
+                return Reflect.set(target, property, value);
+            },
+        });
+        await fn(view);
+        const carveOuts = {};
+        if (touched.has("participantIds"))
+            carveOuts.participantIds = fields.participantIds;
+        if (touched.has("url"))
+            carveOuts.url = fields.url;
+        if (touched.has("highlighted"))
+            carveOuts.highlighted = fields.highlighted;
+        if (touched.has("notify"))
+            carveOuts.notify = fields.notify;
+        return this.putEntry(entryId, fields, carveOuts);
+    }
+    /**
+     * Fetches the entry and derives the full-state half of its writable state.
+     *
+     * Every value here is resent in the full-replace PUT, so every value is
+     * validated before it is read. `?? ""` coalesces only `null` and `undefined`,
+     * leaving corruption wide open: `false`, `0`, `[]`, `{}`, `42`, `true` and
+     * friends would all be forwarded **verbatim** and written to the entry on a
+     * call that never mentioned the field. Nothing below this rejects them —
+     * `schema.d.ts` is erased at build time, so `ScheduleEntry` is a compile-time
+     * claim about runtime data, which puts this composite with Python and Ruby
+     * rather than with Go and Swift. See `merge-safe.ts` and #576.
+     *
+     * The guards differ per field because the spec models the fields
+     * differently:
+     *
+     * - `summary` is `@required` and `Schedule::Entry#summary` is
+     *   `super.presence || "Untitled"`, so blank is impossible from a healthy
+     *   server and absent/null/blank is malformed.
+     * - `starts_at`/`ends_at` are `@required` and `NOT NULL`. The value is a bare
+     *   date for an all-day entry and a timestamp otherwise; it round-trips
+     *   verbatim rather than through a `Date`, which would normalise the two
+     *   spellings into one and rewrite the entry's shape.
+     * - `all_day` is `@required`, `NOT NULL DEFAULT false`. It needs the boolean
+     *   guard specifically because a truthiness test would read the legitimate
+     *   `false` as missing — and defaulting a missing value to `false` converts
+     *   an all-day event into a midnight-to-midnight timed one.
+     * - `description` is optional and nullable both ways, so absent or null is a
+     *   genuinely empty description.
+     */
+    async currentState(entryId) {
+        const current = await this.readEntry(entryId);
+        return {
+            summary: requiredWritableString(current, "summary", guardOptions),
+            startsAt: requiredWritableString(current, "starts_at", guardOptions),
+            endsAt: requiredWritableString(current, "ends_at", guardOptions),
+            description: writableString(current, "description", guardOptions),
+            allDay: requiredWritableBoolean(current, "all_day", guardOptions),
+        };
+    }
+    /**
+     * The full-state fields plus the carve-out seeds the `editEntry` callback can
+     * read.
+     *
+     * `url` is seeded from the response's **`join_url`**, not its `url`: the
+     * latter is the entry's own Basecamp API URL, written by
+     * `recordings/_recording` before the entry partial renders. Echoing it into
+     * the request's `url` would write the API URL into the join link.
+     *
+     * `updateEntry` deliberately does not come through here. It never seeds a
+     * carve-out, so validating `participants` for it would refuse a write that
+     * does not depend on them.
+     */
+    async currentFields(entryId) {
+        const current = await this.readEntry(entryId);
+        return {
+            summary: requiredWritableString(current, "summary", guardOptions),
+            startsAt: requiredWritableString(current, "starts_at", guardOptions),
+            endsAt: requiredWritableString(current, "ends_at", guardOptions),
+            description: writableString(current, "description", guardOptions),
+            allDay: requiredWritableBoolean(current, "all_day", guardOptions),
+            participantIds: writableIdList(current, "participants", guardOptions),
+            url: writableString(current, "join_url", guardOptions),
+            highlighted: writableBoolean(current, "highlighted", guardOptions),
+        };
+    }
+    /**
+     * GETs the entry and checks the envelope before any field is read.
+     *
+     * A successful GET can still return a scalar, an array or null; reading a
+     * property off `null` throws a raw `TypeError` instead of the documented
+     * statusless `api_error`, and reading one off an array or string silently
+     * yields `undefined`, which the field guards would then take at face value.
+     */
+    async readEntry(entryId) {
+        return requireRecord(await this.getEntry(entryId), {
+            record: RECORD,
+            operation: "GetScheduleEntry",
+            escape: ESCAPE,
+        });
+    }
+    /**
+     * PUTs the full writable state via `replaceEntry`, plus whichever carve-outs
+     * the caller addressed.
+     *
+     * The five full-state fields are always named, empties included: on a
+     * full-replace endpoint `""` is how a clear is expressed — never JSON null
+     * (SPEC §18 body compaction), and never by omission, which would leave the
+     * field to BC3's clear-by-default and read as an accident rather than an
+     * intent. The carve-outs are the mirror image: an unaddressed one is absent
+     * from `carveOuts`, so the generated request builder leaves it `undefined`
+     * and it never reaches the wire.
+     */
+    putEntry(entryId, state, carveOuts) {
+        return this.replaceEntry(entryId, {
+            summary: state.summary,
+            startsAt: state.startsAt,
+            endsAt: state.endsAt,
+            description: state.description,
+            allDay: state.allDay,
+            ...carveOuts,
+        });
+    }
+}
+//# sourceMappingURL=schedules-extensions.js.map

package/dist/services/schedules-extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedules-extensions.js","sourceRoot":"","sources":["../../src/services/schedules-extensions.ts"],"names":[],"mappings":"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"}

package/dist/services/todolists-extensions.d.ts

@@ -0,0 +1,110 @@
+import { TodolistsService as GeneratedTodolistsService } from "../generated/services/todolists.js";
+import type { Todolist } from "../generated/services/todolists.js";
+/**
+ * Request parameters for update. Both fields are optional: an omitted field
+ * is left untouched on the todolist, guaranteed. An explicitly-passed empty
+ * string is a set (clears the description).
+ */
+export interface UpdateTodolistRequest {
+    /** Display name. Omit to leave unchanged. */
+    name?: string;
+    /** Rich text description (HTML). Omit to leave unchanged; `""` clears it. */
+    description?: string;
+}
+/**
+ * A todolist's full writable state, handed to the `edit` callback. The whole
+ * object is PUT back to the server, so clearing the description means setting
+ * it empty (`""`) — there is no third state.
+ */
+export interface TodolistFields {
+    /** Display name (required; the server rejects a missing one with a 422). */
+    name: string;
+    /** Rich text description (HTML). Set `""` to clear. */
+    description: string;
+}
+/**
+ * TodolistsService with merge-safe `update` and read-modify-write `edit` on
+ * top of the generated surface (`get`, `replace`, ...).
+ *
+ * `PUT /{accountId}/todolists/{id}` is a full replace: BC3's
+ * `TodolistsController#update` rebuilds the recordable from only the permitted
+ * params, so a sparse PUT that omits `description` erases it, and one that
+ * omits `name` is a 422 — the attribute is presence-validated server-side, so
+ * omitting it is never a preserve. The writable set is exactly
+ * `{name, description}`.
+ *
+ * The route serves a to-do list and a to-do list group alike, and since #544
+ * both are the one flat `Todolist` shape — BC3's
+ * `todolists/groups/{index,show}.json.jbuilder` render
+ * `todolists/_todolist.json.jbuilder`, so a group reports `"type": "Todolist"`
+ * and carries `description`/`description_attachments` like any list. Nothing
+ * here branches on the variant; where it matters at all, discrimination is
+ * structural (`groups_url` for a Todoset parent, `group_position_url` for a
+ * Todolist parent), never the `type` string.
+ *
+ * Both methods compose the public `get` and `replace` methods, so hooks
+ * observe the two wire operations (`GetTodolistOrGroup` then
+ * `UpdateTodolistOrGroup`), not a synthetic composite.
+ */
+export declare class TodolistsService extends GeneratedTodolistsService {
+    /**
+     * Sets the given fields on a todolist and preserves everything else: GETs
+     * the current todolist, overlays the explicitly-set request fields, and PUTs
+     * the full representation back. An omitted (`undefined`) field is untouched,
+     * guaranteed; an explicitly-passed `""` clears the description.
+     *
+     * Not atomic: there is no conditional-update signal on this endpoint, so a
+     * concurrent write between the GET and PUT is overwritten — last write wins
+     * for the whole representation. The window is one round-trip. Use `replace`
+     * to overwrite deliberately.
+     *
+     * @param id - The todolist ID
+     * @param req - Fields to set; omitted fields are preserved
+     * @returns The updated Todolist
+     * @throws {BasecampError} If the request fails
+     *
+     * @example
+     * ```ts
+     * // Rename without erasing the description.
+     * await client.todolists.update(123, { name: "Hardware" });
+     * ```
+     */
+    update(id: number, req: UpdateTodolistRequest): Promise<Todolist>;
+    /**
+     * Applies a read-modify-write callback to a todolist: GETs the current
+     * todolist, hands the callback its full writable representation, and PUTs
+     * the whole thing back. Clearing the description means setting it empty
+     * (`""`) — an untouched field keeps its current value. If the callback
+     * throws (or rejects), the edit aborts and nothing is written.
+     *
+     * Not atomic: there is no conditional-update signal on this endpoint, so a
+     * concurrent write between the GET and PUT is overwritten — last write wins
+     * for the whole representation. The window is one round-trip. Use `replace`
+     * to overwrite deliberately.
+     *
+     * @param id - The todolist ID
+     * @param fn - Callback that mutates the todolist's writable fields in place
+     * @returns The updated Todolist
+     * @throws {BasecampError} If the request fails
+     *
+     * @example
+     * ```ts
+     * await client.todolists.edit(123, (t) => {
+     *   t.name = `🚨 ${t.name}`;
+     *   t.description = ""; // clearing = setting empty on a full object
+     * });
+     * ```
+     */
+    edit(id: number, fn: (t: TodolistFields) => void | Promise<void>): Promise<Todolist>;
+    /** Fetches the todolist and derives its full writable state. */
+    private currentFields;
+    /**
+     * PUTs the full writable state via `replace`. Both fields are always sent:
+     * description included when empty, because on a full-replace endpoint `""`
+     * is how a clear is expressed — never JSON null (SPEC §18 body compaction),
+     * and never by omission, which would leave the field to the server's own
+     * clear-by-default and read as an accident rather than an intent.
+     */
+    private putFields;
+}
+//# sourceMappingURL=todolists-extensions.d.ts.map

package/dist/services/todolists-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todolists-extensions.d.ts","sourceRoot":"","sources":["../../src/services/todolists-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,IAAI,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AACnG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAwKnE;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,6CAA6C;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,gBAAiB,SAAQ,yBAAyB;IAC7D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAOvE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC;IAM1F,gEAAgE;YAClD,aAAa;IAQ3B;;;;;;OAMG;YACW,SAAS;CAyBxB"}

package/dist/services/todolists-extensions.js

@@ -0,0 +1,262 @@
+import { TodolistsService as GeneratedTodolistsService } from "../generated/services/todolists.js";
+import { Errors, truncateErrorMessage } from "../errors.js";
+/**
+ * Renders a value for an error message without ever throwing.
+ *
+ * The guard's own error path must not fail while explaining a failure.
+ * `JSON.stringify` raises `TypeError` on a circular structure, and a value can
+ * carry a `toJSON` that throws — either would replace a clean `api_error`/`usage`
+ * with an incidental `TypeError` and lose the diagnosis. The type name is always
+ * available; the rendering is a bonus, capped per §9 and dropped if it fails.
+ */
+function describeValue(value) {
+    const kind = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+    try {
+        const rendered = JSON.stringify(value);
+        return rendered === undefined ? kind : `${kind} ${truncateErrorMessage(rendered)}`;
+    }
+    catch {
+        return kind;
+    }
+}
+/**
+ * Level 1 of the wire-to-written-value path: the response must be a JSON object
+ * before any field is probed.
+ *
+ * One level up from the malformed-*field* guards. A successful GET can still
+ * return a scalar, an array, or null, and each fails a different way without
+ * this: `null.name` throws a raw `TypeError` instead of the documented
+ * statusless `api_error`, while a scalar or an **array** yields `undefined` for
+ * every key and so gets misdiagnosed one rung down as "name is missing from the
+ * response" — a body-shape fault reported as a field fault. The array case is
+ * the one that used to fall through silently, and `Array.isArray` is what keeps
+ * it caught here.
+ *
+ * Since #544 the route is modelled as one flat `Todolist` — the `TodolistOrGroup`
+ * union and its `{ todolist } | { group }` arms are gone, and with them the
+ * middle rung of this path. It is object → scalar now: the body (here) and each
+ * writable field (`writableString`). A string has no interior, so there is no
+ * third. What is emphatically NOT gone is validation: `schema.d.ts` is erased at
+ * build time, so a flat shape gives TypeScript no decoder it did not have
+ * before. Structural safety for this SDK is #578.
+ *
+ * The cast is an assertion about the body's shape only. It claims nothing about
+ * the fields, which `writableString` still checks one by one.
+ */
+function requireTodolistObject(response, operation) {
+    if (typeof response !== "object" || response === null || Array.isArray(response)) {
+        throw malformedResponse(`${operation} returned ${describeValue(response)} where a todolist object was expected`, "The merge-safe update/edit read this record's fields before rewriting them, so a " +
+            "non-object body cannot be used. Use replace() to write the record deliberately.");
+    }
+    return response;
+}
+/**
+ * Validates a caller-supplied writable value, the mirror of the read step.
+ *
+ * `writableString` owns *response* provenance; this owns *caller* provenance,
+ * and the two are one rule seen from opposite ends. `edit` hands the caller a
+ * mutable `TodolistFields` and the annotation is erased at build time, so a
+ * closure assigning `42` or `[]` — trivially reachable from plain JS, or from
+ * TypeScript via `as any` — would otherwise walk straight into the full-replace
+ * PUT and write it. That is caller misuse, hence `usage`, where the same wrong
+ * type arriving from the server is `api_error`.
+ */
+function callerString(fields, key) {
+    const value = fields[key];
+    if (typeof value !== "string") {
+        throw Errors.usage(truncateErrorMessage(`todolist ${key} must be a string, got ${describeValue(value)}`), "The full writable state is PUT back verbatim, so a non-string would be written to the " +
+            'record. Assign a string; use "" to clear.');
+    }
+    return value;
+}
+/** Builds the malformed-response error, with the message capped per SPEC §9. */
+function malformedResponse(message, hint) {
+    // api_error, not usage: the value arrived in a successful API response, so
+    // nothing the caller passed is at fault. Statusless — there is no HTTP status
+    // to attribute, the transport succeeded — and non-retryable, because
+    // re-requesting cannot repair a malformed body.
+    return Errors.apiError(truncateErrorMessage(message), undefined, {
+        hint,
+        retryable: false,
+    });
+}
+/**
+ * Reads a writable string field off a fetched todolist, refusing to pass a
+ * malformed one through.
+ *
+ * **Classification is by origin, not by value.** The same empty string is a
+ * caller error when the caller passed it and malformed response data when it
+ * came off the wire, so each provenance is checked where it is unambiguous:
+ * this read step owns the response, and `putFields` owns the caller. That is
+ * why an empty `name` here is an `api_error` while an empty `name` the caller
+ * supplied is a `UsageError` — same value, different origin, different fault.
+ *
+ * **Presence and non-emptiness are two different claims, and only one of them
+ * is per-field.** Since #544 `name` and `description` are both `@required` and
+ * never null on this shape — BC3's `format_api_content` funnels a blank rich
+ * text through `call_pipeline`, which returns `""` rather than nil — so for
+ * *both* fields an absent key and an explicit `null` are malformed, and both
+ * are refused here before any PUT. Reading either as `""` would put that `""`
+ * in the full-replace body and erase the record's real value on a call that
+ * never mentioned the field.
+ *
+ * `nonEmpty` is the *other* claim and holds for `name` alone: BC3
+ * presence-validates the attribute, so no real todolist carries an empty one
+ * and `""` off the wire is malformed too. `description` has no such validation
+ * — a description-less list carries `""`, which is the ordinary case — so an
+ * empty description is a real value, preserved and resent verbatim.
+ *
+ * Anything of the wrong type is malformed either way: `?? ""` only coalesces
+ * null and undefined, so a number, boolean, array or object would ride through
+ * **verbatim** into the full-replace PUT and overwrite the real value.
+ *
+ * The type annotation on the GET result is a compile-time claim about runtime
+ * data that nothing validates — `schema.d.ts` is erased at build time, so
+ * TypeScript has no decoder that rejects a wrong-typed field the way Go's
+ * `json.Unmarshal`, Swift's `Codable`, or kotlinx.serialization do. That puts
+ * this composite in the same position as the Python and Ruby ones: the check
+ * has to be explicit here. The shipped Todos and Cards analogues are #576.
+ */
+function writableString(todolist, key, opts = {}) {
+    const value = todolist[key];
+    if (!(key in todolist) || value === undefined) {
+        throw malformedResponse(`todolist ${key} is missing from the response`, `${key} is required on every todolist, so a body without one is a malformed response, ` +
+            "not an empty value to preserve. The merge-safe update/edit PUT the full writable " +
+            "state back, so reading it as empty would erase the record's real value.");
+    }
+    if (value === null) {
+        throw malformedResponse(`todolist ${key} is null in the response`, `${key} is required and never null, so a null one is a malformed response, not an empty ` +
+            "value to preserve. The merge-safe update/edit PUT the full writable state back, so " +
+            "reading it as empty would erase the record's real value.");
+    }
+    if (typeof value !== "string") {
+        throw malformedResponse(`todolist ${key} is not a string: ${describeValue(value)}`, "The merge-safe update/edit resend this field verbatim, so a malformed value would " +
+            "overwrite the current one. Use replace() to write the record deliberately.");
+    }
+    if (opts.nonEmpty && value === "") {
+        throw malformedResponse(`todolist ${key} is empty in the response`, `${key} is presence-validated server-side, so an empty one is a malformed response. ` +
+            "The caller did not ask to clear it.");
+    }
+    return value;
+}
+/**
+ * TodolistsService with merge-safe `update` and read-modify-write `edit` on
+ * top of the generated surface (`get`, `replace`, ...).
+ *
+ * `PUT /{accountId}/todolists/{id}` is a full replace: BC3's
+ * `TodolistsController#update` rebuilds the recordable from only the permitted
+ * params, so a sparse PUT that omits `description` erases it, and one that
+ * omits `name` is a 422 — the attribute is presence-validated server-side, so
+ * omitting it is never a preserve. The writable set is exactly
+ * `{name, description}`.
+ *
+ * The route serves a to-do list and a to-do list group alike, and since #544
+ * both are the one flat `Todolist` shape — BC3's
+ * `todolists/groups/{index,show}.json.jbuilder` render
+ * `todolists/_todolist.json.jbuilder`, so a group reports `"type": "Todolist"`
+ * and carries `description`/`description_attachments` like any list. Nothing
+ * here branches on the variant; where it matters at all, discrimination is
+ * structural (`groups_url` for a Todoset parent, `group_position_url` for a
+ * Todolist parent), never the `type` string.
+ *
+ * Both methods compose the public `get` and `replace` methods, so hooks
+ * observe the two wire operations (`GetTodolistOrGroup` then
+ * `UpdateTodolistOrGroup`), not a synthetic composite.
+ */
+export class TodolistsService extends GeneratedTodolistsService {
+    /**
+     * Sets the given fields on a todolist and preserves everything else: GETs
+     * the current todolist, overlays the explicitly-set request fields, and PUTs
+     * the full representation back. An omitted (`undefined`) field is untouched,
+     * guaranteed; an explicitly-passed `""` clears the description.
+     *
+     * Not atomic: there is no conditional-update signal on this endpoint, so a
+     * concurrent write between the GET and PUT is overwritten — last write wins
+     * for the whole representation. The window is one round-trip. Use `replace`
+     * to overwrite deliberately.
+     *
+     * @param id - The todolist ID
+     * @param req - Fields to set; omitted fields are preserved
+     * @returns The updated Todolist
+     * @throws {BasecampError} If the request fails
+     *
+     * @example
+     * ```ts
+     * // Rename without erasing the description.
+     * await client.todolists.update(123, { name: "Hardware" });
+     * ```
+     */
+    async update(id, req) {
+        const fields = await this.currentFields(id);
+        if (req.name !== undefined)
+            fields.name = req.name;
+        if (req.description !== undefined)
+            fields.description = req.description;
+        return this.putFields(id, fields);
+    }
+    /**
+     * Applies a read-modify-write callback to a todolist: GETs the current
+     * todolist, hands the callback its full writable representation, and PUTs
+     * the whole thing back. Clearing the description means setting it empty
+     * (`""`) — an untouched field keeps its current value. If the callback
+     * throws (or rejects), the edit aborts and nothing is written.
+     *
+     * Not atomic: there is no conditional-update signal on this endpoint, so a
+     * concurrent write between the GET and PUT is overwritten — last write wins
+     * for the whole representation. The window is one round-trip. Use `replace`
+     * to overwrite deliberately.
+     *
+     * @param id - The todolist ID
+     * @param fn - Callback that mutates the todolist's writable fields in place
+     * @returns The updated Todolist
+     * @throws {BasecampError} If the request fails
+     *
+     * @example
+     * ```ts
+     * await client.todolists.edit(123, (t) => {
+     *   t.name = `🚨 ${t.name}`;
+     *   t.description = ""; // clearing = setting empty on a full object
+     * });
+     * ```
+     */
+    async edit(id, fn) {
+        const fields = await this.currentFields(id);
+        await fn(fields);
+        return this.putFields(id, fields);
+    }
+    /** Fetches the todolist and derives its full writable state. */
+    async currentFields(id) {
+        const current = requireTodolistObject(await this.get(id), "GetTodolistOrGroup");
+        return {
+            name: writableString(current, "name", { nonEmpty: true }),
+            description: writableString(current, "description"),
+        };
+    }
+    /**
+     * PUTs the full writable state via `replace`. Both fields are always sent:
+     * description included when empty, because on a full-replace endpoint `""`
+     * is how a clear is expressed — never JSON null (SPEC §18 body compaction),
+     * and never by omission, which would leave the field to the server's own
+     * clear-by-default and read as an accident rather than an intent.
+     */
+    async putFields(id, f) {
+        // The caller's side of the origin rule. `currentFields` already rejected an
+        // empty name coming off the wire, so by here an empty one can only have been
+        // supplied by the caller — genuine misuse, since BC3 presence-validates the
+        // attribute and a full write has no state that clears it. Guarding in the
+        // composite rather than leaning on the generated `replace()` also aligns
+        // this path with the other five SDKs; `replace()` keeps its own
+        // `Errors.validation` for direct callers, where the name really is theirs.
+        const name = callerString(f, "name");
+        const description = callerString(f, "description");
+        if (name === "") {
+            throw Errors.usage("todolist name must not be empty", "BC3 presence-validates the name, so a full write cannot clear it. Pass a non-empty " +
+                "name, or use replace() if you mean to write the record verbatim.");
+        }
+        // The PUT answers with the written record, which is handed straight back to
+        // the caller as a `Todolist`; check its shape too rather than let an array
+        // or a scalar out under that type.
+        return requireTodolistObject(await this.replace(id, { name, description }), "UpdateTodolistOrGroup");
+    }
+}
+//# sourceMappingURL=todolists-extensions.js.map

package/dist/services/todolists-extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"todolists-extensions.js","sourceRoot":"","sources":["../../src/services/todolists-extensions.ts"],"names":[],"mappings":"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"}