contentful-management 11.64.0-new-beta.4 → 11.64.0

package/dist/es-modules/entities/release-action.js

@@ -0,0 +1,53 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+import { pollAsyncActionStatus } from '../methods/action';
+import enhanceWithMethods from '../enhance-with-methods';
+
+/** The object returned by the Releases API */
+
+/**
+ * @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 pollAsyncActionStatus(async () => this.get(), options);
+    }
+  };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Release data
+ * @return Wrapped Release data
+ */
+export function wrapReleaseAction(makeRequest, data) {
+  const releaseAction = toPlainObject(copy(data));
+  const releaseActionWithApiMethods = enhanceWithMethods(releaseAction, createReleaseActionApi(makeRequest));
+  return freezeSys(releaseActionWithApiMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapReleaseActionCollection = wrapCollection(wrapReleaseAction);

package/dist/es-modules/entities/release.js

@@ -0,0 +1,105 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { ScheduledActionReferenceFilters } from '../common-types';
+import { wrapCursorPaginatedCollection } from '../common-utils';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapReleaseAction } from './release-action';
+
+/** Entity types supported by the Release API */
+
+export const ReleaseReferenceFilters = ScheduledActionReferenceFilters;
+
+/** The object returned by the Releases API */
+
+/**
+ * @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 => wrapReleaseAction(makeRequest, data)).then(action => action.waitProcessing(options));
+    },
+    async unpublish(options) {
+      const params = getParams(this);
+      return makeRequest({
+        entityType: 'Release',
+        action: 'unpublish',
+        params
+      }).then(data => 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 => 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
+ */
+export function wrapRelease(makeRequest, data) {
+  const release = toPlainObject(copy(data));
+  const releaseWithApiMethods = enhanceWithMethods(release, createReleaseApi(makeRequest));
+  return freezeSys(releaseWithApiMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapReleaseCollection = wrapCursorPaginatedCollection(wrapRelease);

package/dist/es-modules/entities/resource-provider.js

@@ -0,0 +1,139 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods';
+import entities from '.';
+/**
+ * @private
+ */
+function createResourceProviderApi(makeRequest) {
+  const {
+    wrapResourceType
+  } = entities.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
+ */
+export function wrapResourceProvider(makeRequest, data) {
+  const resourceProvider = toPlainObject(copy(data));
+  const ResourceProviderWithMethods = enhanceWithMethods(resourceProvider, createResourceProviderApi(makeRequest));
+  return freezeSys(ResourceProviderWithMethods);
+}

package/dist/es-modules/entities/resource-type.js

@@ -0,0 +1,93 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapCursorPaginatedCollection } from '../common-utils';
+const publicResourceTypeFields = ['name'];
+/**
+ * @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
+ */
+export function wrapResourceType(makeRequest, data) {
+  const resourceType = toPlainObject(copy(data));
+  const ResourceTypeWithMethods = enhanceWithMethods(resourceType, createResourceTypeApi(makeRequest));
+  return freezeSys(ResourceTypeWithMethods);
+}
+export function wrapResourceTypeforEnvironment(makeRequest, data) {
+  const resourceType = toPlainObject(data);
+  return freezeSys(resourceType);
+}
+export const wrapResourceTypesForEnvironmentCollection = wrapCursorPaginatedCollection(wrapResourceTypeforEnvironment);

package/dist/es-modules/entities/resource.js

@@ -0,0 +1,7 @@
+import { wrapCursorPaginatedCollection } from '../common-utils';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+export function wrapResource(makeRequest, data) {
+  const resource = toPlainObject(data);
+  return freezeSys(resource);
+}
+export const wrapResourceCollection = wrapCursorPaginatedCollection(wrapResource);

package/dist/es-modules/entities/role.js

@@ -0,0 +1,49 @@
+import copy from 'fast-copy';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapCollection } from '../common-utils';
+/**
+ * @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
+ */
+export function wrapRole(makeRequest, data) {
+  const role = toPlainObject(copy(data));
+  const roleWithMethods = enhanceWithMethods(role, createRoleApi(makeRequest));
+  return freezeSys(roleWithMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapRoleCollection = wrapCollection(wrapRole);

package/dist/es-modules/entities/scheduled-action.js

@@ -0,0 +1,155 @@
+const _excluded = ["sys"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+import enhanceWithMethods from '../enhance-with-methods';
+
+/**
+ * Represents that state of the scheduled action
+ */
+export let ScheduledActionStatus = /*#__PURE__*/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";
+  return ScheduledActionStatus;
+}({});
+export default function getInstanceMethods(makeRequest) {
+  const getParams = self => {
+    var _scheduledAction$envi;
+    const scheduledAction = self.toPlainObject();
+    return {
+      spaceId: scheduledAction.sys.space.sys.id,
+      environmentId: (_scheduledAction$envi = scheduledAction.environment) === null || _scheduledAction$envi === void 0 ? void 0 : _scheduledAction$envi.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 _this$toPlainObject = this.toPlainObject(),
+        {
+          sys
+        } = _this$toPlainObject,
+        payload = _objectWithoutProperties(_this$toPlainObject, _excluded);
+      return makeRequest({
+        entityType: 'ScheduledAction',
+        action: 'update',
+        params,
+        payload
+      }).then(data => wrapScheduledAction(makeRequest, data));
+    }
+  };
+}
+
+/**
+ * @private
+ */
+export function wrapScheduledAction(makeRequest, data) {
+  const scheduledAction = toPlainObject(copy(data));
+  const scheduledActionWithMethods = enhanceWithMethods(scheduledAction, getInstanceMethods(makeRequest));
+  return freezeSys(scheduledActionWithMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapScheduledActionCollection = wrapCollection(wrapScheduledAction);

package/dist/es-modules/entities/snapshot.js

@@ -0,0 +1,31 @@
+import copy from 'fast-copy';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapCollection } from '../common-utils';
+/**
+ * @private
+ */
+function createSnapshotApi() {
+  return {
+    /* In case the snapshot object evolve later */
+  };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot data
+ * @return Wrapped snapshot data
+ */
+export function wrapSnapshot(_makeRequest, data) {
+  const snapshot = toPlainObject(copy(data));
+  const snapshotWithMethods = enhanceWithMethods(snapshot, createSnapshotApi());
+  return freezeSys(snapshotWithMethods);
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot collection data
+ * @return Wrapped snapshot collection data
+ */
+export const wrapSnapshotCollection = wrapCollection(wrapSnapshot);

package/dist/es-modules/entities/space-member.js

@@ -0,0 +1,18 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space member data
+ * @return Wrapped space member data
+ */
+export function wrapSpaceMember(_makeRequest, data) {
+  const spaceMember = toPlainObject(copy(data));
+  return freezeSys(spaceMember);
+}
+
+/**
+ * @private
+ */
+export const wrapSpaceMemberCollection = wrapCollection(wrapSpaceMember);