contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/entities/resource-type.js

@@ -0,0 +1,94 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createResourceTypeApi(makeRequest) {
+    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.getResourceType())
+         * .then((resourceType) => {
+         *    resourceType.name = '<new_name>'
+         *    return resourceType.upsert()
+         * })
+         * .catch(console.error)
+         * ```
+         */
+        upsert: function upsert() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'upsert',
+                params: getParams(data),
+                headers: {},
+                payload: getUpsertParams(data),
+            }).then((data) => wrapResourceType(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.getResourceType())
+         * .then((resourceType) => resourceType.delete())
+         * .catch(console.error)
+         * ```
+         */
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ResourceType',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+const getParams = (data) => ({
+    organizationId: data.sys.organization.sys.id,
+    appDefinitionId: data.sys.appDefinition.sys.id,
+    resourceTypeId: data.sys.id,
+});
+const getUpsertParams = (data) => ({
+    name: data.name,
+    defaultFieldMapping: data.defaultFieldMapping,
+});
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Type data
+ * @return Wrapped Resource Type data
+ */
+function wrapResourceType(makeRequest, data) {
+    const resourceType = toPlainObject(copy(data));
+    const ResourceTypeWithMethods = enhanceWithMethods(resourceType, createResourceTypeApi(makeRequest));
+    return freezeSys(ResourceTypeWithMethods);
+}
+function wrapResourceTypeforEnvironment(makeRequest, data) {
+    const resourceType = toPlainObject(data);
+    return freezeSys(resourceType);
+}
+const wrapResourceTypesForEnvironmentCollection = wrapCursorPaginatedCollection(wrapResourceTypeforEnvironment);
+
+export { wrapResourceType, wrapResourceTypeforEnvironment, wrapResourceTypesForEnvironmentCollection };

package/dist/types/entities/resource.d.ts

@@ -0,0 +1,38 @@
+import type { BasicCursorPaginationOptions, CursorPaginatedCollectionProp, Link, MakeRequest } from '../common-types.js';
+export type ResourceQueryOptions = LookupQueryOptions | SearchQueryOptions;
+type LookupQueryOptions = {
+    'sys.urn[in]': string;
+    locale?: string;
+} & BasicCursorPaginationOptions;
+type SearchQueryOptions = {
+    query: string;
+    locale?: string;
+} & BasicCursorPaginationOptions;
+export type ResourceProps = {
+    sys: {
+        type: 'Resource';
+        urn: string;
+        resourceType: Link<'ResourceType'>;
+        resourceProvider: Link<'ResourceProvider'>;
+        appDefinition: Link<'AppDefinition'>;
+    };
+    fields: {
+        title: string;
+        subtitle?: string;
+        description?: string;
+        externalUrl?: string;
+        image?: {
+            url: string;
+            altText?: string;
+        };
+        badge?: {
+            label: string;
+            variant: 'primary' | 'negative' | 'positive' | 'warning' | 'secondary';
+        };
+    };
+};
+export declare function wrapResource(makeRequest: MakeRequest, data: ResourceProps): ResourceProps & {
+    toPlainObject(): ResourceProps;
+};
+export declare const wrapResourceCollection: (makeRequest: MakeRequest, data: CursorPaginatedCollectionProp<ResourceProps>) => CursorPaginatedCollectionProp<ResourceProps>;
+export {};

package/dist/types/entities/resource.js

@@ -0,0 +1,10 @@
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+
+function wrapResource(makeRequest, data) {
+    const resource = toPlainObject(data);
+    return freezeSys(resource);
+}
+const wrapResourceCollection = wrapCursorPaginatedCollection(wrapResource);
+
+export { wrapResource, wrapResourceCollection };

package/dist/types/entities/role.d.ts

@@ -0,0 +1,85 @@
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
+export type ActionType = 'read' | 'create' | 'update' | 'delete' | 'publish' | 'unpublish' | 'archive' | 'unarchive';
+type ConditionType = 'and' | 'or' | 'not' | 'equals';
+export type ConstraintType = {
+    [key in ConditionType]?: ConstraintType[] | any;
+};
+export type RoleProps = {
+    sys: BasicMetaSysProps & {
+        space: Link<'Space'>;
+    };
+    name: string;
+    description?: string;
+    /**
+     * Permissions for application sections
+     */
+    permissions: {
+        ContentDelivery: string[] | string;
+        ContentModel: string[];
+        EnvironmentAliases: string[] | string;
+        Environments: string[] | string;
+        Settings: string[] | string;
+        Tags: string[] | string;
+    };
+    policies: {
+        effect: string;
+        actions: ActionType[] | 'all';
+        constraint: ConstraintType;
+    }[];
+};
+export type CreateRoleProps = Omit<RoleProps, 'sys'>;
+export interface Role extends RoleProps, DefaultElements<RoleProps> {
+    /**
+     * Deletes this object on the server.
+     * @memberof Role
+     * @func delete
+     * @return {Promise} 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.getSpace('<space_id>')
+     * .then((space) => space.getRole('<role_id>'))
+     * .then((role) => role.delete())
+     * .then((role) => console.log(`role deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * 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.getSpace('<space_id>')
+     * .then((space) => space.getRole('<roles_id>'))
+     * .then((roles) => {
+     *   roles.name = 'New role name'
+     *   return roles.update()
+     * })
+     * .then((roles) => console.log(`roles ${roles.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<Role>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw role data
+ * @return Wrapped role data
+ */
+export declare function wrapRole(makeRequest: MakeRequest, data: RoleProps): Role;
+/**
+ * @private
+ */
+export declare const wrapRoleCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<RoleProps>) => import("../common-types.js").Collection<Role, RoleProps>;
+export {};

package/dist/types/entities/role.js

@@ -0,0 +1,50 @@
+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';
+
+/**
+ * @private
+ */
+function createRoleApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        roleId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Role',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapRole(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Role',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw role data
+ * @return Wrapped role data
+ */
+function wrapRole(makeRequest, data) {
+    const role = toPlainObject(copy(data));
+    const roleWithMethods = enhanceWithMethods(role, createRoleApi(makeRequest));
+    return freezeSys(roleWithMethods);
+}
+/**
+ * @private
+ */
+const wrapRoleCollection = wrapCollection(wrapRole);
+
+export { wrapRole, wrapRoleCollection };

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

@@ -0,0 +1,110 @@
+import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest, ScheduledActionReferenceFilters, BasicCursorPaginationOptions, CollectionProp } from '../common-types.js';
+/**
+ * Represents that state of the scheduled action
+ */
+export declare enum ScheduledActionStatus {
+    /** action is pending execution */
+    scheduled = "scheduled",
+    /** action has been started and pending completion */
+    inProgress = "inProgress",
+    /** action was completed successfully (terminal state) */
+    succeeded = "succeeded",
+    /** action failed to complete (terminal state) */
+    failed = "failed",
+    /** action was canceled by a user (terminal state) */
+    canceled = "canceled"
+}
+type SchedulableEntityType = 'Entry' | 'Asset' | 'Release';
+type SchedulableActionType = 'publish' | 'unpublish';
+type ErrorDetail = {
+    error: any;
+};
+interface ScheduledActionFailedError {
+    sys: {
+        type: 'Error';
+        id: string;
+    };
+    message?: string;
+    details?: {
+        errors: ErrorDetail[];
+    };
+}
+export interface CursorPaginatedCollectionProp<TObj> extends Omit<CollectionProp<TObj>, 'total' | 'skip'> {
+    pages?: BasicCursorPaginationOptions;
+}
+export type ScheduledActionSysProps = {
+    id: string;
+    type: 'ScheduledAction';
+    version: number;
+    space: Link<'Space'>;
+    status: ScheduledActionStatus;
+    createdAt: ISO8601Timestamp;
+    createdBy: Link<'User'> | Link<'AppDefinition'>;
+    /** an ISO8601 date string representing when an action was moved to canceled */
+    canceledAt?: ISO8601Timestamp;
+    canceledBy?: Link<'User'> | Link<'AppDefinition'>;
+    /** an ISO8601 date string representing when an action was updated */
+    updatedAt: ISO8601Timestamp;
+    updatedBy: Link<'User'> | Link<'AppDefinition'>;
+};
+export type ScheduledActionPayloadProps = {
+    withReferences?: Record<ScheduledActionReferenceFilters, string[]>;
+};
+export type ScheduledActionProps = {
+    sys: ScheduledActionSysProps;
+    action: SchedulableActionType;
+    entity: Link<SchedulableEntityType>;
+    environment?: Link<'Environment'>;
+    scheduledFor: {
+        datetime: ISO8601Timestamp;
+        /**
+         * A valid IANA timezone Olson identifier
+         *
+         * @see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+         * @example 'Asia/Kolkata'
+         */
+        timezone?: string;
+    };
+    /**
+     * The Contentful-style error that occurred during execution if sys.status is failed
+     *
+     * @example
+     * {
+     *   sys: {
+     *     type: 'Error',
+     *     id: 'InvalidEntry'
+     *   },
+     *   message: 'Entry is invalid',
+     *   details: {
+     *     errors: [...]
+     *   }
+     * }
+     */
+    error?: ScheduledActionFailedError;
+    payload?: ScheduledActionPayloadProps;
+};
+export type CreateUpdateScheduledActionProps = Pick<ScheduledActionProps, 'action' | 'entity' | 'environment' | 'scheduledFor' | 'payload'>;
+export type ScheduledActionCollection = CursorPaginatedCollectionProp<ScheduledActionProps>;
+export interface ScheduledActionQueryOptions {
+    'environment.sys.id': string;
+    [key: string]: any;
+    limit?: number;
+    next?: string;
+    prev?: string;
+}
+export type ScheduledActionApi = {
+    delete(): Promise<ScheduledAction>;
+    update(): Promise<ScheduledAction>;
+};
+export interface ScheduledAction extends ScheduledActionProps, DefaultElements<ScheduledActionProps>, ScheduledActionApi {
+}
+export default function getInstanceMethods(makeRequest: MakeRequest): ScheduledActionApi;
+/**
+ * @private
+ */
+export declare function wrapScheduledAction(makeRequest: MakeRequest, data: ScheduledActionProps): ScheduledAction;
+/**
+ * @private
+ */
+export declare const wrapScheduledActionCollection: (makeRequest: MakeRequest, data: CollectionProp<ScheduledActionProps>) => import("../common-types.js").Collection<ScheduledAction, ScheduledActionProps>;
+export {};

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

@@ -0,0 +1,146 @@
+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';
+
+/**
+ * Represents that state of the scheduled action
+ */
+var ScheduledActionStatus;
+(function (ScheduledActionStatus) {
+    /** action is pending execution */
+    ScheduledActionStatus["scheduled"] = "scheduled";
+    /** action has been started and pending completion */
+    ScheduledActionStatus["inProgress"] = "inProgress";
+    /** action was completed successfully (terminal state) */
+    ScheduledActionStatus["succeeded"] = "succeeded";
+    /** action failed to complete (terminal state) */
+    ScheduledActionStatus["failed"] = "failed";
+    /** action was canceled by a user (terminal state) */
+    ScheduledActionStatus["canceled"] = "canceled";
+})(ScheduledActionStatus || (ScheduledActionStatus = {}));
+function getInstanceMethods(makeRequest) {
+    const getParams = (self) => {
+        const scheduledAction = self.toPlainObject();
+        return {
+            spaceId: scheduledAction.sys.space.sys.id,
+            environmentId: scheduledAction.environment?.sys.id,
+            scheduledActionId: scheduledAction.sys.id,
+            version: scheduledAction.sys.version,
+        };
+    };
+    return {
+        /**
+         * Cancels the current Scheduled Action schedule.
+         *
+         * @example ```javascript
+         *  const contentful = require('contentful-management');
+         *
+         *  const client = contentful.createClient({
+         *    accessToken: '<content_management_api_key>'
+         *  })
+         *
+         *  client.getSpace('<space_id>')
+         *    .then((space) => {
+         *      return space.createScheduledAction({
+         *        entity: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Entry',
+         *            id: '<entry_id>'
+         *          }
+         *        },
+         *        environment: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Environment',
+         *            id: '<environment_id>'
+         *          }
+         *        },
+         *        action: 'publish',
+         *        scheduledFor: {
+         *          datetime: <ISO_date_string>,
+         *          timezone: 'Europe/Berlin'
+         *        }
+         *      })
+         *    .then((scheduledAction) => scheduledAction.delete())
+         *    .then((deletedScheduledAction) => console.log(deletedScheduledAction))
+         *    .catch(console.error);
+         * ```
+         */
+        async delete() {
+            const params = getParams(this);
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'delete',
+                params,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+        /**
+         * Update the current scheduled action. Currently, only changes made to the `scheduledFor` property will be saved.
+         *
+         * @example ```javascript
+         *  const contentful = require('contentful-management');
+         *
+         *  const client = contentful.createClient({
+         *    accessToken: '<content_management_api_key>'
+         *  })
+         *
+         *  client.getSpace('<space_id>')
+         *    .then((space) => {
+         *      return space.createScheduledAction({
+         *        entity: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Entry',
+         *            id: '<entry_id>'
+         *          }
+         *        },
+         *        environment: {
+         *          sys: {
+         *            type: 'Link',
+         *            linkType: 'Environment',
+         *            id: '<environment_id>'
+         *          }
+         *        },
+         *        action: 'publish',
+         *        scheduledFor: {
+         *          datetime: <ISO_date_string>,
+         *          timezone: 'Europe/Berlin'
+         *        }
+         *      })
+         *    .then((scheduledAction) => {
+         *      scheduledAction.scheduledFor.timezone = 'Europe/Paris';
+         *      return scheduledAction.update();
+         *    })
+         *    .then((scheduledAction) => console.log(scheduledAction))
+         *    .catch(console.error);
+         * ```
+         */
+        async update() {
+            const params = getParams(this);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { sys, ...payload } = this.toPlainObject();
+            return makeRequest({
+                entityType: 'ScheduledAction',
+                action: 'update',
+                params,
+                payload,
+            }).then((data) => wrapScheduledAction(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapScheduledAction(makeRequest, data) {
+    const scheduledAction = toPlainObject(copy(data));
+    const scheduledActionWithMethods = enhanceWithMethods(scheduledAction, getInstanceMethods(makeRequest));
+    return freezeSys(scheduledActionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapScheduledActionCollection = wrapCollection(wrapScheduledAction);
+
+export { ScheduledActionStatus, getInstanceMethods as default, wrapScheduledAction, wrapScheduledActionCollection };

package/dist/types/entities/snapshot.d.ts

@@ -0,0 +1,24 @@
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types.js';
+export type SnapshotProps<T> = {
+    sys: MetaSysProps & {
+        snapshotType: string;
+        snapshotEntityType: string;
+    };
+    snapshot: T;
+};
+export interface Snapshot<T> extends SnapshotProps<T>, DefaultElements<SnapshotProps<T>> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot data
+ * @return Wrapped snapshot data
+ */
+export declare function wrapSnapshot<T>(_makeRequest: MakeRequest, data: SnapshotProps<T>): Snapshot<T>;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot collection data
+ * @return Wrapped snapshot collection data
+ */
+export declare const wrapSnapshotCollection: <T>(makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<SnapshotProps<T>>) => import("../common-types.js").Collection<Snapshot<T>, SnapshotProps<T>>;

package/dist/types/entities/snapshot.js

@@ -0,0 +1,33 @@
+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';
+
+/**
+ * @private
+ */
+function createSnapshotApi() {
+    return {
+    /* In case the snapshot object evolve later */
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot data
+ * @return Wrapped snapshot data
+ */
+function wrapSnapshot(_makeRequest, data) {
+    const snapshot = toPlainObject(copy(data));
+    const snapshotWithMethods = enhanceWithMethods(snapshot, createSnapshotApi());
+    return freezeSys(snapshotWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw snapshot collection data
+ * @return Wrapped snapshot collection data
+ */
+const wrapSnapshotCollection = wrapCollection(wrapSnapshot);
+
+export { wrapSnapshot, wrapSnapshotCollection };

package/dist/types/entities/space-member.d.ts

@@ -0,0 +1,29 @@
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types.js';
+export type SpaceMemberProps = {
+    sys: MetaSysProps;
+    /**
+     * User is an admin
+     */
+    admin: boolean;
+    /**
+     * Array of Role Links
+     */
+    roles: Link<'Role'>[];
+};
+export interface SpaceMember extends SpaceMemberProps, DefaultElements<SpaceMemberProps> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space member data
+ * @return Wrapped space member data
+ */
+export declare function wrapSpaceMember(_makeRequest: MakeRequest, data: SpaceMemberProps): SpaceMemberProps & {
+    toPlainObject(): SpaceMemberProps;
+};
+/**
+ * @private
+ */
+export declare const wrapSpaceMemberCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<SpaceMemberProps>) => import("../common-types.js").Collection<SpaceMemberProps & {
+    toPlainObject(): SpaceMemberProps;
+}, SpaceMemberProps>;

package/dist/types/entities/space-member.js

@@ -0,0 +1,20 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw space member data
+ * @return Wrapped space member data
+ */
+function wrapSpaceMember(_makeRequest, data) {
+    const spaceMember = toPlainObject(copy(data));
+    return freezeSys(spaceMember);
+}
+/**
+ * @private
+ */
+const wrapSpaceMemberCollection = wrapCollection(wrapSpaceMember);
+
+export { wrapSpaceMember, wrapSpaceMemberCollection };