@wavyx/pdcli 0.1.0 → 0.3.0

package/src/lib/entity-view.js

@@ -0,0 +1,42 @@
+import { getFields, makeResolver } from './fields.js'
+import { flattenRecord } from './output/record.js'
+
+/**
+ * Output a single entity record: raw JSON for scripting, or a transposed
+ * 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 — omit
+ *   for entities without resolvable custom fields (notes, files, webhooks, …)
+ */
+export async function outputRecord(cmd, record, entity) {
+  if (cmd.resolveFormat() === 'table') {
+    if (
+      entity &&
+      record.custom_fields &&
+      Object.keys(record.custom_fields).length
+    ) {
+      const defs = await getFields(cmd.apiClient, entity)
+      record = makeResolver(defs).resolveCustomFields(record)
+    }
+    await cmd.outputResults(flattenRecord(record), {
+      field: { header: 'Field' },
+      value: { header: 'Value' },
+    })
+    return
+  }
+
+  await cmd.outputResults(record, {})
+}
+
+/**
+ * Fetch field definitions only when --field entries are present.
+ * @param {import('../base-command.js').default} cmd
+ * @param {string} entity
+ * @param {string[]} [fieldFlags]
+ * @returns {Promise<object[] | undefined>}
+ */
+export async function defsForFields(cmd, entity, fieldFlags) {
+  if (!fieldFlags?.length) return undefined
+  return getFields(cmd.apiClient, entity)
+}

package/src/lib/input.js

@@ -0,0 +1,110 @@
+import { CliError } from './errors.js'
+
+const NUMERIC_TYPES = new Set(['double', 'monetary', 'int'])
+
+/**
+ * Build a write-request body from typed flags, repeatable --field entries,
+ * and a raw --body JSON string. Precedence: raw body < typed flags/fields.
+ *
+ * --field entries are "Name=Value" where Name is a field's human name, its
+ * field_code, or a 40-char custom-field hash. Enum labels resolve to option
+ * IDs; set values are comma-separated labels; numeric field types coerce to
+ * Number. Custom-field values nest under custom_fields (v2 shape).
+ *
+ * @param {object} options
+ * @param {Record<string, unknown>} [options.typed] API-named values from typed flags
+ * @param {string[]} [options.fields] repeatable --field "Name=Value" entries
+ * @param {string} [options.rawBody] raw JSON string from --body
+ * @param {object[]} [options.defs] field definitions (required when fields given)
+ * @returns {object} request body
+ */
+export function buildWriteBody({
+  typed = {},
+  fields = [],
+  rawBody,
+  defs,
+} = {}) {
+  let body = {}
+
+  if (rawBody) {
+    try {
+      body = JSON.parse(rawBody)
+    } catch (err) {
+      throw new CliError(`--body is not valid JSON: ${err.message}`, {
+        exitCode: 65,
+      })
+    }
+  }
+
+  for (const [key, value] of Object.entries(typed)) {
+    if (value !== undefined) body[key] = value
+  }
+
+  for (const entry of fields) {
+    const eq = entry.indexOf('=')
+    if (eq === -1) {
+      throw new CliError(`Invalid --field "${entry}". Expected Name=Value`, {
+        exitCode: 64,
+      })
+    }
+    const name = entry.slice(0, eq).trim()
+    const rawValue = entry.slice(eq + 1)
+
+    const def = findField(defs ?? [], name)
+    if (!def) {
+      throw new CliError(
+        `Unknown field "${name}". Run: pdcli field list <entity>`,
+        { exitCode: 65 },
+      )
+    }
+
+    const value = coerceValue(def, rawValue)
+
+    if (def.is_custom_field ?? isHashKey(def.field_code)) {
+      body.custom_fields ??= {}
+      body.custom_fields[def.field_code] = value
+    } else {
+      body[def.field_code] = value
+    }
+  }
+
+  return body
+}
+
+function isHashKey(s) {
+  return /^[a-f0-9]{40}$/.test(s)
+}
+
+function findField(defs, name) {
+  const lower = name.toLowerCase()
+  return defs.find(
+    (d) => d.field_name.toLowerCase() === lower || d.field_code === name,
+  )
+}
+
+function coerceValue(def, rawValue) {
+  if (def.field_type === 'enum') {
+    return resolveOption(def, rawValue)
+  }
+  if (def.field_type === 'set') {
+    return rawValue.split(',').map((label) => resolveOption(def, label.trim()))
+  }
+  if (NUMERIC_TYPES.has(def.field_type)) {
+    return Number(rawValue)
+  }
+  return rawValue
+}
+
+function resolveOption(def, label) {
+  const option = def.options?.find(
+    (o) => o.label.toLowerCase() === label.toLowerCase(),
+  )
+  if (!option) {
+    const valid = def.options?.map((o) => o.label).join(', ') ?? '(none)'
+    throw new CliError(
+      `Unknown option "${label}" for field "${def.field_name}". Valid: ${valid}`,
+      { exitCode: 65 },
+    )
+  }
+  return option.id
+}

package/src/lib/keychain.js

@@ -64,6 +64,53 @@ export async function deleteToken(profile) {
   }
 }
 
+/**
+ * @typedef {object} OAuthTokens
+ * @property {string} accessToken
+ * @property {string} refreshToken
+ * @property {number} expiresAt epoch ms
+ * @property {string} apiDomain e.g. https://acme.pipedrive.com
+ * @property {string} clientId
+ * @property {string} clientSecret kept in the keychain, never in config
+ */
+
+/**
+ * @param {string} profile
+ * @returns {Promise<OAuthTokens | null>}
+ */
+export async function getOAuthTokens(profile) {
+  if (!Entry) return null
+  const account = `${profile}/oauth`
+  try {
+    const raw = getEntry(account).getPassword()
+    return raw ? JSON.parse(raw) : null
+  } catch (err) {
+    debug('getOAuthTokens error: %s', err.message)
+    return null
+  }
+}
+
+/**
+ * @param {string} profile
+ * @param {OAuthTokens} tokens
+ */
+export async function setOAuthTokens(profile, tokens) {
+  if (!Entry) keychainRequired()
+  const account = `${profile}/oauth`
+  getEntry(account).setPassword(JSON.stringify(tokens))
+}
+
+/** @param {string} profile */
+export async function deleteOAuthTokens(profile) {
+  if (!Entry) return
+  const account = `${profile}/oauth`
+  try {
+    getEntry(account).deletePassword()
+  } catch (err) {
+    debug('deleteOAuthTokens error: %s', err.message)
+  }
+}
+
 export function isKeychainAvailable() {
   return Entry !== null
 }

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()
+}