@agility/management-sdk 0.1.37 → 0.1.38

package/README.md

@@ -146,8 +146,8 @@ console.log('Content retrieved:', contentItem.fields.title);
   - [getPage](./docs/page-methods.md#getpage), [getPageByPath](./docs/page-methods.md#getpagebypath), [getPageHistory](./docs/page-methods.md#getpagehistory), [getPageComments](./docs/page-methods.md#getpagecomments), [getPageList](./docs/page-methods.md#getpagelist), [getPageListByPageTemplateID](./docs/page-methods.md#getpagelistbypagetemplateid), [getPageListByPage](./docs/page-methods.md#getpagelistbypage), [getPageListByPageAndPageTemplateID](./docs/page-methods.md#getpagelistbypageandpagetemplateid), [getPageTree](./docs/page-methods.md#getpagetree), [getPageTemplateList](./docs/page-methods.md#getpagetemplatelist), [getPageSecurity](./docs/page-methods.md#getpagesecurity), [getPageItemTemplateList](./docs/page-methods.md#getpageitemtemplatelist), [getPageContentZones](./docs/page-methods.md#getpagecontentzones), [savePage](./docs/page-methods.md#savepage), [savePageSecurity](./docs/page-methods.md#savepagesecurity), [movePageItem](./docs/page-methods.md#movepageitem), [deletePage](./docs/page-methods.md#deletepage), [batchWorkflowPages](./docs/page-methods.md#batchworkflowpages)
 
 ### User Management
-- **[InstanceMethods](./docs/instance-methods.md)** - Instance-level operations (1 function)
-  - [getLocales](./docs/instance-methods.md#getlocales)
+- **[InstanceMethods](./docs/instance-methods.md)** - Instance-level operations (2 functions)
+  - [getLocales](./docs/instance-methods.md#getlocales), [getFetchApiStatus](./docs/instance-methods.md#getfetchapistatus)
 
 - **[InstanceUserMethods](./docs/instance-user-methods.md)** - Instance user management (3 functions)
   - [getUsers](./docs/instance-user-methods.md#getusers), [saveUser](./docs/instance-user-methods.md#saveuser), [deleteUser](./docs/instance-user-methods.md#deleteuser)
@@ -304,6 +304,31 @@ const [batchId] = await client.contentMethods.batchWorkflowContent(
 console.log('Batch submitted, ID:', batchId);
 ```
 
+### Checking Fetch API Sync Status
+
+After batch operations, you may want to verify that changes have propagated to the Fetch API CDN before using the content on your frontend:
+
+```typescript
+import * as mgmtApi from '@agility/management-sdk';
+
+const options = new mgmtApi.Options();
+options.token = 'your-access-token';
+const client = new mgmtApi.ApiClient(options);
+
+const guid = 'your-instance-guid';
+
+// After a batch publish operation, wait for CDN sync
+await client.batchMethods.publishBatch(batchId, guid);
+
+// Wait for sync to complete
+await client.instanceMethods.getFetchApiStatus(guid, 'fetch', true);
+console.log('Sync complete! Content is now available on the CDN');
+
+// Or just check current status without waiting
+const status = await client.instanceMethods.getFetchApiStatus(guid);
+console.log('Sync in progress:', status.inProgress);
+```
+
 ## TypeScript Interfaces
 
 ### Batch Response Interfaces

package/dist/apiMethods/instanceMethods.d.ts

@@ -1,9 +1,22 @@
 import { Options } from "../models/options";
 import { ClientInstance } from "./clientInstance";
 import { Locales } from "../models/locales";
+import { FetchApiStatus, FetchApiSyncMode } from "../models/fetchApiStatus";
 export declare class InstanceMethods {
     _options: Options;
     _clientInstance: ClientInstance;
     constructor(options: Options);
     getLocales(guid: string): Promise<Locales[]>;
+    /**
+     * Gets the Fetch API sync status for an instance.
+     * Use this to check if changes made via the Management API have propagated to the Fetch API CDNs.
+     * This is particularly useful after large batch operations or batch workflows to verify
+     * that content changes are available on the CDN before proceeding with dependent operations.
+     *
+     * @param guid - The website GUID
+     * @param mode - Sync mode: 'fetch' (live/published content) or 'preview' (preview content). Defaults to 'fetch'.
+     * @param waitForCompletion - If true, polls until sync is complete. Defaults to false.
+     * @returns The sync status including whether a sync is in progress and version information
+     */
+    getFetchApiStatus(guid: string, mode?: FetchApiSyncMode, waitForCompletion?: boolean): Promise<FetchApiStatus>;
 }

package/dist/apiMethods/instanceMethods.js

@@ -64,6 +64,54 @@ var InstanceMethods = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Gets the Fetch API sync status for an instance.
+     * Use this to check if changes made via the Management API have propagated to the Fetch API CDNs.
+     * This is particularly useful after large batch operations or batch workflows to verify
+     * that content changes are available on the CDN before proceeding with dependent operations.
+     *
+     * @param guid - The website GUID
+     * @param mode - Sync mode: 'fetch' (live/published content) or 'preview' (preview content). Defaults to 'fetch'.
+     * @param waitForCompletion - If true, polls until sync is complete. Defaults to false.
+     * @returns The sync status including whether a sync is in progress and version information
+     */
+    InstanceMethods.prototype.getFetchApiStatus = function (guid_1) {
+        return __awaiter(this, arguments, void 0, function (guid, mode, waitForCompletion) {
+            var apiPath, resp, resp, status_1, err_2;
+            if (mode === void 0) { mode = 'fetch'; }
+            if (waitForCompletion === void 0) { waitForCompletion = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 6, , 7]);
+                        apiPath = "fetch-api-status?mode=".concat(mode);
+                        if (!!waitForCompletion) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._clientInstance.executeGet(apiPath, guid, this._options.token)];
+                    case 1:
+                        resp = _a.sent();
+                        return [2 /*return*/, resp.data];
+                    case 2:
+                        if (!true) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this._clientInstance.executeGet(apiPath, guid, this._options.token)];
+                    case 3:
+                        resp = _a.sent();
+                        status_1 = resp.data;
+                        if (!status_1.inProgress) {
+                            return [2 /*return*/, status_1];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 2000); })];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _a.sent();
+                        throw new exception_1.Exception("Unable to retrieve Fetch API status.", err_2);
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     return InstanceMethods;
 }());
 exports.InstanceMethods = InstanceMethods;

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from "./models/contentItem";
 export * from "./models/contentViewColumn";
 export * from "./models/instanceRole";
 export * from "./models/locales";
+export * from "./models/fetchApiStatus";
 export * from "./models/instanceUser";
 export * from "./models/media";
 export * from "./models/model";

package/dist/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./models/contentItem"), exports);
 __exportStar(require("./models/contentViewColumn"), exports);
 __exportStar(require("./models/instanceRole"), exports);
 __exportStar(require("./models/locales"), exports);
+__exportStar(require("./models/fetchApiStatus"), exports);
 __exportStar(require("./models/instanceUser"), exports);
 __exportStar(require("./models/media"), exports);
 __exportStar(require("./models/model"), exports);

package/dist/models/fetchApiStatus.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Represents the sync status of the Fetch API CDN for an instance.
+ * Used to check if changes made via the Management API have propagated to the Fetch API CDNs.
+ */
+export interface FetchApiStatus {
+    /** Record timestamp */
+    timestamp?: string;
+    /** When the sync completed */
+    completionTime?: string;
+    /** Error message if sync failed */
+    errorMessage?: string;
+    /** Indicates if a content sync is currently in progress */
+    inProgress: boolean;
+    /** Number of items affected by the sync */
+    itemsAffected: number;
+    /** Last content version ID synced */
+    lastContentVersionID: number;
+    /** Last deleted content version ID synced */
+    lastDeletedContentVersionID: number;
+    /** Last deleted page version ID synced */
+    lastDeletedPageVersionID: number;
+    /** Lease ID for the sync operation */
+    leaseID?: string;
+    /** Maximum change date processed */
+    maxChangeDate?: string;
+    /** Maximum content model date processed */
+    maxContentModelDate?: string;
+    /** Push type (1 = Preview, 2 = Fetch/Live) */
+    pushType: number;
+    /** When the sync started */
+    startTime?: string;
+    /** The website name */
+    websiteName?: string;
+}
+/**
+ * Sync mode for checking Fetch API status
+ */
+export type FetchApiSyncMode = 'fetch' | 'preview';

package/dist/models/fetchApiStatus.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/docs/instance-methods.md

@@ -1,12 +1,13 @@
 # InstanceMethods API Documentation
 
-The `InstanceMethods` class provides instance-level operations for retrieving configuration and settings.
+The `InstanceMethods` class provides instance-level operations for retrieving configuration, settings, and sync status.
 
 ## Function List
 
 | Function | Description |
 |----------|-------------|
 | [getLocales](#getlocales) | Retrieves all available locales for the instance |
+| [getFetchApiStatus](#getfetchapistatus) | Gets the Fetch API CDN sync status for the instance |
 
 ---
 
@@ -51,41 +52,120 @@ interface Locales {
   name: string;           // Display name (e.g., 'English (United States)')
   isDefault: boolean;     // Whether this is the default locale
   isEnabled: boolean;     // Whether this locale is enabled
-  // Additional locale properties may be available
 }
 ```
 
-### Common Use Cases
+---
+
+## getFetchApiStatus
+
+Gets the Fetch API CDN sync status for an instance. Use this to check if changes made via the Management API have propagated to the Fetch API CDNs after batch operations or workflows.
+
+### Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| guid | string | Yes | The website GUID |
+| mode | 'fetch' \| 'preview' | No | Sync mode: 'fetch' for live/published content, 'preview' for preview content. Defaults to 'fetch'. |
+| waitForCompletion | boolean | No | If true, polls until sync is complete. Defaults to false. |
+
+### Returns
+
+`Promise<FetchApiStatus>` - The sync status object
+
+### FetchApiStatus Interface
 
 ```typescript
-// Get locale codes for content operations
-const locales = await client.instanceMethods.getLocales(guid);
-const localeCodes = locales.map(locale => locale.code);
-
-// Use with content operations
-for (const localeCode of localeCodes) {
-  const content = await client.contentMethods.getContentItem(123, guid, localeCode);
-  console.log(`Content in ${localeCode}:`, content.fields.title);
+interface FetchApiStatus {
+  timestamp?: string;                    // Record timestamp
+  completionTime?: string;               // When the sync completed
+  errorMessage?: string;                 // Error message if sync failed
+  inProgress: boolean;                   // Whether sync is currently in progress
+  itemsAffected: number;                 // Number of items being synced (only available during sync)
+  lastContentVersionID: number;          // Last content version ID synced
+  lastDeletedContentVersionID: number;   // Last deleted content version ID synced
+  lastDeletedPageVersionID: number;      // Last deleted page version ID synced
+  leaseID?: string;                      // Lease ID for the sync operation
+  maxChangeDate?: string;                // Maximum change date processed
+  maxContentModelDate?: string;          // Maximum content model date processed
+  pushType: number;                      // Push type (1 = Preview, 2 = Fetch/Live)
+  startTime?: string;                    // When the sync started
+  websiteName?: string;                  // The website name
 }
+```
 
-// Check if a specific locale is available
-const hasSpanish = locales.some(locale => locale.code === 'es-es');
-if (hasSpanish) {
-  console.log('Spanish locale is available');
+> **Note:** The `itemsAffected` count is only meaningful while sync is in progress. It decreases as items are processed and reaches 0 when sync completes.
+
+### Usage Examples
+
+#### Check Current Sync Status
+
+```typescript
+const status = await client.instanceMethods.getFetchApiStatus('your-guid');
+
+if (status.inProgress) {
+  console.log('Fetch API sync is in progress...');
+  console.log('Started at:', status.startTime);
+} else {
+  console.log('Fetch API sync is complete');
+  console.log('Completed at:', status.completionTime);
 }
+
+// Check preview content sync status
+const previewStatus = await client.instanceMethods.getFetchApiStatus('your-guid', 'preview');
+console.log('Preview sync in progress:', previewStatus.inProgress);
+```
+
+#### Wait for Sync to Complete
+
+```typescript
+// After a batch publish, wait for CDN propagation
+await client.batchMethods.publishBatch(batchId, guid);
+
+console.log('Waiting for Fetch API sync to complete...');
+const status = await client.instanceMethods.getFetchApiStatus(guid, 'fetch', true);
+console.log('Sync complete!');
+```
+
+### Complete Workflow Example
+
+```typescript
+import * as mgmtApi from '@agility/management-sdk';
+
+const options = new mgmtApi.Options();
+options.token = 'your-access-token';
+const client = new mgmtApi.ApiClient(options);
+
+const guid = 'your-instance-guid';
+const locale = 'en-us';
+
+// Step 1: Perform a large batch publish operation
+const contentIDs = [101, 102, 103, 104, 105];
+await client.contentMethods.batchWorkflowContent(
+  contentIDs, 
+  guid, 
+  locale, 
+  mgmtApi.WorkflowOperationType.Publish
+);
+console.log('Batch publish submitted');
+
+// Step 2: Wait for changes to propagate to CDN
+console.log('Waiting for Fetch API sync...');
+await client.instanceMethods.getFetchApiStatus(guid, 'fetch', true);
+console.log('Sync complete! Content is now available on the CDN');
 ```
 
 ---
 
 ## Error Handling
 
-The method throws `Exception` objects on failure:
+All methods throw `Exception` objects on failure:
 
 ```typescript
 try {
-  const locales = await client.instanceMethods.getLocales('your-guid');
+  const status = await client.instanceMethods.getFetchApiStatus('your-guid');
 } catch (error) {
-  console.error('Failed to retrieve locales:', error.message);
+  console.error('Failed to get Fetch API status:', error.message);
 }
 ```
 
@@ -102,4 +182,4 @@ try {
 - [ModelMethods](./model-methods.md)
 - [PageMethods](./page-methods.md)
 - [ServerUserMethods](./server-user-methods.md)
-- [WebhookMethods](./webhook-methods.md) 
+- [WebhookMethods](./webhook-methods.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agility/management-sdk",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "Agility CMS Tyescript SDK for Management API.",
   "repository": {
     "type": "git",