@headroom-cms/admin-api 0.1.1

package/dist/index.js

@@ -0,0 +1,601 @@
+// src/error.ts
+var HeadroomApiError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message || code);
+    this.name = "HeadroomApiError";
+    this.status = status;
+    this.code = code;
+  }
+  /** Alias for `message` — eases migration from admin's ApiError which used `detail`. */
+  get detail() {
+    return this.message;
+  }
+};
+
+// src/mime.ts
+var MIME_MAP = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf"
+};
+function mimeFromFilename(filename) {
+  const ext = filename.includes(".") ? "." + filename.split(".").pop().toLowerCase() : "";
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+
+// src/client.ts
+var HeadroomAdminClient = class {
+  baseUrl;
+  tokenProvider;
+  constructor(baseUrl, tokenProvider) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.tokenProvider = tokenProvider;
+  }
+  /**
+   * Low-level fetch — public so admin UI hooks can migrate incrementally.
+   * Prefer typed methods (listSites, createContent, etc.) in new code.
+   */
+  async apiFetch(path, options) {
+    const token = await this.tokenProvider.getToken();
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      ...options?.headers
+    };
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers
+    });
+    if (res.status === 401 && this.tokenProvider.onUnauthorized) {
+      const newToken = await this.tokenProvider.onUnauthorized();
+      headers["Authorization"] = `Bearer ${newToken}`;
+      const retry = await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        headers
+      });
+      return this.handleResponse(retry);
+    }
+    return this.handleResponse(res);
+  }
+  async handleResponse(res) {
+    if (!res.ok) {
+      let code = "UNKNOWN";
+      let message = `HTTP ${res.status}`;
+      try {
+        const body = await res.json();
+        code = body.code || body.error || code;
+        message = body.message || body.error || message;
+      } catch {
+      }
+      throw new HeadroomApiError(res.status, code, message);
+    }
+    if (res.status === 204) return void 0;
+    return res.json();
+  }
+  // ── Sites ──────────────────────────────────────────
+  async listSites(includeArchived = false) {
+    const qs = includeArchived ? "?includeArchived=true" : "";
+    const res = await this.apiFetch(
+      `/v1/admin/sites${qs}`
+    );
+    return res.items;
+  }
+  async createSite(host, name) {
+    return this.apiFetch("/v1/admin/sites", {
+      method: "POST",
+      body: JSON.stringify({ host, name })
+    });
+  }
+  async getSite(host) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}`
+    );
+  }
+  async updateSite(host, data) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}`,
+      { method: "PUT", body: JSON.stringify(data) }
+    );
+  }
+  async deleteSite(host) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}`,
+      { method: "DELETE" }
+    );
+  }
+  async updateSiteAdmins(host, admins) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/admins`,
+      { method: "PUT", body: JSON.stringify({ admins }) }
+    );
+  }
+  async purgeSite(host) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/purge`,
+      { method: "POST" }
+    );
+  }
+  async inviteToSite(host, email, adminUrl) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/invite`,
+      { method: "POST", body: JSON.stringify({ email, adminUrl }) }
+    );
+  }
+  // ── Collections ────────────────────────────────────
+  async listCollections(host) {
+    const res = await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/collections`
+    );
+    return res.collections;
+  }
+  async createCollection(host, input) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/collections`,
+      { method: "POST", body: JSON.stringify(input) }
+    );
+  }
+  async getCollection(host, name) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/collections/${encodeURIComponent(name)}`
+    );
+  }
+  async updateCollection(host, name, input) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/collections/${encodeURIComponent(name)}`,
+      { method: "PUT", body: JSON.stringify(input) }
+    );
+  }
+  async deleteCollection(host, name) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/collections/${encodeURIComponent(name)}`,
+      { method: "DELETE" }
+    );
+  }
+  // ── Block Types ────────────────────────────────────
+  async listBlockTypes(host) {
+    const res = await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/block-types`
+    );
+    return res.blockTypes;
+  }
+  async createBlockType(host, input) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/block-types`,
+      { method: "POST", body: JSON.stringify(input) }
+    );
+  }
+  async getBlockType(host, name) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/block-types/${encodeURIComponent(name)}`
+    );
+  }
+  async updateBlockType(host, name, input) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/block-types/${encodeURIComponent(name)}`,
+      { method: "PUT", body: JSON.stringify(input) }
+    );
+  }
+  async deleteBlockType(host, name) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/block-types/${encodeURIComponent(name)}`,
+      { method: "DELETE" }
+    );
+  }
+  // ── Content ────────────────────────────────────────
+  async listContent(host, params) {
+    const qs = new URLSearchParams();
+    if (params?.collection) qs.set("collection", params.collection);
+    if (params?.q) qs.set("q", params.q);
+    if (params?.search) qs.set("search", params.search);
+    if (params?.tag) qs.set("tag", params.tag);
+    if (params?.status) qs.set("status", params.status);
+    if (params?.sort) qs.set("sort", params.sort);
+    if (params?.relatedTo) qs.set("relatedTo", params.relatedTo);
+    if (params?.limit) qs.set("limit", String(params.limit));
+    if (params?.cursor) qs.set("cursor", params.cursor);
+    const q = qs.toString();
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content${q ? `?${q}` : ""}`
+    );
+  }
+  async createContent(host, params) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+  }
+  async getContent(host, contentId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}`
+    );
+  }
+  async deleteContent(host, contentId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}`,
+      { method: "DELETE" }
+    );
+  }
+  async saveDraft(host, contentId, draft) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/draft`,
+      { method: "PUT", body: JSON.stringify(draft) }
+    );
+  }
+  async publishContent(host, contentId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/publish`,
+      { method: "POST" }
+    );
+  }
+  async unpublishContent(host, contentId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/unpublish`,
+      { method: "POST" }
+    );
+  }
+  async discardDraft(host, contentId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/discard`,
+      { method: "POST" }
+    );
+  }
+  async getPublishedContent(host, contentId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/published`
+    );
+  }
+  async listVersions(host, contentId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/versions`
+    );
+  }
+  async getVersion(host, contentId, blockId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/versions/${blockId}`
+    );
+  }
+  async getReferences(host, contentId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/content/${contentId}/references`
+    );
+  }
+  // ── Media ──────────────────────────────────────────
+  async listMedia(host, params) {
+    const qs = new URLSearchParams();
+    if (params?.tag) qs.set("tag", params.tag);
+    if (params?.folderId) qs.set("folderId", params.folderId);
+    if (params?.q) qs.set("q", params.q);
+    if (params?.sort) qs.set("sort", params.sort);
+    if (params?.limit) qs.set("limit", String(params.limit));
+    if (params?.cursor) qs.set("cursor", params.cursor);
+    const q = qs.toString();
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media${q ? `?${q}` : ""}`
+    );
+  }
+  async getMedia(host, mediaId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}`
+    );
+  }
+  async updateMedia(host, mediaId, data) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}`,
+      { method: "PUT", body: JSON.stringify(data) }
+    );
+  }
+  async deleteMedia(host, mediaId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}`,
+      { method: "DELETE" }
+    );
+  }
+  async getUploadUrl(host, params) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/upload-url`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+  }
+  async completeUpload(host, mediaId, params) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}/complete`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+  }
+  /**
+   * Convenience: download from URL and upload through the media pipeline.
+   * Works in both Node.js and browsers (uses fetch + Uint8Array, no Node APIs).
+   */
+  async uploadFromUrl(host, url, filename, alt) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status}`);
+    const buffer = new Uint8Array(await res.arrayBuffer());
+    let contentType = res.headers.get("content-type")?.split(";")[0]?.trim() || "";
+    if (!contentType || contentType === "application/octet-stream") {
+      contentType = mimeFromFilename(filename);
+    }
+    const { mediaId, uploadUrl } = await this.getUploadUrl(host, {
+      filename,
+      contentType,
+      size: buffer.length
+    });
+    const uploadRes = await fetch(uploadUrl, {
+      method: "PUT",
+      body: buffer,
+      headers: { "Content-Type": contentType }
+    });
+    if (!uploadRes.ok)
+      throw new Error(`S3 upload failed: ${uploadRes.status}`);
+    return this.completeUpload(host, mediaId, { filename, alt });
+  }
+  // Media folders
+  async listMediaFolders(host) {
+    const res = await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/folders`
+    );
+    return res.items;
+  }
+  async createMediaFolder(host, name) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/folders`,
+      { method: "POST", body: JSON.stringify({ name }) }
+    );
+  }
+  async updateMediaFolder(host, folderId, name) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/folders/${folderId}`,
+      { method: "PUT", body: JSON.stringify({ name }) }
+    );
+  }
+  async deleteMediaFolder(host, folderId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/folders/${folderId}`,
+      { method: "DELETE" }
+    );
+  }
+  async bulkMediaOperation(host, params) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/bulk`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+  }
+  async checkDuplicate(host, filename, size) {
+    const qs = new URLSearchParams({ filename, size: String(size) });
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/check-duplicate?${qs}`
+    );
+  }
+  async getTransformUrl(host, mediaId, params) {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0) qs.set(k, String(v));
+    }
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}/transform-url?${qs}`
+    );
+  }
+  async saveTransform(host, mediaId, params) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}/save-transform`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+  }
+  async getMediaUsage(host, mediaId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/media/${mediaId}/usage`
+    );
+  }
+  // ── API Keys ───────────────────────────────────────
+  async listApiKeys(host) {
+    const res = await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/api-keys`
+    );
+    return res.keys;
+  }
+  async createApiKey(host, label) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/api-keys`,
+      { method: "POST", body: JSON.stringify({ label }) }
+    );
+  }
+  async updateApiKey(host, keyId, label) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/api-keys/${keyId}`,
+      { method: "PUT", body: JSON.stringify({ label }) }
+    );
+  }
+  async deleteApiKey(host, keyId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/api-keys/${keyId}`,
+      { method: "DELETE" }
+    );
+  }
+  // ── Webhooks ───────────────────────────────────────
+  async listWebhooks(host) {
+    const res = await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks`
+    );
+    return res.webhooks;
+  }
+  async createWebhook(host, data) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks`,
+      { method: "POST", body: JSON.stringify(data) }
+    );
+  }
+  async getWebhook(host, webhookId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}`
+    );
+  }
+  async updateWebhook(host, webhookId, data) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}`,
+      { method: "PUT", body: JSON.stringify(data) }
+    );
+  }
+  async deleteWebhook(host, webhookId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}`,
+      { method: "DELETE" }
+    );
+  }
+  async testWebhook(host, webhookId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}/test`,
+      { method: "POST" }
+    );
+  }
+  async rotateWebhookSecret(host, webhookId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}/rotate-secret`,
+      { method: "POST" }
+    );
+  }
+  async listWebhookDeliveries(host, webhookId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}/deliveries`
+    );
+  }
+  async getWebhookDelivery(host, webhookId, deliveryId) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}/deliveries/${deliveryId}`
+    );
+  }
+  async retryDelivery(host, webhookId, deliveryId) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/webhooks/${webhookId}/deliveries/${deliveryId}/retry`,
+      { method: "POST" }
+    );
+  }
+  // ── Tags ───────────────────────────────────────────
+  async listTags(host) {
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/tags`
+    );
+  }
+  async createTag(host, tag) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/tags`,
+      { method: "POST", body: JSON.stringify({ tag }) }
+    );
+  }
+  async deleteTag(host, tag) {
+    await this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/tags/${encodeURIComponent(tag)}`,
+      { method: "DELETE" }
+    );
+  }
+  // ── Audit ──────────────────────────────────────────
+  async listAuditEvents(host, params) {
+    const qs = new URLSearchParams();
+    if (params?.action) qs.set("action", params.action);
+    if (params?.before) qs.set("before", String(params.before));
+    const q = qs.toString();
+    return this.apiFetch(
+      `/v1/admin/sites/${encodeURIComponent(host)}/audit${q ? `?${q}` : ""}`
+    );
+  }
+  // ── Users (global, not site-scoped) ────────────────
+  async listUsers() {
+    return this.apiFetch("/v1/admin/users");
+  }
+  async deleteUser(sub) {
+    await this.apiFetch(`/v1/admin/users/${sub}`, {
+      method: "DELETE"
+    });
+  }
+  async disableUserMfa(sub) {
+    await this.apiFetch(`/v1/admin/users/${sub}/mfa`, {
+      method: "DELETE"
+    });
+  }
+  async resolveAdmins(subs) {
+    return this.apiFetch("/v1/admin/users/resolve", {
+      method: "POST",
+      body: JSON.stringify({ subs })
+    });
+  }
+  async listSuperAdmins() {
+    return this.apiFetch("/v1/admin/super-admins");
+  }
+  async updateSuperAdmins(superAdminIds) {
+    await this.apiFetch("/v1/admin/super-admins", {
+      method: "PUT",
+      body: JSON.stringify({ superAdminIds })
+    });
+  }
+};
+
+// src/token-provider.ts
+var StaticTokenProvider = class {
+  constructor(token) {
+    this.token = token;
+  }
+  async getToken() {
+    return this.token;
+  }
+};
+
+// src/blocks.ts
+function text(t, styles) {
+  return { type: "text", text: t, styles: styles || {} };
+}
+function link(href, label) {
+  return { type: "link", href, content: [text(label)] };
+}
+function block(type, content, props, children) {
+  return {
+    id: crypto.randomUUID().slice(0, 8),
+    type,
+    props: { textAlignment: "left", ...props },
+    content: content || [],
+    children: children || []
+  };
+}
+function heading(level, ...content) {
+  return block("heading", content, { level });
+}
+function paragraph(...content) {
+  return block("paragraph", content);
+}
+function bulletItem(...content) {
+  return block("bulletListItem", content);
+}
+function numberedItem(...content) {
+  return block("numberedListItem", content);
+}
+function checkItem(checked, ...content) {
+  return block("checkListItem", content, { checked });
+}
+function codeBlock(language, code) {
+  return block("codeBlock", [text(code)], { language });
+}
+function image(props) {
+  return block("image", void 0, {
+    ...props,
+    textAlignment: "center"
+  });
+}
+export {
+  HeadroomAdminClient,
+  HeadroomApiError,
+  StaticTokenProvider,
+  block,
+  bulletItem,
+  checkItem,
+  codeBlock,
+  heading,
+  image,
+  link,
+  numberedItem,
+  paragraph,
+  text
+};

package/dist/node.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  uploadFile: () => uploadFile
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/mime.ts
+var MIME_MAP = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf"
+};
+function mimeFromFilename(filename) {
+  const ext = filename.includes(".") ? "." + filename.split(".").pop().toLowerCase() : "";
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+
+// src/node.ts
+async function uploadFile(client, host, filePath, alt) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const data = await fs.readFile(filePath);
+  const filename = path.basename(filePath);
+  const contentType = mimeFromFilename(filename);
+  const { mediaId, uploadUrl } = await client.getUploadUrl(host, {
+    filename,
+    contentType,
+    size: data.length
+  });
+  const uploadRes = await fetch(uploadUrl, {
+    method: "PUT",
+    body: data,
+    headers: { "Content-Type": contentType }
+  });
+  if (!uploadRes.ok) {
+    throw new Error(`S3 upload failed: ${uploadRes.status}`);
+  }
+  return client.completeUpload(host, mediaId, { filename, alt });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uploadFile
+});