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

package/dist/es-modules/create-contentful-api.js

@@ -0,0 +1,663 @@
+const _excluded = ["url"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+import { createRequestConfig } from 'contentful-sdk-core';
+import entities from './entities';
+/**
+ * @private
+ */
+export default function createClientApi(makeRequest) {
+  const {
+    wrapSpace,
+    wrapSpaceCollection
+  } = entities.space;
+  const {
+    wrapUser
+  } = entities.user;
+  const {
+    wrapPersonalAccessToken,
+    wrapPersonalAccessTokenCollection
+  } = entities.personalAccessToken;
+  const {
+    wrapAccessToken,
+    wrapAccessTokenCollection
+  } = entities.accessToken;
+  const {
+    wrapOrganization,
+    wrapOrganizationCollection
+  } = entities.organization;
+  const {
+    wrapUsageCollection
+  } = entities.usage;
+  const {
+    wrapAppDefinition
+  } = entities.appDefinition;
+  const {
+    wrapEnvironmentTemplate,
+    wrapEnvironmentTemplateCollection
+  } = entities.environmentTemplate;
+  const {
+    wrapOAuthApplication,
+    wrapOAuthApplicationCollection
+  } = entities.oauthApplication;
+  return {
+    /**
+     * Gets all environment templates for a given organization with the lasted version
+     * @param organizationId - Organization ID
+     * @return Promise for a collection of EnvironmentTemplates
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getEnvironmentTemplates('<organization_id>')
+     * .then((response) => console.log(response.items))
+     * .catch(console.error)
+     * ```
+     */
+    getEnvironmentTemplates: function getEnvironmentTemplates(organizationId, query = {}) {
+      return makeRequest({
+        entityType: 'EnvironmentTemplate',
+        action: 'getMany',
+        params: {
+          organizationId,
+          query: createRequestConfig({
+            query
+          }).params
+        }
+      }).then(data => wrapEnvironmentTemplateCollection(makeRequest, data, organizationId));
+    },
+    /**
+     * Gets the lasted version environment template if params.version is not specified
+     * @param params.organizationId - Organization ID
+     * @param params.environmentTemplateId - Environment template ID
+     * @param [params.version] - Template version number to return a specific version of the environment template
+     * @return Promise for a EnvironmentTemplate
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getEnvironmentTemplate({
+     *   organizationId: '<organization_id>',
+     *   environmentTemplateId: '<environment_template_id>',
+     *   version: version>
+     * })
+     * .then((space) => console.log(space))
+     * .catch(console.error)
+     * ```
+     */
+    getEnvironmentTemplate: function getEnvironmentTemplate({
+      organizationId,
+      environmentTemplateId,
+      version,
+      query = {}
+    }) {
+      return makeRequest({
+        entityType: 'EnvironmentTemplate',
+        action: 'get',
+        params: {
+          organizationId,
+          environmentTemplateId,
+          version,
+          query: createRequestConfig({
+            query
+          }).params
+        }
+      }).then(data => wrapEnvironmentTemplate(makeRequest, data, organizationId));
+    },
+    /**
+     * Creates an environment template
+     * @param organizationId - Organization ID
+     * @param environmentTemplateData - Object representation of the environment template to be created
+     * @return Promise for the newly created EnvironmentTemplate
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.createEnvironmentTemplate('<organization_id>', {<environment_template_date>})
+     * .then((environmentTemplate) => console.log(environmentTemplate))
+     * .catch(console.error)
+     * ```
+     */
+    createEnvironmentTemplate: function createEnvironmentTemplate(organizationId, environmentTemplateData) {
+      return makeRequest({
+        entityType: 'EnvironmentTemplate',
+        action: 'create',
+        params: {
+          organizationId
+        },
+        payload: environmentTemplateData
+      }).then(data => wrapEnvironmentTemplate(makeRequest, data, organizationId));
+    },
+    /**
+     * Gets all spaces
+     * @return Promise for a collection of Spaces
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpaces()
+     * .then((response) => console.log(response.items))
+     * .catch(console.error)
+     * ```
+     */
+    getSpaces: function getSpaces(query = {}) {
+      return makeRequest({
+        entityType: 'Space',
+        action: 'getMany',
+        params: {
+          query: createRequestConfig({
+            query: query
+          }).params
+        }
+      }).then(data => wrapSpaceCollection(makeRequest, data));
+    },
+    /**
+     * Gets a space
+     * @param spaceId - Space ID
+     * @return Promise for a Space
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => console.log(space))
+     * .catch(console.error)
+     * ```
+     */
+    getSpace: function getSpace(spaceId) {
+      return makeRequest({
+        entityType: 'Space',
+        action: 'get',
+        params: {
+          spaceId
+        }
+      }).then(data => wrapSpace(makeRequest, data));
+    },
+    /**
+     * Creates a space
+     * @param spaceData - Object representation of the Space to be created
+     * @param organizationId - Organization ID, if the associated token can manage more than one organization.
+     * @return Promise for the newly created Space
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.createSpace({
+     *   name: 'Name of new space'
+     * })
+     * .then((space) => console.log(space))
+     * .catch(console.error)
+     * ```
+     */
+    createSpace: function createSpace(spaceData, organizationId) {
+      return makeRequest({
+        entityType: 'Space',
+        action: 'create',
+        params: {
+          organizationId
+        },
+        payload: spaceData
+      }).then(data => wrapSpace(makeRequest, data));
+    },
+    /**
+     * Gets an organization
+     * @param  id - Organization ID
+     * @return Promise for a Organization
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('<org_id>')
+     * .then((org) => console.log(org))
+     * .catch(console.error)
+     * ```
+     */
+    getOrganization: function getOrganization(id) {
+      return makeRequest({
+        entityType: 'Organization',
+        action: 'get',
+        params: {
+          organizationId: id
+        }
+      }).then(data => wrapOrganization(makeRequest, data));
+    },
+    /**
+     * Gets a collection of Organizations
+     * @return Promise for a collection of Organizations
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganizations()
+     * .then(result => console.log(result.items))
+     * .catch(console.error)
+     * ```
+     */
+    getOrganizations: function getOrganizations(query = {}) {
+      return makeRequest({
+        entityType: 'Organization',
+        action: 'getMany',
+        params: {
+          query: createRequestConfig({
+            query
+          }).params
+        }
+      }).then(data => wrapOrganizationCollection(makeRequest, data));
+    },
+    /**
+     * Gets the authenticated user
+     * @return Promise for a User
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getCurrentUser()
+     * .then(user => console.log(user.firstName))
+     * .catch(console.error)
+     * ```
+     */
+    getCurrentUser: function getCurrentUser(params) {
+      return makeRequest({
+        entityType: 'User',
+        action: 'getCurrent',
+        params
+      }).then(data => wrapUser(makeRequest, data));
+    },
+    /**
+     *
+     * @param params
+     * @returns Promise of a OAuthApplication
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *  accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOAuthApplication({
+     * userId: '<user_id>'
+     * oauthApplicationId: '<oauth_application_id>'
+     * }).then(oauthApplication => console.log(oauthApplication))
+     * .catch(console.error)
+     */
+    getOAuthApplication: function getOAuthApplication(params) {
+      const {
+        userId
+      } = params;
+      return makeRequest({
+        entityType: 'OAuthApplication',
+        action: 'get',
+        params
+      }).then(data => wrapOAuthApplication(makeRequest, data, userId));
+    },
+    /**
+     *
+     * @param params
+     * @returns Promise of list of user's OAuthApplications
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *  accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOAuthApplications({
+     * userId: '<user_id>'}).then(oauthApplications => console.log(oauthApplications))
+     * .catch(console.error)
+     */
+    getOAuthApplications: function getOAuthApplications(params) {
+      const {
+        userId
+      } = params;
+      return makeRequest({
+        entityType: 'OAuthApplication',
+        action: 'getManyForUser',
+        params
+      }).then(data => wrapOAuthApplicationCollection(makeRequest, data, userId));
+    },
+    /**
+     *
+     * @param params
+     * @returns Promise of a new OAuth application.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *  accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.createOAuthApplication({
+     * userId: '<user_id>'},
+     * { name: '<name>',
+     *   description: '<description>',
+     *   scopes: ['scope'],
+     *   redirectUri: '<redirectUri>',
+     *   confidential: '<true/false>'}).then(oauthApplications => console.log(oauthApplications))
+     * .catch(console.error)
+     */
+    createOAuthApplication: function createOAuthApplication(params, rawData) {
+      const {
+        userId
+      } = params;
+      return makeRequest({
+        entityType: 'OAuthApplication',
+        action: 'create',
+        params,
+        payload: rawData
+      }).then(data => wrapOAuthApplication(makeRequest, data, userId));
+    },
+    /**
+     * Gets App Definition
+     * @return Promise for App Definition
+     * @param organizationId - Id of the organization where the app is installed
+     * @param appDefinitionId - Id of the app that will be returned
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getAppDefinition(<'org_id'>, <'app_id'>)
+     * .then(appDefinition => console.log(appDefinition.name))
+     * .catch(console.error)
+     * ```
+     */
+
+    getAppDefinition: function getAppDefinition(params) {
+      return makeRequest({
+        entityType: 'AppDefinition',
+        action: 'get',
+        params
+      }).then(data => wrapAppDefinition(makeRequest, data));
+    },
+    /**
+     * Creates a personal access token
+     * @param data - personal access token config
+     * @return Promise for a Token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.createPersonalAccessToken(
+     *  {
+     *    "name": "My Token",
+     *    "scope": [
+     *      "content_management_manage"
+     *    ]
+     *  }
+     * )
+     * .then(personalAccessToken => console.log(personalAccessToken.token))
+     * .catch(console.error)
+     * ```
+     */
+    createPersonalAccessToken: function createPersonalAccessToken(data) {
+      return makeRequest({
+        /**
+         * When the `PersonalAccessToken` entity is removed, replace the `entityType` with `AccessToken`
+         * and update the action to `createPersonalToken` to ultilize the new entity called AccessToken.
+         */
+        entityType: 'PersonalAccessToken',
+        action: 'create',
+        params: {},
+        payload: data
+      }).then(response => wrapPersonalAccessToken(makeRequest, response));
+    },
+    /**
+     * @deprecated - use getAccessToken instead
+     *
+     * Gets a personal access token
+     * @param data - personal access token config
+     * @return Promise for a Token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getPersonalAccessToken(tokenId)
+     * .then(token => console.log(token.token))
+     * .catch(console.error)
+     * ```
+     */
+    getPersonalAccessToken: function getPersonalAccessToken(tokenId) {
+      return makeRequest({
+        entityType: 'PersonalAccessToken',
+        action: 'get',
+        params: {
+          tokenId
+        }
+      }).then(data => wrapPersonalAccessToken(makeRequest, data));
+    },
+    /**
+     * @deprecated - use getAccessTokens instead
+     *
+     * Gets all personal access tokens
+     * @return Promise for a Token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getPersonalAccessTokens()
+     * .then(response => console.log(reponse.items))
+     * .catch(console.error)
+     * ```
+     */
+    getPersonalAccessTokens: function getPersonalAccessTokens() {
+      return makeRequest({
+        entityType: 'PersonalAccessToken',
+        action: 'getMany',
+        params: {}
+      }).then(data => wrapPersonalAccessTokenCollection(makeRequest, data));
+    },
+    /**
+     * Gets a users access token
+     * @param data - users access token config
+     * @return Promise for a Token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getAccessToken(tokenId)
+     * .then(token => console.log(token.token))
+     * .catch(console.error)
+     * ```
+     */
+    getAccessToken: function getAccessToken(tokenId) {
+      return makeRequest({
+        entityType: 'AccessToken',
+        action: 'get',
+        params: {
+          tokenId
+        }
+      }).then(data => wrapAccessToken(makeRequest, data));
+    },
+    /**
+     * Gets all user access tokens
+     * @return Promise for a Token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getAccessTokens()
+     * .then(response => console.log(reponse.items))
+     * .catch(console.error)
+     * ```
+     */
+    getAccessTokens: function getAccessTokens() {
+      return makeRequest({
+        entityType: 'AccessToken',
+        action: 'getMany',
+        params: {}
+      }).then(data => wrapAccessTokenCollection(makeRequest, data));
+    },
+    /**
+     * Retrieves a list of redacted versions of access tokens for an organization, accessible to owners or administrators of an organization.
+     *
+     * @return Promise for a Token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganizationAccessTokens(organizationId)
+     * .then(response => console.log(reponse.items))
+     * .catch(console.error)
+     * ```
+     */
+    getOrganizationAccessTokens: function getOrganizationAccessTokens(organizationId, query = {}) {
+      return makeRequest({
+        entityType: 'AccessToken',
+        action: 'getManyForOrganization',
+        params: {
+          organizationId,
+          query
+        }
+      }).then(data => wrapAccessTokenCollection(makeRequest, data));
+    },
+    /**
+     * Get organization usage grouped by {@link UsageMetricEnum metric}
+     *
+     * @param organizationId - Id of an organization
+     * @param query - Query parameters
+     * @return Promise of a collection of usages
+     * @example ```javascript
+     *
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganizationUsage('<organizationId>', {
+     *    'metric[in]': 'cma,gql',
+     *    'dateRange.startAt': '2019-10-22',
+     *    'dateRange.endAt': '2019-11-10'
+     *    }
+     * })
+     * .then(result => console.log(result.items))
+     * .catch(console.error)
+     * ```
+     */
+    getOrganizationUsage: function getOrganizationUsage(organizationId, query = {}) {
+      return makeRequest({
+        entityType: 'Usage',
+        action: 'getManyForOrganization',
+        params: {
+          organizationId,
+          query
+        }
+      }).then(data => wrapUsageCollection(makeRequest, data));
+    },
+    /**
+     * Get organization usage grouped by space and metric
+     *
+     * @param organizationId - Id of an organization
+     * @param query - Query parameters
+     * @return Promise of a collection of usages
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpaceUsage('<organizationId>', {
+     *    skip: 0,
+     *    limit: 10,
+     *    'metric[in]': 'cda,cpa,gql',
+     *    'dateRange.startAt': '2019-10-22',
+     *    'dateRange.endAt': '2020-11-30'
+     *    }
+     * })
+     * .then(result => console.log(result.items))
+     * .catch(console.error)
+     * ```
+     */
+    getSpaceUsage: function getSpaceUsage(organizationId, query = {}) {
+      return makeRequest({
+        entityType: 'Usage',
+        action: 'getManyForSpace',
+        params: {
+          organizationId,
+          query
+        }
+      }).then(data => wrapUsageCollection(makeRequest, data));
+    },
+    /**
+     * Make a custom request to the Contentful management API's /spaces endpoint
+     * @param opts - axios request options (https://github.com/mzabriskie/axios)
+     * @return Promise for the response data
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.rawRequest({
+     *   method: 'GET',
+     *   url: '/custom/path'
+     * })
+     * .then((responseData) => console.log(responseData))
+     * .catch(console.error)
+     * ```
+     */
+    rawRequest: function rawRequest(_ref) {
+      let {
+          url
+        } = _ref,
+        config = _objectWithoutProperties(_ref, _excluded);
+      return makeRequest({
+        entityType: 'Http',
+        action: 'request',
+        params: {
+          url,
+          config
+        }
+      });
+    }
+  };
+}