@bacano/sdk 1.1.10 → 1.1.13

package/content-management-types.d.ts

@@ -0,0 +1,260 @@
+export type ContentManagementTypeKind = "entry" | "component";
+export type ContentManagementTypeStatus = "draft" | "active" | "archived";
+export type ContentManagementTypeUsage = "website_content" | "product_additional" | "product_specification";
+export type ContentManagementScope = "content_types:manage" | "content_entries:manage" | "content_media:upload" | "content_entries:publish";
+export type ContentManagementFieldType = "boolean" | "component" | "date" | "link" | "measure" | "media" | "number" | "reference" | "repeater" | "rich_text" | "rich_text_full" | "select" | "slug" | "text" | "textarea";
+export interface ContentManagementChildFieldInput {
+    id?: string | null;
+    key: string;
+    label: string;
+    type: ContentManagementFieldType;
+    required?: boolean;
+    sortOrder: number;
+    settings?: Record<string, unknown>;
+    componentKey?: string | null;
+}
+export interface ContentManagementFieldInput extends ContentManagementChildFieldInput {
+    sectionKey?: string | null;
+    children?: ContentManagementChildFieldInput[];
+}
+export interface ContentManagementTypeInput {
+    key: string;
+    name: string;
+    description?: string;
+    kind: ContentManagementTypeKind;
+    status?: "draft" | "active";
+    settings?: Record<string, unknown>;
+    usages?: ContentManagementTypeUsage[];
+    sections?: Array<{
+        key: string;
+        title: string;
+        description?: string;
+        sortOrder: number;
+    }>;
+    specificationScopes?: Array<{
+        category?: string | null;
+        subcategoryId?: string | null;
+    }>;
+    deletedPaths?: string[];
+    confirmDestructiveChanges?: boolean;
+    fields?: ContentManagementFieldInput[];
+}
+export interface ContentManagementType extends Omit<ContentManagementTypeInput, "status"> {
+    id: string;
+    companyId: string;
+    description: string;
+    status: ContentManagementTypeStatus;
+    settings: Record<string, unknown>;
+    usages: ContentManagementTypeUsage[];
+    sections: Array<{
+        id: string;
+        key: string;
+        title: string;
+        description: string;
+        sortOrder: number;
+    }>;
+    specificationScopes: Array<{
+        id: string;
+        category: string | null;
+        subcategoryId: string | null;
+    }>;
+    fields: ContentManagementFieldInput[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ContentManagementContext {
+    companyId: string;
+    /** @deprecated Use scopes to inspect the complete grant. */
+    scope: "content_types:manage";
+    scopes: ContentManagementScope[];
+    expiresAt: string;
+}
+export type ContentManagementEntryStatus = "draft" | "published" | "archived";
+export interface ContentManagementEntryInput {
+    contentType: string;
+    key: string;
+    name: string;
+    locale?: string;
+    categoryKey?: string;
+    categoryName?: string;
+    status?: Exclude<ContentManagementEntryStatus, "archived">;
+    tagIds?: string[];
+    content?: Record<string, unknown>;
+    expectedUpdatedAt?: string;
+}
+export interface ContentManagementEntry {
+    id: string;
+    companyId: string;
+    contentType: {
+        id: string;
+        key: string;
+        name: string;
+    };
+    key: string;
+    name: string;
+    locale: string;
+    categoryKey: string;
+    status: ContentManagementEntryStatus;
+    tagIds: string[];
+    tags: string[];
+    content: Record<string, unknown>;
+    publishedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ContentManagementEntryListInput {
+    contentType?: string;
+    locale?: string;
+    status?: ContentManagementEntryStatus;
+    limit?: number;
+    offset?: number;
+}
+export interface ContentManagementEntryList {
+    entries: ContentManagementEntry[];
+    total: number;
+}
+export interface ContentManagementReferences {
+    categories: Array<{
+        code: string;
+        name: string;
+        subcategories: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
+    optionLists: Array<{
+        key: string;
+        name: string;
+        isExtensible: boolean;
+        options: Array<{
+            value: string;
+            label: string;
+        }>;
+    }>;
+    measureDimensions: Array<{
+        code: string;
+        name: string;
+        canonicalUnitCode: string;
+        units: Array<{
+            code: string;
+            name: string;
+            symbol: string;
+        }>;
+    }>;
+}
+export type ContentManagementGroupStatus = "active" | "inactive";
+export interface ContentManagementGroupInput {
+    key: string;
+    name: string;
+    description?: string;
+    sortOrder?: number;
+    status?: ContentManagementGroupStatus;
+}
+export interface ContentManagementGroup {
+    id: string;
+    companyId: string;
+    key: string;
+    name: string;
+    description: string;
+    sortOrder: number;
+    status: ContentManagementGroupStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+export type ContentManagementOptionListStatus = "draft" | "active" | "archived";
+export interface ContentManagementOptionListItemInput {
+    id?: string | null;
+    value: string;
+    label: string;
+    parentItemId?: string | null;
+    sortOrder: number;
+    isActive?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ContentManagementOptionListInput {
+    key: string;
+    name: string;
+    description?: string;
+    status?: Exclude<ContentManagementOptionListStatus, "archived">;
+    parentListId?: string | null;
+    isExtensible?: boolean;
+    confirmDestructiveChanges?: boolean;
+    items?: ContentManagementOptionListItemInput[];
+}
+export interface ContentManagementOptionListItem {
+    id: string;
+    value: string;
+    label: string;
+    parentItemId: string | null;
+    sortOrder: number;
+    isActive: boolean;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ContentManagementOptionList {
+    id: string;
+    companyId: string;
+    key: string;
+    name: string;
+    description: string;
+    status: ContentManagementOptionListStatus;
+    parentListId: string | null;
+    isExtensible: boolean;
+    items: ContentManagementOptionListItem[];
+    createdAt: string;
+    updatedAt: string;
+}
+export type ContentManagementLifecycleOperation = "archive" | "restore" | "delete";
+export interface ContentManagementLifecycleResult {
+    success: boolean;
+    allowed: boolean;
+    applied: boolean;
+    entity_id: string | null;
+    entity_type: "type" | "component" | "entry" | "group" | "option_list" | null;
+    operation: ContentManagementLifecycleOperation | null;
+    name: string | null;
+    status: string | null;
+    dependencies: Array<{
+        code: string;
+        label: string;
+        count: number;
+        blocking: boolean;
+    }>;
+    message: string | null;
+    errors: string[];
+}
+export type ContentManagementAccessTokenProvider = () => string | Promise<string>;
+export interface ContentManagementClientConfig {
+    apiUrl: string;
+    accessToken: string | ContentManagementAccessTokenProvider;
+    fetch?: typeof fetch;
+}
+export interface ContentManagementClient {
+    getContext(): Promise<ContentManagementContext>;
+    getReferences(): Promise<ContentManagementReferences>;
+    listTypes(): Promise<ContentManagementType[]>;
+    getType(identifier: string): Promise<ContentManagementType>;
+    createType(input: ContentManagementTypeInput): Promise<ContentManagementType>;
+    updateType(identifier: string, input: ContentManagementTypeInput): Promise<ContentManagementType>;
+    inspectLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    applyLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    listEntries(input?: ContentManagementEntryListInput): Promise<ContentManagementEntryList>;
+    getEntry(identifier: string, locale?: string): Promise<ContentManagementEntry>;
+    createEntry(input: ContentManagementEntryInput): Promise<ContentManagementEntry>;
+    updateEntry(identifier: string, input: ContentManagementEntryInput): Promise<ContentManagementEntry>;
+    inspectEntryLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    applyEntryLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    listGroups(): Promise<ContentManagementGroup[]>;
+    getGroup(identifier: string): Promise<ContentManagementGroup>;
+    createGroup(input: ContentManagementGroupInput): Promise<ContentManagementGroup>;
+    updateGroup(identifier: string, input: ContentManagementGroupInput): Promise<ContentManagementGroup>;
+    inspectGroupLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    applyGroupLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    listOptionLists(): Promise<ContentManagementOptionList[]>;
+    getOptionList(identifier: string): Promise<ContentManagementOptionList>;
+    createOptionList(input: ContentManagementOptionListInput): Promise<ContentManagementOptionList>;
+    updateOptionList(identifier: string, input: ContentManagementOptionListInput): Promise<ContentManagementOptionList>;
+    inspectOptionListLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+    applyOptionListLifecycle(identifier: string, operation: ContentManagementLifecycleOperation): Promise<ContentManagementLifecycleResult>;
+}

package/content-management.cjs

@@ -0,0 +1,199 @@
+"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);
+
+// libs/sdk/src/content-management.ts
+var content_management_exports = {};
+__export(content_management_exports, {
+  ContentManagementError: () => ContentManagementError,
+  createContentManagementClient: () => createContentManagementClient
+});
+module.exports = __toCommonJS(content_management_exports);
+var ContentManagementError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(input) {
+    super(input.message);
+    this.name = "ContentManagementError";
+    this.code = input.code ?? "CONTENT_MANAGEMENT_ERROR";
+    this.status = input.status;
+    this.details = input.details;
+  }
+};
+function normalizeApiUrl(apiUrl) {
+  const normalized = apiUrl.trim().replace(/\/+$/, "");
+  if (!normalized) {
+    throw new ContentManagementError({
+      message: "apiUrl is required.",
+      code: "CONTENT_MANAGEMENT_CONFIG_INVALID",
+      status: 0
+    });
+  }
+  return normalized;
+}
+function encodeIdentifier(identifier) {
+  const normalized = identifier.trim();
+  if (!normalized) {
+    throw new ContentManagementError({
+      message: "A content type id or key is required.",
+      code: "CONTENT_TYPE_IDENTIFIER_INVALID",
+      status: 0
+    });
+  }
+  return encodeURIComponent(normalized);
+}
+function entryListPath(input = {}) {
+  const search = new URLSearchParams();
+  if (input.contentType) search.set("contentType", input.contentType);
+  if (input.locale) search.set("locale", input.locale);
+  if (input.status) search.set("status", input.status);
+  if (input.limit !== void 0) search.set("limit", String(input.limit));
+  if (input.offset !== void 0) search.set("offset", String(input.offset));
+  const query = search.toString();
+  return query ? `/entries?${query}` : "/entries";
+}
+function createContentManagementClient(config) {
+  const apiUrl = normalizeApiUrl(config.apiUrl);
+  const fetchImplementation = config.fetch ?? globalThis.fetch;
+  if (!fetchImplementation) {
+    throw new ContentManagementError({
+      message: "A fetch implementation is required.",
+      code: "CONTENT_MANAGEMENT_CONFIG_INVALID",
+      status: 0
+    });
+  }
+  const getAccessToken = async () => {
+    const token = typeof config.accessToken === "function" ? await config.accessToken() : config.accessToken;
+    const normalized = token.trim();
+    if (!normalized) {
+      throw new ContentManagementError({
+        message: "A temporary content management access token is required.",
+        code: "CONTENT_MANAGEMENT_ACCESS_REQUIRED",
+        status: 0
+      });
+    }
+    return normalized;
+  };
+  const request = async (path, init) => {
+    const response = await fetchImplementation(
+      `${apiUrl}/api/v1/content-management${path}`,
+      {
+        ...init,
+        headers: {
+          Accept: "application/json",
+          Authorization: `Bearer ${await getAccessToken()}`,
+          ...init?.body ? { "Content-Type": "application/json" } : {},
+          ...init?.headers
+        }
+      }
+    );
+    let payload = null;
+    try {
+      payload = await response.json();
+    } catch {
+    }
+    if (!response.ok || !payload || payload.success !== true) {
+      const error = payload && "error" in payload ? payload.error : null;
+      throw new ContentManagementError({
+        message: error?.message ?? `Content management request failed with HTTP ${response.status}.`,
+        code: error?.code,
+        status: response.status,
+        details: error?.details
+      });
+    }
+    return payload.data;
+  };
+  const lifecycle = (resource, identifier, operation, dryRun) => request(
+    `/${resource}/${encodeIdentifier(identifier)}/lifecycle`,
+    {
+      method: "POST",
+      body: JSON.stringify({ operation, dryRun })
+    }
+  );
+  return {
+    getContext: () => request("/context"),
+    getReferences: () => request("/references"),
+    listTypes: () => request("/types"),
+    getType: (identifier) => request(`/types/${encodeIdentifier(identifier)}`),
+    createType: (input) => request("/types", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateType: (identifier, input) => request(`/types/${encodeIdentifier(identifier)}`, {
+      method: "PUT",
+      body: JSON.stringify(input)
+    }),
+    inspectLifecycle: (identifier, operation) => lifecycle("types", identifier, operation, true),
+    applyLifecycle: (identifier, operation) => lifecycle("types", identifier, operation, false),
+    listEntries: (input) => request(entryListPath(input)),
+    getEntry: (identifier, locale) => {
+      const query = locale ? `?locale=${encodeURIComponent(locale.trim())}` : "";
+      return request(
+        `/entries/${encodeIdentifier(identifier)}${query}`
+      );
+    },
+    createEntry: (input) => request("/entries", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateEntry: (identifier, input) => request(
+      `/entries/${encodeIdentifier(identifier)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(input)
+      }
+    ),
+    inspectEntryLifecycle: (identifier, operation) => lifecycle("entries", identifier, operation, true),
+    applyEntryLifecycle: (identifier, operation) => lifecycle("entries", identifier, operation, false),
+    listGroups: () => request("/groups"),
+    getGroup: (identifier) => request(
+      `/groups/${encodeIdentifier(identifier)}`
+    ),
+    createGroup: (input) => request("/groups", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateGroup: (identifier, input) => request(
+      `/groups/${encodeIdentifier(identifier)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(input)
+      }
+    ),
+    inspectGroupLifecycle: (identifier, operation) => lifecycle("groups", identifier, operation, true),
+    applyGroupLifecycle: (identifier, operation) => lifecycle("groups", identifier, operation, false),
+    listOptionLists: () => request("/option-lists"),
+    getOptionList: (identifier) => request(
+      `/option-lists/${encodeIdentifier(identifier)}`
+    ),
+    createOptionList: (input) => request("/option-lists", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateOptionList: (identifier, input) => request(
+      `/option-lists/${encodeIdentifier(identifier)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(input)
+      }
+    ),
+    inspectOptionListLifecycle: (identifier, operation) => lifecycle("option-lists", identifier, operation, true),
+    applyOptionListLifecycle: (identifier, operation) => lifecycle("option-lists", identifier, operation, false)
+  };
+}

package/content-management.d.ts

@@ -0,0 +1,14 @@
+import type { ContentManagementClient, ContentManagementClientConfig } from "./content-management-types";
+export * from "./content-management-types";
+export declare class ContentManagementError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details: unknown;
+    constructor(input: {
+        message: string;
+        code?: string;
+        status: number;
+        details?: unknown;
+    });
+}
+export declare function createContentManagementClient(config: ContentManagementClientConfig): ContentManagementClient;

package/content-management.js

@@ -0,0 +1,178 @@
+// libs/sdk/src/content-management.ts
+var ContentManagementError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(input) {
+    super(input.message);
+    this.name = "ContentManagementError";
+    this.code = input.code ?? "CONTENT_MANAGEMENT_ERROR";
+    this.status = input.status;
+    this.details = input.details;
+  }
+};
+function normalizeApiUrl(apiUrl) {
+  const normalized = apiUrl.trim().replace(/\/+$/, "");
+  if (!normalized) {
+    throw new ContentManagementError({
+      message: "apiUrl is required.",
+      code: "CONTENT_MANAGEMENT_CONFIG_INVALID",
+      status: 0
+    });
+  }
+  return normalized;
+}
+function encodeIdentifier(identifier) {
+  const normalized = identifier.trim();
+  if (!normalized) {
+    throw new ContentManagementError({
+      message: "A content type id or key is required.",
+      code: "CONTENT_TYPE_IDENTIFIER_INVALID",
+      status: 0
+    });
+  }
+  return encodeURIComponent(normalized);
+}
+function entryListPath(input = {}) {
+  const search = new URLSearchParams();
+  if (input.contentType) search.set("contentType", input.contentType);
+  if (input.locale) search.set("locale", input.locale);
+  if (input.status) search.set("status", input.status);
+  if (input.limit !== void 0) search.set("limit", String(input.limit));
+  if (input.offset !== void 0) search.set("offset", String(input.offset));
+  const query = search.toString();
+  return query ? `/entries?${query}` : "/entries";
+}
+function createContentManagementClient(config) {
+  const apiUrl = normalizeApiUrl(config.apiUrl);
+  const fetchImplementation = config.fetch ?? globalThis.fetch;
+  if (!fetchImplementation) {
+    throw new ContentManagementError({
+      message: "A fetch implementation is required.",
+      code: "CONTENT_MANAGEMENT_CONFIG_INVALID",
+      status: 0
+    });
+  }
+  const getAccessToken = async () => {
+    const token = typeof config.accessToken === "function" ? await config.accessToken() : config.accessToken;
+    const normalized = token.trim();
+    if (!normalized) {
+      throw new ContentManagementError({
+        message: "A temporary content management access token is required.",
+        code: "CONTENT_MANAGEMENT_ACCESS_REQUIRED",
+        status: 0
+      });
+    }
+    return normalized;
+  };
+  const request = async (path, init) => {
+    const response = await fetchImplementation(
+      `${apiUrl}/api/v1/content-management${path}`,
+      {
+        ...init,
+        headers: {
+          Accept: "application/json",
+          Authorization: `Bearer ${await getAccessToken()}`,
+          ...init?.body ? { "Content-Type": "application/json" } : {},
+          ...init?.headers
+        }
+      }
+    );
+    let payload = null;
+    try {
+      payload = await response.json();
+    } catch {
+    }
+    if (!response.ok || !payload || payload.success !== true) {
+      const error = payload && "error" in payload ? payload.error : null;
+      throw new ContentManagementError({
+        message: error?.message ?? `Content management request failed with HTTP ${response.status}.`,
+        code: error?.code,
+        status: response.status,
+        details: error?.details
+      });
+    }
+    return payload.data;
+  };
+  const lifecycle = (resource, identifier, operation, dryRun) => request(
+    `/${resource}/${encodeIdentifier(identifier)}/lifecycle`,
+    {
+      method: "POST",
+      body: JSON.stringify({ operation, dryRun })
+    }
+  );
+  return {
+    getContext: () => request("/context"),
+    getReferences: () => request("/references"),
+    listTypes: () => request("/types"),
+    getType: (identifier) => request(`/types/${encodeIdentifier(identifier)}`),
+    createType: (input) => request("/types", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateType: (identifier, input) => request(`/types/${encodeIdentifier(identifier)}`, {
+      method: "PUT",
+      body: JSON.stringify(input)
+    }),
+    inspectLifecycle: (identifier, operation) => lifecycle("types", identifier, operation, true),
+    applyLifecycle: (identifier, operation) => lifecycle("types", identifier, operation, false),
+    listEntries: (input) => request(entryListPath(input)),
+    getEntry: (identifier, locale) => {
+      const query = locale ? `?locale=${encodeURIComponent(locale.trim())}` : "";
+      return request(
+        `/entries/${encodeIdentifier(identifier)}${query}`
+      );
+    },
+    createEntry: (input) => request("/entries", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateEntry: (identifier, input) => request(
+      `/entries/${encodeIdentifier(identifier)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(input)
+      }
+    ),
+    inspectEntryLifecycle: (identifier, operation) => lifecycle("entries", identifier, operation, true),
+    applyEntryLifecycle: (identifier, operation) => lifecycle("entries", identifier, operation, false),
+    listGroups: () => request("/groups"),
+    getGroup: (identifier) => request(
+      `/groups/${encodeIdentifier(identifier)}`
+    ),
+    createGroup: (input) => request("/groups", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateGroup: (identifier, input) => request(
+      `/groups/${encodeIdentifier(identifier)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(input)
+      }
+    ),
+    inspectGroupLifecycle: (identifier, operation) => lifecycle("groups", identifier, operation, true),
+    applyGroupLifecycle: (identifier, operation) => lifecycle("groups", identifier, operation, false),
+    listOptionLists: () => request("/option-lists"),
+    getOptionList: (identifier) => request(
+      `/option-lists/${encodeIdentifier(identifier)}`
+    ),
+    createOptionList: (input) => request("/option-lists", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateOptionList: (identifier, input) => request(
+      `/option-lists/${encodeIdentifier(identifier)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(input)
+      }
+    ),
+    inspectOptionListLifecycle: (identifier, operation) => lifecycle("option-lists", identifier, operation, true),
+    applyOptionListLifecycle: (identifier, operation) => lifecycle("option-lists", identifier, operation, false)
+  };
+}
+export {
+  ContentManagementError,
+  createContentManagementClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacano/sdk",
-  "version": "1.1.10",
+  "version": "1.1.13",
   "description": "TypeScript SDK for building websites on the Bacano ERP",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -23,6 +23,11 @@
       "import": "./graphql.js",
       "require": "./graphql.cjs"
     },
+    "./content-management": {
+      "types": "./content-management.d.ts",
+      "import": "./content-management.js",
+      "require": "./content-management.cjs"
+    },
     "./react": {
       "types": "./react.d.ts",
       "import": "./react.js",