@unchainedshop/cockpit-api 2.3.1 → 2.4.0

package/dist/client.d.ts

@@ -3,11 +3,11 @@
  */
 import type { DocumentNode } from "graphql";
 import { type CockpitAPIOptions } from "./core/config.ts";
-import { type ContentItemQueryOptions, type ContentListQueryOptions, type TreeQueryOptions, type AggregateQueryOptions, type CockpitContentItem, type CockpitTreeNode, type CockpitListResponse } from "./methods/content.ts";
+import { type ContentItemQueryOptions, type ContentListQueryOptions, type UnchainedContentListQueryOptions, type TreeQueryOptions, type AggregateQueryOptions, type CockpitContentItem, type CockpitTreeNode, type CockpitListResponse } from "./methods/content.ts";
 import { type PageByIdOptions, type CockpitPage } from "./methods/pages.ts";
 import { type MenuQueryOptions, type CockpitMenu } from "./methods/menus.ts";
 import { type CockpitRoutesResponse, type CockpitSitemapEntry, type CockpitSettings } from "./methods/routes.ts";
-import { type ImageAssetQueryParams, type CockpitAsset } from "./methods/assets.ts";
+import { type ImageAssetQueryParams, type CockpitAsset, type UploadAssetsOptions, type UploadAssetsResponse } from "./methods/assets.ts";
 import { type SearchQueryOptions, type CockpitSearchResult } from "./methods/search.ts";
 import { type LocalizeOptions } from "./methods/localize.ts";
 /**
@@ -17,6 +17,12 @@ export interface CockpitAPIClient {
     graphQL<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>): Promise<T | null>;
     getContentItem<T = unknown>(options: ContentItemQueryOptions): Promise<T | null>;
     getContentItems<T = CockpitContentItem>(model: string, options?: ContentListQueryOptions): Promise<CockpitListResponse<T> | null>;
+    /**
+     * Get content items including unpublished via Unchained module.
+     *
+     * Requires admin access with content/{model}/read permission.
+     */
+    getUnchainedContentItems<T = CockpitContentItem>(model: string, options?: UnchainedContentListQueryOptions): Promise<CockpitListResponse<T> | null>;
     getContentTree<T = CockpitContentItem>(model: string, options?: TreeQueryOptions): Promise<CockpitTreeNode<T>[] | null>;
     getAggregateModel<T = unknown>(options: AggregateQueryOptions): Promise<T[] | null>;
     postContentItem<T = unknown>(model: string, item: Record<string, unknown>): Promise<T | null>;
@@ -47,6 +53,12 @@ export interface CockpitAPIClient {
      * @returns URL string to the generated image, or null if not found
      */
     imageAssetById(assetId: string, queryParams: ImageAssetQueryParams): Promise<string | null>;
+    /**
+     * Upload assets to Cockpit CMS (Unchained module).
+     *
+     * Requires admin access (API key with assets/upload permission).
+     */
+    uploadAssets(files: File[], options?: UploadAssetsOptions): Promise<UploadAssetsResponse | null>;
     getFullRouteForSlug(slug: string): Promise<string | undefined>;
     /**
      * Clear cache entries matching pattern

package/dist/client.js

@@ -82,7 +82,7 @@ export async function CockpitAPI(options = {}) {
         baseUrl: config.endpoint.origin,
         replacements: routeReplacements,
     };
-    if (options.tenant !== undefined)
+    if (options.tenant)
         transformerConfig.tenant = options.tenant;
     const transformer = createImagePathTransformer(transformerConfig);
     // Create URL builder
@@ -95,7 +95,7 @@ export async function CockpitAPI(options = {}) {
         url: urlBuilder,
         cache,
         endpoint: endpointString,
-        ...(options.tenant !== undefined && { tenant: options.tenant }),
+        ...(options.tenant && { tenant: options.tenant }),
     };
     // Create method groups
     const contentMethods = createContentMethods(ctx);

package/dist/core/config.js

@@ -17,7 +17,7 @@ export function createConfig(options = {}) {
         ? undefined
         : options.tenant;
     // Validate tenant format to prevent path traversal
-    if (tenant !== undefined && !VALID_TENANT_PATTERN.test(tenant)) {
+    if (tenant && !VALID_TENANT_PATTERN.test(tenant)) {
         throw new Error("Cockpit: Invalid tenant format (only alphanumeric, hyphens, and underscores allowed)");
     }
     const endpoint = new URL(endpointStr);
@@ -28,7 +28,7 @@ export function createConfig(options = {}) {
         useAdminAccess: options.useAdminAccess ?? false,
         defaultLanguage: options.defaultLanguage ?? null,
         cachePrefix: `${endpointStr}:${tenant ?? "default"}:`,
-        ...(tenant !== undefined && { tenant }),
+        ...(tenant && { tenant }),
         ...(apiKey !== undefined && { apiKey }),
     });
     return config;

package/dist/core/http.d.ts

@@ -23,6 +23,10 @@ export interface HttpClient {
      * Make a POST request with JSON body
      */
     post<T>(url: URL | string, body: unknown, options?: HttpFetchOptions): Promise<T | null>;
+    /**
+     * Make a POST request with FormData body (multipart/form-data)
+     */
+    postFormData<T>(url: URL | string, formData: FormData, options?: HttpFetchOptions): Promise<T | null>;
     /**
      * Make a DELETE request
      */

package/dist/core/http.js

@@ -91,6 +91,18 @@ export function createHttpClient(config, transformer) {
         async post(url, body, options = {}) {
             return fetchData(url, prepareJsonRequestOptions(options, "POST", body));
         },
+        async postFormData(url, formData, options = {}) {
+            const { useAdminAccess, headers, ...restOptions } = options;
+            const customHeaders = normalizeHeaders(headers);
+            // Do NOT set Content-Type - let browser set it with correct boundary
+            return fetchData(url, {
+                ...restOptions,
+                method: "POST",
+                body: formData,
+                headers: customHeaders,
+                ...(useAdminAccess !== undefined && { useAdminAccess }),
+            });
+        },
         async delete(url, options = {}) {
             return fetchData(url, prepareJsonRequestOptions(options, "DELETE"));
         },

package/dist/core/url-builder.js

@@ -7,7 +7,7 @@ import { createLocaleNormalizer } from "./locale.js";
  * Creates a URL builder for the given configuration
  */
 export function createUrlBuilder(config) {
-    const apiBasePath = config.tenant !== undefined ? `/:${config.tenant}/api` : "/api";
+    const apiBasePath = config.tenant ? `/:${config.tenant}/api` : "/api";
     const normalizeLocale = createLocaleNormalizer(config.defaultLanguage);
     return {
         build(path, options = {}) {
@@ -26,7 +26,7 @@ export function createUrlBuilder(config) {
         },
         graphqlEndpoint() {
             const url = new URL(config.endpoint);
-            if (config.tenant !== undefined) {
+            if (config.tenant) {
                 url.pathname = `/:${config.tenant}${url.pathname}`;
             }
             return url;

package/dist/fetch/client.js

@@ -14,7 +14,7 @@ import { createLocaleNormalizer } from "../core/locale.js";
  */
 function buildApiBaseUrl(endpoint, tenant) {
     const url = new URL(endpoint);
-    const basePath = tenant !== undefined && tenant !== null ? `/:${tenant}/api` : "/api";
+    const basePath = tenant ? `/:${tenant}/api` : "/api";
     return `${url.origin}${basePath}`;
 }
 /**

package/dist/index.d.ts

@@ -11,16 +11,16 @@ export { getTenantIds, resolveTenantFromUrl, resolveTenantFromSubdomain, } from
 export type { TenantUrlResult, ResolveTenantFromUrlOptions, ResolveTenantFromSubdomainOptions, } from "./utils/tenant.ts";
 export { generateCmsRouteReplacements, generateCollectionAndSingletonSlugRouteMap, } from "./utils/route-map.ts";
 export type { ResponseTransformer } from "./transformers/image-path.ts";
-export { createImagePathTransformer, identityTransformer, FixImagePaths, } from "./transformers/image-path.ts";
+export { createImagePathTransformer, identityTransformer, } from "./transformers/image-path.ts";
 export { createAssetPathTransformer, createPageLinkTransformer, composeTransformers, } from "./transformers/index.ts";
-export type { MethodContext, ListQueryOptions, ContentItemQueryOptions, ContentListQueryOptions, TreeQueryOptions, AggregateQueryOptions, } from "./methods/content.ts";
+export type { MethodContext, ListQueryOptions, ContentItemQueryOptions, ContentListQueryOptions, UnchainedContentListQueryOptions, TreeQueryOptions, AggregateQueryOptions, } from "./methods/content.ts";
 export type { PageByIdOptions, PageByRouteOptions } from "./methods/pages.ts";
 export type { MenuQueryOptions } from "./methods/menus.ts";
 export type { SearchQueryOptions } from "./methods/search.ts";
 export type { LocalizeOptions } from "./methods/localize.ts";
 export type { CockpitContentItem, CockpitNewsItem, CockpitTreeNode, CockpitListResponse, CockpitListMeta, } from "./methods/content.ts";
 export { ImageSizeMode, MimeType } from "./methods/assets.ts";
-export type { CockpitAsset, ImageAssetQueryParams } from "./methods/assets.ts";
+export type { CockpitAsset, ImageAssetQueryParams, UploadAssetsOptions, UploadAssetsResponse, } from "./methods/assets.ts";
 export type { CockpitPageType, CockpitPageMeta, CockpitPageSeo, CockpitLayoutBlock, CockpitPage, } from "./methods/pages.ts";
 export type { CockpitMenuUrl, CockpitMenuLink, CockpitMenu, } from "./methods/menus.ts";
 export type { CockpitRoute, CockpitRoutesResponse, CockpitSitemapEntry, CockpitPreviewConfig, CockpitSettings, } from "./methods/routes.ts";

package/dist/index.js

@@ -6,9 +6,7 @@
 export { CockpitAPI } from "./client.js";
 export { getTenantIds, resolveTenantFromUrl, resolveTenantFromSubdomain, } from "./utils/tenant.js";
 export { generateCmsRouteReplacements, generateCollectionAndSingletonSlugRouteMap, } from "./utils/route-map.js";
-export { createImagePathTransformer, identityTransformer, 
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-FixImagePaths, } from "./transformers/image-path.js";
+export { createImagePathTransformer, identityTransformer, } from "./transformers/image-path.js";
 export { createAssetPathTransformer, createPageLinkTransformer, composeTransformers, } from "./transformers/index.js";
 export { ImageSizeMode, MimeType } from "./methods/assets.js";
 export { parseCockpitUrl, isCockpitPageUrl, isCockpitAssetUrl, extractPageId, extractAssetId, } from "./utils/url-protocols.js";

package/dist/methods/assets.d.ts

@@ -58,6 +58,19 @@ export type ImageAssetQueryParams = {
     w?: number;
     h: number;
 });
+/**
+ * Options for uploading assets
+ */
+export interface UploadAssetsOptions {
+    /** Target folder name for upload */
+    folder?: string;
+}
+/**
+ * Response from asset upload
+ */
+export interface UploadAssetsResponse {
+    assets: CockpitAsset[];
+}
 export interface AssetMethods {
     assetById<T = CockpitAsset>(assetId: string): Promise<T | null>;
     /**
@@ -71,5 +84,22 @@ export interface AssetMethods {
      * @returns URL string to the generated image, or null if not found
      */
     imageAssetById(assetId: string, queryParams: ImageAssetQueryParams): Promise<string | null>;
+    /**
+     * Upload assets to Cockpit CMS (Unchained module).
+     *
+     * Requires admin access (API key with assets/upload permission).
+     *
+     * @param files - Files to upload (File objects or Blob with name)
+     * @param options - Upload options (optional folder name)
+     * @returns Uploaded assets metadata
+     *
+     * @example
+     * ```typescript
+     * const file = new File(['content'], 'test.txt', { type: 'text/plain' });
+     * const result = await client.uploadAssets([file], { folder: 'documents' });
+     * console.log(result?.assets);
+     * ```
+     */
+    uploadAssets(files: File[], options?: UploadAssetsOptions): Promise<UploadAssetsResponse | null>;
 }
 export declare function createAssetMethods(ctx: MethodContext): AssetMethods;

package/dist/methods/assets.js

@@ -33,5 +33,23 @@ export function createAssetMethods(ctx) {
             });
             return ctx.http.fetchText(url);
         },
+        async uploadAssets(files, options = {}) {
+            requireParam(files, "files");
+            if (files.length === 0) {
+                return { assets: [] };
+            }
+            const formData = new FormData();
+            for (const file of files) {
+                formData.append("files[]", file);
+            }
+            const url = ctx.url.build("/unchained/assets/upload", {
+                queryParams: {
+                    ...(options.folder && { folder: options.folder }),
+                },
+            });
+            return ctx.http.postFormData(url, formData, {
+                useAdminAccess: true,
+            });
+        },
     };
 }

package/dist/methods/content.d.ts

@@ -30,6 +30,16 @@ export interface ContentItemQueryOptions extends ListQueryOptions {
 export interface ContentListQueryOptions extends ListQueryOptions {
     queryParams?: Record<string, unknown>;
 }
+/**
+ * Query options for Unchained content endpoint (supports unpublished items)
+ */
+export interface UnchainedContentListQueryOptions extends ContentListQueryOptions {
+    /**
+     * Include unpublished items in results.
+     * Requires admin access with content/{model}/read permission.
+     */
+    includeUnpublished?: boolean;
+}
 export interface TreeQueryOptions {
     parent?: string;
     filter?: Record<string, unknown>;
@@ -101,6 +111,24 @@ export interface ContentMethods {
      * const total = response?.meta?.total;
      */
     getContentItems<T = CockpitContentItem>(model: string, options?: ContentListQueryOptions): Promise<CockpitListResponse<T> | null>;
+    /**
+     * Get content items including unpublished via Unchained module.
+     *
+     * Requires admin access with content/{model}/read permission.
+     *
+     * @returns Always returns `CockpitListResponse<T>` with data array.
+     * Returns `null` if model doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const response = await cockpit.getUnchainedContentItems('posts', {
+     *   limit: 10,
+     *   includeUnpublished: true,
+     * });
+     * const items = response?.data || [];
+     * ```
+     */
+    getUnchainedContentItems<T = CockpitContentItem>(model: string, options?: UnchainedContentListQueryOptions): Promise<CockpitListResponse<T> | null>;
     getContentTree<T = CockpitContentItem>(model: string, options?: TreeQueryOptions): Promise<CockpitTreeNode<T>[] | null>;
     getAggregateModel<T = unknown>(options: AggregateQueryOptions): Promise<T[] | null>;
     postContentItem<T = unknown>(model: string, item: Record<string, unknown>): Promise<T | null>;

package/dist/methods/content.js

@@ -43,6 +43,35 @@ export function createContentMethods(ctx) {
             }
             return result;
         },
+        async getUnchainedContentItems(model, options = {}) {
+            requireParam(model, "a model");
+            validatePathSegment(model, "model");
+            const { locale = "default", limit, skip, sort, filter, fields, populate, includeUnpublished, queryParams = {}, } = options;
+            const url = ctx.url.build(`/unchained/content/items/${model}`, {
+                locale,
+                queryParams: {
+                    ...queryParams,
+                    limit,
+                    skip,
+                    sort,
+                    filter,
+                    fields,
+                    populate,
+                    ...(includeUnpublished && { includeUnpublished: 1 }),
+                },
+            });
+            const result = await ctx.http.fetch(url, {
+                useAdminAccess: true,
+            });
+            // Normalize response to always return { data, meta? }
+            if (result === null) {
+                return null;
+            }
+            if (Array.isArray(result)) {
+                return { data: result };
+            }
+            return result;
+        },
         async getContentTree(model, options = {}) {
             requireParam(model, "a model");
             validatePathSegment(model, "model");

package/dist/schema/executor.js

@@ -59,7 +59,7 @@ export function createRemoteExecutor(options = {}) {
             preloadRoutes: true,
             ...cockpitOptions,
         };
-        if (tenant !== undefined)
+        if (tenant)
             clientOpts.tenant = tenant;
         const clientPromise = CockpitAPI(clientOpts);
         pendingClients.set(key, clientPromise);

package/dist/transformers/asset-path.js

@@ -8,7 +8,7 @@ import { logger } from "../cockpit-logger.js";
  */
 export function transformAssetPaths(jsonString, config) {
     const { baseUrl, tenant } = config;
-    const tenantUrl = `${baseUrl}${tenant !== undefined ? `/:${tenant}` : ""}`;
+    const tenantUrl = `${baseUrl}${tenant ? `/:${tenant}` : ""}`;
     return (jsonString
         // Fix asset paths in "path" fields
         .replace(/"path":"\//g, `"path":"${tenantUrl}/storage/uploads/`)

package/dist/transformers/image-path.d.ts

@@ -19,10 +19,3 @@ export interface ImagePathTransformerConfig extends AssetPathConfig {
  * Uses a single JSON stringify/parse cycle for efficiency.
  */
 export declare function createImagePathTransformer(config: ImagePathTransformerConfig): ResponseTransformer;
-/**
- * Legacy export for backwards compatibility
- * @deprecated Use createImagePathTransformer instead
- */
-export declare function FixImagePaths(endpoint: string, replacements: Record<string, string>, tenant?: string): {
-    transformResult<T>(originalResponse: T): T;
-};

package/dist/transformers/image-path.js

@@ -21,7 +21,7 @@ export function createImagePathTransformer(config) {
     const { baseUrl, tenant, replacements } = config;
     // Build asset config, only including tenant if defined
     const assetConfig = { baseUrl };
-    if (tenant !== undefined)
+    if (tenant)
         assetConfig.tenant = tenant;
     return {
         transform(originalResponse) {
@@ -41,20 +41,3 @@ export function createImagePathTransformer(config) {
         },
     };
 }
-/**
- * Legacy export for backwards compatibility
- * @deprecated Use createImagePathTransformer instead
- */
-export function FixImagePaths(endpoint, replacements, tenant) {
-    const baseUrl = new URL(endpoint).origin;
-    const config = {
-        baseUrl,
-        replacements,
-    };
-    if (tenant !== undefined)
-        config.tenant = tenant;
-    const transformer = createImagePathTransformer(config);
-    return {
-        transformResult: transformer.transform.bind(transformer),
-    };
-}

package/dist/transformers/index.d.ts

@@ -2,7 +2,7 @@
  * Transformer exports
  */
 export type { ResponseTransformer } from "./image-path.ts";
-export { identityTransformer, createImagePathTransformer, FixImagePaths, } from "./image-path.ts";
+export { identityTransformer, createImagePathTransformer, } from "./image-path.ts";
 export { composeTransformers } from "./compose.ts";
 export { createAssetPathTransformer, transformAssetPaths, type AssetPathConfig, } from "./asset-path.ts";
 export { createPageLinkTransformer, transformPageLinks } from "./page-link.ts";

package/dist/transformers/index.js

@@ -1,9 +1,7 @@
 /**
  * Transformer exports
  */
-export { identityTransformer, createImagePathTransformer, 
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-FixImagePaths, } from "./image-path.js";
+export { identityTransformer, createImagePathTransformer, } from "./image-path.js";
 export { composeTransformers } from "./compose.js";
 export { createAssetPathTransformer, transformAssetPaths, } from "./asset-path.js";
 export { createPageLinkTransformer, transformPageLinks } from "./page-link.js";

package/dist/utils/route-map.js

@@ -17,7 +17,7 @@ export async function generateCmsRouteReplacements(endpoint, tenant, cache) {
     };
     try {
         const origin = new URL(endpoint).origin;
-        const apiPath = tenant !== undefined ? `/:${tenant}/api` : "/api";
+        const apiPath = tenant ? `/:${tenant}/api` : "/api";
         const response = await fetch(`${origin}${apiPath}/pages/pages?${new URLSearchParams(filterParams).toString()}`);
         if (!response.ok) {
             logger.warn(`Cockpit: Failed to fetch route replacements (status ${String(response.status)})`);
@@ -60,7 +60,7 @@ export async function generateCollectionAndSingletonSlugRouteMap(endpoint, tenan
     };
     try {
         const origin = new URL(endpoint).origin;
-        const apiPath = tenant !== undefined ? `/:${tenant}/api` : "/api";
+        const apiPath = tenant ? `/:${tenant}/api` : "/api";
         const response = await fetch(`${origin}${apiPath}/pages/pages?locale=default&${new URLSearchParams(filterParams).toString()}`);
         if (!response.ok) {
             logger.warn(`Cockpit: Failed to fetch slug route map (status ${String(response.status)})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/cockpit-api",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "A package to interact with the Cockpit CMS API, including functionalities to handle GraphQL requests and various CMS content manipulations.",
   "main": "dist/index.js",
   "homepage": "https://unchained.shop",