@timbenniks/contentstack-platform-sdk 0.1.0

package/dist/knowledge-vault/index.d.ts

@@ -0,0 +1,49 @@
+import { H as HttpClientConfig } from '../types-DgixK-ll.js';
+import { ContentstackRegion } from '../regions/index.js';
+import { C as ContentstackHttpClient } from '../client-DwVGVSQz.js';
+
+interface KnowledgeVaultItem {
+    uid: string;
+    status: "processing" | "ready" | "failed";
+    created_at: string;
+    updated_at: string;
+}
+interface KnowledgeVaultUsage {
+    total_items: number;
+    storage_used: number;
+}
+interface IngestContentData {
+    content: string;
+}
+interface UpdateContentData {
+    content: string;
+}
+
+declare class KnowledgeVaultItemsClient {
+    private readonly http;
+    constructor(http: ContentstackHttpClient);
+    ingest(data: IngestContentData): Promise<KnowledgeVaultItem>;
+    update(itemUid: string, data: UpdateContentData): Promise<KnowledgeVaultItem>;
+    delete(itemUid: string): Promise<void>;
+    getUsage(): Promise<KnowledgeVaultUsage>;
+}
+
+interface KnowledgeVaultClientConfig {
+    region: ContentstackRegion;
+    organizationUid: string;
+    brandKitUid: string;
+    auth: {
+        type: "oauth";
+        accessToken: string;
+    } | {
+        type: "authtoken";
+        token: string;
+    };
+    httpOptions?: Partial<HttpClientConfig>;
+}
+interface KnowledgeVaultClient {
+    items: KnowledgeVaultItemsClient;
+}
+declare function createKnowledgeVaultClient(config: KnowledgeVaultClientConfig): KnowledgeVaultClient;
+
+export { type IngestContentData, type KnowledgeVaultClient, type KnowledgeVaultClientConfig, type KnowledgeVaultItem, type KnowledgeVaultUsage, type UpdateContentData, createKnowledgeVaultClient };

package/dist/knowledge-vault/index.mjs

@@ -0,0 +1,10 @@
+import {
+  createKnowledgeVaultClient
+} from "../chunk-3KE63N3I.mjs";
+import "../chunk-4CJ4IVPJ.mjs";
+import "../chunk-BK2IBTQS.mjs";
+import "../chunk-DMERADWM.mjs";
+export {
+  createKnowledgeVaultClient
+};
+//# sourceMappingURL=index.mjs.map

package/dist/knowledge-vault/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/launch/index.cjs

@@ -0,0 +1,624 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/launch/index.ts
+var launch_exports = {};
+__export(launch_exports, {
+  createLaunchClient: () => createLaunchClient
+});
+module.exports = __toCommonJS(launch_exports);
+
+// src/http/errors.ts
+var ContentstackError = class extends Error {
+  name = "ContentstackError";
+  status;
+  errorCode;
+  errors;
+  requestPath;
+  constructor(message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.status = options?.status;
+    this.errorCode = options?.errorCode;
+    this.errors = options?.errors;
+    this.requestPath = options?.requestPath;
+  }
+};
+var ContentstackAuthError = class extends ContentstackError {
+  name = "ContentstackAuthError";
+  status = 401;
+};
+var ContentstackForbiddenError = class extends ContentstackError {
+  name = "ContentstackForbiddenError";
+  status = 403;
+};
+var ContentstackNotFoundError = class extends ContentstackError {
+  name = "ContentstackNotFoundError";
+  status = 404;
+};
+var ContentstackValidationError = class extends ContentstackError {
+  name = "ContentstackValidationError";
+  status;
+  constructor(message, options) {
+    super(message, options);
+    this.status = options?.status ?? 400;
+  }
+};
+var ContentstackInvalidApiKeyError = class extends ContentstackError {
+  name = "ContentstackInvalidApiKeyError";
+  status = 412;
+};
+var ContentstackRateLimitError = class extends ContentstackError {
+  name = "ContentstackRateLimitError";
+  status = 429;
+  retryAfter;
+  constructor(message, options) {
+    super(message, { ...options, status: 429 });
+    this.retryAfter = options?.retryAfter;
+  }
+};
+var ContentstackServerError = class extends ContentstackError {
+  name = "ContentstackServerError";
+};
+
+// src/http/client.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRY_LIMIT = 5;
+var DEFAULT_RETRY_DELAY = 300;
+var MAX_JITTER = 100;
+var ContentstackHttpClient = class _ContentstackHttpClient {
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      headers: config.headers ?? {},
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      retryOnError: config.retryOnError ?? true,
+      retryLimit: config.retryLimit ?? DEFAULT_RETRY_LIMIT,
+      retryDelay: config.retryDelay ?? DEFAULT_RETRY_DELAY,
+      fetch: config.fetch ?? globalThis.fetch.bind(globalThis)
+    };
+  }
+  async get(path, params) {
+    let url = `${this.config.baseUrl}${path}`;
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      url += `?${searchParams.toString()}`;
+    }
+    return this.request(url, { method: "GET" }, path);
+  }
+  async post(path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      },
+      path
+    );
+  }
+  async put(path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      },
+      path
+    );
+  }
+  async patch(path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      },
+      path
+    );
+  }
+  async delete(path) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(url, { method: "DELETE" }, path);
+  }
+  async postForm(path, params) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: params.toString()
+      },
+      path
+    );
+  }
+  async upload(path, form) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(url, { method: "POST", body: form }, path);
+  }
+  /** Return a new client with additional headers merged */
+  withHeaders(headers) {
+    return new _ContentstackHttpClient({
+      ...this.config,
+      headers: { ...this.config.headers, ...headers }
+    });
+  }
+  /** Return a new client with a different base URL */
+  withBaseUrl(baseUrl) {
+    return new _ContentstackHttpClient({
+      ...this.config,
+      baseUrl
+    });
+  }
+  async request(url, init, path) {
+    const headers = new Headers(this.config.headers);
+    if (init.headers) {
+      const initHeaders = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+      initHeaders.forEach((value, key) => headers.set(key, value));
+    }
+    let lastError;
+    const maxAttempts = this.config.retryOnError ? this.config.retryLimit + 1 : 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      try {
+        const response = await this.config.fetch(url, {
+          ...init,
+          headers,
+          signal: controller.signal
+        });
+        if (response.ok) {
+          const data = await response.json().catch(() => ({}));
+          return { data, status: response.status, headers: response.headers };
+        }
+        const isRetryable = response.status === 429 || response.status >= 500;
+        if (isRetryable && this.config.retryOnError && attempt < maxAttempts - 1) {
+          const delay = this.calculateDelay(response, attempt);
+          await sleep(delay);
+          lastError = await this.createError(response, path);
+          continue;
+        }
+        throw await this.createError(response, path);
+      } catch (error) {
+        if (error instanceof ContentstackError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw new ContentstackError(`Request timed out after ${this.config.timeout}ms`, {
+            requestPath: path,
+            cause: error
+          });
+        }
+        throw new ContentstackError("Network request failed", {
+          requestPath: path,
+          cause: error instanceof Error ? error : new Error(String(error))
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    throw lastError ?? new ContentstackError("Request failed after retries", { requestPath: path });
+  }
+  calculateDelay(response, attempt) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+      const seconds = Number.parseFloat(retryAfter);
+      if (!Number.isNaN(seconds)) {
+        return seconds * 1e3;
+      }
+    }
+    const jitter = Math.random() * MAX_JITTER;
+    return this.config.retryDelay * 2 ** attempt + jitter;
+  }
+  async createError(response, path) {
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const message = body.error_message ?? body.error_description ?? body.message ?? `HTTP ${response.status} error`;
+    const errorCode = body.error_code;
+    const errors = body.errors;
+    const retryAfter = response.headers.get("Retry-After");
+    const opts = { status: response.status, errorCode, errors, requestPath: path };
+    switch (response.status) {
+      case 400:
+        return new ContentstackValidationError(message, { ...opts, status: 400 });
+      case 401:
+        return new ContentstackAuthError(message, opts);
+      case 403:
+        return new ContentstackForbiddenError(message, opts);
+      case 404:
+        return new ContentstackNotFoundError(message, opts);
+      case 412:
+        return new ContentstackInvalidApiKeyError(message, opts);
+      case 422:
+        return new ContentstackValidationError(message, { ...opts, status: 422 });
+      case 429:
+        return new ContentstackRateLimitError(message, {
+          ...opts,
+          retryAfter: retryAfter ? Number.parseFloat(retryAfter) : void 0
+        });
+      default:
+        if (response.status >= 500) {
+          return new ContentstackServerError(message, opts);
+        }
+        return new ContentstackError(message, opts);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/regions/endpoints.ts
+var import_contentstack_endpoints = require("@timbenniks/contentstack-endpoints");
+var BRAND_KIT_URLS = {
+  us: {
+    brandKit: "https://brand-kits-api.contentstack.com",
+    brandKitAI: "https://ai.contentstack.com/brand-kits"
+  },
+  eu: {
+    brandKit: "https://eu-brand-kits-api.contentstack.com",
+    brandKitAI: "https://eu-ai.contentstack.com/brand-kits"
+  },
+  au: {
+    brandKit: "https://au-brand-kits-api.contentstack.com",
+    brandKitAI: "https://au-ai.contentstack.com/brand-kits"
+  },
+  "azure-na": {
+    brandKit: "https://azure-na-brand-kits-api.contentstack.com",
+    brandKitAI: "https://azure-na-ai.contentstack.com/brand-kits"
+  },
+  "azure-eu": {
+    brandKit: "https://azure-eu-brand-kits-api.contentstack.com",
+    brandKitAI: "https://azure-eu-ai.contentstack.com/brand-kits"
+  },
+  "gcp-na": {
+    brandKit: "https://gcp-na-brand-kits-api.contentstack.com",
+    brandKitAI: "https://gcp-na-ai.contentstack.com/brand-kits"
+  },
+  "gcp-eu": {
+    brandKit: "https://gcp-eu-brand-kits-api.contentstack.com",
+    brandKitAI: "https://gcp-eu-ai.contentstack.com/brand-kits"
+  }
+};
+function mapEndpoints(upstream, region, hostsOnly) {
+  const bk = BRAND_KIT_URLS[region];
+  const stripProtocol = (url) => url.replace(/^https?:\/\//, "");
+  return Object.freeze({
+    cma: upstream.contentManagement ?? "",
+    cda: upstream.contentDelivery ?? "",
+    graphql: upstream.graphqlDelivery ?? "",
+    images: upstream.images ?? "",
+    app: upstream.application ?? "",
+    preview: upstream.preview ?? "",
+    graphqlPreview: upstream.graphqlPreview ?? "",
+    launch: upstream.launch ?? "",
+    personalizeEdge: upstream.personalizeEdge ?? "",
+    brandKit: hostsOnly ? stripProtocol(bk.brandKit) : bk.brandKit,
+    brandKitAI: hostsOnly ? stripProtocol(bk.brandKitAI) : bk.brandKitAI
+  });
+}
+var ALL_REGIONS = [
+  "us",
+  "eu",
+  "au",
+  "azure-na",
+  "azure-eu",
+  "gcp-na",
+  "gcp-eu"
+];
+function buildEndpointMap() {
+  const map = {};
+  for (const region of ALL_REGIONS) {
+    map[region] = mapEndpoints((0, import_contentstack_endpoints.getContentstackEndpoints)(region), region, false);
+  }
+  return Object.freeze(map);
+}
+function buildHostMap() {
+  const map = {};
+  for (const region of ALL_REGIONS) {
+    map[region] = mapEndpoints((0, import_contentstack_endpoints.getContentstackEndpoints)(region, true), region, true);
+  }
+  return Object.freeze(map);
+}
+var ENDPOINT_MAP = buildEndpointMap();
+var HOST_MAP = buildHostMap();
+
+// src/regions/resolver.ts
+var VALID_REGIONS = new Set(Object.keys(ENDPOINT_MAP));
+function resolveEndpoints(region) {
+  return ENDPOINT_MAP[region];
+}
+
+// src/cma/pagination.ts
+var DEFAULT_PAGE_SIZE = 25;
+function paginate(fetchPage, options) {
+  const pageSize = options?.limit ?? DEFAULT_PAGE_SIZE;
+  return {
+    [Symbol.asyncIterator]() {
+      let skip = 0;
+      let done = false;
+      let buffer = [];
+      let bufferIndex = 0;
+      let totalCount;
+      return {
+        async next() {
+          if (bufferIndex < buffer.length) {
+            return { value: buffer[bufferIndex++], done: false };
+          }
+          if (done) {
+            return { value: void 0, done: true };
+          }
+          const page = await fetchPage(skip, pageSize);
+          buffer = page.items;
+          bufferIndex = 0;
+          skip += page.items.length;
+          if (typeof page.count === "number") {
+            totalCount = page.count;
+          }
+          if (page.items.length === 0) {
+            done = true;
+            return { value: void 0, done: true };
+          }
+          if (typeof totalCount === "number" && skip >= totalCount) {
+            done = true;
+          }
+          return { value: buffer[bufferIndex++], done: false };
+        }
+      };
+    }
+  };
+}
+async function collectAll(iterable) {
+  const items = [];
+  for await (const item of iterable) {
+    items.push(item);
+  }
+  return items;
+}
+
+// src/launch/response.ts
+function extractList(body, key) {
+  if (Array.isArray(body)) {
+    return { items: body };
+  }
+  if (body && typeof body === "object") {
+    const obj = body;
+    if (key in obj && Array.isArray(obj[key])) {
+      const pagination = obj.pagination;
+      return { items: obj[key], count: pagination?.count };
+    }
+    if ("data" in obj && Array.isArray(obj.data)) {
+      return { items: obj.data, count: obj.count };
+    }
+  }
+  return { items: [] };
+}
+function extractItem(body) {
+  if (body && typeof body === "object" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+
+// src/launch/deployments.ts
+var DeploymentsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  basePath(projectUid, environmentUid) {
+    return `/projects/${projectUid}/environments/${environmentUid}/deployments`;
+  }
+  list(projectUid, environmentUid, options) {
+    return paginate(
+      async (skip, limit) => {
+        const params = {
+          skip: String(skip),
+          limit: String(limit)
+        };
+        const response = await this.http.get(
+          this.basePath(projectUid, environmentUid),
+          params
+        );
+        return extractList(response.data, "deployments");
+      },
+      { limit: options?.limit }
+    );
+  }
+  async listAll(projectUid, environmentUid, options) {
+    return collectAll(this.list(projectUid, environmentUid, options));
+  }
+  async get(projectUid, environmentUid, deploymentUid) {
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}`
+    );
+    return extractItem(response.data);
+  }
+  async create(projectUid, environmentUid, data) {
+    const response = await this.http.post(this.basePath(projectUid, environmentUid), data);
+    return extractItem(response.data);
+  }
+  async getDeploymentLogs(projectUid, environmentUid, deploymentUid, options) {
+    const params = {};
+    if (options?.timestamp) params.timestamp = options.timestamp;
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}/logs/deployment-logs`,
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return extractList(response.data, "logs").items;
+  }
+  async getServerLogs(projectUid, environmentUid, deploymentUid, options) {
+    const params = {};
+    if (options?.startTime !== void 0) params.startTime = String(options.startTime);
+    if (options?.endTime !== void 0) params.endTime = String(options.endTime);
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}/logs/server-logs`,
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return extractList(response.data, "logs").items;
+  }
+  async getUploadUrl(projectUid, environmentUid) {
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/upload/signed_url`
+    );
+    return extractItem(response.data);
+  }
+  async getDownloadUrl(projectUid, environmentUid, deploymentUid) {
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}/download/signed_url`
+    );
+    const item = extractItem(response.data);
+    return item.downloadUrl;
+  }
+};
+
+// src/launch/environments.ts
+var EnvironmentsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(projectUid) {
+    return paginate(async (skip, limit) => {
+      const response = await this.http.get(`/projects/${projectUid}/environments`, {
+        skip: String(skip),
+        limit: String(limit)
+      });
+      return extractList(response.data, "environments");
+    });
+  }
+  async listAll(projectUid) {
+    return collectAll(this.list(projectUid));
+  }
+  async get(projectUid, envUid) {
+    const response = await this.http.get(`/projects/${projectUid}/environments/${envUid}`);
+    return extractItem(response.data);
+  }
+  async create(projectUid, data) {
+    const response = await this.http.post(`/projects/${projectUid}/environments`, data);
+    return extractItem(response.data);
+  }
+  async update(projectUid, envUid, data) {
+    const response = await this.http.put(
+      `/projects/${projectUid}/environments/${envUid}`,
+      data
+    );
+    return extractItem(response.data);
+  }
+  async delete(projectUid, envUid) {
+    await this.http.delete(`/projects/${projectUid}/environments/${envUid}`);
+  }
+  async revalidateCDNCache(projectUid, envUid, data) {
+    await this.http.post(
+      `/projects/${projectUid}/environments/${envUid}/revalidate-cdn-cache`,
+      data
+    );
+  }
+  async getUploadUrl(projectUid) {
+    const response = await this.http.get(
+      `/projects/${projectUid}/environments/upload/signed_url`
+    );
+    return extractItem(response.data);
+  }
+};
+
+// src/launch/projects.ts
+var ProjectsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(options) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get("/projects", {
+          skip: String(skip),
+          limit: String(limit)
+        });
+        return extractList(response.data, "projects");
+      },
+      { limit: options?.limit }
+    );
+  }
+  async listAll(options) {
+    return collectAll(this.list(options));
+  }
+  async get(projectUid) {
+    const response = await this.http.get(`/projects/${projectUid}`);
+    return extractItem(response.data);
+  }
+  async create(data) {
+    const response = await this.http.post("/projects", data);
+    return extractItem(response.data);
+  }
+  async update(projectUid, data) {
+    const response = await this.http.put(`/projects/${projectUid}`, data);
+    return extractItem(response.data);
+  }
+  async delete(projectUid) {
+    await this.http.delete(`/projects/${projectUid}`);
+  }
+  async transferGitRepository(projectUid, data) {
+    await this.http.patch(`/projects/${projectUid}/git-repository`, data);
+  }
+  async getUploadUrl() {
+    const response = await this.http.get("/projects/upload/signed_url");
+    return extractItem(response.data);
+  }
+};
+
+// src/launch/client.ts
+function createLaunchClient(config) {
+  const endpoints = resolveEndpoints(config.region);
+  const headers = {
+    organization_uid: config.organizationUid
+  };
+  switch (config.auth.type) {
+    case "oauth":
+      headers.authorization = `Bearer ${config.auth.accessToken}`;
+      break;
+    case "authtoken":
+      headers.authtoken = config.auth.token;
+      break;
+  }
+  const http = new ContentstackHttpClient({
+    ...config.httpOptions,
+    baseUrl: config.httpOptions?.baseUrl ?? endpoints.launch,
+    headers: {
+      ...config.httpOptions?.headers,
+      ...headers
+    }
+  });
+  return {
+    projects: new ProjectsClient(http),
+    environments: new EnvironmentsClient(http),
+    deployments: new DeploymentsClient(http)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLaunchClient
+});
+//# sourceMappingURL=index.cjs.map