@agility/management-sdk 0.1.3 → 0.1.4-beta.1

package/dist/apiClient.d.ts

@@ -0,0 +1,86 @@
+import { ContentMethods } from "./apiMethods/contentMethods";
+import { AssetMethods } from "./apiMethods/assetMethods";
+import { BatchMethods } from "./apiMethods/batchMethods";
+import { ContainerMethods } from "./apiMethods/containerMethods";
+import { InstanceUserMethods } from "./apiMethods/instanceUserMethods";
+import { ModelMethods } from "./apiMethods/modelMethods";
+import { PageMethods } from "./apiMethods/pageMethods";
+import { Options } from "./models/options";
+import { ServerUserMethods } from "./apiMethods/serverUserMethods";
+import { WebhookMethods } from "./apiMethods/webhookMethods";
+import { InstanceMethods } from "./apiMethods/instanceMethods";
+export declare class ApiClient {
+    _options: Options;
+    contentMethods: ContentMethods;
+    assetMethods: AssetMethods;
+    batchMethods: BatchMethods;
+    containerMethods: ContainerMethods;
+    instanceUserMethods: InstanceUserMethods;
+    instanceMethods: InstanceMethods;
+    modelMethods: ModelMethods;
+    pageMethods: PageMethods;
+    serverUserMethods: ServerUserMethods;
+    webhookMethods: WebhookMethods;
+    private _authMethods;
+    constructor(options?: Options);
+    /**
+     * Set up automatic token refresh for all method classes
+     */
+    private setupTokenRefresh;
+    /**
+     * Authenticate with Agility CMS using OAuth flow
+     * This method handles the entire OAuth authentication process internally
+     *
+     * @param options - Optional OAuth configuration for custom setup
+     *
+     * @example
+     * ```typescript
+     * // Simple OAuth authentication
+     * const client = new ApiClient();
+     * await client.auth();
+     *
+     * // Client is now authenticated - make API calls directly
+     * const content = await client.contentMethods.getContentItem(123, guid, locale);
+     * ```
+     */
+    auth(options?: {
+        redirectUri?: string;
+        scope?: string;
+        region?: string;
+    }): Promise<void>;
+    /**
+     * Exchange authorization code for access tokens (part of OAuth flow)
+     * @param request - Token exchange request parameters
+     * @param region - Optional region code
+     * @returns Promise containing access and refresh tokens
+     */
+    exchangeCodeForToken(request: {
+        code: string;
+        redirectUri: string;
+        grantType?: string;
+    }, region?: string): Promise<import(".").OAuthTokenResponse>;
+    /**
+     * Check if the client is currently authenticated
+     * @returns Promise resolving to true if authenticated with valid token
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Set the access token directly (for manual token management)
+     * Also stores token in keytar for consistency
+     * @param token - Valid access token
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     * await client.setToken('your_access_token');
+     *
+     * // Now make API calls
+     * const content = await client.contentMethods.getContentItem(123, guid, locale);
+     * ```
+     */
+    setToken(token: string): Promise<void>;
+    /**
+     * Clear the current authentication token and stored tokens
+     */
+    clearToken(): Promise<void>;
+}

package/dist/apiClient.js

@@ -0,0 +1,229 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+var contentMethods_1 = require("./apiMethods/contentMethods");
+var assetMethods_1 = require("./apiMethods/assetMethods");
+var batchMethods_1 = require("./apiMethods/batchMethods");
+var containerMethods_1 = require("./apiMethods/containerMethods");
+var instanceUserMethods_1 = require("./apiMethods/instanceUserMethods");
+var modelMethods_1 = require("./apiMethods/modelMethods");
+var pageMethods_1 = require("./apiMethods/pageMethods");
+var options_1 = require("./models/options");
+var serverUserMethods_1 = require("./apiMethods/serverUserMethods");
+var webhookMethods_1 = require("./apiMethods/webhookMethods");
+var instanceMethods_1 = require("./apiMethods/instanceMethods");
+var authMethods_1 = require("./apiMethods/authMethods");
+var exception_1 = require("./models/exception");
+var ApiClient = /** @class */ (function () {
+    function ApiClient(options) {
+        if (options === void 0) { options = new options_1.Options(); }
+        this._options = options;
+        this.contentMethods = new contentMethods_1.ContentMethods(this._options);
+        this.assetMethods = new assetMethods_1.AssetMethods(this._options);
+        this.batchMethods = new batchMethods_1.BatchMethods(this._options);
+        this.containerMethods = new containerMethods_1.ContainerMethods(this._options);
+        this.instanceUserMethods = new instanceUserMethods_1.InstanceUserMethods(this._options);
+        this.instanceMethods = new instanceMethods_1.InstanceMethods(this._options);
+        this.modelMethods = new modelMethods_1.ModelMethods(this._options);
+        this.pageMethods = new pageMethods_1.PageMethods(this._options);
+        this.serverUserMethods = new serverUserMethods_1.ServerUserMethods(this._options);
+        this.webhookMethods = new webhookMethods_1.WebhookMethods(this._options);
+        this._authMethods = new authMethods_1.AuthMethods(this._options);
+        // Set up automatic token refresh for all method classes
+        this.setupTokenRefresh();
+        // If token is provided via options, store it in keytar
+        if (options.token) {
+            this._authMethods.setAccessToken(options.token).catch(function (error) {
+                // Log error but don't fail constructor
+                console.warn('Failed to store token in keytar:', error.message);
+            });
+        }
+    }
+    /**
+     * Set up automatic token refresh for all method classes
+     */
+    ApiClient.prototype.setupTokenRefresh = function () {
+        var _this = this;
+        var refreshHandler = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._authMethods.getValidAccessToken()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        // Set token refresh handler on all method classes that use ClientInstance
+        this.contentMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.assetMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.batchMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.containerMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.instanceUserMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.instanceMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.modelMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.pageMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.serverUserMethods._clientInstance.setTokenRefreshHandler(refreshHandler);
+        this.webhookMethods._cleintInstance.setTokenRefreshHandler(refreshHandler);
+    };
+    /**
+     * Authenticate with Agility CMS using OAuth flow
+     * This method handles the entire OAuth authentication process internally
+     *
+     * @param options - Optional OAuth configuration for custom setup
+     *
+     * @example
+     * ```typescript
+     * // Simple OAuth authentication
+     * const client = new ApiClient();
+     * await client.auth();
+     *
+     * // Client is now authenticated - make API calls directly
+     * const content = await client.contentMethods.getContentItem(123, guid, locale);
+     * ```
+     */
+    ApiClient.prototype.auth = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var defaultOptions, authUrl;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._authMethods.isAuthenticated()];
+                    case 1:
+                        // Check if already authenticated with valid token
+                        if (_a.sent()) {
+                            return [2 /*return*/];
+                        }
+                        defaultOptions = {
+                            redirectUri: (options === null || options === void 0 ? void 0 : options.redirectUri) || 'http://localhost:3000/auth/callback',
+                            scope: (options === null || options === void 0 ? void 0 : options.scope) || 'openid profile email offline_access',
+                            region: options === null || options === void 0 ? void 0 : options.region
+                        };
+                        authUrl = this._authMethods.generateAuthUrl(__assign(__assign({}, defaultOptions), { state: this._authMethods.generateState() }));
+                        // In a real implementation, this would:
+                        // - Open browser to auth URL
+                        // - Start local server to handle callback
+                        // - Exchange code for tokens automatically
+                        throw new exception_1.Exception("OAuth flow requires manual implementation. Please visit: ".concat(authUrl, "\n\nAfter authorization, exchange the code using:\nconst tokens = await client.exchangeCodeForToken({ code: 'auth_code', redirectUri: '").concat(defaultOptions.redirectUri, "' });"));
+                }
+            });
+        });
+    };
+    /**
+     * Exchange authorization code for access tokens (part of OAuth flow)
+     * @param request - Token exchange request parameters
+     * @param region - Optional region code
+     * @returns Promise containing access and refresh tokens
+     */
+    ApiClient.prototype.exchangeCodeForToken = function (request, region) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._authMethods.exchangeCodeForToken(request, region)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Check if the client is currently authenticated
+     * @returns Promise resolving to true if authenticated with valid token
+     */
+    ApiClient.prototype.isAuthenticated = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._authMethods.isAuthenticated()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Set the access token directly (for manual token management)
+     * Also stores token in keytar for consistency
+     * @param token - Valid access token
+     *
+     * @example
+     * ```typescript
+     * const client = new ApiClient();
+     * await client.setToken('your_access_token');
+     *
+     * // Now make API calls
+     * const content = await client.contentMethods.getContentItem(123, guid, locale);
+     * ```
+     */
+    ApiClient.prototype.setToken = function (token) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._authMethods.setAccessToken(token)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Clear the current authentication token and stored tokens
+     */
+    ApiClient.prototype.clearToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._authMethods.clearAuthentication()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ApiClient;
+}());
+exports.ApiClient = ApiClient;

package/dist/apiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiClient.js","sourceRoot":"","sources":["../src/apiClient.ts"],"names":[],"mappings":";;;AAAA,gEAA6D;AAC7D,4DAAyD;AACzD,4DAAyD;AACzD,oEAAiE;AACjE,0EAAuE;AACvE,4DAAyD;AACzD,0DAAuD;AAEvD,sEAAmE;AACnE,gEAA6D;AAC7D,kEAA+D;AAE/D,MAAa,SAAS;IAYlB,YAAY,OAAgB;QACxB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,cAAc,GAAG,IAAI,+BAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxD,IAAI,CAAC,YAAY,GAAG,IAAI,2BAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,YAAY,GAAG,IAAI,2BAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,gBAAgB,GAAG,IAAI,mCAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5D,IAAI,CAAC,mBAAmB,GAAG,IAAI,yCAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClE,IAAI,CAAC,eAAe,GAAG,IAAI,iCAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,YAAY,GAAG,IAAI,2BAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,IAAI,yBAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClD,IAAI,CAAC,iBAAiB,GAAG,IAAI,qCAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9D,IAAI,CAAC,cAAc,GAAG,IAAI,+BAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5D,CAAC;CAEJ;AA1BD,8BA0BC"}

package/dist/apiMethods/assetMethods.d.ts

@@ -1,14 +1,36 @@
 import { Options } from "../models/options";
 import { ClientInstance } from "./clientInstance";
 import { AssetMediaList, Media } from "../models/media";
+import { assetGalleries } from "../models/assetGalleries";
+import { assetMediaGrouping } from "../models/assetMediaGrouping";
+import { assetContainer } from "../models/assetContainer";
 export declare class AssetMethods {
     _options: Options;
     _clientInstance: ClientInstance;
     constructor(options: Options);
-    deleteFile(mediaID: number): Promise<string>;
-    moveFile(mediaID: number, newFolder: string): Promise<Media>;
-    getMediaList(pageSize: number, recordOffset: number): Promise<AssetMediaList>;
-    getAssetByID(mediaID: number): Promise<Media>;
-    getAssetByUrl(url: string): Promise<Media>;
-    upload(formData: FormData, agilityFolderPath: string, groupingID?: number): Promise<Media[]>;
+    deleteFile(mediaID: number, guid: string): Promise<string>;
+    moveFile(mediaID: number, newFolder: string, guid: string): Promise<Media>;
+    getMediaList(pageSize: number, recordOffset: number, guid: string): Promise<AssetMediaList>;
+    getGalleries(guid: string, search?: string, pageSize?: number, rowIndex?: number): Promise<assetGalleries>;
+    getGalleryById(guid: string, id: number): Promise<assetMediaGrouping>;
+    getGalleryByName(guid: string, galleryName: string): Promise<assetMediaGrouping>;
+    getDefaultContainer(guid: string): Promise<assetContainer>;
+    saveGallery(guid: string, gallery: assetMediaGrouping): Promise<assetMediaGrouping>;
+    deleteGallery(guid: string, id: number): Promise<string>;
+    getAssetByID(mediaID: number, guid: string): Promise<Media>;
+    getAssetByUrl(url: string, guid: string): Promise<Media>;
+    /**
+ * Uploads a file to the specified folder path.
+ *
+ * @param {*} formData - FormData object that axios is expecting for the Upload.
+ * @param {string} agilityFolderPath
+ * @param {string} guid
+ * @param {number} [groupingID=-1]
+ * @returns
+ * @memberof AssetMethods
+ */
+    upload(formData: any, agilityFolderPath: string, guid: string, groupingID?: number): Promise<Media[]>;
+    createFolder(originKey: string, guid: string): Promise<Media>;
+    deleteFolder(originKey: string, guid: string, mediaID?: number): Promise<void>;
+    renameFolder(folderName: string, newFolderName: string, guid: string, mediaID?: number): Promise<void>;
 }