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

package/dist/cjs/entities/preview-api-key.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/**
+ * @private
+ */
+function createPreviewApiKeyApi() {
+    return {};
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key data
+ * @return Wrapped preview api key data
+ */
+function wrapPreviewApiKey(_makeRequest, data) {
+    const previewApiKey = contentfulSdkCore.toPlainObject(copy(data));
+    const previewApiKeyWithMethods = enhanceWithMethods(previewApiKey, createPreviewApiKeyApi());
+    return contentfulSdkCore.freezeSys(previewApiKeyWithMethods);
+}
+/**
+ * @private
+ */
+const wrapPreviewApiKeyCollection = commonUtils.wrapCollection(wrapPreviewApiKey);
+
+exports.wrapPreviewApiKey = wrapPreviewApiKey;
+exports.wrapPreviewApiKeyCollection = wrapPreviewApiKeyCollection;

package/dist/cjs/entities/release-action.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var action = require('../methods/action.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * @private
+ */
+function createReleaseActionApi(makeRequest) {
+    const getParams = (self) => {
+        const action = self.toPlainObject();
+        return {
+            spaceId: action.sys.space.sys.id,
+            environmentId: action.sys.environment.sys.id,
+            releaseId: action.sys.release.sys.id,
+            actionId: action.sys.id,
+        };
+    };
+    return {
+        async get() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'ReleaseAction',
+                action: 'get',
+                params,
+            }).then((releaseAction) => wrapReleaseAction(makeRequest, releaseAction));
+        },
+        /** Waits for a Release Action to complete */
+        async waitProcessing(options) {
+            return action.pollAsyncActionStatus(async () => this.get(), options);
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Release data
+ * @return Wrapped Release data
+ */
+function wrapReleaseAction(makeRequest, data) {
+    const releaseAction = contentfulSdkCore.toPlainObject(copy(data));
+    const releaseActionWithApiMethods = enhanceWithMethods(releaseAction, createReleaseActionApi(makeRequest));
+    return contentfulSdkCore.freezeSys(releaseActionWithApiMethods);
+}
+/**
+ * @private
+ */
+const wrapReleaseActionCollection = commonUtils.wrapCollection(wrapReleaseAction);
+
+exports.wrapReleaseAction = wrapReleaseAction;
+exports.wrapReleaseActionCollection = wrapReleaseActionCollection;

package/dist/cjs/entities/release.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonTypes = require('../common-types.js');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var releaseAction = require('./release-action.js');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const ReleaseReferenceFilters = commonTypes.ScheduledActionReferenceFilters;
+/**
+ * @private
+ */
+function createReleaseApi(makeRequest) {
+    const getParams = (self) => {
+        const release = self.toPlainObject();
+        return {
+            spaceId: release.sys.space.sys.id,
+            environmentId: release.sys.environment.sys.id,
+            releaseId: release.sys.id,
+            version: release.sys.version,
+        };
+    };
+    return {
+        async archive() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'archive',
+                params,
+            }).then((release) => wrapRelease(makeRequest, release));
+        },
+        async unarchive() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'unarchive',
+                params,
+            }).then((release) => wrapRelease(makeRequest, release));
+        },
+        async update(payload) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'update',
+                params,
+                payload,
+            }).then((release) => wrapRelease(makeRequest, release));
+        },
+        async delete() {
+            const params = getParams(this);
+            await makeRequest({
+                entityType: 'Release',
+                action: 'delete',
+                params,
+            });
+        },
+        async publish(options) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'publish',
+                params,
+            })
+                .then((data) => releaseAction.wrapReleaseAction(makeRequest, data))
+                .then((action) => action.waitProcessing(options));
+        },
+        async unpublish(options) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'unpublish',
+                params,
+            })
+                .then((data) => releaseAction.wrapReleaseAction(makeRequest, data))
+                .then((action) => action.waitProcessing(options));
+        },
+        async validate(options) {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'Release',
+                action: 'validate',
+                params,
+                payload: options === null || options === void 0 ? void 0 : options.payload,
+            })
+                .then((data) => releaseAction.wrapReleaseAction(makeRequest, data))
+                .then((action) => action.waitProcessing(options === null || options === void 0 ? void 0 : options.processingOptions));
+        },
+    };
+}
+/**
+ * Return a Release object enhanced with its own API helper functions.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Release data
+ * @return Wrapped Release data
+ */
+function wrapRelease(makeRequest, data) {
+    const release = contentfulSdkCore.toPlainObject(copy(data));
+    const releaseWithApiMethods = enhanceWithMethods(release, createReleaseApi(makeRequest));
+    return contentfulSdkCore.freezeSys(releaseWithApiMethods);
+}
+/**
+ * @private
+ */
+const wrapReleaseCollection = commonUtils.wrapCursorPaginatedCollection(wrapRelease);
+
+exports.ReleaseReferenceFilters = ReleaseReferenceFilters;
+exports.wrapRelease = wrapRelease;
+exports.wrapReleaseCollection = wrapReleaseCollection;

package/dist/cjs/entities/resource-provider.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var index = require('./index.js');
+
+/**
+ * @private
+ */
+function createResourceProviderApi(makeRequest) {
+    const { wrapResourceType } = index.resourceType;
+    return {
+        /**
+         * Sends an update to the server with any changes made to the object's properties
+         * @return Object returned from the server with updated changes.
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceProvider())
+         * .then((resourceProvider) => {
+         *    resourceProvider.function.sys.id = '<new_contentful_function_id>'
+         *    return resourceProvider.upsert()
+         * })
+         * .catch(console.error)
+         * ```
+         */
+        upsert: function upsert() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceProvider',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: getUpsertParams(data),
+            }).then((data) => wrapResourceProvider(makeRequest, data));
+        },
+        /**
+         * Deletes this object on the server.
+         * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceProvider())
+         * .then((resourceProvider) => resourceProvider.delete())
+         * .catch(console.error)
+         * ```
+         */
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceProvider',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+        getResourceType: function getResourceType(id) {
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'get',
+                params: {
+                    organizationId: this.sys.organization.sys.id,
+                    appDefinitionId: this.sys.appDefinition.sys.id,
+                    resourceTypeId: id,
+                },
+            }).then((data) => wrapResourceType(makeRequest, data));
+        },
+        upsertResourceType: function upsertResourceType(id, data) {
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'upsert',
+                params: {
+                    organizationId: this.sys.organization.sys.id,
+                    appDefinitionId: this.sys.appDefinition.sys.id,
+                    resourceTypeId: id,
+                },
+                headers: {},
+                payload: data,
+            }).then((data) => wrapResourceType(makeRequest, data));
+        },
+        getResourceTypes: function getResourceTypes() {
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'getMany',
+                params: {
+                    organizationId: this.sys.organization.sys.id,
+                    appDefinitionId: this.sys.appDefinition.sys.id,
+                },
+            }).then((data) => {
+                data.items = data.items.map((item) => wrapResourceType(makeRequest, item));
+                return data;
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param data - raw ResourceProvider Object
+ * @return Object containing the http params for the ResourceProvider request: organizationId and appDefinitionId
+ */
+const getParams = (data) => ({
+    organizationId: data.sys.organization.sys.id,
+    appDefinitionId: data.sys.appDefinition.sys.id,
+});
+/**
+ * @private
+ * @param data - raw ResourceProvider Object
+ * @return UpsertResourceProviderProps
+ */
+const getUpsertParams = (data) => ({
+    sys: { id: data.sys.id },
+    type: data.type,
+    function: data.function,
+});
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Provider data
+ * @return Wrapped Resource Provider data
+ */
+function wrapResourceProvider(makeRequest, data) {
+    const resourceProvider = contentfulSdkCore.toPlainObject(copy(data));
+    const ResourceProviderWithMethods = enhanceWithMethods(resourceProvider, createResourceProviderApi(makeRequest));
+    return contentfulSdkCore.freezeSys(ResourceProviderWithMethods);
+}
+
+exports.wrapResourceProvider = wrapResourceProvider;

package/dist/cjs/entities/resource-type.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ */
+function createResourceTypeApi(makeRequest) {
+    return {
+        /**
+         * Sends an update to the server with any changes made to the object's properties
+         * @return Object returned from the server with updated changes.
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceType())
+         * .then((resourceType) => {
+         *    resourceType.name = '<new_name>'
+         *    return resourceType.upsert()
+         * })
+         * .catch(console.error)
+         * ```
+         */
+        upsert: function upsert() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: getUpsertParams(data),
+            }).then((data) => wrapResourceType(makeRequest, data));
+        },
+        /**
+         * Deletes this object on the server.
+         * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceType())
+         * .then((resourceType) => resourceType.delete())
+         * .catch(console.error)
+         * ```
+         */
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+const getParams = (data) => ({
+    organizationId: data.sys.organization.sys.id,
+    appDefinitionId: data.sys.appDefinition.sys.id,
+    resourceTypeId: data.sys.id,
+});
+const getUpsertParams = (data) => ({
+    name: data.name,
+    defaultFieldMapping: data.defaultFieldMapping,
+});
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Type data
+ * @return Wrapped Resource Type data
+ */
+function wrapResourceType(makeRequest, data) {
+    const resourceType = contentfulSdkCore.toPlainObject(copy(data));
+    const ResourceTypeWithMethods = enhanceWithMethods(resourceType, createResourceTypeApi(makeRequest));
+    return contentfulSdkCore.freezeSys(ResourceTypeWithMethods);
+}
+function wrapResourceTypeforEnvironment(makeRequest, data) {
+    const resourceType = contentfulSdkCore.toPlainObject(data);
+    return contentfulSdkCore.freezeSys(resourceType);
+}
+const wrapResourceTypesForEnvironmentCollection = commonUtils.wrapCursorPaginatedCollection(wrapResourceTypeforEnvironment);
+
+exports.wrapResourceType = wrapResourceType;
+exports.wrapResourceTypeforEnvironment = wrapResourceTypeforEnvironment;
+exports.wrapResourceTypesForEnvironmentCollection = wrapResourceTypesForEnvironmentCollection;

package/dist/cjs/entities/resource.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var commonUtils = require('../common-utils.js');
+var contentfulSdkCore = require('contentful-sdk-core');
+
+function wrapResource(makeRequest, data) {
+    const resource = contentfulSdkCore.toPlainObject(data);
+    return contentfulSdkCore.freezeSys(resource);
+}
+const wrapResourceCollection = commonUtils.wrapCursorPaginatedCollection(wrapResource);
+
+exports.wrapResource = wrapResource;
+exports.wrapResourceCollection = wrapResourceCollection;

package/dist/cjs/entities/role.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ */
+function createRoleApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        roleId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Role',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapRole(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Role',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw role data
+ * @return Wrapped role data
+ */
+function wrapRole(makeRequest, data) {
+    const role = contentfulSdkCore.toPlainObject(copy(data));
+    const roleWithMethods = enhanceWithMethods(role, createRoleApi(makeRequest));
+    return contentfulSdkCore.freezeSys(roleWithMethods);
+}
+/**
+ * @private
+ */
+const wrapRoleCollection = commonUtils.wrapCollection(wrapRole);
+
+exports.wrapRole = wrapRole;
+exports.wrapRoleCollection = wrapRoleCollection;

package/dist/cjs/entities/scheduled-action.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/**
+ * Represents that state of the scheduled action
+ */
+exports.ScheduledActionStatus = void 0;
+(function (ScheduledActionStatus) {
+    /** action is pending execution */
+    ScheduledActionStatus["scheduled"] = "scheduled";
+    /** action has been started and pending completion */
+    ScheduledActionStatus["inProgress"] = "inProgress";
+    /** action was completed successfully (terminal state) */
+    ScheduledActionStatus["succeeded"] = "succeeded";
+    /** action failed to complete (terminal state) */
+    ScheduledActionStatus["failed"] = "failed";
+    /** action was canceled by a user (terminal state) */
+    ScheduledActionStatus["canceled"] = "canceled";
+})(exports.ScheduledActionStatus || (exports.ScheduledActionStatus = {}));
+function getInstanceMethods(makeRequest) {
+    const getParams = (self) => {
+        var _a;
+        const scheduledAction = self.toPlainObject();
+        return {
+            spaceId: scheduledAction.sys.space.sys.id,
+            environmentId: (_a = scheduledAction.environment) === null || _a === void 0 ? void 0 : _a.sys.id,
+            scheduledActionId: scheduledAction.sys.id,
+            version: scheduledAction.sys.version,
+        };
+    };
+    return {
+        /**
+         * Cancels the current Scheduled Action schedule.
+         *
+         * @example ```javascript
+         *  const contentful = require('contentful-management');
+         *
+         *  const client = contentful.createClient({
+         *    accessToken: '<content_management_api_key>'
+         *  })
+         *
+         *  client.getSpace('<space_id>')
+         *    .then((space) => {
+         *      return space.createScheduledAction({
+         *        entity: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Entry',
+         *            id: '<entry_id>'
+         *          }
+         *        },
+         *        environment: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Environment',
+         *            id: '<environment_id>'
+         *          }
+         *        },
+         *        action: 'publish',
+         *        scheduledFor: {
+         *          datetime: <ISO_date_string>,
+         *          timezone: 'Europe/Berlin'
+         *        }
+         *      })
+         *    .then((scheduledAction) => scheduledAction.delete())
+         *    .then((deletedScheduledAction) => console.log(deletedScheduledAction))
+         *    .catch(console.error);
+         * ```
+         */
+        async delete() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'delete',
+                params,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+        /**
+         * Update the current scheduled action. Currently, only changes made to the `scheduledFor` property will be saved.
+         *
+         * @example ```javascript
+         *  const contentful = require('contentful-management');
+         *
+         *  const client = contentful.createClient({
+         *    accessToken: '<content_management_api_key>'
+         *  })
+         *
+         *  client.getSpace('<space_id>')
+         *    .then((space) => {
+         *      return space.createScheduledAction({
+         *        entity: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Entry',
+         *            id: '<entry_id>'
+         *          }
+         *        },
+         *        environment: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Environment',
+         *            id: '<environment_id>'
+         *          }
+         *        },
+         *        action: 'publish',
+         *        scheduledFor: {
+         *          datetime: <ISO_date_string>,
+         *          timezone: 'Europe/Berlin'
+         *        }
+         *      })
+         *    .then((scheduledAction) => {
+         *      scheduledAction.scheduledFor.timezone = 'Europe/Paris';
+         *      return scheduledAction.update();
+         *    })
+         *    .then((scheduledAction) => console.log(scheduledAction))
+         *    .catch(console.error);
+         * ```
+         */
+        async update() {
+            const params = getParams(this);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _a = this.toPlainObject(), payload = tslib.__rest(_a, ["sys"]);
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'update',
+                params,
+                payload,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapScheduledAction(makeRequest, data) {
+    const scheduledAction = contentfulSdkCore.toPlainObject(copy(data));
+    const scheduledActionWithMethods = enhanceWithMethods(scheduledAction, getInstanceMethods(makeRequest));
+    return contentfulSdkCore.freezeSys(scheduledActionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapScheduledActionCollection = commonUtils.wrapCollection(wrapScheduledAction);
+
+exports.default = getInstanceMethods;
+exports.wrapScheduledAction = wrapScheduledAction;
+exports.wrapScheduledActionCollection = wrapScheduledActionCollection;