@wavyx/pdcli 0.2.0 → 0.4.0

package/src/lib/client.js

@@ -195,12 +195,79 @@ export function createClient({
     }
   }
 
+  function lockedUrl(path) {
+    const url = new URL(path, baseOrigin)
+    if (url.origin !== baseOrigin) {
+      throw new CliError(
+        `Refusing to send request outside your Pipedrive company host ` +
+          `(${baseOrigin}): ${url.origin}`,
+        { exitCode: 78 },
+      )
+    }
+    return url
+  }
+
+  function authHeaders() {
+    return authMode === 'oauth'
+      ? { authorization: `Bearer ${token}`, 'user-agent': userAgent }
+      : { 'x-api-token': token, 'user-agent': userAgent }
+  }
+
+  /**
+   * Download a binary resource (e.g. /api/v1/files/:id/download).
+   * @param {string} path
+   * @returns {Promise<{buffer: ArrayBuffer, contentType: string | null}>}
+   */
+  async function download(path) {
+    const url = lockedUrl(path)
+    const res = await fetch(url, {
+      headers: authHeaders(),
+      signal: AbortSignal.timeout(timeout),
+    })
+    debug('GET (binary) %s → %d', path, res.status)
+    if (!res.ok) {
+      throw ApiError.fromResponse(res.status, await res.text(), path)
+    }
+    return {
+      buffer: await res.arrayBuffer(),
+      contentType: res.headers.get('content-type'),
+    }
+  }
+
+  /**
+   * POST multipart/form-data (file uploads — v1 files API).
+   * @param {string} path
+   * @param {{ file: { name: string, data: Buffer | Uint8Array }, fields?: Record<string, unknown> }} options
+   */
+  async function postMultipart(path, { file, fields = {} }) {
+    const url = lockedUrl(path)
+    const form = new FormData()
+    form.set('file', new Blob([file.data]), file.name)
+    for (const [k, v] of Object.entries(fields)) {
+      if (v != null) form.set(k, String(v))
+    }
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: authHeaders(), // fetch sets the multipart boundary itself
+      body: form,
+      signal: AbortSignal.timeout(timeout),
+    })
+    debug('POST (multipart) %s → %d', path, res.status)
+    const text = await res.text()
+    if (!res.ok) {
+      throw ApiError.fromResponse(res.status, text, path)
+    }
+    return text ? JSON.parse(text) : null
+  }
+
   return {
     get: (path, opts) => request('GET', path, opts),
     post: (path, opts) => request('POST', path, opts),
     put: (path, opts) => request('PUT', path, opts),
     patch: (path, opts) => request('PATCH', path, opts),
     del: (path, opts) => request('DELETE', path, opts),
+    download,
+    postMultipart,
     pageV1,
     pageV2,
   }

package/src/lib/csv-parse.js

@@ -0,0 +1,88 @@
+import { CliError } from './errors.js'
+
+/**
+ * Minimal RFC 4180 CSV parser (quoted fields, escaped quotes, embedded
+ * commas/newlines, CRLF). First record is the header row.
+ * @param {string} text
+ * @returns {{ headers: string[], rows: string[][] }}
+ */
+export function parseCsv(text) {
+  const records = []
+  let record = []
+  let field = ''
+  let inQuotes = false
+  let i = 0
+
+  while (i < text.length) {
+    const char = text[i]
+
+    if (inQuotes) {
+      if (char === '"') {
+        if (text[i + 1] === '"') {
+          field += '"'
+          i += 2
+          continue
+        }
+        inQuotes = false
+        i++
+        continue
+      }
+      field += char
+      i++
+      continue
+    }
+
+    if (char === '"') {
+      inQuotes = true
+      i++
+      continue
+    }
+    if (char === ',') {
+      record.push(field)
+      field = ''
+      i++
+      continue
+    }
+    if (char === '\n' || char === '\r') {
+      if (char === '\r' && text[i + 1] === '\n') i++
+      record.push(field)
+      field = ''
+      if (record.length > 1 || record[0] !== '') records.push(record)
+      record = []
+      i++
+      continue
+    }
+    field += char
+    i++
+  }
+
+  if (inQuotes) {
+    throw new CliError('Unterminated quoted field in CSV', { exitCode: 65 })
+  }
+  if (field !== '' || record.length > 0) {
+    // A tail record only reaches here when non-empty (a bare trailing
+    // newline never starts a record), so push unconditionally.
+    record.push(field)
+    records.push(record)
+  }
+
+  if (records.length === 0) {
+    throw new CliError('CSV file is empty', { exitCode: 65 })
+  }
+
+  const [headers, ...rows] = records
+
+  return {
+    headers,
+    rows: rows.map((row, index) => {
+      if (row.length > headers.length) {
+        throw new CliError(
+          `CSV row ${index + 2} has ${row.length} cells but the header has ${headers.length}`,
+          { exitCode: 65 },
+        )
+      }
+      while (row.length < headers.length) row.push('')
+      return row
+    }),
+  }
+}

package/src/lib/entity-view.js

@@ -6,11 +6,16 @@ import { flattenRecord } from './output/record.js'
  * field/value table with custom-field hash keys and option IDs resolved.
  * @param {import('../base-command.js').default} cmd
  * @param {object} record
- * @param {string} entity deal | person | org | activity | product
+ * @param {string} [entity] deal | person | org | activity | product — omit
+ *   for entities without resolvable custom fields (notes, files, webhooks, …)
  */
 export async function outputRecord(cmd, record, entity) {
   if (cmd.resolveFormat() === 'table') {
-    if (record.custom_fields && Object.keys(record.custom_fields).length) {
+    if (
+      entity &&
+      record.custom_fields &&
+      Object.keys(record.custom_fields).length
+    ) {
       const defs = await getFields(cmd.apiClient, entity)
       record = makeResolver(defs).resolveCustomFields(record)
     }

package/src/lib/import.js

@@ -0,0 +1,49 @@
+import { buildWriteBody } from './input.js'
+import { CliError } from './errors.js'
+
+/**
+ * Turn parsed CSV rows into write bodies. Special columns (matched
+ * case-insensitively) build typed values; every other header resolves
+ * through the entity's field definitions — names, hash keys, and option
+ * labels included. Empty cells are skipped.
+ * @param {object} options
+ * @param {string[]} options.headers
+ * @param {string[][]} options.rows
+ * @param {Record<string, (typed: object, value: string) => void>} [options.specialColumns]
+ * @param {object[]} [options.defs] field definitions for non-special headers
+ * @returns {object[]} one request body per row
+ */
+export function prepareImportBodies({
+  headers,
+  rows,
+  specialColumns = {},
+  defs,
+}) {
+  const specials = Object.fromEntries(
+    Object.entries(specialColumns).map(([k, v]) => [k.toLowerCase(), v]),
+  )
+
+  return rows.map((row, index) => {
+    const typed = {}
+    const fields = []
+
+    headers.forEach((header, i) => {
+      const value = row[i]
+      if (value === '') return
+      const special = specials[header.toLowerCase()]
+      if (special) {
+        special(typed, value)
+        return
+      }
+      fields.push(`${header}=${value}`)
+    })
+
+    try {
+      return buildWriteBody({ typed, fields, defs })
+    } catch (err) {
+      throw new CliError(`CSV row ${index + 2}: ${err.message}`, {
+        exitCode: 65,
+      })
+    }
+  })
+}

package/src/lib/output/csv.js

@@ -0,0 +1,26 @@
+/**
+ * @param {object[]} data
+ * @param {Record<string, import('./table.js').Column>} columns
+ * @returns {string}
+ */
+export function formatCsv(data, columns) {
+  if (!data || data.length === 0) return ''
+  const entries = Object.entries(columns)
+  const header = entries.map(([, col]) => col.header).join(',')
+  const rows = data.map((row) =>
+    entries
+      .map(([key, col]) => {
+        const val = col.get ? col.get(row) : row[col.key ?? key]
+        return csvEscape(val != null ? String(val) : '')
+      })
+      .join(','),
+  )
+  return [header, ...rows].join('\n')
+}
+
+function csvEscape(val) {
+  if (val.includes(',') || val.includes('"') || val.includes('\n')) {
+    return '"' + val.replace(/"/g, '""') + '"'
+  }
+  return val
+}

package/src/lib/output/index.js

@@ -1,10 +1,12 @@
 import { formatTable } from './table.js'
 import { formatJson } from './json.js'
+import { formatYaml } from './yaml.js'
+import { formatCsv } from './csv.js'
 
 /**
  * @param {object | object[]} data
  * @param {Record<string, import('./table.js').Column>} columns
- * @param {'table' | 'json'} format
+ * @param {'table' | 'json' | 'yaml' | 'csv'} format
  * @param {import('@oclif/core').Command} cmd
  */
 export function formatOutput(data, columns, format, cmd) {
@@ -14,6 +16,12 @@ export function formatOutput(data, columns, format, cmd) {
     case 'json':
       cmd.log(formatJson(data))
       break
+    case 'yaml':
+      cmd.log(formatYaml(data))
+      break
+    case 'csv':
+      cmd.log(formatCsv(items, columns))
+      break
     case 'table':
     default:
       cmd.log(formatTable(items, columns))

package/src/lib/output/yaml.js

@@ -0,0 +1,9 @@
+import yaml from 'js-yaml'
+
+/**
+ * @param {unknown} data
+ * @returns {string}
+ */
+export function formatYaml(data) {
+  return yaml.dump(data, { lineWidth: -1 }).trimEnd()
+}