contentful-management 11.52.1 → 12.0.0-beta.1

package/dist/esm/entities/tag.js

@@ -0,0 +1,50 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createTagApi(makeRequest) {
+    const getParams = (tag) => ({
+        spaceId: tag.sys.space.sys.id,
+        environmentId: tag.sys.environment.sys.id,
+        tagId: tag.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Tag',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTag(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Tag',
+                action: 'delete',
+                params: Object.assign(Object.assign({}, getParams(raw)), { version: raw.sys.version }),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapTag(makeRequest, data) {
+    const tag = toPlainObject(copy(data));
+    const tagWithMethods = enhanceWithMethods(tag, createTagApi(makeRequest));
+    return freezeSys(tagWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTagCollection = wrapCollection(wrapTag);
+
+export { createTagApi as default, wrapTag, wrapTagCollection };

package/dist/esm/entities/task.js

@@ -0,0 +1,51 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createTaskApi(makeRequest) {
+    const getParams = (task) => ({
+        spaceId: task.sys.space.sys.id,
+        environmentId: task.sys.environment.sys.id,
+        entryId: task.sys.parentEntity.sys.id,
+        taskId: task.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Task',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTask(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Task',
+                action: 'delete',
+                params: Object.assign(Object.assign({}, getParams(raw)), { version: raw.sys.version }),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapTask(makeRequest, data) {
+    const task = toPlainObject(copy(data));
+    const taskWithMethods = enhanceWithMethods(task, createTaskApi(makeRequest));
+    return freezeSys(taskWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTaskCollection = wrapCollection(wrapTask);
+
+export { createTaskApi as default, wrapTask, wrapTaskCollection };

package/dist/esm/entities/team-membership.js

@@ -0,0 +1,51 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createTeamMembershipApi(makeRequest) {
+    const getParams = (data) => ({
+        teamMembershipId: data.sys.id,
+        teamId: data.sys.team.sys.id,
+        organizationId: data.sys.organization.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTeamMembership(makeRequest, data));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamMembership',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw team membership data
+ * @return Wrapped team membership data
+ */
+function wrapTeamMembership(makeRequest, data) {
+    const teamMembership = toPlainObject(copy(data));
+    const teamMembershipWithMethods = enhanceWithMethods(teamMembership, createTeamMembershipApi(makeRequest));
+    return freezeSys(teamMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamMembershipCollection = wrapCollection(wrapTeamMembership);
+
+export { wrapTeamMembership, wrapTeamMembershipCollection };

package/dist/esm/entities/team-space-membership.js

@@ -0,0 +1,50 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createTeamSpaceMembershipApi(makeRequest) {
+    const getParams = (data) => ({
+        teamSpaceMembershipId: data.sys.id,
+        spaceId: data.sys.space.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamSpaceMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTeamSpaceMembership(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'TeamSpaceMembership',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space membership data
+ * @return Wrapped team space membership data
+ */
+function wrapTeamSpaceMembership(makeRequest, data) {
+    const teamSpaceMembership = toPlainObject(copy(data));
+    const teamSpaceMembershipWithMethods = enhanceWithMethods(teamSpaceMembership, createTeamSpaceMembershipApi(makeRequest));
+    return freezeSys(teamSpaceMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamSpaceMembershipCollection = wrapCollection(wrapTeamSpaceMembership);
+
+export { wrapTeamSpaceMembership, wrapTeamSpaceMembershipCollection };

package/dist/esm/entities/team.js

@@ -0,0 +1,50 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createTeamApi(makeRequest) {
+    const getParams = (data) => ({
+        teamId: data.sys.id,
+        organizationId: data.sys.organization.sys.id,
+    });
+    return {
+        update: function update() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Team',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapTeam(makeRequest, data));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Team',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw team data
+ * @return Wrapped team data
+ */
+function wrapTeam(makeRequest, data) {
+    const team = toPlainObject(copy(data));
+    const teamWithMethods = enhanceWithMethods(team, createTeamApi(makeRequest));
+    return freezeSys(teamWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamCollection = wrapCollection(wrapTeam);
+
+export { wrapTeam, wrapTeamCollection };

package/dist/esm/entities/ui-config.js

@@ -0,0 +1,18 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import createUIConfigApi from '../create-ui-config-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data
+ * @return Wrapped UIConfig
+ */
+function wrapUIConfig(makeRequest, data) {
+    const user = toPlainObject(copy(data));
+    const userWithMethods = enhanceWithMethods(user, createUIConfigApi(makeRequest));
+    return freezeSys(userWithMethods);
+}
+
+export { wrapUIConfig };

package/dist/esm/entities/upload.js

@@ -0,0 +1,36 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createUploadApi(makeRequest) {
+    return {
+        delete: async function del() {
+            const raw = this.toPlainObject();
+            await makeRequest({
+                entityType: 'Upload',
+                action: 'delete',
+                params: {
+                    spaceId: raw.sys.space.sys.id,
+                    environmentId: raw.sys.id,
+                    uploadId: raw.sys.id,
+                },
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {object} data - Raw upload data
+ * @return {Upload} Wrapped upload data
+ */
+function wrapUpload(makeRequest, data) {
+    const upload = toPlainObject(copy(data));
+    const uploadWithMethods = enhanceWithMethods(upload, createUploadApi(makeRequest));
+    return freezeSys(uploadWithMethods);
+}
+
+export { wrapUpload };

package/dist/esm/entities/usage.js

@@ -0,0 +1,22 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data
+ * @return Normalized usage
+ */
+function wrapUsage(_makeRequest, data) {
+    const usage = toPlainObject(copy(data));
+    const usageWithMethods = enhanceWithMethods(usage, {});
+    return freezeSys(usageWithMethods);
+}
+/**
+ * @private
+ */
+const wrapUsageCollection = wrapCollection(wrapUsage);
+
+export { wrapUsage, wrapUsageCollection };

package/dist/esm/entities/user-ui-config.js

@@ -0,0 +1,18 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import createUserUIConfigApi from '../create-user-ui-config-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data
+ * @return Wrapped UserUIConfig
+ */
+function wrapUserUIConfig(makeRequest, data) {
+    const user = toPlainObject(copy(data));
+    const userWithMethods = enhanceWithMethods(user, createUserUIConfigApi(makeRequest));
+    return freezeSys(userWithMethods);
+}
+
+export { wrapUserUIConfig };

package/dist/esm/entities/user.js

@@ -0,0 +1,25 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data
+ * @return Normalized user
+ */
+function wrapUser(_makeRequest, data) {
+    const user = toPlainObject(copy(data));
+    const userWithMethods = enhanceWithMethods(user, {});
+    return freezeSys(userWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data collection
+ * @return Normalized user collection
+ */
+const wrapUserCollection = wrapCollection(wrapUser);
+
+export { wrapUser, wrapUserCollection };

package/dist/esm/entities/webhook.js

@@ -0,0 +1,74 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createWebhookApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        webhookDefinitionId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapWebhook(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+        getCalls: function getCalls() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'getManyCallDetails',
+                params: getParams(data),
+            });
+        },
+        getCall: function getCall(id) {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'getCallDetails',
+                params: Object.assign(Object.assign({}, getParams(data)), { callId: id }),
+            });
+        },
+        getHealth: function getHealth() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'getHealthStatus',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw webhook data
+ * @return Wrapped webhook data
+ */
+function wrapWebhook(makeRequest, data) {
+    const webhook = toPlainObject(copy(data));
+    const webhookWithMethods = enhanceWithMethods(webhook, createWebhookApi(makeRequest));
+    return freezeSys(webhookWithMethods);
+}
+/**
+ * @private
+ */
+const wrapWebhookCollection = wrapCollection(wrapWebhook);
+
+export { wrapWebhook, wrapWebhookCollection };

package/dist/esm/entities/workflow-definition.js

@@ -0,0 +1,73 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+var WorkflowStepPermissionType;
+(function (WorkflowStepPermissionType) {
+    WorkflowStepPermissionType["EntityPermission"] = "entity_permission";
+    WorkflowStepPermissionType["WorkflowPermission"] = "workflow_permission";
+})(WorkflowStepPermissionType || (WorkflowStepPermissionType = {}));
+var WorkflowStepPermissionAction;
+(function (WorkflowStepPermissionAction) {
+    WorkflowStepPermissionAction["Edit"] = "edit";
+    WorkflowStepPermissionAction["Publish"] = "publish";
+    WorkflowStepPermissionAction["Delete"] = "delete";
+})(WorkflowStepPermissionAction || (WorkflowStepPermissionAction = {}));
+var WorkflowStepPermissionEffect;
+(function (WorkflowStepPermissionEffect) {
+    WorkflowStepPermissionEffect["Allow"] = "allow";
+    WorkflowStepPermissionEffect["Deny"] = "deny";
+})(WorkflowStepPermissionEffect || (WorkflowStepPermissionEffect = {}));
+/* Workflow Step Action */
+var WorkflowStepActionType;
+(function (WorkflowStepActionType) {
+    WorkflowStepActionType["App"] = "app";
+    WorkflowStepActionType["Email"] = "email";
+    WorkflowStepActionType["Task"] = "task";
+})(WorkflowStepActionType || (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 = toPlainObject(copy(data));
+    const workflowDefinitionWithMethods = enhanceWithMethods(workflowDefinition, createWorkflowDefinitionApi(makeRequest));
+    return freezeSys(workflowDefinitionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapWorkflowDefinitionCollection = wrapCollection(wrapWorkflowDefinition);
+
+export { WorkflowStepActionType, WorkflowStepPermissionAction, WorkflowStepPermissionEffect, WorkflowStepPermissionType, createWorkflowDefinitionApi as default, wrapWorkflowDefinition, wrapWorkflowDefinitionCollection };

package/dist/esm/index.js

@@ -0,0 +1,36 @@
+import { getUserAgentHeader } from 'contentful-sdk-core';
+import { createAdapter } from './create-adapter.js';
+import createClientApi from './create-contentful-api.js';
+import { createPlainClient } from './plain/plain-client.js';
+import * as index from './constants/editor-interface-defaults/index.js';
+export { index as editorInterfaceDefaults };
+export { asIterator } from './plain/as-iterator.js';
+export { fetchAll } from './plain/pagination-helper.js';
+export { isDraft, isPublished, isUpdated } from './plain/checks.js';
+export { RestAdapter } from './adapters/REST/rest-adapter.js';
+export { makeRequest } from './adapters/REST/make-request.js';
+export { ScheduledActionReferenceFilters } from './common-types.js';
+export { WorkflowStepPermissionAction, WorkflowStepPermissionEffect, WorkflowStepPermissionType } from './entities/workflow-definition.js';
+
+/**
+ * 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 = getUserAgentHeader(`${sdkMain}/${"12.0.0-beta.1"}`, params.application, params.integration, params.feature);
+    const adapter = 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 createPlainClient(makeRequest, opts.defaults);
+    }
+    else {
+        return createClientApi(makeRequest);
+    }
+}
+
+export { createClient };

package/dist/esm/methods/action.js

@@ -0,0 +1,49 @@
+import { sleep } from './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 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 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);
+}
+
+export { AsyncActionFailedError, AsyncActionProcessingError, pollAsyncActionStatus };

package/dist/esm/methods/content-type.js

@@ -0,0 +1,49 @@
+import { __rest } from '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 = __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,
+        });
+    });
+};
+
+export { omitAndDeleteField };

package/dist/esm/methods/utils.js

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