@stackbit/cms-core 0.1.16 → 0.1.17-alpha.1

package/src/utils/create-update-csi-docs.ts

@@ -1,9 +1,9 @@
 import _ from 'lodash';
 import slugify from 'slugify';
 
-import { Model } from '@stackbit/sdk';
-import { Model as CSIModel, Field, FieldObjectProps, FieldSpecificProps, UpdateOperationListFieldItem } from '@stackbit/types';
-import { mapPromise } from '@stackbit/utils';
+import { Model as SDKModel } from '@stackbit/sdk';
+import { Model as CSIModel, Field, FieldSpecificProps, UpdateOperationListFieldItem } from '@stackbit/types';
+import { fieldPathToString, mapPromise } from '@stackbit/utils';
 import * as CSITypes from '@stackbit/types';
 
 import * as ContentStoreTypes from '../content-store-types';
@@ -19,11 +19,13 @@ export type CreateDocumentCallback = ({
 export function getCreateDocumentThunk({
     csiModelMap,
     locale,
+    defaultLocaleDocumentId,
     userContext,
     contentSourceInstance
 }: {
     csiModelMap: Record<string, CSIModel>;
     locale?: string;
+    defaultLocaleDocumentId?: string;
     userContext: unknown;
     contentSourceInstance: CSITypes.ContentSourceInterface;
 }): CreateDocumentCallback {
@@ -41,6 +43,7 @@ export function getCreateDocumentThunk({
             model: csiModel,
             modelMap: csiModelMap,
             locale,
+            defaultLocaleDocumentId,
             userContext
         });
     };
@@ -88,15 +91,18 @@ export async function createDocumentRecursively({
     object,
     modelName,
     modelMap,
+    csiModelMap,
     createDocument
 }: {
     object?: Record<string, any>;
     modelName: string;
-    modelMap: Record<string, Model>;
+    modelMap: Record<string, SDKModel>;
+    csiModelMap: Record<string, CSIModel>;
     createDocument: CreateDocumentCallback;
 }): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
     const model = modelMap[modelName];
-    if (!model) {
+    const csiModel = csiModelMap[modelName];
+    if (!model || !csiModel) {
         throw new Error(`no model with name '${modelName}' was found`);
     }
     if (model.type === 'page') {
@@ -108,11 +114,13 @@ export async function createDocumentRecursively({
         }
     }
 
-    const nestedResult = await createNestedObjectRecursively({
+    const nestedResult = await createObjectRecursively({
         object,
         modelFields: model.fields ?? [],
-        fieldPath: [],
+        csiModelFields: csiModel.fields ?? [],
+        fieldPath: [modelName],
         modelMap,
+        csiModelMap,
         createDocument
     });
 
@@ -137,17 +145,21 @@ function sanitizeSlug(slug: string) {
         .join('/');
 }
 
-async function createNestedObjectRecursively({
+async function createObjectRecursively({
     object,
     modelFields,
+    csiModelFields,
     fieldPath,
     modelMap,
+    csiModelMap,
     createDocument
 }: {
     object?: Record<string, any>;
     modelFields: Field[];
+    csiModelFields: Field[];
     fieldPath: (string | number)[];
-    modelMap: Record<string, Model>;
+    modelMap: Record<string, SDKModel>;
+    csiModelMap: Record<string, CSIModel>;
     createDocument: CreateDocumentCallback;
 }): Promise<{
     fields: Record<string, CSITypes.UpdateOperationField>;
@@ -170,6 +182,10 @@ async function createNestedObjectRecursively({
     const objectFieldNames = Object.keys(object);
     for (const modelField of modelFields) {
         const fieldName = modelField.name;
+        const csiModelField = csiModelFields.find((field) => field.name === fieldName);
+        if (!csiModelField) {
+            throw new Error(`no model field found for field at path ${fieldPathToString(fieldPath.concat(fieldName))}`);
+        }
         let value;
         if (fieldName in object) {
             // if the object has a field name matching a model field, use it
@@ -183,11 +199,13 @@ async function createNestedObjectRecursively({
             value = modelField.default;
         }
         if (!_.isNil(value)) {
-            const fieldResult = await createNestedField({
+            const fieldResult = await createUpdateOperationFieldRecursively({
                 value,
                 modelField,
+                csiModelField,
                 fieldPath: fieldPath.concat(fieldName),
                 modelMap,
+                csiModelMap,
                 createDocument
             });
             result.fields[fieldName] = fieldResult.field;
@@ -201,25 +219,34 @@ async function createNestedObjectRecursively({
     return result;
 }
 
-async function createNestedField({
+async function createUpdateOperationFieldRecursively({
     value,
     modelField,
+    csiModelField,
     fieldPath,
     modelMap,
+    csiModelMap,
     createDocument
 }: {
     value: any;
     modelField: FieldSpecificProps;
+    csiModelField: FieldSpecificProps;
     fieldPath: (string | number)[];
-    modelMap: Record<string, Model>;
+    modelMap: Record<string, SDKModel>;
+    csiModelMap: Record<string, CSIModel>;
     createDocument: CreateDocumentCallback;
 }): Promise<{ field: CSITypes.UpdateOperationField; newRefDocuments: CSITypes.Document[] }> {
-    if (modelField.type === 'object') {
-        const result = await createNestedObjectRecursively({
+    if (csiModelField.type === 'object') {
+        if (modelField.type !== 'object') {
+            throw new Error(`field type mismatch between content-source and mapped models at field path ${fieldPathToString(fieldPath)}`);
+        }
+        const result = await createObjectRecursively({
             object: value,
             modelFields: modelField.fields,
+            csiModelFields: csiModelField.fields,
             fieldPath,
             modelMap,
+            csiModelMap,
             createDocument
         });
         return {
@@ -229,7 +256,10 @@ async function createNestedField({
             },
             newRefDocuments: result.newRefDocuments
         };
-    } else if (modelField.type === 'model') {
+    } else if (csiModelField.type === 'model') {
+        if (modelField.type !== 'model') {
+            throw new Error(`field type mismatch between content-source and mapped models at field path ${fieldPathToString(fieldPath)}`);
+        }
         let { $$type, ...rest } = value;
         const modelNames = modelField.models;
         // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
@@ -243,14 +273,17 @@ async function createNestedField({
             throw new Error(`no $$type was specified for nested model`);
         }
         const model = modelMap[modelName];
-        if (!model) {
+        const csiModel = csiModelMap[modelName];
+        if (!model || !csiModel) {
             throw new Error(`no model with name '${modelName}' was found`);
         }
-        const result = await createNestedObjectRecursively({
+        const result = await createObjectRecursively({
             object: rest,
             modelFields: model.fields ?? [],
+            csiModelFields: csiModel.fields ?? [],
             fieldPath,
             modelMap,
+            csiModelMap,
             createDocument
         });
         return {
@@ -261,7 +294,7 @@ async function createNestedField({
             },
             newRefDocuments: result.newRefDocuments
         };
-    } else if (modelField.type === 'image') {
+    } else if (csiModelField.type === 'image') {
         let refId: string | undefined;
         // TODO: if modelField.source is cloudinary, the new document field
         //  should be of the 'image' type with 'title' and 'url' properties
@@ -281,7 +314,10 @@ async function createNestedField({
             },
             newRefDocuments: []
         };
-    } else if (modelField.type === 'reference') {
+    } else if (csiModelField.type === 'reference') {
+        if (modelField.type !== 'reference') {
+            throw new Error(`field type mismatch between content-source and mapped models at field path ${fieldPathToString(fieldPath)}`);
+        }
         let { $$ref: refId = null, $$type: modelName = null, ...rest } = _.isPlainObject(value) ? value : { $$ref: value };
         if (refId) {
             return {
@@ -308,6 +344,7 @@ async function createNestedField({
                 object: rest,
                 modelName,
                 modelMap,
+                csiModelMap,
                 createDocument
             });
             return {
@@ -319,22 +356,28 @@ async function createNestedField({
                 newRefDocuments: [document, ...newRefDocuments]
             };
         }
-    } else if (modelField.type === 'list') {
+    } else if (csiModelField.type === 'list') {
+        if (modelField.type !== 'list') {
+            throw new Error(`field type mismatch between external and internal models at field path ${fieldPathToString(fieldPath)}`);
+        }
         if (!Array.isArray(value)) {
             throw new Error(`value for list field must be array`);
         }
         const itemsField = modelField.items;
-        if (!itemsField) {
+        const csiItemsField = csiModelField.items;
+        if (!itemsField || !csiItemsField) {
             throw new Error(`list field does not define items`);
         }
         const arrayResult = await mapPromise(
             value,
             async (item, index): Promise<{ field: UpdateOperationListFieldItem; newRefDocuments: CSITypes.Document[] }> => {
-                const result = await createNestedField({
+                const result = await createUpdateOperationFieldRecursively({
                     value: item,
                     modelField: itemsField,
+                    csiModelField: csiItemsField,
                     fieldPath: fieldPath.concat(index),
                     modelMap,
+                    csiModelMap,
                     createDocument
                 });
                 if (result.field.type === 'list') {
@@ -353,10 +396,22 @@ async function createNestedField({
             },
             newRefDocuments: arrayResult.reduce((result: CSITypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
         };
+    } else if (
+        (csiModelField.type === 'string' || csiModelField.type === 'text') &&
+        (modelField.type === 'json' || modelField.type === 'style') &&
+        _.isPlainObject(value)
+    ) {
+        return {
+            field: {
+                type: csiModelField.type,
+                value: JSON.stringify(value)
+            },
+            newRefDocuments: []
+        };
     }
     return {
         field: {
-            type: modelField.type,
+            type: csiModelField.type,
             value: value
         },
         newRefDocuments: []
@@ -367,24 +422,31 @@ export async function convertOperationField({
     operationField,
     fieldPath,
     modelField,
+    csiModelField,
     modelMap,
+    csiModelMap,
     createDocument
 }: {
     operationField: ContentStoreTypes.UpdateOperationField;
     fieldPath: (string | number)[];
-    modelField: Field;
-    modelMap: Record<string, Model>;
+    modelField: FieldSpecificProps;
+    csiModelField: FieldSpecificProps;
+    modelMap: Record<string, SDKModel>;
+    csiModelMap: Record<string, SDKModel>;
     createDocument: CreateDocumentCallback;
 }): Promise<CSITypes.UpdateOperationField> {
-    // for insert operations, the modelField will be of the list, so get the modelField of the list items
-    const modelFieldOrListItems: FieldSpecificProps = modelField.type === 'list' ? modelField.items! : modelField;
     switch (operationField.type) {
         case 'object': {
-            const result = await createNestedObjectRecursively({
+            if (modelField.type !== 'object' || csiModelField.type !== 'object') {
+                throw new Error(`the operation field type 'object' does not match the model field type '${modelField.type}'`);
+            }
+            const result = await createObjectRecursively({
                 object: operationField.object,
-                modelFields: (modelFieldOrListItems as FieldObjectProps).fields,
-                fieldPath: fieldPath,
+                modelFields: modelField.fields,
+                csiModelFields: csiModelField.fields,
+                fieldPath,
                 modelMap,
+                csiModelMap,
                 createDocument
             });
             return {
@@ -394,14 +456,17 @@ export async function convertOperationField({
         }
         case 'model': {
             const model = modelMap[operationField.modelName];
-            if (!model) {
+            const csiModel = csiModelMap[operationField.modelName];
+            if (!model || !csiModel) {
                 throw new Error(`error updating document, could not find document model: '${operationField.modelName}'`);
             }
-            const result = await createNestedObjectRecursively({
+            const result = await createObjectRecursively({
                 object: operationField.object,
-                modelFields: model.fields!,
+                modelFields: model.fields ?? [],
+                csiModelFields: csiModel.fields ?? [],
                 fieldPath,
                 modelMap,
+                csiModelMap,
                 createDocument
             });
             return {
@@ -410,18 +475,22 @@ export async function convertOperationField({
                 fields: result.fields
             };
         }
+        case 'reference':
+            return operationField;
         case 'list': {
-            if (modelField.type !== 'list') {
-                throw new Error(`'the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
+            if (modelField.type !== 'list' || csiModelField.type !== 'list') {
+                throw new Error(`the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
             }
             const result: UpdateOperationListFieldItem[] = await mapPromise(
                 operationField.items,
-                async (item): Promise<UpdateOperationListFieldItem> => {
-                    const result = await createNestedField({
+                async (item, index): Promise<UpdateOperationListFieldItem> => {
+                    const result = await createUpdateOperationFieldRecursively({
                         value: item,
-                        modelField: modelField.items!,
-                        fieldPath,
+                        modelField: modelField.items,
+                        csiModelField: csiModelField.items,
+                        fieldPath: fieldPath.concat(index),
                         modelMap,
+                        csiModelMap,
                         createDocument
                     });
                     if (result.field.type === 'list') {
@@ -435,34 +504,48 @@ export async function convertOperationField({
                 items: result
             };
         }
-        case 'string':
-            // When inserting new string value into a list, the client does not
-            // send value. Set an empty string value.
-            if (typeof operationField.value !== 'string') {
-                return {
-                    type: operationField.type,
-                    value: ''
-                };
-            }
-            return operationField as CSITypes.UpdateOperationField;
         case 'enum':
+            if (csiModelField.type !== 'enum' && csiModelField.type !== 'string') {
+                throw new Error(`the operation field type 'enum' can be performed on 'string' and 'enum' content-source field types '${csiModelField.type}'`);
+            }
             // When inserting new enum value into a list, the client does not
             // send value. Set first option as the value.
             if (typeof operationField.value !== 'string') {
-                if (modelFieldOrListItems.type !== 'enum') {
-                    throw new Error(`'the operation field type 'enum' does not match the model field type '${modelFieldOrListItems.type}'`);
+                if (modelField.type !== 'enum') {
+                    throw new Error(`the operation field type 'enum' does not match the model field type '${modelField.type}'`);
                 }
-                const option = modelFieldOrListItems.options[0]!;
+                const option = modelField.options[0]!;
                 const optionValue = typeof option === 'object' ? option.value : option;
                 return {
-                    type: operationField.type,
+                    type: csiModelField.type,
                     value: optionValue
                 };
             }
-            return operationField as CSITypes.UpdateOperationField;
-        case 'image':
-            return operationField as CSITypes.UpdateOperationField;
-        default:
-            return operationField as CSITypes.UpdateOperationField;
+            return {
+                type: csiModelField.type,
+                value: operationField.value
+            };
+        case 'string':
+            // When inserting new string value into a list, the client does not
+            // send value. Set an empty string value.
+            if (typeof operationField.value !== 'string') {
+                return {
+                    type: operationField.type,
+                    value: ''
+                };
+            }
+            return operationField;
+        default: {
+            const result = await createUpdateOperationFieldRecursively({
+                value: operationField.value,
+                modelField,
+                csiModelField,
+                fieldPath,
+                modelMap,
+                csiModelMap,
+                createDocument
+            });
+            return result.field;
+        }
     }
 }

package/src/utils/csi-to-store-docs-converter.ts

@@ -166,12 +166,6 @@ function mapCSIFieldsToStoreFields({
             localized: modelField.localized,
             context
         });
-        // Override document field types with specific model field types.
-        // For example when developer re-mapped content-source model "string"
-        // field to stackbit "color" field.
-        if (modelField.type === 'color' || modelField.type === 'style') {
-            docField.type = modelField.type;
-        }
         docField.label = modelField.label;
         result[modelField.name] = docField;
         return result;
@@ -201,8 +195,34 @@ function mapCSIFieldToStoreField({
                   })
         } as ContentStoreTypes.DocumentField;
     }
-    // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
     switch (modelField.type) {
+        case 'string':
+        case 'text':
+        case 'html':
+        case 'url':
+        case 'boolean':
+        case 'number':
+        case 'date':
+        case 'datetime':
+        case 'enum':
+        case 'json':
+        case 'style':
+        case 'color':
+        case 'slug':
+            // Override document field types with model field types.
+            // Developer can remap content-source model fields to different field using stackbit config.
+            // For example, a 'string' field in a content-source can be mapped to 'color' field in stackbit config.
+            return {
+                ...csiDocumentField,
+                type: modelField.type
+            } as ContentStoreTypes.DocumentField;
+        // Don't override types of the following document fields.
+        // An 'image' model field can be a 'reference' document field in CMSes like Sanity and Contentful.
+        // Rest of the fields must have the same type across document and model fields.
+        case 'image':
+        case 'file':
+        case 'reference':
+            return csiDocumentField as ContentStoreTypes.DocumentField;
         case 'object':
             return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
         case 'model':
@@ -214,8 +234,10 @@ function mapCSIFieldToStoreField({
             return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
         case 'markdown':
             return mapMarkdownField(csiDocumentField as CSITypes.DocumentValueField);
-        default:
-            return csiDocumentField as ContentStoreTypes.DocumentField;
+        default: {
+            const _exhaustiveCheck: never = modelField;
+            return _exhaustiveCheck;
+        }
     }
 }
 

package/src/utils/model-utils.ts

@@ -60,8 +60,8 @@ export function validateModels<T extends Model>({ models, logger }: { models: T[
     const { config, errors } = validateConfig({
         stackbitVersion: '0.5.0',
         models: models,
-        dirPath: '',
-        filePath: ''
+        dirPath: '.',
+        filePath: 'stackbit.config.js'
     });
 
     for (const error of errors) {

package/src/utils/site-map.ts

@@ -184,10 +184,18 @@ function sanitizeAndGroupSiteMapEntries(siteMapEntries: SiteMapEntry[]): SiteMap
     }, {});
 }
 
-function getSiteMapGroupKey(siteMapEntry: SiteMapEntry) {
+function getSiteMapGroupKey(siteMapEntry: SiteMapEntry): string {
     return 'document' in siteMapEntry
-        ? `${siteMapEntry.document.srcType}:${siteMapEntry.document.srcProjectId}:${siteMapEntry.document.id}`
-        : SiteMapStaticEntriesKey;
+        ? getSiteMapGroupKeyForDocument({
+            srcType: siteMapEntry.document.srcType,
+            srcProjectId: siteMapEntry.document.srcProjectId,
+            srcDocumentId: siteMapEntry.document.id
+        })
+        : SiteMapStaticEntriesKey.toString();
+}
+
+export function getSiteMapGroupKeyForDocument({ srcType, srcProjectId, srcDocumentId }: { srcType: string; srcProjectId: string; srcDocumentId: string }): string {
+    return `${srcType}:${srcProjectId}:${srcDocumentId}`;
 }
 
 export function getDocumentFieldLabelValueForSiteMapEntry({