@syntaxcircus/cmsify-client 0.0.0-bootstrap.0

package/dist/index.js

@@ -0,0 +1,286 @@
+// src/etag.ts
+var ETagStore = class {
+  values = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.values.get(key);
+  }
+  set(key, etag) {
+    if (etag) {
+      this.values.set(key, etag);
+    }
+  }
+};
+
+// src/errors.ts
+var CmsifyApiError = class extends Error {
+  problem;
+  status;
+  traceId;
+  correlationId;
+  constructor(problem, correlationId) {
+    super(problem.detail ?? problem.title ?? `Cmsify API request failed with ${problem.status ?? "unknown status"}`);
+    this.name = "CmsifyApiError";
+    this.problem = problem;
+    this.status = problem.status ?? 0;
+    this.traceId = typeof problem.traceId === "string" ? problem.traceId : void 0;
+    this.correlationId = correlationId;
+  }
+};
+var CmsifyTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Cmsify API request exceeded its ${timeoutMs}ms timeout budget.`);
+    this.name = "CmsifyTimeoutError";
+  }
+};
+var isProblemDetails = (value) => typeof value === "object" && value !== null && ("status" in value || "title" in value || "type" in value);
+
+// src/pagination.ts
+async function* listAll(loader) {
+  for (let page = 1; ; page += 1) {
+    const result = await loader(page);
+    for (const item of result.items) {
+      yield item;
+    }
+    if (page >= result.totalPages || result.items.length === 0) {
+      return;
+    }
+  }
+}
+
+// src/client.ts
+var CmsifyClient = class {
+  content = {
+    list: (options = {}) => this.request(this.workspacePath("/content", contentQuery(options, true))),
+    listAll: (options = {}) => listAll((page) => this.content.list({ ...options, page })),
+    get: (id, options = {}) => this.request(this.workspacePath(`/content/${encodeURIComponent(id)}`, detailQuery(options))),
+    bySlug: (slug, options = {}) => this.request(this.workspacePath(`/content/by-slug/${encodeURIComponent(slug)}`, detailQuery(options, false))),
+    translations: (id, options = {}) => this.request(this.workspacePath(`/content/${encodeURIComponent(id)}/translations`, pageQuery(options)))
+  };
+  templates = {
+    list: (options = {}) => this.request(this.workspacePath("/templates", pageQuery(options))),
+    get: (id) => this.request(this.workspacePath(`/templates/${encodeURIComponent(id)}`))
+  };
+  media = {
+    list: (options = {}) => this.request(this.workspacePath("/media", pageQuery(options))),
+    get: (id) => this.request(this.workspacePath(`/media/${encodeURIComponent(id)}`)),
+    download: (id) => this.request(this.workspacePath(`/media/${encodeURIComponent(id)}/file`), {}, {}, "blob")
+  };
+  baseUrl;
+  baseOrigin;
+  workspaceId;
+  token;
+  fetchImpl;
+  retryByDefault;
+  timeoutMs;
+  now;
+  delay;
+  etags = new ETagStore();
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.baseOrigin = new URL(this.baseUrl).origin;
+    this.workspaceId = options.workspaceId;
+    this.token = options.apiToken;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.retryByDefault = options.retry !== false;
+    this.timeoutMs = options.timeoutMs;
+    this.now = options.now ?? Date.now;
+    this.delay = options.delay ?? delay;
+  }
+  async request(path, init = {}, options = {}, responseType = "json") {
+    const url = this.requestUrl(path);
+    const headers = new Headers(init.headers);
+    headers.set("Accept", responseType === "blob" ? "*/*" : "application/json");
+    headers.set("X-Correlation-Id", createCorrelationId());
+    if (this.token) headers.set("Authorization", `Bearer ${this.token}`);
+    if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+    if (options.idempotencyKey) headers.set("Idempotency-Key", options.idempotencyKey);
+    const method = (init.method ?? "GET").toUpperCase();
+    const trackedEtag = options.ifMatch ?? this.etags.get(url);
+    if (trackedEtag && isMutation(method)) headers.set("If-Match", trackedEtag);
+    const retry = (options.retry ?? this.retryByDefault) && (isIdempotent(method) || Boolean(options.idempotencyKey)) && isReplayableBody(init.body);
+    const response = await this.fetchWithRetry(url, { ...init, headers }, retry, options.signal, options.timeoutMs ?? this.timeoutMs);
+    this.etags.set(url, response.headers.get("ETag"));
+    if (!response.ok) {
+      const correlationId = response.headers.get("X-Correlation-Id") ?? headers.get("X-Correlation-Id") ?? void 0;
+      const body = await this.safeReadJson(response);
+      const problem = isProblemDetails(body) ? { ...body, status: response.status } : { status: response.status, title: response.statusText };
+      throw new CmsifyApiError(problem, correlationId);
+    }
+    if (hasEmptySuccessBody(response)) return void 0;
+    if (responseType === "blob") return await response.blob();
+    return await this.safeReadJson(response);
+  }
+  workspacePath(path, query) {
+    if (!isGuid(this.workspaceId)) throw new Error("workspaceId must be a GUID.");
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(query ?? {})) if (value !== void 0) search.set(key, String(value));
+    const suffix = search.size > 0 ? `?${search}` : "";
+    return `/api/v1/workspaces/${encodeURIComponent(this.workspaceId)}${path}${suffix}`;
+  }
+  requestUrl(path) {
+    const url = new URL(path, `${this.baseUrl}/`);
+    if (url.origin !== this.baseOrigin) throw new Error("CmsifyClient requests must target the configured Cmsify origin.");
+    return url.toString();
+  }
+  async fetchWithRetry(url, init, retry, callerSignal, timeoutMs) {
+    const deadline = timeoutMs === void 0 ? void 0 : this.now() + Math.max(0, timeoutMs);
+    for (let attempt = 1; ; attempt += 1) {
+      const controller = new AbortController();
+      const timeout = timeoutMs === void 0 ? void 0 : Math.max(0, (deadline ?? this.now()) - this.now());
+      const cleanup = connectAbortSignals(controller, callerSignal, timeout, timeoutMs);
+      try {
+        const response = await this.fetchImpl(url, { ...init, signal: controller.signal });
+        if (!retry || attempt >= 3 || !isRetryableResponse(response)) return response;
+        await this.delay(retryDelay(response.headers.get("Retry-After"), attempt, this.now), controller.signal);
+      } catch (error) {
+        if (controller.signal.aborted) throw controller.signal.reason ?? error;
+        if (!retry || attempt >= 3 || !isTransportFault(error)) throw error;
+        await this.delay(100 * 2 ** (attempt - 1), controller.signal);
+      } finally {
+        cleanup();
+      }
+    }
+  }
+  async safeReadJson(response) {
+    const text = await response.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { status: response.status, title: response.statusText };
+    }
+  }
+};
+var contentQuery = (options, resolve) => ({
+  Q: options.q,
+  TemplateVersionId: options.templateVersionId,
+  TemplateId: options.templateId,
+  Status: options.status,
+  LocaleCode: options.localeCode,
+  TranslationGroupId: options.translationGroupId,
+  Slug: options.slug,
+  Tags: options.tags,
+  CreatedAfter: asIso(options.createdAfter),
+  CreatedBefore: asIso(options.createdBefore),
+  PublishedAfter: asIso(options.publishedAfter),
+  PublishedBefore: asIso(options.publishedBefore),
+  Resolve: resolve,
+  AsOf: asIso(options.asOf),
+  SortBy: options.sortBy,
+  SortDesc: options.sortDesc,
+  page: options.page,
+  pageSize: options.pageSize
+});
+var detailQuery = (options, resolve = true) => options.asOf === void 0 ? {} : { ...resolve ? { resolve: true } : {}, asOf: asIso(options.asOf) };
+var pageQuery = (options) => ({ page: options.page, pageSize: options.pageSize });
+var asIso = (value) => value instanceof Date ? value.toISOString() : value;
+var isGuid = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+var isIdempotent = (method) => ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method);
+var isMutation = (method) => !["GET", "HEAD", "OPTIONS"].includes(method);
+var isRetryableResponse = (response) => response.status === 429 || response.status >= 500;
+var isTransportFault = (error) => error instanceof TypeError || error instanceof Error && error.name === "NetworkError";
+var isReplayableBody = (body) => !(typeof ReadableStream !== "undefined" && body instanceof ReadableStream);
+var hasEmptySuccessBody = (response) => response.status === 204 || response.headers.get("Content-Length") === "0";
+var retryDelay = (header, attempt, now) => retryAfterDelay(header, now) ?? 100 * 2 ** (attempt - 1);
+var retryAfterDelay = (header, now) => {
+  if (header === null) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(header);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - now());
+};
+var connectAbortSignals = (controller, callerSignal, timeout, timeoutBudget) => {
+  const abortForCaller = () => controller.abort(callerSignal?.reason);
+  if (callerSignal?.aborted) abortForCaller();
+  else callerSignal?.addEventListener("abort", abortForCaller, { once: true });
+  const timer = timeout === void 0 ? void 0 : setTimeout(() => controller.abort(new CmsifyTimeoutError(timeoutBudget ?? timeout)), timeout);
+  return () => {
+    callerSignal?.removeEventListener("abort", abortForCaller);
+    if (timer !== void 0) clearTimeout(timer);
+  };
+};
+var delay = (milliseconds, signal) => new Promise((resolve, reject) => {
+  if (signal.aborted) {
+    reject(signal.reason);
+    return;
+  }
+  const timer = setTimeout(resolve, milliseconds);
+  signal.addEventListener("abort", () => {
+    clearTimeout(timer);
+    reject(signal.reason);
+  }, { once: true });
+});
+var createCorrelationId = () => globalThis.crypto?.randomUUID?.() ?? `cmsify-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+
+// src/formatting.ts
+var TEXT_FORMAT_HINTS = [
+  "plaintext",
+  "html",
+  "markdown",
+  "json",
+  "xml",
+  "yaml",
+  "csv",
+  "toml",
+  "sql",
+  "code",
+  "url",
+  "email",
+  "regex"
+];
+var MIME_BY_HINT = {
+  plaintext: "text/plain",
+  html: "text/html",
+  markdown: "text/markdown",
+  json: "application/json",
+  xml: "application/xml",
+  yaml: "application/yaml",
+  csv: "text/csv",
+  toml: "application/toml",
+  sql: "application/sql",
+  code: "text/plain",
+  url: "text/uri-list",
+  email: "text/plain",
+  regex: "text/plain"
+};
+function toMimeType(hint) {
+  if (hint && hint in MIME_BY_HINT) {
+    return MIME_BY_HINT[hint];
+  }
+  return "text/plain";
+}
+function getFormatHint(fieldConfig) {
+  if (!fieldConfig || typeof fieldConfig !== "object") {
+    return "plaintext";
+  }
+  const raw = fieldConfig.formatHint;
+  if (typeof raw !== "string") {
+    return "plaintext";
+  }
+  const normalized = raw.toLowerCase();
+  return TEXT_FORMAT_HINTS.includes(normalized) ? normalized : "plaintext";
+}
+function isProseHint(hint) {
+  return hint === "plaintext" || hint === "markdown" || hint === "html";
+}
+
+// src/generated/schema.ts
+var schema_exports = {};
+
+// src/generated/client.ts
+import createClient from "openapi-fetch";
+var createCmsifyFetchClient = (baseUrl, fetchImpl) => fetchImpl ? createClient({ baseUrl, fetch: fetchImpl }) : createClient({ baseUrl });
+export {
+  CmsifyApiError,
+  CmsifyClient,
+  CmsifyTimeoutError,
+  ETagStore,
+  TEXT_FORMAT_HINTS,
+  createCmsifyFetchClient,
+  schema_exports as generated,
+  getFormatHint,
+  isProseHint,
+  listAll,
+  toMimeType
+};
+//# sourceMappingURL=index.js.map