contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/entities/app-access-token.d.ts

@@ -0,0 +1,34 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
+type AppAccessTokenSys = Except<BasicMetaSysProps, 'version' | 'id'> & {
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    appDefinition: Link<'AppDefinition'>;
+    expiresAt: string;
+};
+export type AppAccessTokenProps = {
+    /**
+     * System metadata
+     */
+    sys: AppAccessTokenSys;
+    /**
+     * Token for an app installation in a space environment
+     */
+    token: string;
+};
+export type CreateAppAccessTokenProps = {
+    /**
+     * JSON Web Token
+     */
+    jwt: string;
+};
+export interface AppAccessToken extends AppAccessTokenProps, DefaultElements<AppAccessTokenProps> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw app access token data
+ * @return {AppAccessToken} Wrapped AppAccessToken data
+ */
+export declare function wrapAppAccessToken(_makeRequest: MakeRequest, data: AppAccessTokenProps): AppAccessToken;
+export {};

package/dist/types/entities/app-access-token.js

@@ -0,0 +1,15 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw app access token data
+ * @return {AppAccessToken} Wrapped AppAccessToken data
+ */
+function wrapAppAccessToken(_makeRequest, data) {
+    const appAccessToken = toPlainObject(copy(data));
+    return freezeSys(appAccessToken);
+}
+
+export { wrapAppAccessToken };

package/dist/types/entities/app-action-call.d.ts

@@ -0,0 +1,92 @@
+import type { Except, JsonValue } from 'type-fest';
+import type { BasicMetaSysProps, AppActionCallRetryOptions, DefaultElements, MakeRequest, SysLink, CreateWithResponseParams, CreateWithResultParams, GetAppActionCallDetailsParams, GetAppActionCallParamsWithId } from '../common-types.js';
+import type { WebhookCallDetailsProps } from './webhook.js';
+type AppActionCallSys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: SysLink;
+    space: SysLink;
+    environment: SysLink;
+    action: SysLink;
+    appActionCallResponse?: SysLink;
+} & (AppActionCallSucceeded | AppActionCallProcessing | AppActionCallFailed);
+type RetryOptions = AppActionCallRetryOptions;
+export type AppActionCallStatus = 'processing' | 'succeeded' | 'failed';
+export interface AppActionCallErrorProps {
+    sys: {
+        type: 'Error';
+        id: string;
+    };
+    message: string;
+    details?: Record<string, unknown>;
+    statusCode?: number;
+}
+export type AppActionCallSucceeded = {
+    status: 'succeeded';
+    result: JsonValue;
+};
+export type AppActionCallProcessing = {
+    status: 'processing';
+};
+export type AppActionCallFailed = {
+    status: 'failed';
+    error: AppActionCallErrorProps;
+};
+export type AppActionCallProps = {
+    /**
+     * System metadata
+     */
+    sys: AppActionCallSys;
+};
+export type CreateAppActionCallProps = {
+    /** The body for the call */
+    parameters: {
+        [key: string]: unknown;
+    };
+};
+type AppActionCallApi = {
+    createWithResponse(params: CreateWithResponseParams, payload: CreateAppActionCallProps): Promise<AppActionCallResponse>;
+    getCallDetails(params: GetAppActionCallDetailsParams): Promise<AppActionCallResponse>;
+    get(params: GetAppActionCallParamsWithId): Promise<AppActionCallProps>;
+    createWithResult(params: CreateWithResultParams, payload: CreateAppActionCallProps): Promise<AppActionCallProps>;
+};
+export type AppActionCallResponse = WebhookCallDetailsProps;
+export interface AppActionCallRawResponseProps {
+    sys: {
+        id: string;
+        type: 'AppActionCallResponse';
+        space: SysLink;
+        environment: SysLink;
+        appInstallation: SysLink;
+        appAction: SysLink;
+        createdAt: string;
+        createdBy: SysLink;
+    };
+    response: {
+        headers?: {
+            contentType?: string;
+        };
+        statusCode?: number;
+        body: string;
+    };
+}
+export interface AppActionCallResponseData extends AppActionCallResponse, DefaultElements<AppActionCallResponse>, AppActionCallApi {
+}
+export type AppActionCall = AppActionCallProps & DefaultElements<AppActionCallProps>;
+/**
+ * @private
+ */
+export default function createAppActionCallApi(makeRequest: MakeRequest, retryOptions?: RetryOptions): AppActionCallApi;
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+export declare function wrapAppActionCall(makeRequest: MakeRequest, data: AppActionCallProps): AppActionCall;
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+export declare function wrapAppActionCallResponse(makeRequest: MakeRequest, data: AppActionCallResponse, retryOptions?: RetryOptions): AppActionCallResponseData;
+export {};

package/dist/types/entities/app-action-call.js

@@ -0,0 +1,65 @@
+import copy from 'fast-copy';
+import { toPlainObject } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createAppActionCallApi(makeRequest, retryOptions) {
+    return {
+        createWithResponse: function (params, payload) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'createWithResponse',
+                params: { ...params, ...retryOptions },
+                payload: payload,
+            }).then((data) => wrapAppActionCallResponse(makeRequest, data));
+        },
+        getCallDetails: function getCallDetails(params) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'getCallDetails',
+                params,
+            }).then((data) => wrapAppActionCallResponse(makeRequest, data));
+        },
+        get: function get(params) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'get',
+                params,
+            }).then((data) => wrapAppActionCall(makeRequest, data));
+        },
+        createWithResult: function (params, payload) {
+            return makeRequest({
+                entityType: 'AppActionCall',
+                action: 'createWithResult',
+                params: { ...params, ...retryOptions },
+                payload: payload,
+            }).then((data) => wrapAppActionCall(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+function wrapAppActionCall(makeRequest, data) {
+    const signedRequest = toPlainObject(copy(data));
+    const signedRequestWithMethods = enhanceWithMethods(signedRequest, createAppActionCallApi(makeRequest));
+    return signedRequestWithMethods;
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+function wrapAppActionCallResponse(makeRequest, data, retryOptions) {
+    const appActionCallResponse = toPlainObject(copy(data));
+    const appActionCallResponseWithMethods = enhanceWithMethods(appActionCallResponse, createAppActionCallApi(makeRequest, retryOptions));
+    return appActionCallResponseWithMethods;
+}
+
+export { createAppActionCallApi as default, wrapAppActionCall, wrapAppActionCallResponse };

package/dist/types/entities/app-action.d.ts

@@ -0,0 +1,161 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
+import type { ParameterDefinition } from './widget-parameters.js';
+type AppActionSys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: Link<'AppDefinition'>;
+    organization: Link<'Organization'>;
+};
+export type AppActionParameterDefinition = Omit<ParameterDefinition, 'labels'>;
+export type AppActionCategoryProps = {
+    sys: {
+        id: AppActionCategoryType;
+        type: 'AppActionCategory';
+        version: string;
+    };
+    name: string;
+    description: string;
+    parameters?: AppActionParameterDefinition[];
+};
+type BuiltInCategoriesProps = {
+    /**
+     * Category identifying the shape of the action.
+     */
+    category: 'Entries.v1.0' | 'Notification.v1.0';
+};
+type CustomAppActionProps = {
+    /**
+     * "Custom" category requires "parameters"
+     */
+    category: 'Custom';
+    parameters: AppActionParameterDefinition[];
+};
+type AppActionCategory = BuiltInCategoriesProps | CustomAppActionProps;
+export type AppActionCategoryType = AppActionCategory['category'];
+/**
+ * 'function' is deprecated, use 'function-invocation' instead
+ */
+export type AppActionType = 'endpoint' | 'function' | 'function-invocation';
+type BaseAppActionProps = AppActionCategory & {
+    /**
+     * System metadata
+     */
+    sys: AppActionSys;
+    /**
+     * Human readable name for the action
+     */
+    name: string;
+    /**
+     * Human readable description of the action
+     */
+    description?: string;
+    /**
+     * Optional JSON Schema describing the request payload shape
+     */
+    parametersSchema?: Record<string, unknown>;
+    /**
+     * Optional JSON Schema describing the result shape
+     */
+    resultSchema?: Record<string, unknown>;
+};
+type CreateEndpointAppActionProps = {
+    /**
+     * Type of the action, defaults to endpoint if not provided
+     * endpoint: action is sent to specified URL
+     */
+    type?: 'endpoint';
+    /**
+     * Url that will be called when the action is invoked
+     */
+    url: string;
+};
+type EndpointAppActionProps = {
+    /**
+     * Type of the action
+     * endpoint: action is sent to specified URL
+     */
+    type: 'endpoint';
+    /**
+     * Url that will be called when the action is invoked
+     */
+    url: string;
+};
+type CreateFunctionAppActionProps = {
+    /**
+     * Type of the action
+     * function-invocation: action invokes a contentful function
+     */
+    type: 'function-invocation';
+    /**
+     * Link to a Function
+     */
+    function: Link<'Function'>;
+    /**
+     * ID of the action
+     */
+    id?: string;
+};
+type FunctionAppActionProps = {
+    /**
+     * Type of the action
+     * function-invocation: action invokes a contentful function
+     */
+    type: 'function-invocation';
+    /**
+     * Link to a Function
+     */
+    function: Link<'Function'>;
+};
+/**
+ * @deprecated Use FunctionAppActionProps instead
+ */
+type LegacyFunctionAppActionProps = Record<string, unknown> & {
+    type: 'function';
+};
+export type CreateAppActionProps = AppActionCategory & {
+    name: string;
+    description?: string;
+    /**
+     * Optional JSON Schema describing the request payload shape
+     */
+    parametersSchema?: Record<string, unknown>;
+    /**
+     * Optional JSON Schema describing the result shape
+     */
+    resultSchema?: Record<string, unknown>;
+} & (CreateEndpointAppActionProps | CreateFunctionAppActionProps | LegacyFunctionAppActionProps);
+export type AppActionProps = BaseAppActionProps & (EndpointAppActionProps | FunctionAppActionProps | LegacyFunctionAppActionProps);
+export type AppAction = AppActionProps & DefaultElements<AppActionProps> & {
+    /**
+     * 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.getAppAction('<app-action-id>'))
+     * .then((appAction) => appAction.delete())
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+};
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle data
+ * @return Wrapped App Bundle data
+ */
+export declare function wrapAppAction(makeRequest: MakeRequest, data: AppActionProps): AppAction;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle collection data
+ * @return Wrapped App Bundle collection data
+ */
+export declare const wrapAppActionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppActionProps>) => import("../common-types.js").Collection<AppAction, AppActionProps>;
+export {};

package/dist/types/entities/app-action.js

@@ -0,0 +1,45 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createAppActionApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+        appActionId: data.sys.id,
+    });
+    return {
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppAction',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle data
+ * @return Wrapped App Bundle data
+ */
+function wrapAppAction(makeRequest, data) {
+    const appAction = toPlainObject(copy(data));
+    const appActionWithMethods = enhanceWithMethods(appAction, createAppActionApi(makeRequest));
+    return freezeSys(appActionWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle collection data
+ * @return Wrapped App Bundle collection data
+ */
+const wrapAppActionCollection = wrapCollection(wrapAppAction);
+
+export { wrapAppAction, wrapAppActionCollection };

package/dist/types/entities/app-bundle.d.ts

@@ -0,0 +1,86 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, Link, MakeRequest } from '../common-types.js';
+type AppBundleSys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: Link<'AppDefinition'>;
+    organization: Link<'Organization'>;
+};
+interface ActionManifestProps {
+    id?: string;
+    name: string;
+    description: string;
+    category: string;
+    path: string;
+    allowNetworks?: string[];
+}
+interface FunctionManifestProps {
+    id: string;
+    name: string;
+    description: string;
+    path: string;
+    accepts?: string[];
+    allowNetworks?: string[];
+}
+export type AppBundleFile = {
+    name: string;
+    size: number;
+    md5: string;
+};
+export type CreateAppBundleProps = {
+    appUploadId: string;
+    comment?: string;
+    actions?: ActionManifestProps[];
+    functions?: FunctionManifestProps[];
+};
+export type AppBundleProps = {
+    /**
+     * System metadata
+     */
+    sys: AppBundleSys;
+    /**
+     * List of all the files that are in this bundle
+     */
+    files: AppBundleFile[];
+    /**
+     * A comment that describes this bundle
+     */
+    comment?: string;
+    /**
+     * List of all functions in the bundle
+     */
+    functions?: FunctionManifestProps[];
+};
+export interface AppBundle extends AppBundleProps, DefaultElements<AppBundleProps> {
+    /**
+     * 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.getAppBundle('<app-bundle-id>'))
+     * .then((appBundle) => appBundle.delete())
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle data
+ * @return Wrapped App Bundle data
+ */
+export declare function wrapAppBundle(makeRequest: MakeRequest, data: AppBundleProps): AppBundle;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle collection data
+ * @return Wrapped App Bundle collection data
+ */
+export declare const wrapAppBundleCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppBundleProps>) => import("../common-types.js").Collection<AppBundle, AppBundleProps>;
+export {};

package/dist/types/entities/app-bundle.js

@@ -0,0 +1,45 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createAppBundleApi(makeRequest) {
+    const getParams = (data) => ({
+        organizationId: data.sys.organization.sys.id,
+        appDefinitionId: data.sys.appDefinition.sys.id,
+        appBundleId: data.sys.id,
+    });
+    return {
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'AppBundle',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle data
+ * @return Wrapped App Bundle data
+ */
+function wrapAppBundle(makeRequest, data) {
+    const appBundle = toPlainObject(copy(data));
+    const appBundleWithMethods = enhanceWithMethods(appBundle, createAppBundleApi(makeRequest));
+    return freezeSys(appBundleWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Bundle collection data
+ * @return Wrapped App Bundle collection data
+ */
+const wrapAppBundleCollection = wrapCollection(wrapAppBundle);
+
+export { wrapAppBundle, wrapAppBundleCollection };

package/dist/types/entities/app-definition.d.ts

@@ -0,0 +1,82 @@
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
+import type { ContentfulAppDefinitionAPI } from '../create-app-definition-api.js';
+import type { SetOptional, Except } from 'type-fest';
+import type { FieldType } from './field-type.js';
+import type { InstallationParameterType, ParameterDefinition } from './widget-parameters.js';
+import type { AppInstallationProps } from './app-installation.js';
+import type { EnvironmentProps } from './environment.js';
+export interface NavigationItem {
+    name: string;
+    path: string;
+}
+type LocationType = 'app-config' | 'entry-sidebar' | 'entry-editor' | 'dialog' | 'page' | 'home';
+export interface SimpleLocation {
+    location: LocationType;
+}
+export interface EntryFieldLocation {
+    location: 'entry-field';
+    fieldTypes: FieldType[];
+}
+export interface PageLocation {
+    location: 'page';
+    navigationItem?: NavigationItem;
+}
+export type AppLocation = SimpleLocation | EntryFieldLocation | PageLocation;
+export type AppDefinitionProps = {
+    /**
+     * System metadata
+     */
+    sys: BasicMetaSysProps & {
+        organization: Link<'Organization'>;
+        shared: boolean;
+    };
+    /**
+     * App name
+     */
+    name: string;
+    /**
+     * URL where the root HTML document of the app can be found
+     */
+    src?: string;
+    /**
+     * Link to an AppBundle
+     */
+    bundle?: Link<'AppBundle'>;
+    /**
+     * Locations where the app can be installed
+     */
+    locations?: AppLocation[];
+    /**
+     * Instance parameter definitions
+     */
+    parameters?: {
+        instance?: ParameterDefinition[];
+        installation?: ParameterDefinition<InstallationParameterType>[];
+    };
+};
+export type CreateAppDefinitionProps = SetOptional<Except<AppDefinitionProps, 'sys' | 'bundle'>, 'src' | 'locations'>;
+export type AppDefinition = ContentfulAppDefinitionAPI & AppDefinitionProps & DefaultElements<AppDefinitionProps>;
+export type AppInstallationsForOrganizationProps = {
+    sys: {
+        type: 'Array';
+    };
+    items: AppInstallationProps[];
+    includes: {
+        Environment: EnvironmentProps[];
+    };
+};
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition data
+ * @return Wrapped App Definition data
+ */
+export declare function wrapAppDefinition(makeRequest: MakeRequest, data: AppDefinitionProps): AppDefinition;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition collection data
+ * @return Wrapped App Definition collection data
+ */
+export declare const wrapAppDefinitionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<AppDefinitionProps>) => import("../common-types.js").Collection<AppDefinition, AppDefinitionProps>;
+export {};

package/dist/types/entities/app-definition.js

@@ -0,0 +1,26 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+import createAppDefinitionApi from '../create-app-definition-api.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition data
+ * @return Wrapped App Definition data
+ */
+function wrapAppDefinition(makeRequest, data) {
+    const appDefinition = toPlainObject(copy(data));
+    const appDefinitionWithMethods = enhanceWithMethods(appDefinition, createAppDefinitionApi(makeRequest));
+    return freezeSys(appDefinitionWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Definition collection data
+ * @return Wrapped App Definition collection data
+ */
+const wrapAppDefinitionCollection = wrapCollection(wrapAppDefinition);
+
+export { wrapAppDefinition, wrapAppDefinitionCollection };