@stackbit/cms-sanity 0.2.23-develop.2 → 0.2.23-staging.1

package/src/sanity-api-client.ts

@@ -1,6 +1,7 @@
 import https from 'https';
 import _ from 'lodash';
 import { SanityClient as SanityClientType, SanityDocument } from '@sanity/client';
+import { isDraftId } from './sanity-document-converter';
 export { default as SanityClient } from '@sanity/client';
 
 export interface SanityUser {
@@ -72,20 +73,35 @@ export async function testToken(apiToken: string): Promise<{
     });
 }
 
-export async function fetchDocumentsHistory(documentIds: string[], dataset: string, client: SanityClientType): Promise<DocumentHistory[]> {
+export async function fetchDocumentsHistory({
+    documentIds,
+    dataset,
+    client,
+    limitTime = true
+}: {
+    documentIds: string[];
+    dataset: string;
+    client: SanityClientType;
+    limitTime?: boolean;
+}): Promise<DocumentHistory[]> {
     if (!documentIds.length) {
         return [];
     }
-    // get docs history from last 30 days
-    const fromTime = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
     // max size of one request to Sanity is 32Kb
     // Sanity response: AssertionError [ERR_ASSERTION]: Your message must be < 32kb.
     // it's undocumented, so 11Kb is query limit - https://www.sanity.io/docs/http-query, hence stick to that
     const chunkedDocumentIds = chunkArray(documentIds, 11000);
     const result: DocumentHistory[] = [];
     for (const idsChunk of chunkedDocumentIds) {
+        const searchParams = new URLSearchParams();
+        searchParams.append('excludeContent', 'true');
+        searchParams.append('reverse', 'true');
+        if (limitTime) {
+            // get docs history from last 30 days
+            searchParams.append('fromTime', new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString());
+        }
         const data = await client.request({
-            uri: `data/history/${dataset}/transactions/${idsChunk.join(',')}?excludeContent=true&fromTime=${fromTime}&reverse=true`
+            uri: `data/history/${dataset}/transactions/${idsChunk.join(',')}?${searchParams.toString()}`
         });
         for (const line of data.split('\n')) {
             if (line) {
@@ -96,6 +112,51 @@ export async function fetchDocumentsHistory(documentIds: string[], dataset: stri
     return result;
 }
 
+export async function fetchDocumentRevision({
+    documentId,
+    draftDocumentId,
+    versionId,
+    dataset,
+    client
+}: {
+    documentId: string;
+    draftDocumentId?: string;
+    versionId: string;
+    dataset: string;
+    client: SanityClientType;
+}): Promise<DocumentHistory> {
+    const searchParams = new URLSearchParams();
+    searchParams.append('excludeContent', 'true');
+    searchParams.append('fromTransaction', versionId);
+    searchParams.append('toTransaction', versionId);
+    const documentIds = [documentId, draftDocumentId];
+    const data = await client.request({
+        uri: `data/history/${dataset}/transactions/${documentIds.join(',')}?${searchParams.toString()}`
+    });
+    return JSON.parse(data);
+}
+
+export async function fetchDocumentForRevision({
+    documentId,
+    draftDocumentId,
+    versionId,
+    dataset,
+    client
+}: {
+    documentId: string;
+    draftDocumentId?: string;
+    versionId: string;
+    dataset: string;
+    client: SanityClientType;
+}): Promise<SanityDocument> {
+    const documentIds = [documentId, draftDocumentId];
+    const data = await client.request({
+        uri: `data/history/${dataset}/documents/${documentIds.join(',')}?revision=${versionId}`
+    });
+    // take either latest draft revision object, or latest object
+    return data.documents.find((object: SanityDocument) => isDraftId(object._id)) ?? data.documents[data.documents.length - 1];
+}
+
 export async function fetchUsers(userIds: string[], client: SanityClientType): Promise<SanityUser[]> {
     const chunkedDocumentIds = chunkArray(userIds, 11000);
     const result = [];

package/src/sanity-content-source.ts

@@ -6,7 +6,18 @@ import path from 'path';
 import fse from 'fs-extra';
 import { glob } from 'glob';
 import { MutationEvent, PatchOperations, SanityAssetDocument, SanityClient as SanityClientType, SanityDocument, SanityDocumentStub } from '@sanity/client';
-import type { Field, FieldList, FieldListItems, FieldObjectProps, FieldSpecificProps, Model, Schema, UserCommandSpawner } from '@stackbit/types';
+import type {
+    DocumentVersion,
+    DocumentVersionWithDocument,
+    Field,
+    FieldList,
+    FieldListItems,
+    FieldObjectProps,
+    FieldSpecificProps,
+    Model,
+    Schema,
+    UserCommandSpawner
+} from '@stackbit/types';
 import type * as ContentSourceTypes from '@stackbit/types';
 import { getVersion as stackbitUtilsGetVersion } from '@stackbit/types';
 
@@ -16,10 +27,12 @@ import {
     testToken,
     DocumentHistory,
     DocumentHistoryMap,
-    fetchDocumentsHistory,
     fetchUsers,
     SanityUser,
-    fetchScheduledActions
+    fetchScheduledActions,
+    fetchDocumentsHistory,
+    fetchDocumentForRevision,
+    fetchDocumentRevision
 } from './sanity-api-client';
 import { convertSchema } from './sanity-schema-converter';
 import {
@@ -431,6 +444,30 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         return this.cache.updateContent(result);
     }
 
+    private convertVersionsFromDocumentHistory(versions: DocumentHistory[]): DocumentVersion[] {
+        return versions.map((version) => {
+            return {
+                id: version.id,
+                documentId: getPureObjectId(version.documentIDs[0]!),
+                srcType: this.getContentSourceType(),
+                srcProjectId: this.projectId,
+                createdAt: version.timestamp,
+                createdBy: this.userMap[version.author]?.email
+            };
+        });
+    }
+
+    private convertVersionForDocument(version: DocumentHistory, document: ContextualDocument): DocumentVersionWithDocument {
+        const [documentVersion] = this.convertVersionsFromDocumentHistory([version]);
+        if (!documentVersion) {
+            throw new Error('Document version could not be converted');
+        }
+        return {
+            ...documentVersion,
+            document
+        };
+    }
+
     async getSanitySchema(): Promise<any> {
         let sanitySchema;
         try {
@@ -461,7 +498,7 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         this.logger.debug('getDocumentsHistory started', documentIds.length);
 
         const draftDocumentIds = documentIds.filter((documentId) => isDraftId(documentId));
-        const historyData = await fetchDocumentsHistory(draftDocumentIds, this.dataset, this.client);
+        const historyData = await fetchDocumentsHistory({ documentIds: draftDocumentIds, dataset: this.dataset, client: this.client });
 
         const notCachedDocAuthors = historyData.reduce((acc: string[], doc: DocumentHistory) => {
             const user = this.userMap[doc.author];
@@ -899,6 +936,44 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
             apiVersion: SANITY_API_VERSION
         });
     }
+
+    async getDocumentVersions({ documentId }: { documentId: string }): Promise<{ versions: DocumentVersion[] }> {
+        this.logger.debug('getDocumentVersions', { documentId });
+
+        const documentHistory = await fetchDocumentsHistory({
+            documentIds: [documentId, getDraftObjectId(documentId)],
+            dataset: this.dataset,
+            client: this.client,
+            limitTime: false
+        });
+
+        if (!documentHistory) {
+            return { versions: [] };
+        }
+
+        return { versions: this.convertVersionsFromDocumentHistory(documentHistory) };
+    }
+
+    async getDocumentForVersion({ documentId, versionId }: { documentId: string; versionId: string }): Promise<{ version: DocumentVersionWithDocument }> {
+        this.logger.debug('getDocumentForVersion', { documentId, versionId });
+
+        const draftDocumentId = getDraftObjectId(documentId);
+        const [version, document] = await Promise.all([
+            fetchDocumentRevision({ documentId, draftDocumentId, versionId, dataset: this.dataset, client: this.client }),
+            fetchDocumentForRevision({ documentId, draftDocumentId, versionId, dataset: this.dataset, client: this.client })
+        ]);
+        const [contextualDocument] = await this.convertDocuments({
+            documents: [document],
+            getModelByName: this.cache.getModelByName,
+            studioUrl: this.studioUrl
+        });
+
+        if (!contextualDocument) {
+            throw new Error(`Could not get document ${documentId} for revision ${versionId}`);
+        }
+
+        return { version: this.convertVersionForDocument(version, contextualDocument) };
+    }
 }
 
 function mapUpdateOperationFieldToSanityValue(

package/src/sanity-schema-converter.ts

@@ -5,7 +5,8 @@ import { deepMap, omitByNil } from '@stackbit/utils';
 import { resolveLabelFieldForModel } from './utils';
 
 // sanity cloudinary plugin adds these models, we are replacing them to our internal image model, so we removing them from schema response
-const skipModels = ['cloudinary.asset', 'cloudinary.assetDerived', 'bynder.asset', 'aprimo.asset', 'aprimo.cdnasset', 'media.tag'];
+const thirdPartyImageModels = ['cloudinary.asset', 'cloudinary.assetDerived', 'bynder.asset', 'aprimo.asset', 'aprimo.cdnasset'];
+const skipModels = [...thirdPartyImageModels, 'media.tag'];
 
 export function convertSchema(schema: any): { models: Model[] } {
     // sanity schema allow arrays to be at the root level, we don't.
@@ -238,6 +239,10 @@ const fieldConverterMap = {
         if (_.has(arrayModelsByName, type)) {
             return fieldConverterMap.array(arrayModelsByName[type], arrayModelsByName);
         }
+        if (thirdPartyImageModels.includes(type)) {
+            const fn = (fieldConverterMap[type as keyof typeof fieldConverterMap] as any) ?? fieldConverterMap.image;
+            return fn();
+        }
         return {
             type: 'model',
             models: [type]