contentful-management 12.0.0-beta.8 → 12.0.0-beta.9

package/dist/types/entities/resource-provider.js

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

package/dist/types/entities/resource-type.js

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

package/dist/types/entities/resource.js

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

package/dist/types/entities/role.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 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 = toPlainObject(copy(data));
+    const roleWithMethods = enhanceWithMethods(role, createRoleApi(makeRequest));
+    return freezeSys(roleWithMethods);
+}
+/**
+ * @private
+ */
+const wrapRoleCollection = wrapCollection(wrapRole);
+
+export { wrapRole, wrapRoleCollection };

package/dist/types/entities/scheduled-action.js

@@ -0,0 +1,146 @@
+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';
+
+/**
+ * Represents that state of the scheduled action
+ */
+var ScheduledActionStatus;
+(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";
+})(ScheduledActionStatus || (ScheduledActionStatus = {}));
+function getInstanceMethods(makeRequest) {
+    const getParams = (self) => {
+        const scheduledAction = self.toPlainObject();
+        return {
+            spaceId: scheduledAction.sys.space.sys.id,
+            environmentId: scheduledAction.environment?.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 { sys, ...payload } = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'update',
+                params,
+                payload,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapScheduledAction(makeRequest, data) {
+    const scheduledAction = toPlainObject(copy(data));
+    const scheduledActionWithMethods = enhanceWithMethods(scheduledAction, getInstanceMethods(makeRequest));
+    return freezeSys(scheduledActionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapScheduledActionCollection = wrapCollection(wrapScheduledAction);
+
+export { ScheduledActionStatus, getInstanceMethods as default, wrapScheduledAction, wrapScheduledActionCollection };

package/dist/types/entities/snapshot.js

@@ -0,0 +1,33 @@
+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 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
+ */
+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
+ */
+const wrapSnapshotCollection = wrapCollection(wrapSnapshot);
+
+export { wrapSnapshot, wrapSnapshotCollection };

package/dist/types/entities/space-member.js

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

package/dist/types/entities/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 createSpaceMembershipApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        spaceMembershipId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'SpaceMembership',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapSpaceMembership(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'SpaceMembership',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space membership data
+ * @return Wrapped space membership data
+ */
+function wrapSpaceMembership(makeRequest, data) {
+    const spaceMembership = toPlainObject(copy(data));
+    const spaceMembershipWithMethods = enhanceWithMethods(spaceMembership, createSpaceMembershipApi(makeRequest));
+    return freezeSys(spaceMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapSpaceMembershipCollection = wrapCollection(wrapSpaceMembership);
+
+export { wrapSpaceMembership, wrapSpaceMembershipCollection };

package/dist/types/entities/space.js

@@ -0,0 +1,30 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import createSpaceApi from '../create-space-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * This method creates the API for the given space with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a space id, so the base path for requests now has the
+ * space id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Space
+ * @return {Space}
+ */
+function wrapSpace(makeRequest, data) {
+    const space = toPlainObject(copy(data));
+    const spaceApi = createSpaceApi(makeRequest);
+    const enhancedSpace = enhanceWithMethods(space, spaceApi);
+    return freezeSys(enhancedSpace);
+}
+/**
+ * This method wraps each space in a collection with the space API. See wrapSpace
+ * above for more details.
+ * @private
+ */
+const wrapSpaceCollection = wrapCollection(wrapSpace);
+
+export { wrapSpace, wrapSpaceCollection };

package/dist/types/entities/tag.js

@@ -0,0 +1,53 @@
+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: {
+                    ...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/types/entities/task.js

@@ -0,0 +1,54 @@
+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: {
+                    ...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 };