@unchainedshop/cockpit-api 2.3.2 → 2.4.1

package/dist/client.d.ts

@@ -3,20 +3,26 @@
  */
 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";
 /**
  * Cockpit API Client interface
  */
 export interface CockpitAPIClient {
-    graphQL<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>): Promise<T | null>;
+    graphQL<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>, operationName?: string): 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/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/index.d.ts

@@ -13,14 +13,14 @@ export { generateCmsRouteReplacements, generateCollectionAndSingletonSlugRouteMa
 export type { ResponseTransformer } 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/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/methods/graphql.d.ts

@@ -4,6 +4,6 @@
 import { type DocumentNode } from "graphql";
 import type { MethodContext } from "./content.ts";
 export interface GraphQLMethods {
-    graphQL<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>): Promise<T | null>;
+    graphQL<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>, operationName?: string): Promise<T | null>;
 }
 export declare function createGraphQLMethods(ctx: MethodContext): GraphQLMethods;

package/dist/methods/graphql.js

@@ -1,13 +1,18 @@
 /**
  * GraphQL API method
  */
-import { print } from "graphql";
+import { print, getOperationAST } from "graphql";
 export function createGraphQLMethods(ctx) {
     return {
-        async graphQL(document, variables) {
+        async graphQL(document, variables, operationName) {
             const query = print(document);
+            const resolvedOperationName = operationName ?? getOperationAST(document)?.name?.value;
             const endpoint = ctx.url.graphqlEndpoint();
-            return ctx.http.post(endpoint, { query, variables });
+            return ctx.http.post(endpoint, {
+                query,
+                variables,
+                operationName: resolvedOperationName,
+            });
         },
     };
 }

package/dist/schema/executor.d.ts

@@ -36,6 +36,7 @@ export interface MakeCockpitSchemaOptions {
 export interface ExecutorRequest {
     document: DocumentNode;
     variables?: Record<string, unknown>;
+    operationName?: string;
     context?: CockpitExecutorContext;
 }
 /**

package/dist/schema/executor.js

@@ -72,7 +72,7 @@ export function createRemoteExecutor(options = {}) {
             pendingClients.delete(key);
         }
     }
-    return async ({ document, variables, context }) => {
+    return async ({ document, variables, operationName, context, }) => {
         // Extract tenant from context
         const tenant = extractTenant
             ? extractTenant(context)
@@ -80,6 +80,6 @@ export function createRemoteExecutor(options = {}) {
         // Get or create pooled client
         const cockpit = await getOrCreateClient(tenant);
         // Execute GraphQL query
-        return cockpit.graphQL(document, variables);
+        return cockpit.graphQL(document, variables, operationName);
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/cockpit-api",
-  "version": "2.3.2",
+  "version": "2.4.1",
   "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",
@@ -50,8 +50,8 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@unchainedshop/logger": "^4.6.0",
-    "lru-cache": "^11.2.4"
+    "@unchainedshop/logger": "^4.6.2",
+    "lru-cache": "^11.2.6"
   },
   "types": "dist/index.d.ts",
   "peerDependencies": {
@@ -68,13 +68,13 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@types/node": "^24.10.7",
+    "@types/node": "^25.3.1",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "graphql": "^16.12.0",
-    "prettier": "^3.7.4",
+    "eslint-plugin-prettier": "^5.5.5",
+    "graphql": "^16.13.0",
+    "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.52.0"
+    "typescript-eslint": "^8.56.1"
   }
 }