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

package/dist/types/create-contentful-api.js

@@ -0,0 +1,587 @@
+import { createRequestConfig } from 'contentful-sdk-core';
+import { wrapOrganization, wrapOrganizationCollection } from './entities/organization.js';
+import { wrapPersonalAccessToken, wrapPersonalAccessTokenCollection } from './entities/personal-access-token.js';
+import { wrapSpaceCollection, wrapSpace } from './entities/space.js';
+import { wrapAppDefinition } from './entities/app-definition.js';
+import { wrapUsageCollection } from './entities/usage.js';
+import { wrapUser } from './entities/user.js';
+import { wrapEnvironmentTemplateCollection, wrapEnvironmentTemplate } from './entities/environment-template.js';
+import { wrapAccessToken, wrapAccessTokenCollection } from './entities/access-token.js';
+import { wrapOAuthApplication, wrapOAuthApplicationCollection } from './entities/oauth-application.js';
+
+/**
+ * @private
+ */
+function createClientApi(makeRequest) {
+    return {
+        version: __VERSION__,
+        /**
+         * 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({ url, ...config }) {
+            return makeRequest({
+                entityType: 'Http',
+                action: 'request',
+                params: { url, config },
+            });
+        },
+    };
+}
+
+export { createClientApi as default };

package/dist/types/create-entry-api.d.ts

@@ -1,8 +1,8 @@
 import type { OpPatch } from 'json-patch';
 import type { MakeRequest } from './common-types.js';
-import type { CreateCommentProps } from './entities/comment.js';
-import type { Entry, EntryProps, EntryReferenceOptionsProps } from './entities/entry.js';
-import type { CreateTaskProps } from './entities/task.js';
+import { type CreateCommentProps } from './entities/comment.js';
+import { type Entry, type EntryProps, type EntryReferenceOptionsProps } from './entities/entry.js';
+import { type CreateTaskProps } from './entities/task.js';
 /**
  * @private
  */
@@ -170,7 +170,7 @@ export default function createEntryApi(makeRequest: MakeRequest): {
      * .catch(console.error)
      * ```
      */
-    getSnapshots: (query?: {}) => Promise<import("./common-types.js").Collection<import("./export-types.js").Snapshot<EntryProps>, import("./export-types.js").SnapshotProps<EntryProps>>>;
+    getSnapshots: (query?: {}) => Promise<import("./common-types.js").Collection<import("./entities/snapshot.js").Snapshot<EntryProps>, import("./entities/snapshot.js").SnapshotProps<EntryProps>>>;
     /**
      * Gets a snapshot of an entry
      * @param snapshotId - Id of the snapshot
@@ -189,7 +189,7 @@ export default function createEntryApi(makeRequest: MakeRequest): {
      * .catch(console.error)
      * ```
      */
-    getSnapshot: (snapshotId: string) => Promise<import("./export-types.js").Snapshot<EntryProps>>;
+    getSnapshot: (snapshotId: string) => Promise<import("./entities/snapshot.js").Snapshot<EntryProps>>;
     /**
      * Creates a new comment for an entry
      * @param data Object representation of the Comment to be created