contentful-management
Version:
Client for Contentful's Content Management API
588 lines (585 loc) • 22.7 kB
JavaScript
import { createRequestConfig } from 'contentful-sdk-core';
import { wrapSpace, wrapSpaceCollection } from './entities/space.js';
import { wrapUser } from './entities/user.js';
import { wrapPersonalAccessTokenCollection, wrapPersonalAccessToken } from './entities/personal-access-token.js';
import { wrapAccessTokenCollection, wrapAccessToken } from './entities/access-token.js';
import { wrapOrganizationCollection, wrapOrganization } from './entities/organization.js';
import { wrapUsageCollection } from './entities/usage.js';
import { wrapAppDefinition } from './entities/app-definition.js';
import { wrapEnvironmentTemplate, wrapEnvironmentTemplateCollection } from './entities/environment-template.js';
import { wrapOAuthApplication, wrapOAuthApplicationCollection } from './entities/oauth-application.js';
/**
* @internal
*/
function createClientApi(makeRequest) {
return {
/**
* Gets all environment templates for a given organization with the lasted version
* @param organizationId - Organization ID
* @returns 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
* @returns 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
* @returns 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
* @returns 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
* @returns 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.
* @returns 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
* @returns 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
* @returns 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
* @returns 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
* @returns 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
* @returns 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
* @returns 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
* @returns 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(response.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
* @returns 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
* @returns 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.
*
* @returns 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
* @returns 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
* @returns 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)
* @returns 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 };
//# sourceMappingURL=create-contentful-api.js.map