@stackbit/cms-core 0.0.19-alpha.1 → 0.0.19-alpha.4

package/src/content-store.ts

@@ -17,10 +17,11 @@ import {
 } from '@stackbit/sdk';
 import { mapPromise, omitByNil } from '@stackbit/utils';
 import * as CSITypes from './content-source-interface';
-import { isLocalizedField } from './content-source-interface';
+import { isLocalizedField, getLocalizedFieldForLocale } from './content-source-interface';
 import * as ContentStoreTypes from './content-store-types';
 import { IMAGE_MODEL } from './common/common-schema';
 import { Timer } from './utils/timer';
+import { UserCommandSpawner } from './common/common-types';
 
 export interface ContentSourceOptions {
     logger: ContentStoreTypes.Logger;
@@ -28,6 +29,7 @@ export interface ContentSourceOptions {
     localDev: boolean;
     stackbitYamlDir: string;
     contentSources: CSITypes.ContentSourceInterface[];
+    userCommandSpawner?: UserCommandSpawner;
     onSchemaChangeCallback: () => void;
     onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
     handleConfigAssets: (config: Config) => Promise<Config>;
@@ -38,17 +40,29 @@ interface ContentSourceData {
     instance: CSITypes.ContentSourceInterface;
     type: string;
     projectId: string;
-    models: Model[];
-    modelMap: Record<string, Model>;
     locales?: CSITypes.Locale[];
     defaultLocaleCode?: string;
+    /* Array of extended and validated Models */
+    models: Model[];
+    /* Map of extended and validated Models by model name */
+    modelMap: Record<string, Model>;
+    /* Map of original Models (as provided by content source) by model name */
+    csiModelMap: Record<string, Model>;
+    /* Array of original content source Documents */
     csiDocuments: CSITypes.Document[];
+    /* Map of original content source Documents by document ID */
     csiDocumentMap: Record<string, CSITypes.Document>;
+    /* Array of converted content-store Documents */
     documents: ContentStoreTypes.Document[];
+    /* Map of converted content-store Documents by document ID */
     documentMap: Record<string, ContentStoreTypes.Document>;
+    /* Array of original content source Assets */
     csiAssets: CSITypes.Asset[];
+    /* Map of original content source Assets by asset ID */
     csiAssetMap: Record<string, CSITypes.Asset>;
+    /* Array of converted content-store Assets */
     assets: ContentStoreTypes.Asset[];
+    /* Map of converted content-store Assets by asset ID */
     assetMap: Record<string, ContentStoreTypes.Asset>;
 }
 
@@ -56,6 +70,7 @@ export class ContentStore {
     private readonly contentSources: CSITypes.ContentSourceInterface[];
     private readonly logger: ContentStoreTypes.Logger;
     private readonly userLogger: ContentStoreTypes.Logger;
+    private readonly userCommandSpawner?: UserCommandSpawner;
     private readonly localDev: boolean;
     private readonly stackbitYamlDir: string; // TODO: remove stackbitYamlDir, ContentStore should not be aware of filesystem, instead pass autoreloading Config object
     private readonly onSchemaChangeCallback: () => void;
@@ -70,6 +85,7 @@ export class ContentStore {
         this.logger = options.logger.createLogger({ label: 'content-store' });
         this.userLogger = options.userLogger.createLogger({ label: 'content-store' });
         this.localDev = options.localDev;
+        this.userCommandSpawner = options.userCommandSpawner;
         this.stackbitYamlDir = options.stackbitYamlDir; // TODO: remove stackbitYamlDir, ContentStore should not be aware of filesystem, instead pass autoreloading Config object
         this.contentSources = options.contentSources;
         this.onSchemaChangeCallback = options.onSchemaChangeCallback;
@@ -223,6 +239,7 @@ export class ContentStore {
             await contentSourceInstance.init({
                 logger: this.logger,
                 userLogger: this.userLogger,
+                userCommandSpawner: this.userCommandSpawner,
                 localDev: this.localDev
             });
         } else {
@@ -230,9 +247,9 @@ export class ContentStore {
             await contentSourceInstance.reset();
         }
 
-        const csModels = await contentSourceInstance.getModels();
+        const csiModels = await contentSourceInstance.getModels();
         const locales = await contentSourceInstance?.getLocales();
-        const result = await extendConfig({ dirPath: this.stackbitYamlDir, config: this.rawStackbitConfig, externalModels: csModels });
+        const result = await extendConfig({ dirPath: this.stackbitYamlDir, config: this.rawStackbitConfig, externalModels: csiModels });
         const config = await this.handleConfigAssets(result.config);
         const models = config.models;
         const modelMap = _.keyBy(models, 'name');
@@ -283,6 +300,7 @@ export class ContentStore {
             defaultLocaleCode: defaultLocaleCode,
             models: models,
             modelMap: modelMap,
+            csiModelMap: _.keyBy(csiModels, 'name'),
             csiDocuments: csiDocuments,
             csiDocumentMap: csiDocumentMap,
             documents: contentStoreDocuments,
@@ -296,7 +314,7 @@ export class ContentStore {
         contentSourceInstance.startWatchingContentUpdates({
             getModelMap: () => {
                 const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-                return contentSourceData.modelMap;
+                return contentSourceData.csiModelMap;
             },
             getDocument({ documentId }: { documentId: string }) {
                 return csiDocumentMap[documentId];
@@ -677,15 +695,15 @@ export class ContentStore {
 
         // get the document model
         const documentModelName = document.srcModelName;
-        const modelMap = contentSourceData.modelMap;
-        const model = modelMap[documentModelName];
+        const csiModelMap = contentSourceData.csiModelMap;
+        const model = csiModelMap[documentModelName];
         if (!model) {
             throw new Error(`error updating document, could not find document model: '${documentModelName}'`);
         }
 
         // get the 'reference' model field in the updated document that will be used to link the new document
         locale = locale ?? contentSourceData.defaultLocaleCode;
-        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale);
+        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, csiModelMap, locale);
         if (!modelField) {
             throw Error(`the "fieldPath" points to non existing model field: ${fieldPath.join('.')}`);
         }
@@ -721,7 +739,7 @@ export class ContentStore {
         } as const;
         const updatedDocument = await contentSourceData.instance.updateDocument({
             document: csiDocument,
-            modelMap: modelMap,
+            modelMap: csiModelMap,
             userContext: userContext,
             operations: [
                 modelField.type === 'list'
@@ -777,15 +795,15 @@ export class ContentStore {
 
         // get the document model
         const documentModelName = document.srcModelName;
-        const modelMap = contentSourceData.modelMap;
-        const model = modelMap[documentModelName];
-        if (!model) {
+        const csiModelMap = contentSourceData.csiModelMap;
+        const csiModel = csiModelMap[documentModelName];
+        if (!csiModel) {
             throw new Error(`error updating document, could not find document model: '${documentModelName}'`);
         }
 
         // get the 'reference' model field in the updated document that will be used to link the new asset
         locale = locale ?? contentSourceData.defaultLocaleCode;
-        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale);
+        const modelField = getModelFieldForFieldAtPath(document, csiModel, fieldPath, csiModelMap, locale);
         if (!modelField) {
             throw Error(`the "fieldPath" points to non existing model field: ${fieldPath.join('.')}`);
         }
@@ -812,7 +830,7 @@ export class ContentStore {
         } as const;
         const updatedDocument = await contentSourceData.instance.updateDocument({
             document: csiDocument,
-            modelMap: modelMap,
+            modelMap: csiModelMap,
             userContext: userContext,
             operations: [
                 modelField.type === 'list'
@@ -907,6 +925,7 @@ export class ContentStore {
         }
 
         const modelMap = contentSourceData.modelMap;
+        const csiModelMap = contentSourceData.csiModelMap;
         const documentModelName = document.srcModelName;
         const model = modelMap[documentModelName];
         if (!model) {
@@ -961,7 +980,7 @@ export class ContentStore {
 
         const updatedDocumentResult = await contentSourceData.instance.updateDocument({
             document: csiDocument,
-            modelMap,
+            modelMap: csiModelMap,
             userContext,
             operations
         });
@@ -1005,7 +1024,7 @@ export class ContentStore {
         // TODO: handle duplicatable and non duplicatable models
         // TODO: handle fields from the provided object
         const documentResult = await contentSourceData.instance.createDocument({
-            documentFields: mapStoreFieldsToSourceFields({
+            updateOperationFields: mapStoreFieldsToOperationFields({
                 documentFields: document.fields,
                 modelFields: model.fields!,
                 modelMap: contentSourceData.modelMap
@@ -1113,8 +1132,10 @@ export class ContentStore {
             locale = locale ?? contentSourceData.defaultLocaleCode;
             const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
             const userContext = getUserContextForSrcType(contentSourceData.type, user);
+            const internalValidationErrors = internalValidateContent(documents, assets, contentSourceData);
             const validationResult = await contentSourceData.instance.validateDocuments({ documents, assets, locale, userContext });
             errors = errors.concat(
+                internalValidationErrors,
                 validationResult.errors.map((validationError) => ({
                     message: validationError.message,
                     srcType: contentSourceData.type,
@@ -1487,7 +1508,7 @@ function mapMarkdownField(csiDocumentField: CSITypes.DocumentValueField): Conten
     };
 }
 
-function mapStoreFieldsToSourceFields({
+function mapStoreFieldsToOperationFields({
     documentFields,
     modelFields,
     modelMap
@@ -1495,7 +1516,7 @@ function mapStoreFieldsToSourceFields({
     documentFields: Record<string, ContentStoreTypes.DocumentField>;
     modelFields: Field[];
     modelMap: Record<string, Model>;
-}): Record<string, CSITypes.DocumentField> {
+}): Record<string, CSITypes.UpdateOperationField> {
     // TODO: implement
     throw new Error(`duplicateDocument not implemented yet`);
 }
@@ -1585,6 +1606,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
     if (docFieldLocalized.type === 'object' || docFieldLocalized.type === 'model') {
         return {
             ...docFieldLocalized,
+            type: 'object',
             ...commonProps,
             ...(docFieldLocalized.isUnset
                 ? null
@@ -1725,8 +1747,10 @@ async function createDocumentRecursively({
         contentSourceInstance
     });
     const document = await contentSourceInstance.createDocument({
-        documentFields: nestedResult.fields,
+        updateOperationFields: nestedResult.fields,
+        // TODO: pass csiModel
         model,
+        // TODO: pass csiModelMap
         modelMap,
         locale,
         userContext
@@ -2172,9 +2196,6 @@ async function convertOperationField({
             }
             return operationField as CSITypes.UpdateOperationField;
         case 'image':
-            if (typeof operationField.value !== 'string') {
-                throw new Error('image value was not specified');
-            }
             return operationField as CSITypes.UpdateOperationField;
         default:
             return operationField as CSITypes.UpdateOperationField;
@@ -2231,3 +2252,61 @@ function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
         assets
     };
 }
+
+function internalValidateContent(
+    documents: CSITypes.Document[],
+    assets: CSITypes.Asset[],
+    contentSourceData: ContentSourceData
+): ContentStoreTypes.ValidationError[] {
+
+    const errors: ContentStoreTypes.ValidationError[] = [];
+    _.forEach(documents, (document) => {
+        _.forEach(document.fields, (documentField, fieldName) => {
+            const localizedField = getLocalizedFieldForLocale(documentField)!;
+            errors.push(...validateDocumentFields(document, localizedField, [fieldName], contentSourceData));
+        })
+    })
+    return errors;
+}
+
+function validateDocumentFields(
+    document: CSITypes.Document,
+    documentField: CSITypes.DocumentFieldNonLocalized,
+    fieldPath: (string | number)[],
+    contentSourceData: ContentSourceData
+): ContentStoreTypes.ValidationError[] {
+    const errors: ContentStoreTypes.ValidationError[] = [];
+    
+    if (documentField.type === 'object') {
+        _.forEach(documentField.fields, (documentField, fieldName) => {
+            const localizedField = getLocalizedFieldForLocale(documentField)!;
+            errors.push(...validateDocumentFields(document, localizedField, fieldPath.concat(fieldName), contentSourceData));
+        });
+    } else if (documentField.type === 'model') {
+        _.forEach(documentField.fields, (documentField, fieldName) => {
+            const localizedField = getLocalizedFieldForLocale(documentField)!;
+            errors.push(...validateDocumentFields(document, localizedField, fieldPath.concat(fieldName), contentSourceData));
+        });
+    } else if (documentField.type === 'reference') {
+        const objRef = documentField.refType === 'asset' 
+            ? contentSourceData.assetMap[documentField.refId] 
+            : contentSourceData.documentMap[documentField.refId];        
+        if (!objRef) {
+            errors.push({
+                fieldPath,
+                srcType: contentSourceData.type,
+                srcProjectId: contentSourceData.projectId,
+                srcObjectType: documentField.refType,
+                srcObjectId: document.id,
+                message: `Can't find referenced ${documentField.refType}: ${documentField.refId}`
+            });
+        }
+    } else if (documentField.type === 'list') {
+        _.forEach(documentField.items, (documentField, i) => {
+            const localizedField = getLocalizedFieldForLocale(documentField)!;
+            errors.push(...validateDocumentFields(document, documentField, fieldPath.concat(i), contentSourceData));
+        });
+    }
+
+    return errors;
+}

package/src/index.ts

@@ -3,8 +3,9 @@ export * as annotator from './annotator';
 export * as utils from './utils';
 export * as consts from './consts';
 export * from './common/common-schema';
+export * from './common/common-types';
 export * from './content-store';
 export * as ContentSourceTypes from './content-source-interface';
 export * as ContentStoreTypes from './content-store-types';
 export { default as encodeData } from './encoder';
-export * from './encoder';
+export * from './encoder';