contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Contentful Management API SDK. Allows you to create instances of a client
+ * with access to the Contentful Content Management API.
+ * @packageDocumentation
+ */
+import type { RestAdapterParams } from './adapters/REST/rest-adapter.js';
+import type { XOR } from './common-types.js';
+import type { AdapterParams } from './create-adapter.js';
+import type { ClientAPI } from './create-contentful-api.js';
+import type { PlainClientAPI } from './plain/common-types.js';
+import type { DefaultParams } from './plain/plain-client.js';
+import * as editorInterfaceDefaults from './constants/editor-interface-defaults/index.js';
+export type { ClientAPI } from './create-contentful-api.js';
+export { asIterator } from './plain/as-iterator.js';
+export { fetchAll } from './plain/pagination-helper.js';
+export { isDraft, isPublished, isUpdated } from './plain/checks.js';
+export type { PlainClientAPI } from './plain/common-types.js';
+export { createClient };
+export { RestAdapter } from './adapters/REST/rest-adapter.js';
+export type { RestAdapterParams } from './adapters/REST/rest-adapter.js';
+export { makeRequest } from './adapters/REST/make-request.js';
+export { editorInterfaceDefaults };
+export type PlainClientDefaultParams = DefaultParams;
+export * from './export-types.js';
+interface UserAgentParams {
+    /**
+     * Application name and version e.g myApp/version
+     */
+    application?: string;
+    /**
+     * Integration name and version e.g react/version
+     */
+    integration?: string;
+    feature?: string;
+}
+/**
+ * @deprecated
+ */
+export type ClientParams = RestAdapterParams & UserAgentParams;
+export type ClientOptions = UserAgentParams & XOR<RestAdapterParams, AdapterParams>;
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = contentfulManagement.createClient({
+ *  accessToken: 'myAccessToken'
+ * })
+ * ```
+ */
+declare function createClient(params: ClientOptions): ClientAPI;
+declare function createClient(params: ClientOptions, opts: {
+    type: 'plain';
+    defaults?: DefaultParams;
+}): PlainClientAPI;
+/**
+ * @deprecated The `alphaFeatures` option is no longer supported. Please use the function without this option.
+ */
+declare function createClient(params: ClientOptions, opts: {
+    type?: 'plain';
+    alphaFeatures: string[];
+    defaults?: DefaultParams;
+}): ClientAPI | PlainClientAPI;

package/dist/types/index.js

@@ -0,0 +1,36 @@
+import { getUserAgentHeader } from 'contentful-sdk-core';
+import { createAdapter } from './create-adapter.js';
+import createClientApi from './create-contentful-api.js';
+import { createPlainClient } from './plain/plain-client.js';
+import * as index from './constants/editor-interface-defaults/index.js';
+export { index as editorInterfaceDefaults };
+export { asIterator } from './plain/as-iterator.js';
+export { fetchAll } from './plain/pagination-helper.js';
+export { isDraft, isPublished, isUpdated } from './plain/checks.js';
+export { RestAdapter } from './adapters/REST/rest-adapter.js';
+export { makeRequest } from './adapters/REST/make-request.js';
+export { ScheduledActionReferenceFilters } from './common-types.js';
+export { WorkflowStepPermissionAction, WorkflowStepPermissionEffect, WorkflowStepPermissionType } from './entities/workflow-definition.js';
+
+/**
+ * Contentful Management API SDK. Allows you to create instances of a client
+ * with access to the Contentful Content Management API.
+ * @packageDocumentation
+ */
+function createClient(params, opts = {}) {
+    const sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
+    const userAgent = getUserAgentHeader(`${sdkMain}/${__VERSION__}`, params.application, params.integration, params.feature);
+    const adapter = createAdapter({ ...params, userAgent });
+    // Parameters<?> and ReturnType<?> only return the types of the last overload
+    // https://github.com/microsoft/TypeScript/issues/26591
+    // @ts-expect-error
+    const makeRequest = (options) => adapter.makeRequest({ ...options, userAgent });
+    if (opts.type === 'plain') {
+        return createPlainClient(makeRequest, opts.defaults);
+    }
+    else {
+        return createClientApi(makeRequest);
+    }
+}
+
+export { createClient };

package/dist/types/methods/action.js

@@ -0,0 +1,48 @@
+import { sleep } from './utils.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const DEFAULT_MAX_RETRIES = 30;
+const DEFAULT_INITIAL_DELAY_MS = 1000;
+const DEFAULT_RETRY_INTERVAL_MS = 2000;
+class AsyncActionProcessingError extends Error {
+    constructor(message, action) {
+        super(message);
+        this.action = action;
+        this.name = this.constructor.name;
+    }
+}
+class AsyncActionFailedError extends AsyncActionProcessingError {
+}
+/**
+ * @description Waits for an Action to be completed and to be in one of the final states (failed or succeeded)
+ * @param {Function} actionFunction - GET function that will be called every interval to fetch an Action status
+ * @throws {ActionFailedError} throws an error if `throwOnFailedExecution = true` with the Action that failed.
+ * @throws {AsyncActionProcessingError} throws an error with a Action when processing takes too long.
+ */
+async function pollAsyncActionStatus(actionFunction, options) {
+    let retryCount = 0;
+    let done = false;
+    let action;
+    const maxRetries = options?.retryCount ?? DEFAULT_MAX_RETRIES;
+    const retryIntervalMs = options?.retryIntervalMs ?? DEFAULT_RETRY_INTERVAL_MS;
+    const initialDelayMs = options?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+    const throwOnFailedExecution = options?.throwOnFailedExecution ?? true;
+    // Initial delay for short-running Actions
+    await sleep(initialDelayMs);
+    while (retryCount < maxRetries && !done) {
+        action = await actionFunction();
+        // Terminal states
+        if (action && ['succeeded', 'failed'].includes(action.sys.status)) {
+            done = true;
+            if (action.sys.status === 'failed' && throwOnFailedExecution) {
+                throw new AsyncActionFailedError(`${action.sys.type} failed to execute.`, action);
+            }
+            return action;
+        }
+        await sleep(retryIntervalMs);
+        retryCount += 1;
+    }
+    throw new AsyncActionProcessingError(`${action?.sys.type} didn't finish processing within the expected timeframe.`, action);
+}
+
+export { AsyncActionFailedError, AsyncActionProcessingError, pollAsyncActionStatus };

package/dist/types/methods/bulk-action.d.ts

@@ -0,0 +1,14 @@
+import type { BulkActionPayload, BulkActionProps } from '../entities/bulk-action.js';
+import type { PlainClientAPI } from '../plain/common-types.js';
+import type { AsyncActionProcessingOptions } from './action.js';
+type PlainOptions = {
+    /** Used by the PlainClient to perform a poll for the BulkAction status */
+    plainClient: PlainClientAPI;
+    spaceId: string;
+    environmentId: string;
+    bulkActionId: string;
+};
+/** Waits for a BulkAction status to be either succeeded or failed.
+ * Used by the Plain client */
+export declare function waitForBulkActionProcessing<T extends BulkActionPayload = any>({ plainClient, spaceId, environmentId, bulkActionId }: PlainOptions, options?: AsyncActionProcessingOptions): Promise<BulkActionProps<T>>;
+export {};

package/dist/types/methods/content-type.d.ts

@@ -0,0 +1,5 @@
+import type { GetContentTypeParams, MakeRequest } from '../common-types.js';
+import type { ContentTypeProps } from '../entities/content-type.js';
+export declare const omitAndDeleteField: (makeRequest: MakeRequest, { fieldId, ...params }: {
+    fieldId: string;
+} & GetContentTypeParams, contentType: ContentTypeProps) => Promise<ContentTypeProps>;

package/dist/types/methods/content-type.js

@@ -0,0 +1,46 @@
+/**
+ * @private
+ * @param id - unique ID of the field
+ * @param key - the attribute on the field to change
+ * @param value - the value to set the attribute to
+ */
+const findAndUpdateField = function (contentType, fieldId, omitOrDelete) {
+    const field = contentType.fields.find((field) => field.id === fieldId);
+    if (!field) {
+        return Promise.reject(new Error(`Tried to omitAndDeleteField on a nonexistent field, ${fieldId}, on the content type ${contentType.name}.`));
+    }
+    field[omitOrDelete] = true;
+    return Promise.resolve(contentType);
+};
+const omitAndDeleteField = (makeRequest, { fieldId, ...params }, contentType) => {
+    return findAndUpdateField(contentType, fieldId, 'omitted')
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'update',
+            params,
+            payload: newContentType,
+        });
+    })
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'publish',
+            params,
+            payload: newContentType,
+        });
+    })
+        .then((newContentType) => {
+        return findAndUpdateField(newContentType, fieldId, 'deleted');
+    })
+        .then((newContentType) => {
+        return makeRequest({
+            entityType: 'ContentType',
+            action: 'update',
+            params,
+            payload: newContentType,
+        });
+    });
+};
+
+export { omitAndDeleteField };

package/dist/types/methods/release-action.d.ts

@@ -0,0 +1,15 @@
+import type { ReleaseActionProps, ReleaseActionTypes } from '../entities/release-action.js';
+import type { PlainClientAPI } from '../plain/common-types.js';
+import type { AsyncActionProcessingOptions } from './action.js';
+type PlainOptions = {
+    /** Used by the PlainClient to perform a poll for the BulkAction status */
+    plainClient: PlainClientAPI;
+    spaceId: string;
+    environmentId: string;
+    releaseId: string;
+    actionId: string;
+};
+/** Waits for a ReleaseAction status to be either succeeded or failed.
+ * Used by the Plain client */
+export declare function waitForReleaseActionProcessing<T extends ReleaseActionTypes = any>({ plainClient, spaceId, environmentId, releaseId, actionId }: PlainOptions, options?: AsyncActionProcessingOptions): Promise<ReleaseActionProps<T>>;
+export {};

package/dist/types/methods/utils.js

@@ -0,0 +1,9 @@
+/**
+ * Helper function that resolves a Promise after the specified duration (in milliseconds)
+ * @private
+ */
+function sleep(durationMs) {
+    return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+
+export { sleep };

package/dist/types/plain/as-iterator.d.ts

@@ -0,0 +1,5 @@
+import type { CollectionProp, QueryParams } from '../common-types.js';
+type IterableFn<P = any, T = any> = (params: P) => Promise<CollectionProp<T>>;
+type ParamsType<T extends IterableFn> = T extends (params: infer P) => any ? P : never;
+export declare const asIterator: <P extends QueryParams, T, F extends IterableFn<P, T>>(fn: F, params: ParamsType<F>) => AsyncIterable<T>;
+export {};

package/dist/types/plain/as-iterator.js

@@ -0,0 +1,36 @@
+import copy from 'fast-copy';
+
+const asIterator = (fn, params) => {
+    return {
+        [Symbol.asyncIterator]() {
+            let options = copy(params);
+            const get = () => fn(copy(options));
+            let currentResult = get();
+            return {
+                current: 0,
+                async next() {
+                    const { total = 0, items = [], skip = 0, limit = 100 } = await currentResult;
+                    if (total === this.current) {
+                        return { done: true, value: null };
+                    }
+                    const value = items[this.current++ - skip];
+                    const endOfPage = this.current % limit === 0;
+                    const endOfList = this.current === total;
+                    if (endOfPage && !endOfList) {
+                        options = {
+                            ...options,
+                            query: {
+                                ...options.query,
+                                skip: skip + limit,
+                            },
+                        };
+                        currentResult = get();
+                    }
+                    return { done: false, value };
+                },
+            };
+        },
+    };
+};
+
+export { asIterator };

package/dist/types/plain/checks.d.ts

@@ -0,0 +1,13 @@
+import type { MetaSysProps } from '../common-types.js';
+export declare const isPublished: (data: {
+    sys: MetaSysProps;
+}) => boolean;
+export declare const isUpdated: (data: {
+    sys: MetaSysProps;
+}) => boolean;
+export declare const isDraft: (data: {
+    sys: MetaSysProps;
+}) => boolean;
+export declare const isArchived: (data: {
+    sys: MetaSysProps;
+}) => boolean;

package/dist/types/plain/checks.js

@@ -0,0 +1,10 @@
+const isPublished = (data) => !!data.sys.publishedVersion;
+const isUpdated = (data) => {
+    // The act of publishing an entity increases its version by 1, so any entry which has
+    // 2 versions higher or more than the publishedVersion has unpublished changes.
+    return !!(data.sys.publishedVersion && data.sys.version > data.sys.publishedVersion + 1);
+};
+const isDraft = (data) => !data.sys.publishedVersion;
+const isArchived = (data) => !!data.sys.archivedVersion;
+
+export { isArchived, isDraft, isPublished, isUpdated };