@stackbit/cms-sanity 0.2.45-develop.1 → 0.2.45-staging.1

package/src/sanity-content-source.ts

@@ -1,56 +1,46 @@
 import _ from 'lodash';
-import { v4 as uuid } from 'uuid';
-import tinycolor from 'tinycolor2';
 import https from 'https';
 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 {
-    DocumentVersion,
-    DocumentVersionWithDocument,
-    Field,
-    FieldList,
-    FieldListItems,
-    FieldObjectProps,
-    FieldSpecificProps,
-    Model,
-    Schema,
-    UserCommandSpawner
-} from '@stackbit/types';
+import { MutationEvent, SanityAssetDocument, SanityClient as SanityClientType, SanityDocument, SanityDocumentStub } from '@sanity/client';
 import type * as ContentSourceTypes from '@stackbit/types';
+import type { DocumentVersion, DocumentVersionWithDocument, Field, Model, Schema, UserCommandSpawner } from '@stackbit/types';
 import { getVersion as stackbitUtilsGetVersion } from '@stackbit/types';
+import type * as SanityTypes from '@sanity/types';
+import { deferWhileRunning, getPackageManager, omitByNil } from '@stackbit/utils';
 
 import * as fetcher from './sanity-schema-fetcher';
 import {
-    SanityClient,
-    testToken,
     DocumentHistory,
     DocumentHistoryMap,
+    fetchDocumentForRevision,
+    fetchDocumentRevision,
+    fetchDocumentsHistory,
+    fetchScheduledActions,
     fetchUsers,
+    SanityClient,
     SanityUser,
-    fetchScheduledActions,
-    fetchDocumentsHistory,
-    fetchDocumentForRevision,
-    fetchDocumentRevision
+    testToken
 } from './sanity-api-client';
-import { convertSchema } from './sanity-schema-converter';
+import { convertSchema, ModelContext, SchemaContext } from './sanity-schema-converter';
 import {
-    convertDocuments,
-    convertAssets,
-    DocumentContext,
     AssetContext,
-    ContextualDocument,
     ContextualAsset,
-    getDraftObjectId,
-    getPureObjectId,
-    isDraftId,
-    DRAFT_ID_PREFIX,
+    ContextualDocument,
+    convertAndFilterScheduledActions,
+    convertAssets,
+    convertDocuments,
     ConvertDocumentsOptions,
     convertScheduledAction,
-    convertAndFilterScheduledActions
+    DocumentContext,
+    DRAFT_ID_PREFIX,
+    getDraftObjectId,
+    getPureObjectId,
+    isDraftId
 } from './sanity-document-converter';
-import { deferWhileRunning, getPackageManager, omitByNil } from '@stackbit/utils';
+import { isLocalizedModelField } from './utils';
+import { convertUpdateOperation, localizedValue, mapUpdateOperationFieldToSanityValue } from './sanity-operation-converter';
 
 export interface ContentSourceOptions {
     /**
@@ -107,22 +97,29 @@ export interface ContentSourceOptions {
      * 'query' - the listener will be notified of changes when they are available for querying.
      */
     listenerVisibility?: 'transaction' | 'query';
+
+    /**
+     * When using Sanity Internationalized-Array plugin, specify the default language
+     * that will be used by the Visual Editor. If not specified, the first language
+     * in the `languages` will be selected.
+     *
+     * https://www.sanity.io/plugins/internationalized-array
+     */
+    defaultLocale?: string;
 }
 
 export type UserContext = {
     accessToken: string;
 };
 
-export type SchemaContext = unknown;
-
-export type ContextualInitOptions = ContentSourceTypes.InitOptions<SchemaContext, DocumentContext, AssetContext>;
-type Cache = ContentSourceTypes.Cache<SchemaContext, DocumentContext, AssetContext>;
+export type ContextualInitOptions = ContentSourceTypes.InitOptions<SchemaContext, DocumentContext, AssetContext, ModelContext>;
+type Cache = ContentSourceTypes.Cache<SchemaContext, DocumentContext, AssetContext, ModelContext>;
 type ContentChanges = Required<ContentSourceTypes.ContentChanges<DocumentContext, AssetContext>>;
 
 const ASSET_TYPES = ['sanity.imageAsset', 'cloudinary.asset', 'bynder.asset', 'aprimo.cdnasset'];
 const SANITY_API_VERSION = '1';
 
-export class SanityContentSource implements ContentSourceTypes.ContentSourceInterface<UserContext, SchemaContext, DocumentContext, AssetContext> {
+export class SanityContentSource implements ContentSourceTypes.ContentSourceInterface<UserContext, SchemaContext, DocumentContext, AssetContext, ModelContext> {
     private readonly projectId: string;
     private readonly dataset: string;
     private readonly token: string;
@@ -144,6 +141,7 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
     private contentChangeSubscriptionInterval: any;
     private userMap: Record<string, SanityUser> = {};
     private cache!: Cache;
+    private defaultLocale?: string;
 
     constructor(options: ContentSourceOptions) {
         this.projectId = options.projectId;
@@ -156,6 +154,7 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         this.studioInstallCommand = options.studioInstallCommand;
         this.schemaGlob = options.schemaGlob;
         this.listenerVisibility = options.listenerVisibility;
+        this.defaultLocale = options.defaultLocale;
 
         if (!this.rootPath) {
             throw new Error(`Required parameter 'rootPath' is missing.`);
@@ -479,7 +478,7 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         };
     }
 
-    async getSanitySchema(): Promise<any> {
+    async getSanitySchema(): Promise<{ models: SanityTypes.SchemaTypeDefinition[] }> {
         let sanitySchema;
         try {
             sanitySchema = await fetcher.spawnFetchSchema({
@@ -498,11 +497,19 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         return sanitySchema;
     }
 
-    async getSchema(): Promise<Schema<SchemaContext>> {
+    async getSchema(): Promise<Schema<SchemaContext, ModelContext>> {
         this.logger.debug('getSchema');
         const sanitySchema = await this.getSanitySchema();
-        const { models } = convertSchema(sanitySchema);
-        return { models, context: {} };
+        const { models, locales } = convertSchema({
+            schema: sanitySchema,
+            logger: this.logger,
+            defaultLocale: this.defaultLocale
+        });
+        return {
+            models,
+            locales,
+            context: null
+        };
     }
 
     async getDocumentsHistory(documentIds: string[]): Promise<DocumentHistoryMap> {
@@ -663,7 +670,7 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         userContext
     }: {
         updateOperationFields: Record<string, ContentSourceTypes.UpdateOperationField>;
-        model: Model;
+        model: Model<ModelContext>;
         locale?: string;
         userContext?: UserContext;
     }): Promise<{ documentId: string }> {
@@ -672,18 +679,41 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
             _type: model.name
         };
 
-        _.forEach(updateOperationFields, (updateOperationField, fieldName) => {
-            const childModelField = _.find(model.fields, (field: Field) => field.name === fieldName);
-            const value = mapUpdateOperationFieldToSanityValue(updateOperationField, this.cache.getModelByName, childModelField);
-            _.set(sanityDocument, fieldName, value);
-        });
-        const userClient = this.getApiClientForUser({ userContext });
-        const result = await userClient.create(sanityDocument).catch((err) => {
-            this.logger.error('Error creating document', err);
-            throw err;
-        });
-        const pureObjectId = getPureObjectId(result._id);
-        return { documentId: pureObjectId };
+        try {
+            _.forEach(updateOperationFields, (updateOperationField, fieldName) => {
+                const childModelField = _.find(model.fields, (field: Field) => field.name === fieldName);
+                if (!childModelField) {
+                    throw new Error(`No model field found for field: ${fieldName}`);
+                }
+                const value = mapUpdateOperationFieldToSanityValue({
+                    updateOperationField,
+                    getModelByName: this.cache.getModelByName,
+                    modelField: childModelField,
+                    rootModel: model,
+                    modelFieldPath: [fieldName],
+                    locale
+                });
+                if (isLocalizedModelField(childModelField)) {
+                    _.set(sanityDocument, fieldName, [
+                        localizedValue({
+                            value,
+                            model,
+                            modelFieldPath: [fieldName],
+                            locale
+                        })
+                    ]);
+                } else {
+                    _.set(sanityDocument, fieldName, value);
+                }
+            });
+            const userClient = this.getApiClientForUser({ userContext });
+            const result = await userClient.create(sanityDocument);
+            const pureObjectId = getPureObjectId(result._id);
+            return { documentId: pureObjectId };
+        } catch (error: any) {
+            this.logger.error('Error creating document', error);
+            throw new Error(`Error creating document. ${error.message}`);
+        }
     }
 
     async updateDocument({
@@ -704,26 +734,31 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         const sanityDocument = (document.context.draftDocument || document.context.publishedDocument)!;
         const modelName = document.modelName;
         const model = this.cache.getModelByName(modelName);
-        if (!model) {
-            throw new Error(`Error updating document: could not find document model '${modelName}'.`);
+        try {
+            if (!model) {
+                throw new Error(`Could not find document model '${modelName}'.`);
+            }
+            const transaction = _.reduce(
+                operations,
+                (transaction, operation) => {
+                    const patchObject = convertUpdateOperation({
+                        operation,
+                        sanityDocument,
+                        getModelByName: this.cache.getModelByName,
+                        model
+                    });
+                    return transaction.patch(draftObjectId, patchObject);
+                },
+                userClient.transaction().createIfNotExists({
+                    ...sanityDocument,
+                    _id: draftObjectId
+                })
+            );
+            await transaction.commit({ visibility: this.listenerVisibility === 'query' ? 'sync' : 'async', returnDocuments: true });
+        } catch (error: any) {
+            this.logger.error(`Error updating document ${document.id}`, error);
+            throw new Error(`Error updating document ${document.id}. ${error.message}`);
         }
-        const transaction = _.reduce(
-            operations,
-            (transaction, operation) => {
-                const opFunc = Operations[operation.opType] as OperationFunction<typeof operation.opType>;
-                const patchObject = opFunc?.({ sanityDocument, operation, getModelByName: this.cache.getModelByName });
-                return transaction.patch(draftObjectId, patchObject);
-            },
-            userClient.transaction().createIfNotExists({
-                ...sanityDocument,
-                _id: draftObjectId
-            })
-        );
-
-        await transaction.commit({ visibility: this.listenerVisibility === 'query' ? 'sync' : 'async', returnDocuments: true }).catch((err) => {
-            this.logger.error('Error updating document', err);
-            throw err;
-        });
     }
 
     async deleteDocument({ document, userContext }: { document: ContextualDocument; userContext?: UserContext }): Promise<void> {
@@ -973,7 +1008,7 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
             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({
+        const [contextualDocument] = this.convertDocuments({
             documents: [document],
             getModelByName: this.cache.getModelByName,
             studioUrl: this.studioUrl
@@ -986,246 +1021,3 @@ export class SanityContentSource implements ContentSourceTypes.ContentSourceInte
         return { version: this.convertVersionForDocument(version, contextualDocument) };
     }
 }
-
-function mapUpdateOperationFieldToSanityValue(
-    updateOperationField: ContentSourceTypes.UpdateOperationField,
-    getModelByName: ContentSourceTypes.Cache['getModelByName'],
-    modelField?: FieldSpecificProps,
-    isInList?: boolean
-): any {
-    if (updateOperationField.type === 'object') {
-        const result = {};
-        _.forEach(updateOperationField.fields, (updateOperationField, fieldName) => {
-            const childModelField = _.find((modelField as FieldObjectProps).fields, (field) => field.name === fieldName);
-            const value = mapUpdateOperationFieldToSanityValue(updateOperationField, getModelByName, childModelField);
-            _.set(result, fieldName, value);
-        });
-        return listItem(result, isInList);
-    } else if (updateOperationField.type === 'model') {
-        const modelName = updateOperationField.modelName;
-        const childModel = getModelByName(modelName);
-        const result = listItem(
-            {
-                _type: modelName
-            },
-            isInList
-        );
-        _.forEach(updateOperationField.fields, (updateOperationField, fieldName) => {
-            const childModelField = _.find(childModel?.fields, (field) => field.name === fieldName);
-            const value = mapUpdateOperationFieldToSanityValue(updateOperationField, getModelByName, childModelField);
-            _.set(result, fieldName, value);
-        });
-        return result;
-    } else if (updateOperationField.type === 'image') {
-        const value = updateOperationField?.value;
-        if (modelField?.type === 'image') {
-            if (modelField?.source === 'cloudinary' || modelField?.source === 'aprimo') {
-                const type = modelField?.source === 'cloudinary' ? 'cloudinary.asset' : 'aprimo.cdnasset';
-                return listItem(
-                    {
-                        _type: type,
-                        ...value
-                    },
-                    isInList
-                );
-            } else if (modelField?.source === 'bynder') {
-                let imageValue = value;
-                if (imageValue?.__typename) {
-                    imageValue = _.omitBy(
-                        {
-                            id: value.id,
-                            name: value.name,
-                            databaseId: value.databaseId,
-                            type: value.type,
-                            previewUrl: value.type === 'VIDEO' ? value.previewUrls[0] : value.files.webImage.url,
-                            previewImg: value.files.webImage.url,
-                            datUrl: value.files.transformBaseUrl?.url,
-                            videoUrl: value.type === 'VIDEO' ? value.files.original?.url : null,
-                            description: value.description,
-                            aspectRatio: value.height / value.width
-                        },
-                        _.isUndefined
-                    );
-                }
-                return listItem(
-                    {
-                        _type: 'bynder.asset',
-                        ...imageValue
-                    },
-                    isInList
-                );
-            }
-        }
-        // TODO: there is a bug right now because documentField is inferred from the model which is an "image", not reference
-        return listItem(linkForAssetId(value), isInList);
-    } else if (updateOperationField.type === 'reference') {
-        return listItem(
-            updateOperationField.refType === 'document'
-                ? {
-                      _ref: updateOperationField.refId,
-                      _type: 'reference',
-                      //TODO lookup document and decide if reference needs to be weak and what is its type
-                      _weak: true,
-                      _strengthenOnPublish: {
-                          //   type: <type for referenced item>,
-                          //   template: {
-                          //       id: <type for referenced item>,
-                          //   }
-                      }
-                  }
-                : linkForAssetId(updateOperationField.refId),
-            isInList
-        );
-    } else if (updateOperationField.type === 'list') {
-        const listItemsModel = modelField?.type === 'list' && modelField.items;
-        return updateOperationField.items.map((item) => {
-            let listItemModelField: FieldListItems | undefined;
-            if (_.isArray(listItemsModel)) {
-                listItemModelField = (listItemsModel as FieldListItems[]).find((listItemsModel) => listItemsModel.type === item.type);
-            } else if (listItemsModel) {
-                listItemModelField = listItemsModel;
-            }
-            return mapUpdateOperationFieldToSanityValue(item, getModelByName, listItemModelField, true);
-        });
-    } else if (updateOperationField.type === 'number') {
-        return Number(updateOperationField.value);
-    } else if (updateOperationField.type === 'slug') {
-        return {
-            _type: 'slug',
-            current: updateOperationField.value
-        };
-    } else if (updateOperationField.type === 'color') {
-        const color = tinycolor(updateOperationField.value);
-        return {
-            _type: 'color',
-            hex: color.toHexString(),
-            alpha: color.getAlpha(),
-            hsl: {
-                _type: 'hslaColor',
-                ...color.toHsl()
-            },
-            hsv: {
-                _type: 'hsvaColor',
-                ...color.toHsv()
-            },
-            rgb: {
-                _type: 'rgbaColor',
-                ...color.toRgb()
-            }
-        };
-    }
-    return updateOperationField.value;
-}
-
-function listItem(field: any, isInList?: boolean) {
-    if (isInList) {
-        _.set(field, '_key', uuid());
-    }
-    return field;
-}
-
-function linkForAssetId(assetId?: string): any {
-    return {
-        _type: 'image',
-        asset: {
-            _ref: assetId,
-            _type: 'reference'
-        }
-    };
-}
-
-type FindByOpType<Union, Type> = Union extends { opType: Type } ? Union : never;
-type OperationForType<Type> = FindByOpType<ContentSourceTypes.UpdateOperation, Type>;
-type OperationFunction<Type> = ({
-    sanityDocument,
-    operation,
-    getModelByName
-}: {
-    sanityDocument: SanityDocument;
-    operation: OperationForType<Type>;
-    getModelByName: ContentSourceTypes.Cache['getModelByName'];
-}) => PatchOperations;
-
-type OperationMap = {
-    [Type in ContentSourceTypes.UpdateOperation['opType']]: OperationFunction<Type>;
-};
-
-const Operations: OperationMap = {
-    set: ({ operation, sanityDocument, getModelByName }) => {
-        const { field, fieldPath, modelField } = operation;
-        const value = mapUpdateOperationFieldToSanityValue(field, getModelByName, modelField);
-        const patch = {};
-        _.set(patch, ['set', keyedFieldPathToString(sanityDocument, fieldPath)], value);
-        return patch;
-    },
-    unset: ({ operation, sanityDocument }) => {
-        const { fieldPath } = operation;
-        return {
-            unset: [keyedFieldPathToString(sanityDocument, fieldPath)]
-        };
-    },
-    insert: ({ operation, sanityDocument, getModelByName }) => {
-        const { item, fieldPath, modelField, index } = operation;
-        const listItemModelField = (modelField as FieldList).items ?? { type: 'string' };
-        const value = mapUpdateOperationFieldToSanityValue(item, getModelByName, listItemModelField, true);
-        const array = _.get(sanityDocument, fieldPath);
-        if (!array?.length) {
-            return {
-                set: {
-                    [keyedFieldPathToString(sanityDocument, fieldPath)]: [value]
-                }
-            };
-        }
-        if (_.isNil(index) || index >= array.length) {
-            return {
-                insert: {
-                    after: `${keyedFieldPathToString(sanityDocument, fieldPath)}[-1]`,
-                    items: [value]
-                }
-            };
-        }
-        return {
-            insert: {
-                before: `${keyedFieldPathToString(sanityDocument, fieldPath)}[${index}]`,
-                items: [value]
-            }
-        };
-    },
-    remove: ({ sanityDocument, operation }) => {
-        const { fieldPath, index } = operation;
-        return {
-            unset: [keyedFieldPathToString(sanityDocument, [...fieldPath, index])]
-        };
-    },
-    reorder: ({ sanityDocument, operation }) => {
-        const { fieldPath, order } = operation;
-        const array = _.get(sanityDocument, fieldPath);
-        const newEntryArr = order.map((newIndex) => array[newIndex]);
-        const patch = {};
-        _.set(patch, ['set', keyedFieldPathToString(sanityDocument, fieldPath)], newEntryArr);
-        return patch;
-    }
-};
-
-export const keyedFieldPathToString = (document: SanityDocument, fieldPath: (string | number)[]) =>
-    _.reduce(
-        fieldPath,
-        (accumulator, fieldName, index) => {
-            if (_.isString(fieldName) && /\W/.test(fieldName)) {
-                // field name is a string with non alphanumeric character
-                accumulator += `['${fieldName}']`;
-            } else if (_.isNumber(fieldName)) {
-                // try to use Sanity _key as explicit accessor
-                const val = _.get(document, [...fieldPath.slice(0, index), Number(fieldName)]);
-                const key = val?._key;
-                accumulator += key ? `[_key=="${key}"]` : `[${Number(fieldName)}]`;
-            } else {
-                if (index > 0) {
-                    accumulator += '.';
-                }
-                accumulator += fieldName;
-            }
-            return accumulator;
-        },
-        ''
-    );