contentful-management 12.0.0-beta.1 → 12.0.0-beta.3

package/dist/cjs/entities/workflow-definition.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+exports.WorkflowStepPermissionType = void 0;
+(function (WorkflowStepPermissionType) {
+    WorkflowStepPermissionType["EntityPermission"] = "entity_permission";
+    WorkflowStepPermissionType["WorkflowPermission"] = "workflow_permission";
+})(exports.WorkflowStepPermissionType || (exports.WorkflowStepPermissionType = {}));
+exports.WorkflowStepPermissionAction = void 0;
+(function (WorkflowStepPermissionAction) {
+    WorkflowStepPermissionAction["Edit"] = "edit";
+    WorkflowStepPermissionAction["Publish"] = "publish";
+    WorkflowStepPermissionAction["Delete"] = "delete";
+})(exports.WorkflowStepPermissionAction || (exports.WorkflowStepPermissionAction = {}));
+exports.WorkflowStepPermissionEffect = void 0;
+(function (WorkflowStepPermissionEffect) {
+    WorkflowStepPermissionEffect["Allow"] = "allow";
+    WorkflowStepPermissionEffect["Deny"] = "deny";
+})(exports.WorkflowStepPermissionEffect || (exports.WorkflowStepPermissionEffect = {}));
+/* Workflow Step Action */
+exports.WorkflowStepActionType = void 0;
+(function (WorkflowStepActionType) {
+    WorkflowStepActionType["App"] = "app";
+    WorkflowStepActionType["Email"] = "email";
+    WorkflowStepActionType["Task"] = "task";
+})(exports.WorkflowStepActionType || (exports.WorkflowStepActionType = {}));
+/**
+ * @private
+ */
+function createWorkflowDefinitionApi(makeRequest) {
+    const getParams = (workflowDefinition) => ({
+        spaceId: workflowDefinition.sys.space.sys.id,
+        environmentId: workflowDefinition.sys.environment.sys.id,
+        workflowDefinitionId: workflowDefinition.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'WorkflowDefinition',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapWorkflowDefinition(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'WorkflowDefinition',
+                action: 'delete',
+                params: Object.assign(Object.assign({}, getParams(raw)), { version: raw.sys.version }),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapWorkflowDefinition(makeRequest, data) {
+    const workflowDefinition = contentfulSdkCore.toPlainObject(copy(data));
+    const workflowDefinitionWithMethods = enhanceWithMethods(workflowDefinition, createWorkflowDefinitionApi(makeRequest));
+    return contentfulSdkCore.freezeSys(workflowDefinitionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapWorkflowDefinitionCollection = commonUtils.wrapCollection(wrapWorkflowDefinition);
+
+exports.default = createWorkflowDefinitionApi;
+exports.wrapWorkflowDefinition = wrapWorkflowDefinition;
+exports.wrapWorkflowDefinitionCollection = wrapWorkflowDefinitionCollection;

package/dist/cjs/index.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var createAdapter = require('./create-adapter.js');
+var createContentfulApi = require('./create-contentful-api.js');
+var plainClient = require('./plain/plain-client.js');
+var index = require('./constants/editor-interface-defaults/index.js');
+var asIterator = require('./plain/as-iterator.js');
+var paginationHelper = require('./plain/pagination-helper.js');
+var checks = require('./plain/checks.js');
+var restAdapter = require('./adapters/REST/rest-adapter.js');
+var makeRequest = require('./adapters/REST/make-request.js');
+var commonTypes = require('./common-types.js');
+var workflowDefinition = require('./entities/workflow-definition.js');
+
+function _interopNamespaceDefaultOnly (e) { return Object.freeze({ __proto__: null, default: e }); }
+
+var index__namespace = /*#__PURE__*/_interopNamespaceDefaultOnly(index);
+
+/**
+ * Contentful Management API SDK. Allows you to create instances of a client
+ * with access to the Contentful Content Management API.
+ * @packageDocumentation
+ */
+function createClient(params, opts = {}) {
+    const sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
+    const userAgent = contentfulSdkCore.getUserAgentHeader(`${sdkMain}/${"12.0.0-beta.3"}`, params.application, params.integration, params.feature);
+    const adapter = createAdapter.createAdapter(Object.assign(Object.assign({}, params), { userAgent }));
+    // Parameters<?> and ReturnType<?> only return the types of the last overload
+    // https://github.com/microsoft/TypeScript/issues/26591
+    // @ts-expect-error
+    const makeRequest = (options) => adapter.makeRequest(Object.assign(Object.assign({}, options), { userAgent }));
+    if (opts.type === 'plain') {
+        return plainClient.createPlainClient(makeRequest, opts.defaults);
+    }
+    else {
+        return createContentfulApi(makeRequest);
+    }
+}
+
+exports.editorInterfaceDefaults = index__namespace;
+exports.asIterator = asIterator.asIterator;
+exports.fetchAll = paginationHelper.fetchAll;
+exports.isDraft = checks.isDraft;
+exports.isPublished = checks.isPublished;
+exports.isUpdated = checks.isUpdated;
+exports.RestAdapter = restAdapter.RestAdapter;
+exports.makeRequest = makeRequest.makeRequest;
+Object.defineProperty(exports, "ScheduledActionReferenceFilters", {
+    enumerable: true,
+    get: function () { return commonTypes.ScheduledActionReferenceFilters; }
+});
+Object.defineProperty(exports, "WorkflowStepPermissionAction", {
+    enumerable: true,
+    get: function () { return workflowDefinition.WorkflowStepPermissionAction; }
+});
+Object.defineProperty(exports, "WorkflowStepPermissionEffect", {
+    enumerable: true,
+    get: function () { return workflowDefinition.WorkflowStepPermissionEffect; }
+});
+Object.defineProperty(exports, "WorkflowStepPermissionType", {
+    enumerable: true,
+    get: function () { return workflowDefinition.WorkflowStepPermissionType; }
+});
+exports.createClient = createClient;

package/dist/cjs/methods/action.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var utils = require('./utils.js');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const DEFAULT_MAX_RETRIES = 30;
+const DEFAULT_INITIAL_DELAY_MS = 1000;
+const DEFAULT_RETRY_INTERVAL_MS = 2000;
+class AsyncActionProcessingError extends Error {
+    constructor(message, action) {
+        super(message);
+        this.action = action;
+        this.name = this.constructor.name;
+    }
+}
+class AsyncActionFailedError extends AsyncActionProcessingError {
+}
+/**
+ * @description Waits for an Action to be completed and to be in one of the final states (failed or succeeded)
+ * @param {Function} actionFunction - GET function that will be called every interval to fetch an Action status
+ * @throws {ActionFailedError} throws an error if `throwOnFailedExecution = true` with the Action that failed.
+ * @throws {AsyncActionProcessingError} throws an error with a Action when processing takes too long.
+ */
+async function pollAsyncActionStatus(actionFunction, options) {
+    var _a, _b, _c, _d;
+    let retryCount = 0;
+    let done = false;
+    let action;
+    const maxRetries = (_a = options === null || options === void 0 ? void 0 : options.retryCount) !== null && _a !== void 0 ? _a : DEFAULT_MAX_RETRIES;
+    const retryIntervalMs = (_b = options === null || options === void 0 ? void 0 : options.retryIntervalMs) !== null && _b !== void 0 ? _b : DEFAULT_RETRY_INTERVAL_MS;
+    const initialDelayMs = (_c = options === null || options === void 0 ? void 0 : options.initialDelayMs) !== null && _c !== void 0 ? _c : DEFAULT_INITIAL_DELAY_MS;
+    const throwOnFailedExecution = (_d = options === null || options === void 0 ? void 0 : options.throwOnFailedExecution) !== null && _d !== void 0 ? _d : true;
+    // Initial delay for short-running Actions
+    await utils.sleep(initialDelayMs);
+    while (retryCount < maxRetries && !done) {
+        action = await actionFunction();
+        // Terminal states
+        if (action && ['succeeded', 'failed'].includes(action.sys.status)) {
+            done = true;
+            if (action.sys.status === 'failed' && throwOnFailedExecution) {
+                throw new AsyncActionFailedError(`${action.sys.type} failed to execute.`, action);
+            }
+            return action;
+        }
+        await utils.sleep(retryIntervalMs);
+        retryCount += 1;
+    }
+    throw new AsyncActionProcessingError(`${action === null || action === void 0 ? void 0 : action.sys.type} didn't finish processing within the expected timeframe.`, action);
+}
+
+exports.AsyncActionFailedError = AsyncActionFailedError;
+exports.AsyncActionProcessingError = AsyncActionProcessingError;
+exports.pollAsyncActionStatus = pollAsyncActionStatus;

package/dist/cjs/methods/content-type.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var tslib = require('tslib');
+
+/**
+ * @private
+ * @param id - unique ID of the field
+ * @param key - the attribute on the field to change
+ * @param value - the value to set the attribute to
+ */
+const findAndUpdateField = function (contentType, fieldId, omitOrDelete) {
+    const field = contentType.fields.find((field) => field.id === fieldId);
+    if (!field) {
+        return Promise.reject(new Error(`Tried to omitAndDeleteField on a nonexistent field, ${fieldId}, on the content type ${contentType.name}.`));
+    }
+    field[omitOrDelete] = true;
+    return Promise.resolve(contentType);
+};
+const omitAndDeleteField = (makeRequest, _a, contentType) => {
+    var { fieldId } = _a, params = tslib.__rest(_a, ["fieldId"]);
+    return findAndUpdateField(contentType, fieldId, 'omitted')
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'update',
+            params,
+            payload: newContentType,
+        });
+    })
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'publish',
+            params,
+            payload: newContentType,
+        });
+    })
+        .then((newContentType) => {
+        return findAndUpdateField(newContentType, fieldId, 'deleted');
+    })
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'update',
+            params,
+            payload: newContentType,
+        });
+    });
+};
+
+exports.omitAndDeleteField = omitAndDeleteField;

package/dist/cjs/methods/utils.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Helper function that resolves a Promise after the specified duration (in milliseconds)
+ * @private
+ */
+function sleep(durationMs) {
+    return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+
+exports.sleep = sleep;

package/dist/cjs/plain/as-iterator.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var copy = require('fast-copy');
+
+const asIterator = (fn, params) => {
+    return {
+        [Symbol.asyncIterator]() {
+            let options = copy(params);
+            const get = () => fn(copy(options));
+            let currentResult = get();
+            return {
+                current: 0,
+                async next() {
+                    const { total = 0, items = [], skip = 0, limit = 100 } = await currentResult;
+                    if (total === this.current) {
+                        return { done: true, value: null };
+                    }
+                    const value = items[this.current++ - skip];
+                    const endOfPage = this.current % limit === 0;
+                    const endOfList = this.current === total;
+                    if (endOfPage && !endOfList) {
+                        options = Object.assign(Object.assign({}, options), { query: Object.assign(Object.assign({}, options.query), { skip: skip + limit }) });
+                        currentResult = get();
+                    }
+                    return { done: false, value };
+                },
+            };
+        },
+    };
+};
+
+exports.asIterator = asIterator;

package/dist/cjs/plain/checks.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const isPublished = (data) => !!data.sys.publishedVersion;
+const isUpdated = (data) => {
+    // The act of publishing an entity increases its version by 1, so any entry which has
+    // 2 versions higher or more than the publishedVersion has unpublished changes.
+    return !!(data.sys.publishedVersion && data.sys.version > data.sys.publishedVersion + 1);
+};
+const isDraft = (data) => !data.sys.publishedVersion;
+const isArchived = (data) => !!data.sys.archivedVersion;
+
+exports.isArchived = isArchived;
+exports.isDraft = isDraft;
+exports.isPublished = isPublished;
+exports.isUpdated = isUpdated;

package/dist/cjs/plain/pagination-helper.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+function isOffsetBasedCollection(collection) {
+    return 'total' in collection;
+}
+function isCursorBasedCollection(collection) {
+    return 'pages' in collection;
+}
+function getSearchParam(url, paramName) {
+    const searchIndex = url.indexOf('?');
+    if (searchIndex < 0) {
+        return null;
+    }
+    const rawSearchParams = url.slice(searchIndex + 1);
+    const searchParams = new URLSearchParams(rawSearchParams);
+    return searchParams.get(paramName);
+}
+function range(from, to) {
+    return Array.from(Array(Math.abs(to - from)), (_, i) => from + i);
+}
+/**
+ * Parameters for endpoint methods that can be paginated are inconsistent, `fetchAll` will only
+ * work with the more common version of supplying the limit, skip, and pageNext parameters via a distinct `query` property in the
+ * parameters.
+ */
+async function fetchAll(fetchFn, params) {
+    const response = await fetchFn(Object.assign({}, params));
+    if (isOffsetBasedCollection(response)) {
+        const { total, limit, items } = response;
+        const hasMorePages = total > items.length;
+        if (!hasMorePages) {
+            return items;
+        }
+        const pageCount = Math.ceil(total / limit);
+        const promises = range(1, pageCount).map((page) => fetchFn(Object.assign(Object.assign({}, params), { query: Object.assign(Object.assign({}, params.query), { limit, skip: page * limit }) })).then((result) => result.items));
+        const remainingItems = await Promise.all(promises);
+        return [...items, ...remainingItems.flat(1)];
+    }
+    if (isCursorBasedCollection(response)) {
+        const { pages, items } = response;
+        if (!pages.next) {
+            return items;
+        }
+        const pageNext = getSearchParam(pages.next, 'pageNext');
+        if (!pageNext) {
+            throw new Error('Missing "pageNext" query param from pages.next from response.');
+        }
+        return [
+            ...items,
+            ...(await fetchAll(fetchFn, Object.assign(Object.assign({}, params), { query: Object.assign(Object.assign({}, params.query), { pageNext }) }))),
+        ];
+    }
+    throw new Error(`Can not determine collection type of response, neither property "total" nor "pages" are present.`);
+}
+
+exports.fetchAll = fetchAll;