@stackbit/cms-core 0.1.5 → 0.1.7

package/src/stackbit/index.ts

@@ -1,8 +1,8 @@
 import _ from 'lodash';
-import { loadConfig, isListDataModel, Config } from '@stackbit/sdk';
+import { Config, isListDataModel, loadConfigWithModelsPresetsAndValidate } from '@stackbit/sdk';
 
 export function fetchAndConvertSchema(options: { dirPath: string }): Promise<{ schema: Config; errors: Error[] }> {
-    return loadConfig({ dirPath: options.dirPath }).then(({ config, errors }) => {
+    return loadConfigWithModelsPresetsAndValidate({ dirPath: options.dirPath }).then(({ config, errors }) => {
         if (!config) {
             return { schema: {} as Config, errors };
         }

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

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import { Field, FieldListProps, FieldModelProps, FieldObjectProps, FieldSpecificProps, Model } from '@stackbit/sdk';
+import { Field, FieldListProps, FieldModelProps, FieldObjectProps, FieldSpecificProps, Model, ImageModel } from '@stackbit/sdk';
 import { isLocalizedField } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
 
@@ -341,7 +341,7 @@ function getMetadataFromContentStore({
 
 function getObjectLabel(
     documentFields: Record<string, CSITypes.DocumentField | CSITypes.AssetFileField>,
-    modelOrObjectField: Model | FieldObjectProps,
+    modelOrObjectField: Model | FieldObjectProps | ImageModel,
     locale?: string
 ): string {
     const labelField = modelOrObjectField.labelField;

package/src/utils/model-utils.ts

@@ -0,0 +1,72 @@
+import _ from 'lodash';
+
+import { Logger } from '@stackbit/types';
+import { Model, assignLabelFieldIfNeeded, isObjectField, isPageModel, mapModelFieldsRecursively, mapListItemsPropsOrSelfSpecificProps } from '@stackbit/sdk';
+import { validateConfig } from '@stackbit/sdk';
+
+export function normalizeModels<T extends Model>({ models, logger }: { models: T[]; logger: Logger }): T[] {
+    return models.map((model) => {
+        model = { ...model };
+
+        if (!('name' in model)) {
+            logger.warn('model does not have a name');
+        }
+
+        if (!('type' in model)) {
+            logger.warn(`model '${model['name']}' does not have a type, using 'object'`);
+            _.set(model, 'type', 'object');
+        }
+
+        // add model label if not set
+        if (!('label' in model)) {
+            model.label = _.startCase(model.name);
+        }
+
+        if (!('fields' in model) || !Array.isArray(model.fields)) {
+            model.fields = [];
+        }
+
+        if (isPageModel(model)) {
+            // set default urlPath if not set
+            if (!model.urlPath) {
+                model.urlPath = '/{slug}';
+            }
+        }
+
+        assignLabelFieldIfNeeded(model);
+
+        model = mapModelFieldsRecursively(model, (field) => {
+            field = { ...field };
+
+            if (!('label' in field)) {
+                field.label = _.startCase(field.name);
+            }
+
+            mapListItemsPropsOrSelfSpecificProps(field, (listItemsPropsOrField) => {
+                if (isObjectField(listItemsPropsOrField)) {
+                    assignLabelFieldIfNeeded(listItemsPropsOrField);
+                }
+                return listItemsPropsOrField;
+            });
+
+            return field;
+        }) as T;
+
+        return model;
+    });
+}
+
+export function validateModels<T extends Model>({ models, logger }: { models: T[], logger: Logger }): T[] {
+    const { config, errors } = validateConfig({
+        stackbitVersion: '0.5.0',
+        models: models,
+        dirPath: '',
+        filePath: ''
+    });
+
+    for (const error of errors) {
+        logger.warn(error.message);
+    }
+
+    return config.models as T[];
+}

package/src/utils/search-utils.ts

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import { Model } from '@stackbit/sdk';
+import { ImageModel, Model } from '@stackbit/sdk';
 import * as ContentSourceInterface from '@stackbit/types';
 import { getLocalizedFieldForLocale } from '@stackbit/types';
 
@@ -15,7 +15,7 @@ const META_FIELD = {
     }
 } as const;
 
-type Schema = Record<string, Record<string, Record<string, Model>>>;
+type Schema = Record<string, Record<string, Record<string, Model | ImageModel>>>;
 
 export const searchDocuments = (data: {
     query?: string;
@@ -156,7 +156,7 @@ const isFieldMatchesFilter = ({
 
         case 'list': {
             const model = schema?.[document.srcType]?.[document.srcProjectId]?.[document.srcModelName];
-            if (!model) {
+            if (!model || model.type === 'image') {
                 throw new Error(`Can't find model for the ${filter.field}`);
             }
             return isListFieldMatches({ field, filter, model, locale });