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

package/dist/cjs/entities/snapshot.cjs

@@ -0,0 +1,36 @@
+'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 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 = contentfulSdkCore.toPlainObject(copy(data));
+    const snapshotWithMethods = enhanceWithMethods(snapshot, createSnapshotApi());
+    return contentfulSdkCore.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 = commonUtils.wrapCollection(wrapSnapshot);
+
+exports.wrapSnapshot = wrapSnapshot;
+exports.wrapSnapshotCollection = wrapSnapshotCollection;

package/dist/cjs/entities/space-member.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../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 = contentfulSdkCore.toPlainObject(copy(data));
+    return contentfulSdkCore.freezeSys(spaceMember);
+}
+/**
+ * @private
+ */
+const wrapSpaceMemberCollection = commonUtils.wrapCollection(wrapSpaceMember);
+
+exports.wrapSpaceMember = wrapSpaceMember;
+exports.wrapSpaceMemberCollection = wrapSpaceMemberCollection;

package/dist/cjs/entities/space-membership.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 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 = contentfulSdkCore.toPlainObject(copy(data));
+    const spaceMembershipWithMethods = enhanceWithMethods(spaceMembership, createSpaceMembershipApi(makeRequest));
+    return contentfulSdkCore.freezeSys(spaceMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapSpaceMembershipCollection = commonUtils.wrapCollection(wrapSpaceMembership);
+
+exports.wrapSpaceMembership = wrapSpaceMembership;
+exports.wrapSpaceMembershipCollection = wrapSpaceMembershipCollection;

package/dist/cjs/entities/space.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var createSpaceApi = require('../create-space-api.js');
+var enhanceWithMethods = require('../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 = contentfulSdkCore.toPlainObject(copy(data));
+    const spaceApi = createSpaceApi(makeRequest);
+    const enhancedSpace = enhanceWithMethods(space, spaceApi);
+    return contentfulSdkCore.freezeSys(enhancedSpace);
+}
+/**
+ * This method wraps each space in a collection with the space API. See wrapSpace
+ * above for more details.
+ * @private
+ */
+const wrapSpaceCollection = commonUtils.wrapCollection(wrapSpace);
+
+exports.wrapSpace = wrapSpace;
+exports.wrapSpaceCollection = wrapSpaceCollection;

package/dist/cjs/entities/tag.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/**
+ * @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 = contentfulSdkCore.toPlainObject(copy(data));
+    const tagWithMethods = enhanceWithMethods(tag, createTagApi(makeRequest));
+    return contentfulSdkCore.freezeSys(tagWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTagCollection = commonUtils.wrapCollection(wrapTag);
+
+exports.default = createTagApi;
+exports.wrapTag = wrapTag;
+exports.wrapTagCollection = wrapTagCollection;

package/dist/cjs/entities/task.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/**
+ * @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 = contentfulSdkCore.toPlainObject(copy(data));
+    const taskWithMethods = enhanceWithMethods(task, createTaskApi(makeRequest));
+    return contentfulSdkCore.freezeSys(taskWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTaskCollection = commonUtils.wrapCollection(wrapTask);
+
+exports.default = createTaskApi;
+exports.wrapTask = wrapTask;
+exports.wrapTaskCollection = wrapTaskCollection;

package/dist/cjs/entities/team-membership.cjs

@@ -0,0 +1,54 @@
+'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 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 = contentfulSdkCore.toPlainObject(copy(data));
+    const teamMembershipWithMethods = enhanceWithMethods(teamMembership, createTeamMembershipApi(makeRequest));
+    return contentfulSdkCore.freezeSys(teamMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamMembershipCollection = commonUtils.wrapCollection(wrapTeamMembership);
+
+exports.wrapTeamMembership = wrapTeamMembership;
+exports.wrapTeamMembershipCollection = wrapTeamMembershipCollection;

package/dist/cjs/entities/team-space-membership.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 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 = contentfulSdkCore.toPlainObject(copy(data));
+    const teamSpaceMembershipWithMethods = enhanceWithMethods(teamSpaceMembership, createTeamSpaceMembershipApi(makeRequest));
+    return contentfulSdkCore.freezeSys(teamSpaceMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamSpaceMembershipCollection = commonUtils.wrapCollection(wrapTeamSpaceMembership);
+
+exports.wrapTeamSpaceMembership = wrapTeamSpaceMembership;
+exports.wrapTeamSpaceMembershipCollection = wrapTeamSpaceMembershipCollection;

package/dist/cjs/entities/team.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 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 = contentfulSdkCore.toPlainObject(copy(data));
+    const teamWithMethods = enhanceWithMethods(team, createTeamApi(makeRequest));
+    return contentfulSdkCore.freezeSys(teamWithMethods);
+}
+/**
+ * @private
+ */
+const wrapTeamCollection = commonUtils.wrapCollection(wrapTeam);
+
+exports.wrapTeam = wrapTeam;
+exports.wrapTeamCollection = wrapTeamCollection;

package/dist/cjs/entities/ui-config.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var createUiConfigApi = require('../create-ui-config-api.js');
+var enhanceWithMethods = require('../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 = contentfulSdkCore.toPlainObject(copy(data));
+    const userWithMethods = enhanceWithMethods(user, createUiConfigApi(makeRequest));
+    return contentfulSdkCore.freezeSys(userWithMethods);
+}
+
+exports.wrapUIConfig = wrapUIConfig;

package/dist/cjs/entities/upload.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../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 = contentfulSdkCore.toPlainObject(copy(data));
+    const uploadWithMethods = enhanceWithMethods(upload, createUploadApi(makeRequest));
+    return contentfulSdkCore.freezeSys(uploadWithMethods);
+}
+
+exports.wrapUpload = wrapUpload;

package/dist/cjs/entities/usage.cjs

@@ -0,0 +1,25 @@
+'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
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data
+ * @return Normalized usage
+ */
+function wrapUsage(_makeRequest, data) {
+    const usage = contentfulSdkCore.toPlainObject(copy(data));
+    const usageWithMethods = enhanceWithMethods(usage, {});
+    return contentfulSdkCore.freezeSys(usageWithMethods);
+}
+/**
+ * @private
+ */
+const wrapUsageCollection = commonUtils.wrapCollection(wrapUsage);
+
+exports.wrapUsage = wrapUsage;
+exports.wrapUsageCollection = wrapUsageCollection;

package/dist/cjs/entities/user-ui-config.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var createUserUiConfigApi = require('../create-user-ui-config-api.js');
+var enhanceWithMethods = require('../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 = contentfulSdkCore.toPlainObject(copy(data));
+    const userWithMethods = enhanceWithMethods(user, createUserUiConfigApi(makeRequest));
+    return contentfulSdkCore.freezeSys(userWithMethods);
+}
+
+exports.wrapUserUIConfig = wrapUserUIConfig;

package/dist/cjs/entities/user.cjs

@@ -0,0 +1,28 @@
+'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
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data
+ * @return Normalized user
+ */
+function wrapUser(_makeRequest, data) {
+    const user = contentfulSdkCore.toPlainObject(copy(data));
+    const userWithMethods = enhanceWithMethods(user, {});
+    return contentfulSdkCore.freezeSys(userWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw data collection
+ * @return Normalized user collection
+ */
+const wrapUserCollection = commonUtils.wrapCollection(wrapUser);
+
+exports.wrapUser = wrapUser;
+exports.wrapUserCollection = wrapUserCollection;

package/dist/cjs/entities/webhook.cjs

@@ -0,0 +1,77 @@
+'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 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 = contentfulSdkCore.toPlainObject(copy(data));
+    const webhookWithMethods = enhanceWithMethods(webhook, createWebhookApi(makeRequest));
+    return contentfulSdkCore.freezeSys(webhookWithMethods);
+}
+/**
+ * @private
+ */
+const wrapWebhookCollection = commonUtils.wrapCollection(wrapWebhook);
+
+exports.wrapWebhook = wrapWebhook;
+exports.wrapWebhookCollection = wrapWebhookCollection;