@deployfoundation/foundation-deploy 0.2.50 → 0.2.52

package/dist/chunk-m76jt5rc.js

@@ -0,0 +1,376 @@
+import {
+  CRM_MAX_OUTREACH_CANDIDATES_PAGE,
+  CRM_MAX_REQUEST_BYTES,
+  CRM_MAX_RESPONSE_BYTES,
+  CRM_REFUSAL_REASONS,
+  CrmInputError,
+  isCrmIdempotencyKey,
+  parseCrmGetActivityResponse,
+  parseCrmGetRecordResponse,
+  parseCrmOperationAck,
+  parseCrmOutreachCandidatesResponse,
+  parseCrmOutreachState,
+  parseCrmProviderMeta,
+  parseCrmSearchResponse
+} from "./chunk-3614v9rr.js";
+
+// ../connectors/src/crm-http.ts
+import { randomUUID } from "node:crypto";
+var CRM_HTTP_CONTRACT = "crm/1";
+var CRM_HTTP_UPSERT_TIMEOUT_MS = 25000;
+var CRM_HTTP_TIMEOUT_MS = 1e4;
+var MAX_ERROR_BODY_BYTES = 4096;
+var MAX_URL_CHARS = 2048;
+var MAX_KEY_CHARS = 1024;
+var CRM_HTTP_HEADERS = {
+  contract: "foundation-contract",
+  requestId: "foundation-request-id",
+  actor: "foundation-actor",
+  idempotencyKey: "idempotency-key",
+  tenant: "foundation-tenant",
+  replayed: "idempotent-replayed"
+};
+var CRM_HTTP_ROUTES = {
+  meta: { method: "GET", path: "/meta" },
+  search: { method: "POST", path: "/records/search" },
+  get_record: { method: "POST", path: "/records/get" },
+  get_activity: { method: "POST", path: "/activities/get" },
+  upsert_records: { method: "POST", path: "/records/upsert" },
+  update_status: { method: "POST", path: "/records/status" },
+  log_activity: { method: "POST", path: "/activities" },
+  update_note: { method: "POST", path: "/activities/update" },
+  outreach_state: { method: "POST", path: "/outreach/state" },
+  outreach_candidates: { method: "POST", path: "/outreach/candidates" },
+  delete_record: { method: "POST", path: "/records/delete" }
+};
+var CRM_HTTP_DETAIL_CODES = [
+  "contract",
+  "unknown_field",
+  "field_invalid",
+  "batch_too_large",
+  "idempotency_key_mismatch",
+  "contact_company_unknown",
+  "status_unknown",
+  "activity_type_unknown",
+  "cursor_invalid",
+  "outreach_invalid"
+];
+
+class CrmHttpError extends Error {
+  code;
+  status;
+  reason;
+  detailCode;
+  definitive;
+  sent;
+  constructor(code, details = {}) {
+    super(`CRM provider call failed: ${code}`);
+    this.code = code;
+    this.name = "CrmHttpError";
+    this.status = details.status;
+    this.reason = details.reason;
+    this.detailCode = details.detailCode;
+    this.definitive = details.definitive === true;
+    this.sent = details.sent !== false;
+  }
+  get statusClass() {
+    return this.status === undefined ? "none" : `${Math.floor(this.status / 100)}xx`;
+  }
+}
+function encodeCrmActor(actor) {
+  return Buffer.from(JSON.stringify({
+    agent: actor.agent,
+    slackTeamId: actor.slackTeamId,
+    slackUserId: actor.slackUserId,
+    channelId: actor.channelId,
+    ...actor.jobKind === undefined ? {} : { jobKind: actor.jobKind },
+    sessionHash: actor.sessionHash
+  })).toString("base64url");
+}
+function crmHttpBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("CRM provider base URL must be an HTTPS URL");
+  }
+  if (value.length > MAX_URL_CHARS || url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || value.includes("?") || value.includes("#")) {
+    throw new Error("CRM provider base URL must be an HTTPS URL");
+  }
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+function isCrmHttpKey(value) {
+  return typeof value === "string" && value.length >= 16 && value.length <= MAX_KEY_CHARS && /^[\x21-\x7e]+$/.test(value);
+}
+function createCrmHttpClient(options) {
+  const baseUrl = crmHttpBaseUrl(options.baseUrl);
+  if (!/^[\x21-\x7e][\x20-\x7e]{0,127}$/.test(options.userAgent)) {
+    throw new Error("CRM provider user agent is invalid");
+  }
+  if (!headerSafe(options.expectedTenant, 256)) {
+    throw new Error("CRM provider tenant is invalid");
+  }
+  if (options.actor !== undefined && !/^[A-Za-z0-9_-]{1,2048}$/.test(options.actor)) {
+    throw new Error("CRM provider actor is invalid");
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  async function call(route, body, timeoutMs) {
+    const serialized = body === undefined ? undefined : JSON.stringify(body);
+    if (serialized !== undefined && Buffer.byteLength(serialized, "utf8") > CRM_MAX_REQUEST_BYTES) {
+      throw new CrmInputError(`CRM request may not exceed ${CRM_MAX_REQUEST_BYTES} bytes`);
+    }
+    const idempotencyKey = typeof body?.idempotencyKey === "string" ? body.idempotencyKey : undefined;
+    if (idempotencyKey !== undefined && !isCrmIdempotencyKey(idempotencyKey)) {
+      throw new CrmInputError("idempotencyKey must be printable ASCII for this CRM");
+    }
+    let key = await options.credentials.get();
+    try {
+      return await send(route, serialized, idempotencyKey, key, timeoutMs);
+    } catch (error) {
+      if (!(error instanceof CrmHttpError) || error.code !== "unauthorized")
+        throw error;
+      const refreshed = await options.credentials.refresh();
+      if (refreshed === key)
+        throw error;
+      key = refreshed;
+      return send(route, serialized, idempotencyKey, key, timeoutMs);
+    }
+  }
+  async function send(route, serialized, idempotencyKey, key, timeoutMs) {
+    if (!isCrmHttpKey(key))
+      throw new CrmHttpError("unauthorized", { sent: false });
+    const { method, path } = CRM_HTTP_ROUTES[route];
+    const signal = options.deadline === undefined ? AbortSignal.timeout(timeoutMs) : AbortSignal.any([AbortSignal.timeout(timeoutMs), options.deadline]);
+    if (signal.aborted)
+      throw new CrmHttpError("timeout", { sent: false });
+    let response;
+    try {
+      response = await fetchImpl(`${baseUrl}${path}`, {
+        method,
+        redirect: "error",
+        headers: {
+          authorization: `Bearer ${key}`,
+          accept: "application/json",
+          "user-agent": options.userAgent,
+          [CRM_HTTP_HEADERS.contract]: CRM_HTTP_CONTRACT,
+          [CRM_HTTP_HEADERS.requestId]: randomUUID(),
+          ...options.actor === undefined ? {} : { [CRM_HTTP_HEADERS.actor]: options.actor },
+          ...idempotencyKey === undefined ? {} : { [CRM_HTTP_HEADERS.idempotencyKey]: idempotencyKey },
+          ...serialized === undefined ? {} : { "content-type": "application/json" }
+        },
+        ...serialized === undefined ? {} : { body: serialized },
+        signal
+      });
+    } catch {
+      throw new CrmHttpError(signal.aborted ? "timeout" : "unavailable");
+    }
+    return readReply(response, signal, options.expectedTenant);
+  }
+  function ack(value, expected, matches) {
+    const parsed = parseReply(value, parseCrmOperationAck);
+    if (parsed.operation !== expected || !matches(parsed))
+      throw new CrmHttpError("protocol");
+    return parsed;
+  }
+  const sameRecord = (args) => (reply) => ("recordId" in reply) && reply.recordType === args.recordType && reply.recordId === args.recordId;
+  return {
+    meta: async () => parseReply(await call("meta", undefined, CRM_HTTP_TIMEOUT_MS), parseCrmProviderMeta),
+    search: async (args) => parseReply(await call("search", { ...args }, CRM_HTTP_TIMEOUT_MS), parseCrmSearchResponse),
+    getRecord: async (args) => parseReply(await call("get_record", { ...args }, CRM_HTTP_TIMEOUT_MS), parseCrmGetRecordResponse),
+    getActivity: async (args) => {
+      const activity = parseReply(await call("get_activity", { recordType: args.recordType, recordId: args.recordId, activityId: args.activityId }, CRM_HTTP_TIMEOUT_MS), parseCrmGetActivityResponse);
+      if (activity.id !== args.activityId)
+        throw new CrmHttpError("protocol");
+      return activity;
+    },
+    upsertRecords: async (args) => {
+      const records = (args.companies?.length ?? 0) + (args.contacts?.length ?? 0);
+      return ack(await call("upsert_records", { ...args }, CRM_HTTP_UPSERT_TIMEOUT_MS), "upsert_records", (reply) => ("records" in reply) && reply.records === records);
+    },
+    updateStatus: async (args, expect) => ack(await call("update_status", {
+      recordType: args.recordType,
+      recordId: args.recordId,
+      status: args.status,
+      idempotencyKey: args.idempotencyKey,
+      expect: { status: expect.status, statusVersion: expect.statusVersion }
+    }, CRM_HTTP_TIMEOUT_MS), "update_status", (reply) => sameRecord(args)(reply) && ("status" in reply) && reply.status === args.status),
+    logActivity: async (args, outreach) => ack(await call("log_activity", { ...args, ...outreach === undefined ? {} : { outreach: { ...outreach } } }, CRM_HTTP_TIMEOUT_MS), "log_activity", (reply) => sameRecord(args)(reply) && ("activityType" in reply) && reply.activityType === args.activityType),
+    updateNote: async (args) => ack(await call("update_note", {
+      recordType: args.recordType,
+      recordId: args.recordId,
+      activityId: args.activityId,
+      summary: args.summary,
+      idempotencyKey: args.idempotencyKey,
+      expect: { version: args.version }
+    }, CRM_HTTP_TIMEOUT_MS), "update_note", (reply) => sameRecord(args)(reply) && ("activityId" in reply) && reply.activityId === args.activityId && reply.version > args.version),
+    outreachState: async (args) => {
+      const state = parseReply(await call("outreach_state", { contactId: args.contactId }, CRM_HTTP_TIMEOUT_MS), parseCrmOutreachState);
+      if (state.contactId !== args.contactId)
+        throw new CrmHttpError("protocol");
+      return state;
+    },
+    outreachCandidates: async (args) => {
+      if (!Number.isInteger(args.limit) || args.limit < 1 || args.limit > CRM_MAX_OUTREACH_CANDIDATES_PAGE) {
+        throw new CrmInputError(`limit must be an integer between 1 and ${CRM_MAX_OUTREACH_CANDIDATES_PAGE}`);
+      }
+      const page = parseReply(await call("outreach_candidates", {
+        rankAttribute: args.rankAttribute,
+        statuses: { contact: [...args.statuses.contact] },
+        limit: args.limit,
+        ...args.cursor === undefined ? {} : { cursor: args.cursor }
+      }, CRM_HTTP_TIMEOUT_MS), parseCrmOutreachCandidatesResponse);
+      if (page.candidates.length > args.limit)
+        throw new CrmHttpError("protocol");
+      return page;
+    },
+    deleteRecord: async (args) => ack(await call("delete_record", { ...args }, CRM_HTTP_TIMEOUT_MS), "delete_record", sameRecord(args))
+  };
+}
+function parseReply(value, parser) {
+  try {
+    return parser(value);
+  } catch {
+    throw new CrmHttpError("protocol");
+  }
+}
+async function readReply(response, signal, expectedTenant) {
+  const { status } = response;
+  const contract = response.headers.get(CRM_HTTP_HEADERS.contract);
+  if (contract === null) {
+    await discard(response);
+    if (status === 401)
+      throw new CrmHttpError("unauthorized", { status });
+    if (status === 403)
+      throw new CrmHttpError("forbidden", { status });
+    if (status === 429)
+      throw new CrmHttpError("rate_limited", { status });
+    if (status >= 500)
+      throw new CrmHttpError("server_error", { status });
+    throw new CrmHttpError("protocol", { status });
+  }
+  if (contractMajor(contract) !== contractMajor(CRM_HTTP_CONTRACT)) {
+    await discard(response);
+    throw new CrmHttpError("contract_mismatch", { status });
+  }
+  const tenantMatches = response.headers.get(CRM_HTTP_HEADERS.tenant) === expectedTenant;
+  if (status === 403) {
+    const error = contractError(status, parseJson(await readBounded(response, MAX_ERROR_BODY_BYTES, signal), status));
+    if (error.code === "forbidden" || tenantMatches)
+      throw error;
+    throw new CrmHttpError("tenant_mismatch", { status });
+  }
+  if (status !== 401 && !tenantMatches) {
+    await discard(response);
+    throw new CrmHttpError("tenant_mismatch", { status });
+  }
+  if (status === 200 || status === 201) {
+    return parseJson(await readBounded(response, CRM_MAX_RESPONSE_BYTES, signal), status);
+  }
+  if (status >= 500 && status !== 501) {
+    await discard(response);
+    throw new CrmHttpError("server_error", { status });
+  }
+  if (status === 429) {
+    await discard(response);
+    throw new CrmHttpError("rate_limited", { status });
+  }
+  if (status < 400) {
+    await discard(response);
+    throw new CrmHttpError("protocol", { status });
+  }
+  const body = parseJson(await readBounded(response, MAX_ERROR_BODY_BYTES, signal), status);
+  throw contractError(status, body);
+}
+function contractError(status, body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    return new CrmHttpError("protocol", { status });
+  }
+  const fields = Object.fromEntries(Object.entries(body));
+  if (Object.keys(fields).some((key) => !["error", "reason", "detail_code"].includes(key))) {
+    return new CrmHttpError("protocol", { status });
+  }
+  const { error, reason } = fields;
+  const detailCode = CRM_HTTP_DETAIL_CODES.find((code2) => code2 === fields.detail_code);
+  const definitive = { status, definitive: true };
+  if (error === "invalid_input" && (status === 400 || status === 422)) {
+    return new CrmHttpError("invalid_input", {
+      ...definitive,
+      ...detailCode === undefined ? {} : { detailCode }
+    });
+  }
+  if (error === "refused" && status === 422) {
+    const known = CRM_REFUSAL_REASONS.find((candidate) => candidate === reason);
+    return known === undefined ? new CrmHttpError("protocol", { status }) : new CrmHttpError("refused", { ...definitive, reason: known });
+  }
+  const byStatus = {
+    401: ["unauthorized"],
+    403: ["forbidden", "not_editable"],
+    404: ["not_found"],
+    409: ["conflict"],
+    412: ["stale_status", "stale_version"],
+    501: ["unsupported"]
+  };
+  const allowed = byStatus[status] ?? [];
+  const code = allowed.find((candidate) => candidate === error);
+  return code === undefined ? new CrmHttpError("protocol", { status }) : new CrmHttpError(code, definitive);
+}
+function contractMajor(value) {
+  return /^crm\/(\d{1,4})(?:\.\d{1,4})?$/.exec(value.trim())?.[1];
+}
+function parseJson(text, status) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CrmHttpError("protocol", { status });
+  }
+}
+async function readCrmHttpBody(response, maxBytes, signal) {
+  return readBounded(response, maxBytes, signal);
+}
+async function readBounded(response, maxBytes, signal) {
+  const declared = Number(response.headers.get("content-length") ?? "");
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    await discard(response);
+    throw new CrmHttpError("protocol", { status: response.status });
+  }
+  const reader = response.body?.getReader();
+  if (reader === undefined)
+    return "";
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      let next;
+      try {
+        next = await reader.read();
+      } catch {
+        throw new CrmHttpError(signal?.aborted === true ? "timeout" : "unavailable", {
+          status: response.status
+        });
+      }
+      if (next.done)
+        break;
+      total += next.value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => {
+          return;
+        });
+        throw new CrmHttpError("protocol", { status: response.status });
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder().decode(Buffer.concat(chunks));
+}
+async function discard(response) {
+  await response.body?.cancel().catch(() => {
+    return;
+  });
+}
+function headerSafe(value, max) {
+  return value.length > 0 && value.length <= max && /^[\x21-\x7e](?:[\x20-\x7e]*[\x21-\x7e])?$/.test(value);
+}
+
+export { CRM_HTTP_CONTRACT, CRM_HTTP_HEADERS, CRM_HTTP_ROUTES, CrmHttpError, encodeCrmActor, crmHttpBaseUrl, isCrmHttpKey, createCrmHttpClient, readCrmHttpBody };