not-manage 0.1.17

package/src/resource-utils.js

@@ -0,0 +1,141 @@
+function parseLimit(limitInput, max = 200) {
+  if (limitInput === undefined || limitInput === null || limitInput === "") {
+    return undefined;
+  }
+
+  const parsed = Number(limitInput);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+    throw new Error(`\`--limit\` must be an integer between 1 and ${max}.`);
+  }
+
+  return parsed;
+}
+
+function compactQuery(query) {
+  const next = { ...query };
+  Object.keys(next).forEach((key) => {
+    if (next[key] === undefined || next[key] === null || next[key] === "") {
+      delete next[key];
+    }
+  });
+  return next;
+}
+
+function clip(value, maxLength) {
+  const text = String(value || "");
+  if (text.length <= maxLength) {
+    return text;
+  }
+  if (maxLength <= 3) {
+    return ".".repeat(maxLength);
+  }
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+
+function readContactName(contact) {
+  if (!contact || typeof contact !== "object") {
+    return "-";
+  }
+
+  return (
+    contact.name ||
+    [contact.first_name, contact.last_name].filter(Boolean).join(" ").trim() ||
+    "-"
+  );
+}
+
+function readUserName(user) {
+  if (!user || typeof user !== "object") {
+    return "-";
+  }
+
+  return (
+    user.name ||
+    [user.first_name, user.last_name].filter(Boolean).join(" ").trim() ||
+    user.email ||
+    "-"
+  );
+}
+
+function readMatterLabel(matter) {
+  if (!matter || typeof matter !== "object") {
+    return "-";
+  }
+
+  return matter.display_number || matter.number || matter.description || String(matter.id || "-");
+}
+
+function formatBoolean(value) {
+  if (value === undefined || value === null) {
+    return "-";
+  }
+
+  return value ? "yes" : "no";
+}
+
+function formatMoney(value) {
+  if (value === undefined || value === null || value === "") {
+    return "-";
+  }
+
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return String(value);
+  }
+
+  return parsed.toFixed(2);
+}
+
+function printKeyValueRows(rows) {
+  const normalized = rows
+    .filter(([label]) => label)
+    .map(([label, value]) => [
+      label,
+      value === undefined || value === null || value === "" ? "-" : String(value),
+    ]);
+
+  if (normalized.length === 0) {
+    return;
+  }
+
+  const width = normalized.reduce((max, [label]) => Math.max(max, label.length), 0);
+  normalized.forEach(([label, value]) => {
+    console.log(`${label.padEnd(width, " ")} : ${value}`);
+  });
+}
+
+async function fetchPages(fetchPage, initialQuery, fetchAllPages) {
+  const firstPage = await fetchPage(initialQuery);
+  const firstData = Array.isArray(firstPage?.data) ? firstPage.data : [];
+  const aggregatedData = [...firstData];
+  let pagesFetched = 1;
+  let nextPageUrl = firstPage?.meta?.paging?.next || null;
+
+  while (fetchAllPages && nextPageUrl) {
+    const nextPage = await fetchPage({}, nextPageUrl);
+    const nextData = Array.isArray(nextPage?.data) ? nextPage.data : [];
+    aggregatedData.push(...nextData);
+    pagesFetched += 1;
+    nextPageUrl = nextPage?.meta?.paging?.next || null;
+  }
+
+  return {
+    firstPage,
+    data: fetchAllPages ? aggregatedData : firstData,
+    pagesFetched,
+    nextPageUrl: fetchAllPages ? null : firstPage?.meta?.paging?.next || null,
+  };
+}
+
+module.exports = {
+  clip,
+  compactQuery,
+  fetchPages,
+  formatBoolean,
+  formatMoney,
+  parseLimit,
+  printKeyValueRows,
+  readContactName,
+  readMatterLabel,
+  readUserName,
+};

package/src/store.js

@@ -0,0 +1,178 @@
+const {
+  DEFAULT_REDIRECT_URI,
+  DEFAULT_REGION,
+  REGIONS,
+} = require("./constants");
+const { deleteSecret, getSecret, setSecret } = require("./keychain");
+const { parseLoopbackRedirectUri } = require("./redirect-uri");
+
+const ACCOUNTS = {
+  region: "config:region",
+  clientId: "config:client_id",
+  clientSecret: "config:client_secret",
+  redirectUri: "config:redirect_uri",
+  tokens: "tokens:default",
+};
+
+function normalizeRegion(regionInput) {
+  const code = String(regionInput || "")
+    .trim()
+    .toLowerCase();
+
+  if (!REGIONS[code]) {
+    const valid = Object.keys(REGIONS).join(", ");
+    throw new Error(`Unsupported region "${regionInput}". Use one of: ${valid}`);
+  }
+
+  return code;
+}
+
+function parseRedirectUri(redirectUri) {
+  return parseLoopbackRedirectUri(redirectUri).toString();
+}
+
+function buildConfig(region, clientId, clientSecret, redirectUri, source) {
+  const regionCode = normalizeRegion(region || DEFAULT_REGION);
+  const regionInfo = REGIONS[regionCode];
+
+  if (!clientId || !clientSecret) {
+    throw new Error(
+      "Client credentials are missing. Run `not-manage setup` or `not-manage auth setup`."
+    );
+  }
+
+  return {
+    source,
+    region: regionCode,
+    regionLabel: regionInfo.label,
+    host: regionInfo.host,
+    clientId,
+    clientSecret,
+    redirectUri: parseRedirectUri(redirectUri || DEFAULT_REDIRECT_URI),
+  };
+}
+
+async function getStoredConfig() {
+  const [region, clientId, clientSecret, redirectUri] = await Promise.all([
+    getSecret(ACCOUNTS.region),
+    getSecret(ACCOUNTS.clientId),
+    getSecret(ACCOUNTS.clientSecret),
+    getSecret(ACCOUNTS.redirectUri),
+  ]);
+
+  if (!region || !clientId || !clientSecret) {
+    return null;
+  }
+
+  return buildConfig(
+    region,
+    clientId,
+    clientSecret,
+    redirectUri || DEFAULT_REDIRECT_URI,
+    "keychain"
+  );
+}
+
+async function saveConfig(configInput) {
+  const config = buildConfig(
+    configInput.region,
+    configInput.clientId,
+    configInput.clientSecret,
+    configInput.redirectUri || DEFAULT_REDIRECT_URI,
+    "keychain"
+  );
+
+  await Promise.all([
+    setSecret(ACCOUNTS.region, config.region),
+    setSecret(ACCOUNTS.clientId, config.clientId),
+    setSecret(ACCOUNTS.clientSecret, config.clientSecret),
+    setSecret(ACCOUNTS.redirectUri, config.redirectUri),
+  ]);
+
+  return config;
+}
+
+async function getConfig() {
+  const config = await findConfig();
+  if (config) {
+    return config;
+  }
+
+  throw new Error(
+    "Clio app credentials are not configured. Run `not-manage setup`."
+  );
+}
+
+async function findConfig() {
+  const storedConfig = await getStoredConfig();
+  if (storedConfig) {
+    return storedConfig;
+  }
+
+  return null;
+}
+
+function normalizeTokenSet(rawTokenSet, previousTokenSet) {
+  if (!rawTokenSet || !rawTokenSet.access_token) {
+    throw new Error("Clio token response is missing access_token.");
+  }
+
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  const expiresIn = Number(rawTokenSet.expires_in || 0);
+  const expiresAt = expiresIn > 0 ? nowSeconds + expiresIn : null;
+
+  return {
+    source: "keychain",
+    tokenType: rawTokenSet.token_type || "Bearer",
+    accessToken: rawTokenSet.access_token,
+    refreshToken: rawTokenSet.refresh_token || previousTokenSet?.refreshToken || null,
+    expiresAt,
+  };
+}
+
+async function saveTokenSet(tokenSetInput, previousTokenSet = null) {
+  const tokenSet = normalizeTokenSet(tokenSetInput, previousTokenSet);
+  await setSecret(ACCOUNTS.tokens, JSON.stringify(tokenSet));
+  return tokenSet;
+}
+
+async function getStoredTokenSet() {
+  const raw = await getSecret(ACCOUNTS.tokens);
+  if (!raw) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      source: "keychain",
+      tokenType: parsed.tokenType || "Bearer",
+      accessToken: parsed.accessToken || null,
+      refreshToken: parsed.refreshToken || null,
+      expiresAt: parsed.expiresAt || null,
+    };
+  } catch (_error) {
+    throw new Error(
+      "Stored token data is invalid. Run `not-manage auth revoke` then `not-manage auth login`."
+    );
+  }
+}
+
+async function getTokenSet() {
+  return getStoredTokenSet();
+}
+
+async function clearTokenSet() {
+  await deleteSecret(ACCOUNTS.tokens);
+}
+
+module.exports = {
+  clearTokenSet,
+  findConfig,
+  getConfig,
+  getTokenSet,
+  normalizeRegion,
+  parseRedirectUri,
+  saveConfig,
+  saveTokenSet,
+};