not-manage 0.2.0 → 0.2.2

package/src/clio-api.js

@@ -5,6 +5,10 @@ function createError(message, responseText) {
   return new Error(`${message}.${suffix}`.trim());
 }
 
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 async function postForm(url, formFields, headers = {}) {
   const response = await fetch(url, {
     method: "POST",
@@ -136,21 +140,45 @@ function parseTrustedApiUrl(config, url, expectedPathPrefix = "/api/v4/") {
 function buildUrlWithQuery(baseUrl, query = {}) {
   const url = new URL(baseUrl);
 
-  Object.entries(query).forEach(([key, value]) => {
+  function appendQueryValue(key, value) {
     if (value === undefined || value === null || value === "") {
       return;
     }
 
     if (Array.isArray(value)) {
       value.forEach((item) => {
-        if (item !== undefined && item !== null && item !== "") {
-          url.searchParams.append(key, String(item));
+        appendQueryValue(key, item);
+      });
+      return;
+    }
+
+    if (isPlainObject(value)) {
+      Object.entries(value).forEach(([nestedKey, nestedValue]) => {
+        if (nestedValue === undefined || nestedValue === null || nestedValue === "") {
+          return;
         }
+
+        const compositeKey = `${key}[${nestedKey}]`;
+        if (Array.isArray(nestedValue)) {
+          const serialized = nestedValue
+            .filter((item) => item !== undefined && item !== null && item !== "")
+            .map((item) => String(item));
+          if (serialized.length > 0) {
+            url.searchParams.append(compositeKey, `[${serialized.join(", ")}]`);
+          }
+          return;
+        }
+
+        appendQueryValue(compositeKey, nestedValue);
       });
       return;
     }
 
-    url.searchParams.set(key, String(value));
+    url.searchParams.append(key, String(value));
+  }
+
+  Object.entries(query).forEach(([key, value]) => {
+    appendQueryValue(key, value);
   });
 
   return url.toString();
@@ -382,6 +410,7 @@ module.exports = {
   fetchWhoAmI,
   getValidAccessToken,
   __private: {
+    buildUrlWithQuery,
     parseTrustedApiUrl,
   },
 };

package/src/commands-activities.js

@@ -1,14 +1,13 @@
 const { fetchResourceById, fetchResourcePage } = require("./clio-api");
 const {
-  clip,
+  createDetailPrinter,
+  createListPrinter,
+} = require("./resource-display");
+const { buildListQueryFromResource } = require("./resource-query-builder");
+const {
   compactQuery,
   fetchPages,
-  formatBoolean,
-  formatMoney,
-  parseLimit,
-  printKeyValueRows,
-  readMatterLabel,
-  readUserName,
+  readHours,
 } = require("./resource-utils");
 const {
   buildSummaryMessage,
@@ -21,122 +20,12 @@ const { getResourceMetadata } = require("./resource-metadata");
 const ACTIVITY_RESOURCE = getResourceMetadata("activities");
 const MATTER_RESOURCE = getResourceMetadata("matters");
 
-function readHours(activity) {
-  const quantityInHours = Number(activity?.quantity_in_hours);
-  if (Number.isFinite(quantityInHours)) {
-    return quantityInHours.toFixed(2);
-  }
-
-  const quantity = Number(activity?.quantity);
-  if (Number.isFinite(quantity)) {
-    return (quantity / 3600).toFixed(2);
-  }
-
-  return "-";
-}
-
 function buildActivityQuery(options) {
-  return compactQuery({
-    activity_description_id: options.activityDescriptionId || undefined,
-    created_since: options.createdSince || undefined,
-    end_date: options.endDate || undefined,
-    fields: options.fields || ACTIVITY_RESOURCE.defaultFields.list,
-    flat_rate:
-      options.flatRate === undefined || options.flatRate === null
-        ? undefined
-        : Boolean(options.flatRate),
-    limit: parseLimit(options.limit),
-    matter_id: options.matterId || undefined,
-    only_unaccounted_for: options.onlyUnaccountedFor ? true : undefined,
-    order: options.order || undefined,
-    page_token: options.pageToken || undefined,
-    query: options.query || undefined,
-    start_date: options.startDate || undefined,
-    status: options.status || undefined,
-    task_id: options.taskId || undefined,
-    type: options.type || undefined,
-    updated_since: options.updatedSince || undefined,
-    user_id: options.userId || undefined,
-  });
+  return buildListQueryFromResource(ACTIVITY_RESOURCE, options, ACTIVITY_RESOURCE.listQuery);
 }
 
 function formatActivityRow(activity) {
-  return {
-    billed: formatBoolean(activity.billed),
-    date: String(activity.date || "-"),
-    hours: readHours(activity),
-    id: String(activity.id || "-"),
-    matter: readMatterLabel(activity.matter),
-    note: String(activity.note || "-"),
-    total: formatMoney(activity.total),
-    type: String(activity.type || "-"),
-  };
-}
-
-function printActivityList(rows, options) {
-  if (rows.length === 0) {
-    console.log("No activities found for the selected filters.");
-    return;
-  }
-
-  const visibleRows = rows.slice(0, 50);
-  console.log("ID       TYPE        DATE       HOURS TOTAL      BILLED MATTER               NOTE");
-  console.log("-------- ----------- ---------- ----- ---------- ------ -------------------- ------------------------------");
-
-  visibleRows.forEach((row) => {
-    const line = [
-      clip(row.id, 8).padEnd(8, " "),
-      clip(row.type, 11).padEnd(11, " "),
-      clip(row.date, 10).padEnd(10, " "),
-      clip(row.hours, 5).padEnd(5, " "),
-      clip(row.total, 10).padEnd(10, " "),
-      clip(row.billed, 6).padEnd(6, " "),
-      clip(row.matter, 20).padEnd(20, " "),
-      clip(row.note, 30),
-    ].join(" ");
-
-    console.log(line);
-  });
-
-  if (rows.length > visibleRows.length) {
-    console.log(`Showing ${visibleRows.length} of ${rows.length} activities. Use --json for full output.`);
-  }
-
-  if (!options.all && options.nextPageUrl) {
-    console.log("");
-    console.log("More results are available.");
-    if (options.pageTokenSupported === false) {
-      console.log("Run again with `--all` to fetch every matching activity.");
-      return;
-    }
-    console.log("Run again with `--all` or pass `--page-token` from `--json` output.");
-  }
-}
-
-function printActivity(activity) {
-  printKeyValueRows([
-    ["ID", activity.id],
-    ["Type", activity.type],
-    ["Date", activity.date],
-    ["Hours", readHours(activity)],
-    ["Price", formatMoney(activity.price)],
-    ["Total", formatMoney(activity.total)],
-    ["Billed", formatBoolean(activity.billed)],
-    ["On Bill", formatBoolean(activity.on_bill)],
-    ["Non-Billable", formatBoolean(activity.non_billable)],
-    ["No Charge", formatBoolean(activity.no_charge)],
-    ["Flat Rate", formatBoolean(activity.flat_rate)],
-    ["Contingency Fee", formatBoolean(activity.contingency_fee)],
-    ["User", readUserName(activity.user)],
-    ["Matter", readMatterLabel(activity.matter)],
-    ["Activity Description", activity.activity_description?.name],
-    ["Bill", activity.bill?.number],
-    ["Bill State", activity.bill?.state],
-    ["Reference", activity.reference],
-    ["Note", activity.note],
-    ["Created", activity.created_at],
-    ["Updated", activity.updated_at],
-  ]);
+  return ACTIVITY_RESOURCE.display.list.formatRow(activity);
 }
 
 async function fetchMatterIdsForClient(config, accessToken, clientId) {
@@ -302,6 +191,9 @@ function printActivitySummary({ result, rows }) {
   );
 }
 
+const printActivityList = createListPrinter(ACTIVITY_RESOURCE.display.list);
+const printActivity = createDetailPrinter(ACTIVITY_RESOURCE.display.get);
+
 const activitiesList = createListCommand({
   apiPath: ACTIVITY_RESOURCE.apiPath,
   buildJsonMeta: buildActivityJsonMeta,

package/src/commands-practice-areas.js

@@ -1,10 +1,9 @@
 const { fetchResourceById } = require("./clio-api");
 const {
-  clip,
-  compactQuery,
-  parseLimit,
-  printKeyValueRows,
-} = require("./resource-utils");
+  createDetailPrinter,
+  createListPrinter,
+} = require("./resource-display");
+const { buildListQueryFromResource } = require("./resource-query-builder");
 const {
   createGetCommand,
   createListCommand,
@@ -17,16 +16,11 @@ const PRACTICE_AREA_RESOURCE = getResourceMetadata("practice-areas");
 const MATTER_LOOKUP_FIELDS = "id,practice_area{id}";
 
 function buildPracticeAreaQuery(options) {
-  return compactQuery({
-    code: options.code || undefined,
-    created_since: options.createdSince || undefined,
-    fields: options.fields || PRACTICE_AREA_RESOURCE.defaultFields.list,
-    limit: parseLimit(options.limit),
-    name: options.name || undefined,
-    order: options.order || undefined,
-    page_token: options.pageToken || undefined,
-    updated_since: options.updatedSince || undefined,
-  });
+  return buildListQueryFromResource(
+    PRACTICE_AREA_RESOURCE,
+    options,
+    PRACTICE_AREA_RESOURCE.listQuery
+  );
 }
 
 function matchesTimestampOnOrAfter(value, threshold) {
@@ -120,57 +114,7 @@ async function practiceAreasListForMatter(config, accessToken, options = {}) {
 }
 
 function formatPracticeAreaRow(practiceArea) {
-  return {
-    category: String(practiceArea.category || "-"),
-    code: String(practiceArea.code || "-"),
-    id: String(practiceArea.id || "-"),
-    name: String(practiceArea.name || "-"),
-  };
-}
-
-function printPracticeAreaList(rows, options) {
-  if (rows.length === 0) {
-    console.log("No practice areas found for the selected filters.");
-    return;
-  }
-
-  const visibleRows = rows.slice(0, 50);
-  console.log("ID       CODE         NAME                         CATEGORY");
-  console.log("-------- ------------ ---------------------------- ------------------------------");
-
-  visibleRows.forEach((row) => {
-    const line = [
-      clip(row.id, 8).padEnd(8, " "),
-      clip(row.code, 12).padEnd(12, " "),
-      clip(row.name, 28).padEnd(28, " "),
-      clip(row.category, 30),
-    ].join(" ");
-
-    console.log(line);
-  });
-
-  if (rows.length > visibleRows.length) {
-    console.log(
-      `Showing ${visibleRows.length} of ${rows.length} practice areas. Use --json for full output.`
-    );
-  }
-
-  if (!options.all && options.nextPageUrl) {
-    console.log("");
-    console.log("More results are available.");
-    console.log("Run again with `--all` or pass `--page-token` from `--json` output.");
-  }
-}
-
-function printPracticeArea(practiceArea) {
-  printKeyValueRows([
-    ["ID", practiceArea.id],
-    ["Code", practiceArea.code],
-    ["Name", practiceArea.name],
-    ["Category", practiceArea.category],
-    ["Created", practiceArea.created_at],
-    ["Updated", practiceArea.updated_at],
-  ]);
+  return PRACTICE_AREA_RESOURCE.display.list.formatRow(practiceArea);
 }
 
 async function fetchPracticeAreaListResult({ accessToken, apiPath, config, options, query }) {
@@ -187,6 +131,9 @@ async function fetchPracticeAreaListResult({ accessToken, apiPath, config, optio
   });
 }
 
+const printPracticeAreaList = createListPrinter(PRACTICE_AREA_RESOURCE.display.list);
+const printPracticeArea = createDetailPrinter(PRACTICE_AREA_RESOURCE.display.get);
+
 const practiceAreasList = createListCommand({
   apiPath: PRACTICE_AREA_RESOURCE.apiPath,
   buildQuery: buildPracticeAreaQuery,

package/src/redaction-policy.js

@@ -1,36 +1,131 @@
+const SET_KEYS = [
+  "clientObjectKeys",
+  "freeTextFields",
+  "labelFields",
+  "matterLabelFields",
+  "safeIdentityObjectKeys",
+];
+
 const DEFAULT_POLICY = {
   clientObjectKeys: new Set(["client", "clients", "contact", "contacts"]),
   contactLikeResource: false,
-  freeTextFields: new Set(["description", "memo", "note", "reference", "subject"]),
-  labelFields: new Set(["display_number", "number", "identifier", "title"]),
+  freeTextFields: new Set([
+    "body",
+    "caption",
+    "comment",
+    "content",
+    "description",
+    "detail",
+    "display_value",
+    "field_value",
+    "instructions",
+    "location",
+    "memo",
+    "message",
+    "note",
+    "primary_detail",
+    "reference",
+    "secondary_detail",
+    "snippet",
+    "subject",
+    "summary",
+    "text",
+    "value",
+    "value_text",
+  ]),
+  labelFields: new Set([
+    "display_value",
+    "display_number",
+    "file_name",
+    "filename",
+    "identifier",
+    "name",
+    "number",
+    "option",
+    "secondary_identifier",
+    "summary",
+    "tertiary_identifier",
+    "title",
+  ]),
   matterLabelFields: new Set(["display_number", "number"]),
   safeIdentityObjectKeys: new Set([
+    "author",
     "user",
     "assignee",
     "assigner",
+    "calendar_owner",
+    "created_by",
+    "creator",
     "responsible_attorney",
     "responsible_staff",
     "originating_attorney",
+    "updated_by",
   ]),
   safeIdentityResource: false,
 };
 
 const RESOURCE_POLICY_OVERRIDES = {
+  "calendar-entry": {
+    clientObjectKeys: new Set(["attendees"]),
+    freeTextFields: new Set(["summary", "location"]),
+    labelFields: new Set(["summary"]),
+  },
   "billable-client": {
     contactLikeResource: true,
   },
+  communication: {
+    clientObjectKeys: new Set(["senders", "receivers"]),
+    freeTextFields: new Set(["body", "content", "detail", "message"]),
+  },
   contact: {
     contactLikeResource: true,
   },
+  conversation: {
+    freeTextFields: new Set(["body", "content", "message", "snippet"]),
+  },
+  "conversation-message": {
+    clientObjectKeys: new Set(["receivers", "sender"]),
+    freeTextFields: new Set(["body", "content", "message", "text"]),
+  },
+  "custom-field": {
+    freeTextFields: new Set(["value", "display_value", "value_text", "field_value"]),
+    labelFields: new Set(["name", "title"]),
+  },
+  document: {
+    freeTextFields: new Set(["name", "summary"]),
+    labelFields: new Set(["file_name", "filename", "name", "title"]),
+  },
+  note: {
+    freeTextFields: new Set(["detail", "message", "text"]),
+  },
+  "my-event": {
+    freeTextFields: new Set([
+      "description",
+      "message",
+      "primary_detail",
+      "secondary_detail",
+      "title",
+    ]),
+    labelFields: new Set(["primary_detail", "secondary_detail", "title"]),
+  },
   user: {
     safeIdentityResource: true,
   },
 };
 
 function getRedactionPolicy(resourceType) {
+  const overrides = RESOURCE_POLICY_OVERRIDES[resourceType] || {};
+
   return {
     ...DEFAULT_POLICY,
-    ...(RESOURCE_POLICY_OVERRIDES[resourceType] || {}),
+    ...overrides,
+    ...SET_KEYS.reduce((merged, key) => {
+      merged[key] = new Set([
+        ...(DEFAULT_POLICY[key] || []),
+        ...(overrides[key] || []),
+      ]);
+      return merged;
+    }, {}),
   };
 }
 

package/src/redaction.js

@@ -400,6 +400,10 @@ function isMatterLabelContext(policy, path, key) {
   return path[path.length - 1] === "matter" && policy.matterLabelFields.has(key);
 }
 
+function isLabelContext(policy, key) {
+  return policy.labelFields.has(key);
+}
+
 function redactStringValue(
   policy,
   text,
@@ -414,7 +418,7 @@ function redactStringValue(
   output = replaceKnownSensitiveValues(output, replacements);
   output = redactPatternPii(output);
 
-  if (isMatterLabelContext(policy, path, key)) {
+  if (isMatterLabelContext(policy, path, key) || isLabelContext(policy, key)) {
     output = replaceMatterLabelDerivedNames(output, derivedLabelReplacements);
   }
 

package/src/resource-display.js

@@ -0,0 +1,100 @@
+const { clip, printKeyValueRows } = require("./resource-utils");
+
+function resolveDescriptorValue(item, descriptor) {
+  if (typeof descriptor.value === "function") {
+    return descriptor.value(item);
+  }
+
+  return item?.[descriptor.key];
+}
+
+function createListPrinter(config) {
+  const {
+    columns,
+    emptyMessage,
+    moreResults,
+    noun,
+    rowLimit = 50,
+  } = config;
+
+  const headerLine = columns
+    .map((column) => {
+      if (column.width) {
+        return String(column.header).padEnd(column.width, " ");
+      }
+
+      return String(column.header);
+    })
+    .join(" ");
+
+  const dividerLine = columns
+    .map((column) => "-".repeat(column.width || String(column.header).length))
+    .join(" ");
+
+  return function printList(rows, options = {}) {
+    if (rows.length === 0) {
+      console.log(emptyMessage);
+      return;
+    }
+
+    const visibleRows = rows.slice(0, rowLimit);
+    console.log(headerLine);
+    console.log(dividerLine);
+
+    visibleRows.forEach((row) => {
+      const line = columns
+        .map((column) => {
+          const rawValue = row?.[column.key];
+          const text = clip(
+            rawValue === undefined || rawValue === null ? "-" : String(rawValue),
+            column.width || String(rawValue || "-").length
+          );
+
+          if (!column.width || column.pad === false) {
+            return text;
+          }
+
+          return text.padEnd(column.width, " ");
+        })
+        .join(" ");
+
+      console.log(line);
+    });
+
+    if (rows.length > visibleRows.length) {
+      console.log(`Showing ${visibleRows.length} of ${rows.length} ${noun}. Use --json for full output.`);
+    }
+
+    if (!options.all && options.nextPageUrl) {
+      const lines =
+        typeof moreResults === "function"
+          ? moreResults(options)
+          : [
+              "More results are available.",
+              "Run again with `--all` or pass `--page-token` from `--json` output.",
+            ];
+
+      if (Array.isArray(lines) && lines.length > 0) {
+        console.log("");
+        lines.forEach((line) => {
+          console.log(line);
+        });
+      }
+    }
+  };
+}
+
+function createDetailPrinter(config) {
+  const { fields } = config;
+
+  return function printItem(item = {}) {
+    printKeyValueRows(
+      fields.map((field) => [field.label, resolveDescriptorValue(item, field)])
+    );
+  };
+}
+
+module.exports = {
+  createDetailPrinter,
+  createListPrinter,
+};

package/src/resource-handlers.js

@@ -0,0 +1,81 @@
+const { activitiesGet, activitiesList } = require("./commands-activities");
+const { practiceAreasGet, practiceAreasList } = require("./commands-practice-areas");
+const {
+  createDetailPrinter,
+  createListPrinter,
+} = require("./resource-display");
+const { buildListQueryFromResource } = require("./resource-query-builder");
+const { createGetCommand, createListCommand } = require("./resource-command-runner");
+
+const RESOURCE_HANDLERS = {
+  activities: {
+    get: activitiesGet,
+    list: activitiesList,
+  },
+  "practice-areas": {
+    get: practiceAreasGet,
+    list: practiceAreasList,
+  },
+};
+
+const GENERIC_HANDLER_CACHE = new Map();
+
+function createGenericHandlers(resourceMetadata) {
+  if (!resourceMetadata || !resourceMetadata.display) {
+    return null;
+  }
+
+  const cached = GENERIC_HANDLER_CACHE.get(resourceMetadata.handlerKey);
+  if (cached) {
+    return cached;
+  }
+
+  const handlers = {};
+
+  if (resourceMetadata.capabilities.list.enabled && resourceMetadata.display.list) {
+    const printList = createListPrinter(resourceMetadata.display.list);
+    handlers.list = createListCommand({
+      apiPath: resourceMetadata.apiPath,
+      buildQuery: (options) =>
+        buildListQueryFromResource(resourceMetadata, options, resourceMetadata.listQuery),
+      formatRow: resourceMetadata.display.list.formatRow,
+      pluralLabel: resourceMetadata.summaryLabels.plural,
+      printList,
+      redactionResourceType: resourceMetadata.redaction.resourceType,
+      singularLabel: resourceMetadata.summaryLabels.singular,
+    });
+  }
+
+  if (resourceMetadata.capabilities.get.enabled && resourceMetadata.display.get) {
+    const printItem = createDetailPrinter(resourceMetadata.display.get);
+    handlers.get = createGetCommand({
+      apiPath: resourceMetadata.apiPath,
+      defaultFields: resourceMetadata.defaultFields.get,
+      printItem,
+      redactionResourceType: resourceMetadata.redaction.resourceType,
+      usage: `Usage: not-manage ${resourceMetadata.handlerKey} get <id> [--fields ...] [--json]`,
+    });
+  }
+
+  GENERIC_HANDLER_CACHE.set(resourceMetadata.handlerKey, handlers);
+  return handlers;
+}
+
+function getResourceHandler(resourceMetadata, subcommand) {
+  if (!resourceMetadata) {
+    return null;
+  }
+
+  const explicitHandler = RESOURCE_HANDLERS[resourceMetadata.handlerKey]?.[subcommand];
+  if (explicitHandler) {
+    return explicitHandler;
+  }
+
+  const genericHandlers = createGenericHandlers(resourceMetadata);
+  return genericHandlers?.[subcommand] || null;
+}
+
+module.exports = {
+  RESOURCE_HANDLERS,
+  getResourceHandler,
+};