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

package/dist/cjs/entities/app-installation.cjs

@@ -0,0 +1,55 @@
+'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 createAppInstallationApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        environmentId: data.sys.environment.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppInstallation',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: data,
+            }).then((data) => wrapAppInstallation(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppInstallation',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Installation data
+ * @return Wrapped App installation data
+ */
+function wrapAppInstallation(makeRequest, data) {
+    const appInstallation = contentfulSdkCore.toPlainObject(copy(data));
+    const appInstallationWithMethods = enhanceWithMethods(appInstallation, createAppInstallationApi(makeRequest));
+    return contentfulSdkCore.freezeSys(appInstallationWithMethods);
+}
+/**
+ * @private
+ */
+const wrapAppInstallationCollection = commonUtils.wrapCollection(wrapAppInstallation);
+
+exports.wrapAppInstallation = wrapAppInstallation;
+exports.wrapAppInstallationCollection = wrapAppInstallationCollection;

package/dist/cjs/entities/app-key.cjs

@@ -0,0 +1,44 @@
+'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');
+
+function createKeyApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+        fingerprint: data.sys.id,
+    });
+    return {
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AppKey',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppKey data
+ * @return Wrapped AppKey data
+ */
+function wrapAppKey(makeRequest, data) {
+    const key = contentfulSdkCore.toPlainObject(copy(data));
+    return enhanceWithMethods(key, createKeyApi(makeRequest));
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Key collection data
+ * @return Wrapped App Key collection data
+ */
+const wrapAppKeyCollection = commonUtils.wrapCollection(wrapAppKey);
+
+exports.wrapAppKey = wrapAppKey;
+exports.wrapAppKeyCollection = wrapAppKeyCollection;

package/dist/cjs/entities/app-signed-request.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppSignedRequest data
+ * @return Wrapped AppSignedRequest data
+ */
+function wrapAppSignedRequest(_makeRequest, data) {
+    const signedRequest = contentfulSdkCore.toPlainObject(copy(data));
+    return signedRequest;
+}
+
+exports.wrapAppSignedRequest = wrapAppSignedRequest;

package/dist/cjs/entities/app-signing-secret.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+function createSigningSecretApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+    });
+    return {
+        delete: function del() {
+            const self = this;
+            return makeRequest({
+                entityType: 'AppSigningSecret',
+                action: 'delete',
+                params: getParams(self),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppSigningSecret data
+ * @return Wrapped AppSigningSecret data
+ */
+function wrapAppSigningSecret(makeRequest, data) {
+    const signingSecret = contentfulSdkCore.toPlainObject(copy(data));
+    return enhanceWithMethods(signingSecret, createSigningSecretApi(makeRequest));
+}
+
+exports.wrapAppSigningSecret = wrapAppSigningSecret;

package/dist/cjs/entities/app-upload.cjs

@@ -0,0 +1,47 @@
+'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 createAppUploadApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appUploadId: data.sys.id,
+    });
+    return {
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppUpload',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Upload data
+ * @return Wrapped App Upload data
+ */
+function wrapAppUpload(makeRequest, data) {
+    const appUpload = contentfulSdkCore.toPlainObject(copy(data));
+    const appUploadWithMethods = enhanceWithMethods(appUpload, createAppUploadApi(makeRequest));
+    return contentfulSdkCore.freezeSys(appUploadWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Upload collection data
+ * @return Wrapped App Upload collection data
+ */
+const wrapAppUploadCollection = commonUtils.wrapCollection(wrapAppUpload);
+
+exports.wrapAppUpload = wrapAppUpload;
+exports.wrapAppUploadCollection = wrapAppUploadCollection;

package/dist/cjs/entities/asset-key.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw asset key data
+ * @return Wrapped asset key data
+ */
+function wrapAssetKey(_makeRequest, data) {
+    const assetKey = contentfulSdkCore.toPlainObject(copy(data));
+    return assetKey;
+}
+
+exports.wrapAssetKey = wrapAssetKey;

package/dist/cjs/entities/asset.cjs

@@ -0,0 +1,124 @@
+'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');
+var checks = require('../plain/checks.js');
+
+/**
+ * @private
+ */
+function createAssetApi(makeRequest) {
+    const getParams = (raw) => {
+        return {
+            spaceId: raw.sys.space.sys.id,
+            environmentId: raw.sys.environment.sys.id,
+            assetId: raw.sys.id,
+        };
+    };
+    return {
+        processForLocale: function processForLocale(locale, options) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'processForLocale',
+                params: Object.assign(Object.assign({}, getParams(raw)), { locale,
+                    options, asset: raw }),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        processForAllLocales: function processForAllLocales(options) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'processForAllLocales',
+                params: Object.assign(Object.assign({}, getParams(raw)), { asset: raw, options }),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        update: function update() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+                headers: {},
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+        publish: function publish() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'publish',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        unpublish: function unpublish() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'unpublish',
+                params: getParams(raw),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        archive: function archive() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'archive',
+                params: getParams(raw),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        unarchive: function unarchive() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Asset',
+                action: 'unarchive',
+                params: getParams(raw),
+            }).then((data) => wrapAsset(makeRequest, data));
+        },
+        isPublished: function isPublished() {
+            const raw = this.toPlainObject();
+            return checks.isPublished(raw);
+        },
+        isUpdated: function isUpdated() {
+            const raw = this.toPlainObject();
+            return checks.isUpdated(raw);
+        },
+        isDraft: function isDraft() {
+            const raw = this.toPlainObject();
+            return checks.isDraft(raw);
+        },
+        isArchived: function isArchived() {
+            const raw = this.toPlainObject();
+            return checks.isArchived(raw);
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw asset data
+ * @return Wrapped asset data
+ */
+function wrapAsset(makeRequest, data) {
+    const asset = contentfulSdkCore.toPlainObject(copy(data));
+    const assetWithMethods = enhanceWithMethods(asset, createAssetApi(makeRequest));
+    return contentfulSdkCore.freezeSys(assetWithMethods);
+}
+/**
+ * @private
+ */
+const wrapAssetCollection = commonUtils.wrapCollection(wrapAsset);
+
+exports.wrapAsset = wrapAsset;
+exports.wrapAssetCollection = wrapAssetCollection;

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

@@ -0,0 +1,60 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var action = require('../methods/action.js');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Represents the state of the BulkAction */
+exports.BulkActionStatus = void 0;
+(function (BulkActionStatus) {
+    /** BulkAction is pending execution */
+    BulkActionStatus["created"] = "created";
+    /** BulkAction has been started and pending completion */
+    BulkActionStatus["inProgress"] = "inProgress";
+    /** BulkAction was completed successfully (terminal state) */
+    BulkActionStatus["succeeded"] = "succeeded";
+    /** BulkAction failed to complete (terminal state) */
+    BulkActionStatus["failed"] = "failed";
+})(exports.BulkActionStatus || (exports.BulkActionStatus = {}));
+Object.values(exports.BulkActionStatus);
+/**
+ * @private
+ */
+function createBulkActionApi(makeRequest) {
+    const getParams = (self) => {
+        const bulkAction = self.toPlainObject();
+        return {
+            spaceId: bulkAction.sys.space.sys.id,
+            environmentId: bulkAction.sys.environment.sys.id,
+            bulkActionId: bulkAction.sys.id,
+        };
+    };
+    return {
+        async get() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'BulkAction',
+                action: 'get',
+                params,
+            }).then((bulkAction) => wrapBulkAction(makeRequest, bulkAction));
+        },
+        async waitProcessing(options) {
+            return action.pollAsyncActionStatus(async () => this.get(), options);
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw BulkAction data
+ * @return Wrapped BulkAction data
+ */
+function wrapBulkAction(makeRequest, data) {
+    const bulkAction = contentfulSdkCore.toPlainObject(copy(data));
+    const bulkActionWithApiMethods = enhanceWithMethods(bulkAction, createBulkActionApi(makeRequest));
+    return contentfulSdkCore.freezeSys(bulkActionWithApiMethods);
+}
+
+exports.wrapBulkAction = wrapBulkAction;

package/dist/cjs/entities/comment.cjs

@@ -0,0 +1,63 @@
+'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');
+
+// Remove and replace with BLOCKS as soon as rich-text-types supports mentions
+exports.CommentNode = void 0;
+(function (CommentNode) {
+    CommentNode["Document"] = "document";
+    CommentNode["Paragraph"] = "paragraph";
+    CommentNode["Mention"] = "mention";
+})(exports.CommentNode || (exports.CommentNode = {}));
+/**
+ * @private
+ */
+function createCommentApi(makeRequest) {
+    const getParams = (comment) => ({
+        spaceId: comment.sys.space.sys.id,
+        environmentId: comment.sys.environment.sys.id,
+        entryId: comment.sys.parentEntity.sys.id,
+        commentId: comment.sys.id,
+    });
+    return {
+        update: async function () {
+            const raw = this.toPlainObject();
+            const data = await makeRequest({
+                entityType: 'Comment',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            });
+            return wrapComment(makeRequest, data);
+        },
+        delete: async function () {
+            const raw = this.toPlainObject();
+            await makeRequest({
+                entityType: 'Comment',
+                action: 'delete',
+                params: Object.assign(Object.assign({}, getParams(raw)), { version: raw.sys.version }),
+            });
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapComment(makeRequest, data) {
+    const comment = contentfulSdkCore.toPlainObject(copy(data));
+    const commentWithMethods = enhanceWithMethods(comment, createCommentApi(makeRequest));
+    return contentfulSdkCore.freezeSys(commentWithMethods);
+}
+/**
+ * @private
+ */
+const wrapCommentCollection = commonUtils.wrapCollection(wrapComment);
+
+exports.default = createCommentApi;
+exports.wrapComment = wrapComment;
+exports.wrapCommentCollection = wrapCommentCollection;

package/dist/cjs/entities/concept-scheme.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/entities/concept.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,120 @@
+'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');
+var checks = require('../plain/checks.js');
+var editorInterface = require('./editor-interface.js');
+var snapshot = require('./snapshot.js');
+var contentType = require('../methods/content-type.js');
+
+/**
+ * @private
+ */
+function createContentTypeApi(makeRequest) {
+    const getParams = (self) => {
+        const contentType = self.toPlainObject();
+        return {
+            raw: contentType,
+            params: {
+                spaceId: contentType.sys.space.sys.id,
+                environmentId: contentType.sys.environment.sys.id,
+                contentTypeId: contentType.sys.id,
+            },
+        };
+    };
+    return {
+        update: function () {
+            const { raw, params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'update',
+                params,
+                payload: raw,
+            }).then((data) => wrapContentType(makeRequest, data));
+        },
+        delete: function () {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'delete',
+                params,
+            }).then(() => {
+                // noop
+            });
+        },
+        publish: function () {
+            const { raw, params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'publish',
+                params,
+                payload: raw,
+            }).then((data) => wrapContentType(makeRequest, data));
+        },
+        unpublish: function () {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'ContentType',
+                action: 'unpublish',
+                params,
+            }).then((data) => wrapContentType(makeRequest, data));
+        },
+        getEditorInterface: function () {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'EditorInterface',
+                action: 'get',
+                params,
+            }).then((data) => editorInterface.wrapEditorInterface(makeRequest, data));
+        },
+        getSnapshots: function (query = {}) {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'Snapshot',
+                action: 'getManyForContentType',
+                params: Object.assign(Object.assign({}, params), { query }),
+            }).then((data) => snapshot.wrapSnapshotCollection(makeRequest, data));
+        },
+        getSnapshot: function (snapshotId) {
+            const { params } = getParams(this);
+            return makeRequest({
+                entityType: 'Snapshot',
+                action: 'getForContentType',
+                params: Object.assign(Object.assign({}, params), { snapshotId }),
+            }).then((data) => snapshot.wrapSnapshot(makeRequest, data));
+        },
+        isPublished: function () {
+            return checks.isPublished(this);
+        },
+        isUpdated: function () {
+            return checks.isUpdated(this);
+        },
+        isDraft: function () {
+            return checks.isDraft(this);
+        },
+        omitAndDeleteField: function (fieldId) {
+            const { raw, params } = getParams(this);
+            return contentType.omitAndDeleteField(makeRequest, Object.assign(Object.assign({}, params), { fieldId }), raw).then((data) => wrapContentType(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw content type data
+ * @return Wrapped content type data
+ */
+function wrapContentType(makeRequest, data) {
+    const contentType = contentfulSdkCore.toPlainObject(copy(data));
+    const contentTypeWithMethods = enhanceWithMethods(contentType, createContentTypeApi(makeRequest));
+    return contentfulSdkCore.freezeSys(contentTypeWithMethods);
+}
+/**
+ * @private
+ */
+const wrapContentTypeCollection = commonUtils.wrapCollection(wrapContentType);
+
+exports.wrapContentType = wrapContentType;
+exports.wrapContentTypeCollection = wrapContentTypeCollection;

package/dist/cjs/entities/editor-interface.cjs

@@ -0,0 +1,50 @@
+'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 createEditorInterfaceApi(makeRequest) {
+    return {
+        update: function () {
+            const self = this;
+            const raw = self.toPlainObject();
+            return makeRequest({
+                entityType: 'EditorInterface',
+                action: 'update',
+                params: {
+                    spaceId: self.sys.space.sys.id,
+                    environmentId: self.sys.environment.sys.id,
+                    contentTypeId: self.sys.contentType.sys.id,
+                },
+                payload: raw,
+            }).then((response) => wrapEditorInterface(makeRequest, response));
+        },
+        getControlForField: function (fieldId) {
+            const self = this;
+            const result = (self.controls || []).filter((control) => {
+                return control.fieldId === fieldId;
+            });
+            return result && result.length > 0 ? result[0] : null;
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapEditorInterface(makeRequest, data) {
+    const editorInterface = contentfulSdkCore.toPlainObject(copy(data));
+    const editorInterfaceWithMethods = enhanceWithMethods(editorInterface, createEditorInterfaceApi(makeRequest));
+    return contentfulSdkCore.freezeSys(editorInterfaceWithMethods);
+}
+/**
+ * @private
+ */
+const wrapEditorInterfaceCollection = commonUtils.wrapCollection(wrapEditorInterface);
+
+exports.wrapEditorInterface = wrapEditorInterface;
+exports.wrapEditorInterfaceCollection = wrapEditorInterfaceCollection;

package/dist/cjs/entities/entry.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var createEntryApi = require('../create-entry-api.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw entry data
+ * @return Wrapped entry data
+ */
+function wrapEntry(makeRequest, data) {
+    const entry = contentfulSdkCore.toPlainObject(copy(data));
+    const entryWithMethods = enhanceWithMethods(entry, createEntryApi(makeRequest));
+    return contentfulSdkCore.freezeSys(entryWithMethods);
+}
+/**
+ * Data is also mixed in with link getters if links exist and includes were requested
+ * @private
+ */
+const wrapEntryCollection = commonUtils.wrapCollection(wrapEntry);
+
+exports.wrapEntry = wrapEntry;
+exports.wrapEntryCollection = wrapEntryCollection;