contentful-management 11.48.3 → 11.49.0-beta.2

package/dist/esm/constants/editor-interface-defaults/controls-defaults.js

@@ -0,0 +1,153 @@
+import { in_ } from './types.js';
+
+const DROPDOWN_TYPES = ['Text', 'Symbol', 'Integer', 'Number', 'Boolean'];
+const INTERNAL_TO_API = {
+    Symbol: { type: 'Symbol' },
+    Text: { type: 'Text' },
+    RichText: { type: 'RichText' },
+    Integer: { type: 'Integer' },
+    Number: { type: 'Number' },
+    Boolean: { type: 'Boolean' },
+    Date: { type: 'Date' },
+    Location: { type: 'Location' },
+    Object: { type: 'Object' },
+    File: { type: 'File' },
+    Entry: { type: 'Link', linkType: 'Entry' },
+    Asset: { type: 'Link', linkType: 'Asset' },
+    Resource: { type: 'ResourceLink' },
+    Symbols: { type: 'Array', items: { type: 'Symbol' } },
+    Entries: { type: 'Array', items: { type: 'Link', linkType: 'Entry' } },
+    Assets: { type: 'Array', items: { type: 'Link', linkType: 'Asset' } },
+    Resources: { type: 'Array', items: { type: 'ResourceLink' } },
+};
+const FIELD_TYPES = Object.keys(INTERNAL_TO_API);
+/**
+ * Returns an internal string identifier for an API field object.
+ *
+ * We use this string as a simplified reference to field types.
+ * Possible values are:
+ *
+ * - Symbol
+ * - Symbols
+ * - Text
+ * - RichText
+ * - Integer
+ * - Number
+ * - Boolean
+ * - Date
+ * - Location
+ * - Object
+ * - Entry
+ * - Entries
+ * - Asset
+ * - Assets
+ * - File
+ */
+function toInternalFieldType(api) {
+    return FIELD_TYPES.find((key) => {
+        const internalApi = INTERNAL_TO_API[key];
+        const stripped = {
+            type: api.type,
+            linkType: api.linkType,
+            items: api.items,
+        };
+        if (stripped.items) {
+            stripped.items = { type: stripped.items.type, linkType: stripped.items.linkType };
+        }
+        if (internalApi.type === 'Link') {
+            return internalApi.linkType === stripped.linkType;
+        }
+        if (internalApi.type === 'Array' && internalApi.items && stripped.items) {
+            if (internalApi.items.type === 'Link') {
+                return internalApi.items.linkType === stripped.items.linkType;
+            }
+            return internalApi.items.type === stripped.items.type;
+        }
+        return internalApi.type === stripped.type;
+    });
+}
+const DEFAULTS_WIDGET = {
+    Text: { widgetId: 'markdown' },
+    Symbol: { widgetId: 'singleLine' },
+    Integer: { widgetId: 'numberEditor' },
+    Number: { widgetId: 'numberEditor' },
+    Boolean: { widgetId: 'boolean' },
+    Date: { widgetId: 'datePicker' },
+    Location: { widgetId: 'locationEditor' },
+    Object: { widgetId: 'objectEditor' },
+    RichText: { widgetId: 'richTextEditor' },
+    Entry: { widgetId: 'entryLinkEditor' },
+    Asset: { widgetId: 'assetLinkEditor' },
+    Symbols: { widgetId: 'tagEditor' },
+    Entries: { widgetId: 'entryLinksEditor' },
+    Assets: { widgetId: 'assetLinksEditor' },
+    File: { widgetId: 'fileEditor' },
+    Resource: { widgetId: 'resourceLinkEditor' },
+    Resources: { widgetId: 'resourceLinksEditor' },
+};
+const DEFAULTS_SETTINGS = {
+    Boolean: {
+        falseLabel: 'No',
+        helpText: null,
+        trueLabel: 'Yes',
+    },
+    Date: {
+        helpText: null,
+        ampm: '24',
+        format: 'timeZ',
+    },
+    Entry: {
+        helpText: null,
+        showCreateEntityAction: true,
+        showLinkEntityAction: true,
+    },
+    Asset: {
+        helpText: null,
+        showCreateEntityAction: true,
+        showLinkEntityAction: true,
+    },
+    Entries: {
+        helpText: null,
+        bulkEditing: false,
+        showCreateEntityAction: true,
+        showLinkEntityAction: true,
+    },
+    Assets: {
+        helpText: null,
+        showCreateEntityAction: true,
+        showLinkEntityAction: true,
+    },
+};
+function getDefaultWidget(field, fieldId) {
+    const defaultWidget = Object.assign(Object.assign({}, DEFAULTS_WIDGET[field]), { settings: {
+            helpText: null,
+        }, widgetNamespace: 'builtin', fieldId });
+    if (in_(field, DEFAULTS_SETTINGS)) {
+        defaultWidget.settings = Object.assign(Object.assign({}, defaultWidget.settings), DEFAULTS_SETTINGS[field]);
+    }
+    return defaultWidget;
+}
+/*
+ * Gets the default widget ID for a field:
+ * - If a field allows predefined values then `dropdown` widget is used
+ *   in the presence of the `in` validation.
+ * - If a Text field is a title then the `singleLine` widget is used.
+ * - Otherwise a simple type-to-editor mapping is used.
+ */
+function getDefaultControlOfField(field) {
+    const fieldType = toInternalFieldType(field);
+    if (!fieldType) {
+        throw new Error('Invalid field type');
+    }
+    const hasInValidation = (field.validations || []).find((v) => 'in' in v);
+    if (hasInValidation && DROPDOWN_TYPES.includes(fieldType)) {
+        return {
+            widgetId: 'dropdown',
+            fieldId: field.id,
+            widgetNamespace: 'builtin',
+        };
+    }
+    return getDefaultWidget(fieldType, field.id);
+}
+
+export { DEFAULTS_SETTINGS, DEFAULTS_WIDGET, FIELD_TYPES, getDefaultControlOfField as default, toInternalFieldType };

package/dist/esm/constants/editor-interface-defaults/editors-defaults.js

@@ -0,0 +1,37 @@
+import { WidgetNamespace, DEFAULT_EDITOR_ID } from './types.js';
+
+const EntryEditorWidgetTypes = {
+    DEFAULT_EDITOR: {
+        name: 'Editor',
+        id: DEFAULT_EDITOR_ID,
+        icon: 'Entry',
+    },
+    REFERENCE_TREE: {
+        name: 'References',
+        id: 'reference-tree',
+        icon: 'References',
+    },
+    TAGS_EDITOR: {
+        name: 'Tags',
+        id: 'tags-editor',
+        icon: 'Tags',
+    },
+};
+const DefaultEntryEditor = {
+    widgetId: EntryEditorWidgetTypes.DEFAULT_EDITOR.id,
+    widgetNamespace: WidgetNamespace.EDITOR_BUILTIN,
+    name: EntryEditorWidgetTypes.DEFAULT_EDITOR.name,
+};
+const ReferencesEntryEditor = {
+    widgetId: EntryEditorWidgetTypes.REFERENCE_TREE.id,
+    widgetNamespace: WidgetNamespace.EDITOR_BUILTIN,
+    name: EntryEditorWidgetTypes.REFERENCE_TREE.name,
+};
+const TagsEditor = {
+    widgetId: EntryEditorWidgetTypes.TAGS_EDITOR.id,
+    widgetNamespace: WidgetNamespace.EDITOR_BUILTIN,
+    name: EntryEditorWidgetTypes.TAGS_EDITOR.name,
+};
+const EntryConfiguration = [DefaultEntryEditor, ReferencesEntryEditor, TagsEditor];
+
+export { EntryConfiguration, EntryEditorWidgetTypes };

package/dist/esm/constants/editor-interface-defaults/index.js

@@ -0,0 +1,12 @@
+import { SidebarEntryConfiguration, SidebarAssetConfiguration } from './sidebar-defaults.js';
+import { EntryConfiguration } from './editors-defaults.js';
+import getDefaultControlOfField from './controls-defaults.js';
+
+var index = {
+    SidebarEntryConfiguration,
+    SidebarAssetConfiguration,
+    EntryConfiguration,
+    getDefaultControlOfField,
+};
+
+export { index as default };

package/dist/esm/constants/editor-interface-defaults/sidebar-defaults.js

@@ -0,0 +1,68 @@
+import { WidgetNamespace } from './types.js';
+
+const SidebarWidgetTypes = {
+    USERS: 'users-widget',
+    CONTENT_PREVIEW: 'content-preview-widget',
+    TRANSLATION: 'translation-widget',
+    INCOMING_LINKS: 'incoming-links-widget',
+    PUBLICATION: 'publication-widget',
+    RELEASES: 'releases-widget',
+    VERSIONS: 'versions-widget',
+    INFO_PANEL: 'info-panel',
+    JOBS: 'jobs-widget',
+    COMMENTS_PANEL: 'comments-panel',
+};
+const Publication = {
+    widgetId: SidebarWidgetTypes.PUBLICATION,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Publish & Status',
+    description: 'Built-in - View entry status, publish, etc.',
+};
+const Releases = {
+    widgetId: SidebarWidgetTypes.RELEASES,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Release',
+    description: 'Built-in - View release, add to it, etc.',
+};
+const ContentPreview = {
+    widgetId: SidebarWidgetTypes.CONTENT_PREVIEW,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Preview',
+    description: 'Built-in - Displays preview functionality.',
+};
+const Links = {
+    widgetId: SidebarWidgetTypes.INCOMING_LINKS,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Links',
+    description: 'Built-in - Shows where an entry is linked.',
+};
+const Translation = {
+    widgetId: SidebarWidgetTypes.TRANSLATION,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Translation',
+    description: 'Built-in - Manage which translations are visible.',
+};
+const Versions = {
+    widgetId: SidebarWidgetTypes.VERSIONS,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Versions',
+    description: 'Built-in - View previously published versions. Available only for master environment.',
+};
+const Users = {
+    widgetId: SidebarWidgetTypes.USERS,
+    widgetNamespace: WidgetNamespace.SIDEBAR_BUILTIN,
+    name: 'Users',
+    description: 'Built-in - Displays users on the same entry.',
+};
+const SidebarEntryConfiguration = [
+    Publication,
+    Releases,
+    ContentPreview,
+    Links,
+    Translation,
+    Versions,
+    Users,
+];
+const SidebarAssetConfiguration = [Publication, Releases, Links, Translation, Users];
+
+export { SidebarAssetConfiguration, SidebarEntryConfiguration };

package/dist/esm/constants/editor-interface-defaults/types.js

@@ -0,0 +1,15 @@
+var WidgetNamespace;
+(function (WidgetNamespace) {
+    WidgetNamespace["BUILTIN"] = "builtin";
+    WidgetNamespace["EXTENSION"] = "extension";
+    WidgetNamespace["SIDEBAR_BUILTIN"] = "sidebar-builtin";
+    WidgetNamespace["APP"] = "app";
+    WidgetNamespace["EDITOR_BUILTIN"] = "editor-builtin";
+})(WidgetNamespace || (WidgetNamespace = {}));
+const DEFAULT_EDITOR_ID = 'default-editor';
+/**
+ * @private
+ */
+const in_ = (key, object) => key in object;
+
+export { DEFAULT_EDITOR_ID, WidgetNamespace, in_ };

package/dist/esm/create-adapter.js

@@ -0,0 +1,19 @@
+import { RestAdapter } from './adapters/REST/rest-adapter.js';
+
+/**
+ * @packageDocumentation
+ * @hidden
+ */
+/**
+ * @private
+ */
+function createAdapter(params) {
+    if ('apiAdapter' in params) {
+        return params.apiAdapter;
+    }
+    else {
+        return new RestAdapter(params);
+    }
+}
+
+export { createAdapter };

package/dist/esm/create-app-definition-api.js

@@ -0,0 +1,252 @@
+import entities from './entities/index.js';
+import { wrapAppDefinition } from './entities/app-definition.js';
+
+/**
+ * @private
+ */
+function createAppDefinitionApi(makeRequest) {
+    const { wrapAppBundle, wrapAppBundleCollection } = entities.appBundle;
+    const { wrapResourceProvider } = entities.resourceProvider;
+    const getParams = (data) => ({
+        appDefinitionId: data.sys.id,
+        organizationId: data.sys.organization.sys.id,
+    });
+    return {
+        /**
+         * Sends an update to the server with any changes made to the object's properties
+         * @return Object returned from the server with updated changes.
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         *
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => {
+         *   appDefinition.name = 'New App Definition name'
+         *   return appDefinition.update()
+         * })
+         * .then((appDefinition) => console.log(`App Definition ${appDefinition.sys.id} updated.`))
+         * .catch(console.error)
+         * ```
+         */
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppDefinition',
+                action: 'update',
+                params: getParams(data),
+                headers: {},
+                payload: data,
+            }).then((data) => wrapAppDefinition(makeRequest, data));
+        },
+        /**
+         * Deletes this object on the server.
+         * @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.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.delete())
+         * .then(() => console.log(`App Definition deleted.`))
+         * .catch(console.error)
+         * ```
+         */
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppDefinition',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+        /**
+         * Gets an app bundle
+         * @param id - AppBundle ID
+         * @return Promise for an AppBundle
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getAppBundle('<app_upload_id>'))
+         * .then((appBundle) => console.log(appBundle))
+         * .catch(console.error)
+         * ```
+         */
+        getAppBundle(id) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppBundle',
+                action: 'get',
+                params: {
+                    appBundleId: id,
+                    appDefinitionId: raw.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+            }).then((data) => wrapAppBundle(makeRequest, data));
+        },
+        /**
+         * Gets a collection of AppBundles
+         * @return Promise for a collection of AppBundles
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getAppBundles())
+         * .then((response) => console.log(response.items))
+         * .catch(console.error)
+         * ```
+         */
+        getAppBundles(query = {}) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppBundle',
+                action: 'getMany',
+                params: { organizationId: raw.sys.organization.sys.id, appDefinitionId: raw.sys.id, query },
+            }).then((data) => wrapAppBundleCollection(makeRequest, data));
+        },
+        /**
+         * Creates an app bundle
+         * @param Object representation of the App Bundle to be created
+         * @return Promise for the newly created AppBundle
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.createAppBundle('<app_upload_id>'))
+         * .then((appBundle) => console.log(appBundle))
+         * .catch(console.error)
+         * ```
+         */
+        createAppBundle(data) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppBundle',
+                action: 'create',
+                params: {
+                    appDefinitionId: raw.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+                payload: data,
+            }).then((data) => wrapAppBundle(makeRequest, data));
+        },
+        /**
+         * Gets a list of App Installations across an org for given organization and App Definition
+         * If a spaceId is provided in the query object, it will return the App Installations for that specific space.
+         * @return Promise for the newly created AppBundle
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         * client.getAppDefinition('<organization_id>', '<app_definition_id>')
+         * .then((appDefinition) => appDefinition.getInstallationsForOrg(
+         *   { spaceId: '<space_id>' } // optional
+         * ))
+         * .then((appInstallationsForOrg) => console.log(appInstallationsForOrg.items))
+         * .catch(console.error)
+         * ```
+         */
+        getInstallationsForOrg(query = {}) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppDefinition',
+                action: 'getInstallationsForOrg',
+                params: {
+                    appDefinitionId: raw.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                    query,
+                },
+            });
+        },
+        /**
+         * Creates or updates a resource provider
+         * @param data representation of the ResourceProvider
+         * @return Promise for the newly created or updated ResourceProvider
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * // You need a valid AppDefinition with an activated AppBundle that has a contentful function configured
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.upsertResourceProvider({
+         *    sys: {
+         *      id: '<resource_provider_id>'
+         *    },
+         *    type: 'function',
+         *    function: {
+         *      sys: {
+         *        id: '<contentful_function_id>',
+         *        type: 'Link'
+         *        linkType: 'Function'
+         *      }
+         *    }
+         * }))
+         * .then((resourceProvider) => console.log(resourceProvider))
+         * .catch(console.error)
+         * ```
+         */
+        upsertResourceProvider(data) {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceProvider',
+                action: 'upsert',
+                params: {
+                    appDefinitionId: raw.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+                payload: data,
+            }).then((payload) => wrapResourceProvider(makeRequest, payload));
+        },
+        /**
+         * Gets a Resource Provider
+         * @return Promise for a Resource Provider
+         * @example ```javascript
+         * const contentful = require('contentful-management')
+         * const client = contentful.createClient({
+         *   accessToken: '<content_management_api_key>'
+         * })
+         *
+         * client.getOrganization('<org_id>')
+         * .then((org) => org.getAppDefinition('<app_def_id>'))
+         * .then((appDefinition) => appDefinition.getResourceProvider())
+         * .then((resourceProvider) => console.log(resourceProvider))
+         * .catch(console.error)
+         * ```
+         */
+        getResourceProvider() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceProvider',
+                action: 'get',
+                params: {
+                    appDefinitionId: raw.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+            }).then((payload) => wrapResourceProvider(makeRequest, payload));
+        },
+    };
+}
+
+export { createAppDefinitionApi as default };