contentful-management 11.49.0-beta.2 → 11.50.0

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

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

package/dist/es-modules/entities/environment-alias.js

@@ -0,0 +1,54 @@
+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 createEnvironmentAliasApi(makeRequest) {
+  const getParams = alias => ({
+    spaceId: alias.sys.space.sys.id,
+    environmentAliasId: alias.sys.id
+  });
+  return {
+    update: function () {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'EnvironmentAlias',
+        action: 'update',
+        params: getParams(raw),
+        payload: raw
+      }).then(data => wrapEnvironmentAlias(makeRequest, data));
+    },
+    delete: function () {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'EnvironmentAlias',
+        action: 'delete',
+        params: getParams(raw)
+      }).then(() => {
+        // noop
+      });
+    }
+  };
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias data
+ * @return Wrapped environment alias data
+ */
+export function wrapEnvironmentAlias(makeRequest, data) {
+  const alias = toPlainObject(copy(data));
+  const enhancedAlias = enhanceWithMethods(alias, createEnvironmentAliasApi(makeRequest));
+  return freezeSys(enhancedAlias);
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias collection data
+ * @return Wrapped environment alias collection data
+ */
+export const wrapEnvironmentAliasCollection = wrapCollection(wrapEnvironmentAlias);

package/dist/es-modules/entities/environment-template-installation.js

@@ -0,0 +1,17 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils';
+var EnvironmentTemplateInstallationStatuses = /*#__PURE__*/function (EnvironmentTemplateInstallationStatuses) {
+  EnvironmentTemplateInstallationStatuses["created"] = "created";
+  EnvironmentTemplateInstallationStatuses["inProgress"] = "inProgress";
+  EnvironmentTemplateInstallationStatuses["failed"] = "failed";
+  EnvironmentTemplateInstallationStatuses["succeeded"] = "succeeded";
+  EnvironmentTemplateInstallationStatuses["disconnected"] = "disconnected";
+  EnvironmentTemplateInstallationStatuses["inRetry"] = "inRetry";
+  return EnvironmentTemplateInstallationStatuses;
+}(EnvironmentTemplateInstallationStatuses || {});
+export function wrapEnvironmentTemplateInstallation(makeRequest, data) {
+  const environmentTemplate = toPlainObject(copy(data));
+  return freezeSys(environmentTemplate);
+}
+export const wrapEnvironmentTemplateInstallationCollection = wrapCursorPaginatedCollection(wrapEnvironmentTemplateInstallation);

package/dist/es-modules/entities/environment-template.js

@@ -0,0 +1,12 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils';
+import { createEnvironmentTemplateApi } from '../create-environment-template-api';
+import enhanceWithMethods from '../enhance-with-methods';
+export function wrapEnvironmentTemplate(makeRequest, data, organizationId) {
+  const environmentTemplate = toPlainObject(copy(data));
+  const environmentTemplateApi = createEnvironmentTemplateApi(makeRequest, organizationId);
+  const enhancedEnvironmentTemplate = enhanceWithMethods(environmentTemplate, environmentTemplateApi);
+  return freezeSys(enhancedEnvironmentTemplate);
+}
+export const wrapEnvironmentTemplateCollection = wrapCursorPaginatedCollection(wrapEnvironmentTemplate);

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

@@ -0,0 +1,29 @@
+import copy from 'fast-copy';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods';
+import createEnvironmentApi from '../create-environment-api';
+import { wrapCollection } from '../common-utils';
+/**
+ * This method creates the API for the given environment with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a environment id, so the base path for requests now has the
+ * environment id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Environment
+ * @return
+ */
+export function wrapEnvironment(makeRequest, data) {
+  // do not pollute generated typings
+  const environment = toPlainObject(copy(data));
+  const environmentApi = createEnvironmentApi(makeRequest);
+  const enhancedEnvironment = enhanceWithMethods(environment, environmentApi);
+  return freezeSys(enhancedEnvironment);
+}
+
+/**
+ * This method wraps each environment in a collection with the environment API. See wrapEnvironment
+ * above for more details.
+ * @private
+ */
+export const wrapEnvironmentCollection = wrapCollection(wrapEnvironment);

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

@@ -0,0 +1,50 @@
+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 createExtensionApi(makeRequest) {
+  const getParams = data => ({
+    spaceId: data.sys.space.sys.id,
+    environmentId: data.sys.environment.sys.id,
+    extensionId: data.sys.id
+  });
+  return {
+    update: function update() {
+      const data = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Extension',
+        action: 'update',
+        params: getParams(data),
+        payload: data
+      }).then(response => wrapExtension(makeRequest, response));
+    },
+    delete: function del() {
+      const data = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Extension',
+        action: 'delete',
+        params: getParams(data)
+      });
+    }
+  };
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw UI Extension data
+ * @return Wrapped UI Extension data
+ */
+export function wrapExtension(makeRequest, data) {
+  const extension = toPlainObject(copy(data));
+  const extensionWithMethods = enhanceWithMethods(extension, createExtensionApi(makeRequest));
+  return freezeSys(extensionWithMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapExtensionCollection = wrapCollection(wrapExtension);

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

@@ -0,0 +1 @@
+export {};

package/dist/{esm → es-modules}/entities/function-log.js

@@ -1,23 +1,21 @@
-import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
 import copy from 'fast-copy';
-import { wrapCollection } from '../common-utils.js';
-
+import { wrapCollection } from '../common-utils';
 /**
  * @private
  * @param makeRequest - function to make requests via an adapter
  * @param data - raw contentful-Function data
  * @return Wrapped Function data
  */
-function wrapFunctionLog(makeRequest, data) {
-    const functionLog = toPlainObject(copy(data));
-    return freezeSys(functionLog);
+export function wrapFunctionLog(makeRequest, data) {
+  const functionLog = toPlainObject(copy(data));
+  return freezeSys(functionLog);
 }
+
 /**
  * @private
  * @param makeRequest - function to make requests via an adapter
  * @param data - raw contentful-function data
  * @return Wrapped App Function collection data
  */
-const wrapFunctionLogCollection = wrapCollection(wrapFunctionLog);
-
-export { wrapFunctionLog, wrapFunctionLogCollection };
+export const wrapFunctionLogCollection = wrapCollection(wrapFunctionLog);

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

@@ -0,0 +1,61 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+import enhanceWithMethods from '../enhance-with-methods';
+/**
+ * @private
+ */
+function createFunctionApi(makeRequest) {
+  return {
+    getFunction: function getFunction() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'get',
+        params: {
+          organizationId: raw.sys.organization.sys.id,
+          appDefinitionId: raw.sys.appDefinition.sys.id,
+          functionId: raw.sys.id
+        }
+      }).then(data => wrapFunction(makeRequest, data));
+    },
+    getManyFunctions: function getManyFunctions() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Function',
+        action: 'getMany',
+        params: {
+          appDefinitionId: raw.sys.appDefinition.sys.id,
+          organizationId: raw.sys.organization.sys.id
+        }
+      }).then(data => wrapFunctionCollection(makeRequest, data));
+    },
+    getManyFunctionsForEnvironment(spaceId, environmentId, appInstallationId) {
+      return makeRequest({
+        entityType: 'Function',
+        action: 'getManyForEnvironment',
+        params: {
+          spaceId: spaceId,
+          environmentId: environmentId,
+          appInstallationId: appInstallationId
+        }
+      }).then(data => wrapFunctionCollection(makeRequest, data));
+    }
+  };
+}
+
+/**
+ * @private
+ * @param makeRequest - (real) function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+export function wrapFunction(makeRequest, data) {
+  const func = toPlainObject(copy(data));
+  const funcWithMethods = enhanceWithMethods(func, createFunctionApi(makeRequest));
+  return freezeSys(funcWithMethods);
+}
+/**
+ * @private
+ */
+export const wrapFunctionCollection = wrapCollection(wrapFunction);

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

@@ -0,0 +1,126 @@
+import * as aiAction from './ai-action';
+import * as aiActionInvocation from './ai-action-invocation';
+import * as apiKey from './api-key';
+import * as appAction from './app-action';
+import * as appActionCall from './app-action-call';
+import * as appBundle from './app-bundle';
+import * as appDefinition from './app-definition';
+import * as appDetails from './app-details';
+import * as appInstallation from './app-installation';
+import * as appSignedRequest from './app-signed-request';
+import * as appSigningSecret from './app-signing-secret';
+import * as appEventSubscription from './app-event-subscription';
+import * as appKey from './app-key';
+import * as appAccessToken from './app-access-token';
+import * as appUpload from './app-upload';
+import * as asset from './asset';
+import * as assetKey from './asset-key';
+import * as bulkAction from './bulk-action';
+import * as comment from './comment';
+import * as contentType from './content-type';
+import * as editorInterface from './editor-interface';
+import * as entry from './entry';
+import * as environment from './environment';
+import * as environmentAlias from './environment-alias';
+import * as environmentTemplate from './environment-template';
+import * as environmentTemplateInstallation from './environment-template-installation';
+import * as extension from './extension';
+import * as func from './function';
+import * as functionLog from './function-log';
+import * as locale from './locale';
+import * as oauthApplication from './oauth-application';
+import * as organization from './organization';
+import * as organizationInvitation from './organization-invitation';
+import * as organizationMembership from './organization-membership';
+import * as personalAccessToken from './personal-access-token';
+import * as accessToken from './access-token';
+import * as previewApiKey from './preview-api-key';
+import * as release from './release';
+import * as releaseAction from './release-action';
+import * as role from './role';
+import * as scheduledAction from './scheduled-action';
+import * as snapshot from './snapshot';
+import * as space from './space';
+import * as spaceMember from './space-member';
+import * as spaceMembership from './space-membership';
+import * as tag from './tag';
+import * as task from './task';
+import * as team from './team';
+import * as teamMembership from './team-membership';
+import * as teamSpaceMembership from './team-space-membership';
+import * as uiConfig from './ui-config';
+import * as upload from './upload';
+import * as usage from './usage';
+import * as user from './user';
+import * as userUIConfig from './user-ui-config';
+import * as webhook from './webhook';
+import * as workflowDefinition from './workflow-definition';
+import * as concept from './concept';
+import * as conceptScheme from './concept-scheme';
+import * as resourceProvider from './resource-provider';
+import * as resourceType from './resource-type';
+import * as resource from './resource';
+export default {
+  aiAction,
+  aiActionInvocation,
+  accessToken,
+  appAction,
+  appActionCall,
+  appBundle,
+  apiKey,
+  appDefinition,
+  appInstallation,
+  appUpload,
+  appDetails,
+  appSignedRequest,
+  appSigningSecret,
+  appEventSubscription,
+  appKey,
+  appAccessToken,
+  asset,
+  assetKey,
+  bulkAction,
+  comment,
+  concept,
+  conceptScheme,
+  contentType,
+  editorInterface,
+  entry,
+  environment,
+  environmentAlias,
+  environmentTemplate,
+  environmentTemplateInstallation,
+  extension,
+  func,
+  functionLog,
+  locale,
+  oauthApplication,
+  organization,
+  organizationInvitation,
+  organizationMembership,
+  personalAccessToken,
+  previewApiKey,
+  release,
+  releaseAction,
+  resourceProvider,
+  resourceType,
+  resource,
+  role,
+  scheduledAction,
+  snapshot,
+  space,
+  spaceMember,
+  spaceMembership,
+  tag,
+  task,
+  team,
+  teamMembership,
+  teamSpaceMembership,
+  uiConfig,
+  upload,
+  usage,
+  user,
+  userUIConfig,
+  webhook,
+  workflowDefinition
+};

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

@@ -0,0 +1,53 @@
+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 createLocaleApi(makeRequest) {
+  const getParams = locale => ({
+    spaceId: locale.sys.space.sys.id,
+    environmentId: locale.sys.environment.sys.id,
+    localeId: locale.sys.id
+  });
+  return {
+    update: function () {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Locale',
+        action: 'update',
+        params: getParams(raw),
+        payload: raw
+      }).then(data => wrapLocale(makeRequest, data));
+    },
+    delete: function () {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Locale',
+        action: 'delete',
+        params: getParams(raw)
+      }).then(() => {
+        // noop
+      });
+    }
+  };
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw locale data
+ * @return Wrapped locale data
+ */
+export function wrapLocale(makeRequest, data) {
+  delete data.internal_code;
+  const locale = toPlainObject(copy(data));
+  const localeWithMethods = enhanceWithMethods(locale, createLocaleApi(makeRequest));
+  return freezeSys(localeWithMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapLocaleCollection = wrapCollection(wrapLocale);

package/dist/es-modules/entities/oauth-application.js

@@ -0,0 +1,62 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils';
+export let ScopeValues = /*#__PURE__*/function (ScopeValues) {
+  ScopeValues["Read"] = "content_management_read";
+  ScopeValues["Manage"] = "content_management_manage";
+  return ScopeValues;
+}({});
+/**
+ * @private
+ */
+function createOAuthApplicationApi(makeRequest, userId) {
+  const getParams = data => ({
+    userId,
+    oauthApplicationId: data.sys.id
+  });
+  return {
+    /**
+     * Updates an OAuth application
+     * @return Promise for the updated OAuth application
+     */
+    async update() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'OAuthApplication',
+        action: 'update',
+        params: getParams(raw),
+        payload: raw
+      });
+    },
+    /**
+     * Deletes an OAuth application
+     * @return Promise for the deleted OAuth application
+     */
+    async delete() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'OAuthApplication',
+        action: 'delete',
+        params: getParams(raw)
+      });
+    }
+  };
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw OAuth application data
+ * @return Wrapped OAuth application data
+ */
+export function wrapOAuthApplication(makeRequest, data, userId) {
+  const oauthApplication = toPlainObject(copy(data));
+  const oauthApplicationWithMethods = enhanceWithMethods(oauthApplication, createOAuthApplicationApi(makeRequest, userId));
+  return freezeSys(oauthApplicationWithMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapOAuthApplicationCollection = wrapCursorPaginatedCollection(wrapOAuthApplication);

package/dist/es-modules/entities/organization-invitation.js

@@ -0,0 +1,12 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw invitation data
+ * @return {OrganizationInvitation} Wrapped Inviation data
+ */
+export function wrapOrganizationInvitation(_makeRequest, data) {
+  const invitation = toPlainObject(copy(data));
+  return freezeSys(invitation);
+}

package/dist/es-modules/entities/organization-membership.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 createOrganizationMembershipApi(makeRequest, organizationId) {
+  const getParams = data => ({
+    organizationMembershipId: data.sys.id,
+    organizationId
+  });
+  return {
+    update: function () {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'OrganizationMembership',
+        action: 'update',
+        params: getParams(raw),
+        payload: raw
+      }).then(data => wrapOrganizationMembership(makeRequest, data, organizationId));
+    },
+    delete: function del() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'OrganizationMembership',
+        action: 'delete',
+        params: getParams(raw)
+      });
+    }
+  };
+}
+
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {Object} data - Raw organization membership data
+ * @return {OrganizationMembership} Wrapped organization membership data
+ */
+export function wrapOrganizationMembership(makeRequest, data, organizationId) {
+  const organizationMembership = toPlainObject(copy(data));
+  const organizationMembershipWithMethods = enhanceWithMethods(organizationMembership, createOrganizationMembershipApi(makeRequest, organizationId));
+  return freezeSys(organizationMembershipWithMethods);
+}
+
+/**
+ * @private
+ */
+export const wrapOrganizationMembershipCollection = wrapCollection(wrapOrganizationMembership);

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

@@ -0,0 +1,32 @@
+import copy from 'fast-copy';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods';
+import createOrganizationApi from '../create-organization-api';
+import { wrapCollection } from '../common-utils';
+
+/**
+ * @deprecated Use `OrganizationProps` instead.
+ */
+
+/**
+ * This method creates the API for the given organization with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with an organization id, so the base path for requests now has the
+ * organization id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for an Organization
+ * @return {Organization}
+ */
+export function wrapOrganization(makeRequest, data) {
+  const org = toPlainObject(copy(data));
+  const orgApi = createOrganizationApi(makeRequest);
+  const enhancedOrganization = enhanceWithMethods(org, orgApi);
+  return freezeSys(enhancedOrganization);
+}
+
+/**
+ * This method normalizes each organization in a collection.
+ * @private
+ */
+export const wrapOrganizationCollection = wrapCollection(wrapOrganization);

package/dist/es-modules/entities/personal-access-token.js

@@ -0,0 +1,38 @@
+import copy from 'fast-copy';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapCollection } from '../common-utils';
+
+/**
+ * @deprecated Use `PersonalAccessTokenProps` instead.
+ */
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  personal access token data
+ * @return Wrapped personal access token
+ */
+export function wrapPersonalAccessToken(makeRequest, data) {
+  const personalAccessToken = toPlainObject(copy(data));
+  const personalAccessTokenWithMethods = enhanceWithMethods(personalAccessToken, {
+    revoke: function () {
+      return makeRequest({
+        entityType: 'PersonalAccessToken',
+        action: 'revoke',
+        params: {
+          tokenId: data.sys.id
+        }
+      }).then(data => wrapPersonalAccessToken(makeRequest, data));
+    }
+  });
+  return freezeSys(personalAccessTokenWithMethods);
+}
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw personal access collection data
+ * @return Wrapped personal access token collection data
+ */
+export const wrapPersonalAccessTokenCollection = wrapCollection(wrapPersonalAccessToken);