@stackbit/cms-contentful 0.4.45-staging.1 → 0.4.46-feature-document-statuses.1

package/src/contentful-api-client.ts

@@ -27,7 +27,8 @@ import {
     ScheduledActionProps,
     CursorPaginatedCollectionProp,
     ReleasePayload,
-    ReleaseQueryOptions
+    ReleaseQueryOptions,
+    BulkActionUnpublishPayload
 } from 'contentful-management';
 import { Logger } from '@stackbit/types';
 import { convertScheduledAction, findScheduleForRelease } from './contentful-scheduled-actions-converter';
@@ -77,6 +78,14 @@ export async function unpublishEntry(client: PlainClientAPI, entryId: string) {
     return client.entry.unpublish({ entryId });
 }
 
+export async function archiveEntry(client: PlainClientAPI, entryId: string) {
+    return client.entry.archive({ entryId });
+}
+
+export async function unarchiveEntry(client: PlainClientAPI, entryId: string) {
+    return client.entry.unarchive({ entryId });
+}
+
 export async function deleteEntry(client: PlainClientAPI, entryId: string) {
     return client.entry.delete({ entryId });
 }
@@ -113,6 +122,14 @@ export async function createPublishBulkAction(
     return client.bulkAction.publish(options, data);
 }
 
+export async function createUnpublishBulkAction(
+    client: PlainClientAPI,
+    options: GetSpaceEnvironmentParams,
+    data: BulkActionUnpublishPayload
+): Promise<BulkActionProps<BulkActionUnpublishPayload>> {
+    return client.bulkAction.unpublish(options, data);
+}
+
 export async function createWebhook(client: PlainClientAPI, data: CreateWebhooksProps) {
     return client.webhook.create({}, data);
 }

package/src/contentful-content-source.ts

@@ -18,7 +18,7 @@ import {
     SnapshotProps
 } from 'contentful-management';
 
-import type { DocumentVersion, DocumentVersionWithDocument, FieldList, FieldSpecificProps, Model, Schema } from '@stackbit/types';
+import { DocumentVersion, DocumentVersionWithDocument, FieldList, FieldSpecificProps, Model, Schema } from '@stackbit/types';
 import type * as ContentSourceTypes from '@stackbit/types';
 import * as stackbitUtils from '@stackbit/types';
 import { TaskQueue } from '@stackbit/utils';
@@ -59,7 +59,10 @@ import {
     getScheduledAction,
     fetchScheduleById,
     fetchEntityVersions,
-    fetchEntityVersion
+    fetchEntityVersion,
+    createUnpublishBulkAction,
+    archiveEntry,
+    unarchiveEntry
 } from './contentful-api-client';
 import { convertSchema } from './contentful-schema-converter';
 import {
@@ -809,6 +812,88 @@ export class ContentfulContentSource implements ContentSourceTypes.ContentSource
         );
     }
 
+    async unpublishDocuments({
+        documents,
+        assets,
+        userContext
+    }: {
+        documents: ContextualDocument[];
+        assets: ContextualAsset[];
+        userContext?: UserContext;
+    }): Promise<void> {
+        const apiClient = this.getPlainApiClientForUser({ userContext });
+
+        const entities = [...documents, ...assets];
+        // Max active bulk actions per space is limited to 5.
+        // Max of 200 items per bulk action.
+        const taskQueue = new TaskQueue({ limit: 5 });
+        const linkChunks: Link<'Entry' | 'Asset'>[][] = _.chunk(
+            entities.map((entity) => ({
+                sys: {
+                    type: 'Link',
+                    id: entity.id,
+                    linkType: entity.type === 'document' ? 'Entry' : 'Asset'
+                }
+            })),
+            200
+        );
+
+        await Promise.all(
+            linkChunks.map((links) => {
+                return taskQueue.addTask(async (): Promise<void> => {
+                    const bulkActionOptions = {
+                        spaceId: this.spaceId,
+                        environmentId: this.environment
+                    };
+                    const bulkActionCreateResult = await createUnpublishBulkAction(apiClient, bulkActionOptions, {
+                        entities: {
+                            sys: { type: 'Array' },
+                            items: links
+                        }
+                    });
+                    await waitBulkActionToComplete(bulkActionCreateResult, apiClient, bulkActionOptions);
+                });
+            })
+        );
+    }
+
+    async archiveDocument({ document, userContext }: { document: ContextualDocument; userContext?: UserContext }): Promise<void> {
+        this.logger.debug('archiveDocument');
+        const documentId = document.id;
+        try {
+            const entry = await fetchEntryById(this.plainClient, documentId);
+            const apiClient = this.getPlainApiClientForUser({ userContext });
+            // Contentful won't let us archive a published entry, so if the entry is
+            // published we must unpublish it first.
+            if (_.get(entry, 'sys.publishedVersion')) {
+                await unpublishEntry(apiClient, documentId);
+            }
+
+            await archiveEntry(apiClient, documentId);
+        } catch (err) {
+            this.logger.error('Contentful: Failed to archive object', {
+                documentId: documentId,
+                error: err
+            });
+            throw err;
+        }
+    }
+
+    async unarchiveDocument({ document, userContext }: { document: ContextualDocument; userContext?: UserContext }): Promise<void> {
+        this.logger.debug('unarchiveDocument');
+        const documentId = document.id;
+        try {
+            const apiClient = this.getPlainApiClientForUser({ userContext });
+            await unarchiveEntry(apiClient, documentId);
+        } catch (err) {
+            this.logger.error('Contentful: Failed to archive object', {
+                documentId: documentId,
+                error: err
+            });
+            throw err;
+        }
+    }
+
     async onWebhook({ data, headers }: { data: unknown; headers: Record<string, string> }) {
         const topic = headers['x-contentful-topic'] || '';
         const didContentTypeChange = topic.startsWith('ContentManagement.ContentType.');

package/src/contentful-entries-converter.ts

@@ -234,9 +234,12 @@ function commonFields(
     updatedBy?: string[];
 } {
     // currently we only expose isChanged that is treated as isDraft and isChanged because in Sanity there is no way to tell the difference
-    const isDraft = !entity.sys?.publishedVersion && !entity.sys?.archivedVersion;
+    const isArchived = !!entity.sys?.archivedVersion;
+    const isPublished = !!entity.sys?.publishedVersion;
+    // unpublished and deleted appear the same in contentful's API response.
     const isChanged = !!entity.sys?.publishedVersion && entity.sys?.version >= entity.sys?.publishedVersion + 2;
-    const status = isDraft ? 'added' : isChanged ? 'modified' : 'published';
+    const status = isChanged ? 'modified' : isArchived ? 'archived' : isPublished ? 'published' : 'added'; // draft is the remaining possible status due to isArchived and isPublished being false.
+
     const createdByEmail = getUserEmailById(entity.sys?.createdBy?.sys?.id, userMap);
     const updatedByEmail = getUserEmailById(entity.sys?.updatedBy?.sys?.id, userMap);
     const updatedByList = updatedByEmail ? [updatedByEmail] : [];