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

package/dist/types/create-environment-template-api.d.ts

@@ -1,6 +1,6 @@
-import type { BasicCursorPaginationOptions, MakeRequest } from './common-types';
-import type { EnvironmentTemplateProps } from './entities/environment-template';
-import type { CreateEnvironmentTemplateInstallationProps, ValidateEnvironmentTemplateInstallationProps } from './entities/environment-template-installation';
+import type { BasicCursorPaginationOptions, MakeRequest } from './common-types.js';
+import { type EnvironmentTemplateProps } from './entities/environment-template.js';
+import { type CreateEnvironmentTemplateInstallationProps, type ValidateEnvironmentTemplateInstallationProps } from './entities/environment-template-installation.js';
 export type ContentfulEnvironmentTemplateApi = ReturnType<typeof createEnvironmentTemplateApi>;
 export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, organizationId: string): {
     /**
@@ -23,7 +23,7 @@ export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, o
      * ).catch(console.error)
      * ```
      */
-    update: () => Promise<import("./entities/environment-template").EnvironmentTemplate>;
+    update: () => Promise<import("./entities/environment-template.js").EnvironmentTemplate>;
     /**
      * Updates environment template version data
      * @param version.versionName - Name of the environment template version
@@ -51,7 +51,7 @@ export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, o
     updateVersion: ({ versionName, versionDescription, }: {
         versionName: string;
         versionDescription: string;
-    }) => Promise<import("./entities/environment-template").EnvironmentTemplate>;
+    }) => Promise<import("./entities/environment-template.js").EnvironmentTemplate>;
     /**
      * Deletes the environment template
      * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
@@ -84,7 +84,7 @@ export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, o
      * .catch(console.error)
      * ```
      */
-    getVersions: () => Promise<import("./common-types").CursorPaginatedCollection<import("./entities/environment-template").EnvironmentTemplate, EnvironmentTemplateProps>>;
+    getVersions: () => Promise<import("./common-types.js").CursorPaginatedCollection<import("./entities/environment-template.js").EnvironmentTemplate, EnvironmentTemplateProps>>;
     /**
      * Gets a collection of all installations for the environment template
      * @param [installationParams.spaceId] - Space ID to filter installations by space and environment
@@ -108,7 +108,7 @@ export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, o
     getInstallations: ({ spaceId, environmentId, ...query }?: {
         spaceId?: string;
         environmentId?: string;
-    } & BasicCursorPaginationOptions) => Promise<import("./common-types").CursorPaginatedCollection<import("./entities/environment-template-installation").EnvironmentTemplateInstallation, import("./entities/environment-template-installation").EnvironmentTemplateInstallationProps>>;
+    } & BasicCursorPaginationOptions) => Promise<import("./common-types.js").CursorPaginatedCollection<import("./entities/environment-template-installation.js").EnvironmentTemplateInstallation, import("./entities/environment-template-installation.js").EnvironmentTemplateInstallationProps>>;
     /**
      * Validates an environment template against a given space and environment
      * @param params.spaceId - Space ID where the template should be installed into
@@ -138,7 +138,7 @@ export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, o
         spaceId: string;
         environmentId: string;
         version?: number;
-    } & ValidateEnvironmentTemplateInstallationProps) => Promise<import("./entities/environment-template-installation").EnvironmentTemplateValidationProps>;
+    } & ValidateEnvironmentTemplateInstallationProps) => Promise<import("./entities/environment-template-installation.js").EnvironmentTemplateValidationProps>;
     /**
      * Installs a template against a given space and environment
      * @param params.spaceId - Space ID where the template should be installed into
@@ -170,7 +170,7 @@ export declare function createEnvironmentTemplateApi(makeRequest: MakeRequest, o
         spaceId: string;
         environmentId: string;
         installation: CreateEnvironmentTemplateInstallationProps;
-    }) => Promise<import("./entities/environment-template-installation").EnvironmentTemplateInstallationProps>;
+    }) => Promise<import("./entities/environment-template-installation.js").EnvironmentTemplateInstallationProps>;
     /**
      * Disconnects the template from a given environment
      * @param params.spaceId - Space ID where the template should be installed into

package/dist/types/create-environment-template-api.js

@@ -0,0 +1,268 @@
+import { createRequestConfig } from 'contentful-sdk-core';
+import { wrapEnvironmentTemplate, wrapEnvironmentTemplateCollection } from './entities/environment-template.js';
+import { wrapEnvironmentTemplateInstallationCollection } from './entities/environment-template-installation.js';
+
+function createEnvironmentTemplateApi(makeRequest, organizationId) {
+    return {
+        /**
+         * Updates a environment template
+         * @return Promise for new version of the template
+         * ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         * .then((environmentTemplate) => {
+         *   environmentTemplate.name = 'New name'
+         *   return environmentTemplate.update()
+         * })
+         * .then((environmentTemplate) =>
+         *   console.log(`Environment template ${environmentTemplate.sys.id} renamed.`)
+         * ).catch(console.error)
+         * ```
+         */
+        update: function updateEnvironmentTemplate() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'update',
+                params: { organizationId, environmentTemplateId: raw.sys.id },
+                payload: raw,
+            }).then((data) => wrapEnvironmentTemplate(makeRequest, data, organizationId));
+        },
+        /**
+         * Updates environment template version data
+         * @param version.versionName - Name of the environment template version
+         * @param version.versionDescription - Description of the environment template version
+         * @return Promise for an updated EnvironmentTemplate
+         * ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         * .then((environmentTemplate) => {
+         *   return environmentTemplate.updateVersion({
+         *     versionName: 'New Name',
+         *     versionDescription: 'New Description',
+         *   })
+         * })
+         * .then((environmentTemplate) =>
+         *   console.log(`Environment template version ${environmentTemplate.sys.id} renamed.`)
+         * ).catch(console.error)
+         * ```
+         */
+        updateVersion: function updateEnvironmentTemplateVersion({ versionName, versionDescription, }) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'versionUpdate',
+                params: { organizationId, environmentTemplateId: raw.sys.id, version: raw.sys.version },
+                payload: { versionName, versionDescription },
+            }).then((data) => wrapEnvironmentTemplate(makeRequest, data, organizationId));
+        },
+        /**
+         * Deletes the environment template
+         * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         *   .then((environmentTemplate) => environmentTemplate.delete())
+         *   .then(() => console.log('Environment template deleted.'))
+         *   .catch(console.error)
+         * ```
+         */
+        delete: function deleteEnvironmentTemplate() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'delete',
+                params: { organizationId, environmentTemplateId: raw.sys.id },
+            });
+        },
+        /**
+         * Gets a collection of all versions for 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('<organization_id>', '<environment_template_id>')
+         * .then((environmentTemplate) => environmentTemplate.getVersions())
+         * .then((environmentTemplateVersions) => console.log(environmentTemplateVersions.items))
+         * .catch(console.error)
+         * ```
+         */
+        getVersions: function getEnvironmentTemplateVersions() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'versions',
+                params: {
+                    organizationId,
+                    environmentTemplateId: raw.sys.id,
+                },
+            }).then((data) => wrapEnvironmentTemplateCollection(makeRequest, data, organizationId));
+        },
+        /**
+         * Gets a collection of all installations for the environment template
+         * @param [installationParams.spaceId] - Space ID to filter installations by space and environment
+         * @param [installationParams.environmentId] - Environment ID to filter installations by space and environment
+         * @return Promise for a collection of EnvironmentTemplateInstallations
+         * ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         * .then((environmentTemplate) => environmentTemplate.getInstallations())
+         * .then((environmentTemplateInstallations) =>
+         *   console.log(environmentTemplateInstallations.items)
+         * )
+         * .catch(console.error)
+         * ```
+         */
+        getInstallations: function getEnvironmentTemplateInstallations({ spaceId, environmentId, ...query } = {}) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplateInstallation',
+                action: 'getMany',
+                params: {
+                    organizationId,
+                    environmentTemplateId: raw.sys.id,
+                    query: { ...createRequestConfig({ query }).params },
+                    spaceId,
+                    environmentId,
+                },
+            }).then((data) => wrapEnvironmentTemplateInstallationCollection(makeRequest, data));
+        },
+        /**
+         * Validates an environment template against a given space and environment
+         * @param params.spaceId - Space ID where the template should be installed into
+         * @param params.environmentId - Environment ID where the template should be installed into
+         * @param [params.version] - Version of the template
+         * @param [params.installation.takeover] - Already existing Content types to takeover in the target environment
+         * @param [params.changeSet] - Change set which should be applied
+         * @return Promise for a EnvironmentTemplateValidation
+         * ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         * .then((environmentTemplate) => environmentTemplate.validate({
+         *   spaceId: '<space_id>',
+         *   environmentId: '<environment_id>',
+         *   version: <version>,
+         * }))
+         * .then((validationResult) => console.log(validationResult))
+         * .catch(console.error)
+         * ```
+         */
+        validate: function validateEnvironmentTemplate({ spaceId, environmentId, version, takeover, changeSet, }) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'validate',
+                params: {
+                    spaceId,
+                    version,
+                    environmentId,
+                    environmentTemplateId: raw.sys.id,
+                },
+                payload: {
+                    ...(takeover && { takeover }),
+                    ...(changeSet && { changeSet }),
+                },
+            });
+        },
+        /**
+         * Installs a template against a given space and environment
+         * @param params.spaceId - Space ID where the template should be installed into
+         * @param params.environmentId - Environment ID where the template should be installed into
+         * @param params.installation.version- Template version which should be installed
+         * @param [params.installation.takeover] - Already existing Content types tp takeover in the target environment
+         * @param [params.changeSet] - Change set which should be applied
+         * @return Promise for a EnvironmentTemplateInstallation
+         * ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         * .then((environmentTemplate) => environmentTemplate.validate({
+         *   spaceId: '<space_id>',
+         *   environmentId: '<environment_id>',
+         *   installation: {
+         *     version: <version>,
+         *   }
+         * }))
+         * .then((installation) => console.log(installation))
+         * .catch(console.error)
+         * ```
+         */
+        install: function installEnvironmentTemplate({ spaceId, environmentId, installation, }) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'install',
+                params: {
+                    spaceId,
+                    environmentId,
+                    environmentTemplateId: raw.sys.id,
+                },
+                payload: installation,
+            });
+        },
+        /**
+         * Disconnects the template from a given environment
+         * @param params.spaceId - Space ID where the template should be installed into
+         * @param params.environmentId - Environment ID where the template should be installed into
+         * @return Promise for the disconnection with no data
+         * ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getEnvironmentTemplate('<organization_id>', '<environment_template_id>')
+         * .then(environmentTemplate) => environmentTemplate.disconnected())
+         * .then(() => console.log('Template disconnected'))
+         * .catch(console.error)
+         * ```
+         */
+        disconnect: function disconnectEnvironmentTemplate({ spaceId, environmentId, }) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentTemplate',
+                action: 'disconnect',
+                params: {
+                    spaceId,
+                    environmentId,
+                    environmentTemplateId: raw.sys.id,
+                },
+            });
+        },
+    };
+}
+
+export { createEnvironmentTemplateApi };