@wavyx/pdcli 0.10.0 → 0.11.0

package/src/commands/task/update.js

@@ -0,0 +1,72 @@
+import { Args, Flags } from '@oclif/core'
+import BaseCommand from '../../base-command.js'
+import { buildWriteBody } from '../../lib/input.js'
+import { outputRecord } from '../../lib/entity-view.js'
+import { CliError } from '../../lib/errors.js'
+
+export default class TaskUpdateCommand extends BaseCommand {
+  static description = 'Update a task (v2 PATCH — only provided fields change)'
+
+  static examples = [
+    '<%= config.bin %> task update 7 --title "Renamed"',
+    '<%= config.bin %> task update 7 --done',
+    '<%= config.bin %> task update 7 --assignee 9',
+  ]
+
+  static args = {
+    id: Args.integer({ required: true, description: 'Task ID' }),
+  }
+
+  static flags = {
+    ...BaseCommand.baseFlags,
+    title: Flags.string({ description: 'Task title' }),
+    project: Flags.integer({ description: 'Project ID' }),
+    description: Flags.string({ description: 'Task description' }),
+    assignee: Flags.integer({ description: 'Assignee (user) ID' }),
+    'due-date': Flags.string({ description: 'Due date (YYYY-MM-DD)' }),
+    parent: Flags.integer({ description: 'Parent task ID' }),
+    done: Flags.boolean({
+      description: 'Mark the task as done',
+      exclusive: ['undone'],
+    }),
+    undone: Flags.boolean({
+      description: 'Mark the task as not done',
+      exclusive: ['done'],
+    }),
+    body: Flags.string({ description: 'Raw JSON body to merge (flags win)' }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(TaskUpdateCommand)
+
+    // The v2 task body takes `done` as an integer enum (0 = not done, 1 = done).
+    let done
+    if (flags.done) done = 1
+    else if (flags.undone) done = 0
+
+    const body = buildWriteBody({
+      typed: {
+        title: flags.title,
+        project_id: flags.project,
+        description: flags.description,
+        assignee_id: flags.assignee,
+        due_date: flags['due-date'],
+        parent_task_id: flags.parent,
+        done,
+      },
+      rawBody: flags.body,
+    })
+
+    if (Object.keys(body).length === 0) {
+      throw new CliError(
+        'Nothing to update — pass at least one field flag or --body',
+        { exitCode: 64 },
+      )
+    }
+
+    const res = await this.apiClient.patch(`/api/v2/tasks/${args.id}`, {
+      body,
+    })
+    await outputRecord(this, res.data)
+  }
+}

package/src/lib/client.js

@@ -307,6 +307,24 @@ export function createClient({
     })
   }
 
+  /**
+   * PUT application/x-www-form-urlencoded (v1 form endpoints, e.g.
+   * /api/v1/files/:id — JSON is not accepted there).
+   * @param {string} path
+   * @param {Record<string, unknown>} fields Null/undefined values are omitted.
+   */
+  async function putForm(path, fields = {}) {
+    const params = new URLSearchParams()
+    for (const [k, v] of Object.entries(fields)) {
+      if (v != null) params.set(k, String(v))
+    }
+    return transport('PUT', lockedUrl(path), {
+      path,
+      makeBody: () => params.toString(),
+      extraHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
+    })
+  }
+
   return {
     get: (path, opts) => request('GET', path, opts),
     post: (path, opts) => request('POST', path, opts),
@@ -316,6 +334,7 @@ export function createClient({
     download,
     postMultipart,
     postForm,
+    putForm,
     pageV1,
     pageV2,
   }

package/src/lib/fields.js

@@ -13,19 +13,35 @@ const ENTITY_FIELDS = {
   activity: 'activityFields',
 }
 
+/**
+ * Entities whose fields live ONLY on v1 — offset-paginated and returning the
+ * legacy key/name shape that getFields normalizes to field_code/field_name.
+ */
+const V1_ENTITY_FIELDS = {
+  lead: 'leadFields',
+  note: 'noteFields',
+}
+
 /**
  * @param {string} entity deal | person | org(anization) | product | activity
- * @returns {string} v2 fields endpoint path
+ *   | lead | note
+ * @returns {string} fields endpoint path (v2 for core entities, v1 for
+ *   lead/note)
  */
 export function entityToFieldsPath(entity) {
-  const resource = ENTITY_FIELDS[entity]
-  if (!resource) {
-    throw new CliError(
-      `Unknown entity "${entity}". Use one of: ${Object.keys(ENTITY_FIELDS).join(', ')}`,
-      { exitCode: 64 },
-    )
-  }
-  return `/api/v2/${resource}`
+  const v2 = ENTITY_FIELDS[entity]
+  if (v2) return `/api/v2/${v2}`
+
+  const v1 = V1_ENTITY_FIELDS[entity]
+  if (v1) return `/api/v1/${v1}`
+
+  throw new CliError(
+    `Unknown entity "${entity}". Use one of: ${[
+      ...Object.keys(ENTITY_FIELDS),
+      ...Object.keys(V1_ENTITY_FIELDS),
+    ].join(', ')}`,
+    { exitCode: 64 },
+  )
 }
 
 /** @type {Map<string, object[]>} per-run field-definition cache */
@@ -35,9 +51,22 @@ export function clearFieldsCache() {
   cache.clear()
 }
 
+/**
+ * Normalize a v1 field definition (key/name) to the v2 shape
+ * (field_code/field_name) so callers can treat both alike.
+ * @param {object} def
+ */
+function normalizeV1Field(def) {
+  const { key, name, ...rest } = def
+  return { ...rest, field_code: key, field_name: name }
+}
+
 /**
  * Fetch (and memoize for this run) all field definitions for an entity.
- * @param {{ pageV2: (path: string) => AsyncGenerator<object> }} client
+ * Core entities use the v2 cursor pager; lead/note use the v1 offset pager
+ * and are normalized to the v2 field_code/field_name shape.
+ * @param {{ pageV2: (path: string) => AsyncGenerator<object>,
+ *   pageV1: (path: string) => AsyncGenerator<object> }} client
  * @param {string} entity
  * @returns {Promise<object[]>}
  */
@@ -45,10 +74,12 @@ export async function getFields(client, entity) {
   const path = entityToFieldsPath(entity)
   if (cache.has(path)) return cache.get(path)
 
+  const isV1 = path.startsWith('/api/v1/')
   debug('fetching field definitions: %s', path)
   const defs = []
-  for await (const def of client.pageV2(path)) {
-    defs.push(def)
+  const pager = isV1 ? client.pageV1(path) : client.pageV2(path)
+  for await (const def of pager) {
+    defs.push(isV1 ? normalizeV1Field(def) : def)
   }
   cache.set(path, defs)
   return defs