@stackbit/sdk 0.3.5 → 0.3.6

package/src/config/config-schema.ts

@@ -2,7 +2,6 @@ import Joi from 'joi';
 import _ from 'lodash';
 import { append } from '@stackbit/utils';
 import {
-    StackbitConfig,
     ContentfulImport,
     SanityImport,
     Assets,
@@ -16,20 +15,21 @@ import {
     ModelsSourceSanity,
     Field,
     FieldObjectProps,
-    FieldGroupItem
+    FieldGroupItem,
+    FieldSpecificProps
 } from '@stackbit/types';
 
 import { CMS_NAMES, FIELD_TYPES, SSG_NAMES } from './config-consts';
 import { styleFieldPartialSchema } from './config-schema/style-field-schema';
-import { YamlBaseModel, YamlConfigModel, YamlDataModel, YamlModel, YamlModelMap, YamlPageModel, YamlObjectModel } from './config-types';
+import { Config, Model, PageModel, ObjectModel, DataModel, ConfigModel } from './config-types';
 
-function getConfigFromValidationState(state: Joi.State): StackbitConfig {
+function getConfigFromValidationState(state: Joi.State): Config {
     return _.last(state.ancestors)!;
 }
 
-function getModelsFromValidationState(state: Joi.State): YamlModelMap {
+function getModelsFromValidationState(state: Joi.State): Model[] {
     const config = getConfigFromValidationState(state);
-    return config.models ?? {};
+    return config.models ?? [];
 }
 
 const fieldNamePattern = /^[a-zA-Z0-9]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
@@ -47,8 +47,7 @@ const fieldNameSchema = Joi.string()
 const objectModelNameErrorCode = 'model.not.object.model';
 const validObjectModelNames = Joi.custom((value, { error, state }) => {
     const models = getModelsFromValidationState(state);
-    const modelNames = Object.keys(models);
-    const objectModelNames = modelNames.filter((modelName) => models[modelName]!.type === 'object');
+    const objectModelNames = models.filter((model) => model.type === 'object').map((model) => model.name);
     if (!objectModelNames.includes(value)) {
         return error(objectModelNameErrorCode);
     }
@@ -63,9 +62,8 @@ const validObjectModelNames = Joi.custom((value, { error, state }) => {
 const documentModelNameErrorCode = 'model.not.document.model';
 const validReferenceModelNames = Joi.custom((value, { error, state }) => {
     const models = getModelsFromValidationState(state);
-    const modelNames = Object.keys(models);
-    const documentModels = modelNames.filter((modelName) => ['page', 'data'].includes(models[modelName]!.type));
-    if (!documentModels.includes(value)) {
+    const documentModelNames = models.filter((model) => ['page', 'data'].includes(model.type)).map((model) => model.name);
+    if (!documentModelNames.includes(value)) {
         return error(documentModelNameErrorCode);
     }
     return value;
@@ -123,16 +121,16 @@ const validReferenceFieldGroups = Joi.string()
         errors: { wrap: { label: false } }
     });
 
-function getModelNamesForGroup(group: string, config: StackbitConfig) {
-    const models = config.models ?? {};
+function getModelNamesForGroup(group: string, config: Config) {
+    const models = config.models ?? [];
     return _.reduce(
         models,
-        (result: { objectModels: string[]; documentModels: string[] }, model, modelName) => {
+        (result: { objectModels: string[]; documentModels: string[] }, model) => {
             if (model?.groups && _.includes(model.groups, group)) {
                 if (model?.type === 'object') {
-                    result.objectModels.push(modelName);
+                    result.objectModels.push(model.name);
                 } else {
-                    result.documentModels.push(modelName);
+                    result.documentModels.push(model.name);
                 }
             }
             return result;
@@ -150,7 +148,7 @@ const logicField = Joi.string();
 const labelFieldNotFoundError = 'labelField.not.found';
 const labelFieldNotSimple = 'labelField.not.simple';
 const labelFieldSchema = Joi.custom((value, { error, state }) => {
-    const modelOrObjectField: YamlBaseModel | FieldObjectProps = _.head(state.ancestors)!;
+    const modelOrObjectField: Model | FieldObjectProps = _.head(state.ancestors)!;
     const fields = modelOrObjectField?.fields ?? [];
     if (!_.isArray(fields)) {
         return error(labelFieldNotFoundError);
@@ -174,7 +172,7 @@ const labelFieldSchema = Joi.custom((value, { error, state }) => {
 const variantFieldNotFoundError = 'variantField.not.found';
 const variantFieldNotEnum = 'variantField.not.enum';
 const variantFieldSchema = Joi.custom((value, { error, state }) => {
-    const modelOrObjectField: YamlBaseModel | FieldObjectProps = _.head(state.ancestors)!;
+    const modelOrObjectField: Model | FieldObjectProps = _.head(state.ancestors)!;
     const fields = modelOrObjectField?.fields ?? [];
     if (!_.isArray(fields)) {
         return error(variantFieldNotFoundError);
@@ -206,11 +204,11 @@ const styleObjectModelNameSchema = Joi.string()
             return value;
         }
         const models = getModelsFromValidationState(state);
-        const modelNames = Object.keys(models);
-        if (!modelNames.includes(value)) {
+        const styleObjectModel = models.find((model) => model.name === value);
+        if (!styleObjectModel) {
             return error(styleObjectModelReferenceError);
         }
-        if (models[value]!.type !== 'data') {
+        if (styleObjectModel.type !== 'data') {
             return error(styleObjectModelNotObject);
         }
         return value;
@@ -484,6 +482,7 @@ const fieldsSchema = Joi.array().items(fieldSchema).unique('name').id('fieldsSch
 const contentModelKeyNotFound = 'contentModel.model.not.found';
 const contentModelTypeNotPage = 'contentModel.type.not.page';
 const contentModelTypeNotData = 'contentModel.type.not.data';
+
 const contentModelSchema = Joi.object<ContentModel>({
     isPage: Joi.boolean(),
     newFilePath: Joi.string(),
@@ -502,12 +501,12 @@ const contentModelSchema = Joi.object<ContentModel>({
         })
     })
     .custom((contentModel, { error, state, prefs }) => {
-        const models = _.get(prefs, 'context.models');
-        if (!models) {
+        const modelMap = _.get(prefs, 'context.modelMap');
+        if (!modelMap) {
             return contentModel;
         }
         const modelName = _.last(state.path)!;
-        const model = models[modelName];
+        const model = modelMap[modelName];
         if (!model) {
             return error(contentModelKeyNotFound, { modelName });
         } else if (contentModel.isPage && model.type && !['page', 'object'].includes(model.type)) {
@@ -536,10 +535,25 @@ export const contentModelsSchema = Joi.object({
     contentModels: Joi.object<ContentModelMap>().pattern(Joi.string(), contentModelSchema)
 });
 
-const baseModelSchema = Joi.object<YamlBaseModel>({
+const modelNamePattern = /^[a-zA-Z]([a-zA-Z0-9_]*[a-zA-Z0-9])?$/;
+const modelNameError =
+    'Invalid model name "{{#value}}" at "{{#label}}". A model name must contain only alphanumeric characters ' +
+    'and underscores, must start with a letter, and end with alphanumeric character.';
+const modelNameSchema = Joi.string()
+    .required()
+    .pattern(modelNamePattern)
+    .prefs({
+        messages: { 'string.pattern.base': modelNameError },
+        errors: { wrap: { label: false } }
+    });
+
+const baseModelSchema = Joi.object<Model & { srcType: string; srcProjectId: string }>({
     __metadata: Joi.object({
         filePath: Joi.string()
     }),
+    name: modelNameSchema,
+    srcType: Joi.string(),
+    srcProjectId: Joi.string(),
     type: Joi.string().valid('page', 'data', 'config', 'object').required(),
     label: Joi.string(),
     description: Joi.string(),
@@ -553,13 +567,13 @@ const baseModelSchema = Joi.object<YamlBaseModel>({
     fields: Joi.link('#fieldsSchema')
 });
 
-const objectModelSchema: Joi.ObjectSchema<YamlObjectModel> = baseModelSchema.concat(
+const objectModelSchema: Joi.ObjectSchema<ObjectModel> = baseModelSchema.concat(
     Joi.object({
         type: Joi.string().valid('object').required()
     })
 );
 
-const dataModelSchema: Joi.ObjectSchema<YamlDataModel> = baseModelSchema
+const dataModelSchema: Joi.ObjectSchema<DataModel> = baseModelSchema
     .concat(
         Joi.object({
             type: Joi.string().valid('data').required(),
@@ -588,14 +602,14 @@ const dataModelSchema: Joi.ObjectSchema<YamlDataModel> = baseModelSchema
         })
     });
 
-const configModelSchema: Joi.ObjectSchema<YamlConfigModel> = baseModelSchema.concat(
+const configModelSchema: Joi.ObjectSchema<ConfigModel> = baseModelSchema.concat(
     Joi.object({
         type: Joi.string().valid('config').required(),
         file: Joi.string()
     })
 );
 
-const pageModelSchema: Joi.ObjectSchema<YamlPageModel> = baseModelSchema
+const pageModelSchema: Joi.ObjectSchema<PageModel> = baseModelSchema
     .concat(
         Joi.object({
             type: Joi.string().valid('page').required(),
@@ -621,35 +635,122 @@ const pageModelSchema: Joi.ObjectSchema<YamlPageModel> = baseModelSchema
     })
     .when('.singleInstance', { is: true, then: { file: Joi.required() } });
 
-const modelSchema = Joi.object<YamlModel>({
-    type: Joi.string().valid('page', 'data', 'config', 'object').required()
-}).when('.type', {
-    switch: [
-        { is: 'object', then: objectModelSchema },
-        { is: 'data', then: dataModelSchema },
-        { is: 'config', then: configModelSchema },
-        { is: 'page', then: pageModelSchema }
-    ]
-});
-
-const modelNamePattern = /^[a-zA-Z]([a-zA-Z0-9_]*[a-zA-Z0-9])?$/;
-const modelNamePatternMatchErrorCode = 'model.name.pattern.match';
 const modelFileExclusiveErrorCode = 'model.file.only';
 const modelIsListItemsRequiredErrorCode = 'model.isList.items.required';
 const modelIsListFieldsForbiddenErrorCode = 'model.isList.fields.forbidden';
 const modelListForbiddenErrorCode = 'model.items.forbidden';
 const fieldNameUnique = 'field.name.unique';
+
+function errorLabelFromModelAndFieldPath(model: Model, modelIndex: number, fieldPath: (string | number | object)[]): string {
+    let fieldSpecificProps: Model | FieldSpecificProps | undefined = model;
+    let fields: Field[] | undefined;
+    let label = `models[${ model.name ? `name='${model.name}'` : modelIndex }]`;
+
+    for (const pathPart of fieldPath) {
+        if (typeof pathPart === 'string') {
+            if (pathPart === 'fields' && fieldSpecificProps && 'fields' in fieldSpecificProps) {
+                fields = fieldSpecificProps.fields;
+                fieldSpecificProps = undefined;
+                label += '.fields';
+            } else if (pathPart === 'items' && fieldSpecificProps && 'items' in fieldSpecificProps) {
+                fieldSpecificProps = fieldSpecificProps.items;
+                label += '.items';
+            } else {
+                fieldSpecificProps = undefined;
+                label += `.${pathPart}`;
+            }
+        } else if (fields && typeof pathPart === 'number') {
+            const field = fields[pathPart];
+            label += '[' + (field?.name ? `name='${field.name}'` : pathPart) + ']';
+            fieldSpecificProps = field;
+            fields = undefined;
+        } else {
+            // when the schema is marked as Joi.array().items(...).single()
+            // and the validated value is not an array, Joi injects (new Number(0))
+            // which is an object. Don't use it to generate path
+            if (typeof pathPart === 'object') {
+                continue;
+            }
+            label += `[${pathPart}]`;
+        }
+    }
+    return label;
+}
+
+const modelSchema = Joi.object<Model>({
+    type: Joi.string().valid('page', 'data', 'config', 'object').required(),
+    name: Joi.string()
+})
+    .when('.type', {
+        switch: [
+            { is: 'object', then: objectModelSchema },
+            { is: 'data', then: dataModelSchema },
+            { is: 'config', then: configModelSchema },
+            { is: 'page', then: pageModelSchema }
+        ]
+    })
+    .error(((errors: Joi.ErrorReport[]): Joi.ErrorReport[] => {
+        return _.map(errors, (error) => {
+            if (error.path[0] === 'models' && typeof error.path[1] === 'number') {
+                const modelIndex = error.path[1];
+                const config = error.prefs.context?.config as Config;
+                if (config && config.models[modelIndex]) {
+                    const model = config.models[modelIndex]!;
+                    error.path = error.path.slice();
+                    error.path.splice(1, 1, model.name);
+                    const label = errorLabelFromModelAndFieldPath(model, modelIndex, error.path.slice(2));
+                    _.set(error, 'local.label', label);
+                    // const label = _.get(error, 'local.label', '') as string;
+                    // _.set(error, 'local.label', label.replace(/models\[(\d+)]/, (match, indexMatch) => {
+                    //     if (Number(indexMatch) !== modelIndex) {
+                    //         return match;
+                    //     }
+                    //     return `models[name='${model.name}']`;
+                    // }));
+                }
+            }
+            if (
+                error.code === 'any.unknown' &&
+                error.path.length === 3 &&
+                error.path[0] === 'models' &&
+                error.path[2] &&
+                ['folder', 'match', 'exclude'].includes(error.path[2])
+            ) {
+                error.code = modelFileExclusiveErrorCode;
+            } else if (error.code === 'any.required' && error.path.length === 3 && error.path[0] === 'models' && error.path[2] === 'items') {
+                error.code = modelIsListItemsRequiredErrorCode;
+            } else if (error.code === 'any.unknown' && error.path.length === 3 && error.path[0] === 'models' && error.path[2] === 'fields') {
+                error.code = modelIsListFieldsForbiddenErrorCode;
+            } else if (error.code === 'object.unknown' && error.path.length === 3 && error.path[0] === 'models' && error.path[2] === 'items') {
+                error.code = modelListForbiddenErrorCode;
+            } else if (error.code === 'array.unique' && error.path.length > 3 && error.path[0] === 'models' && _.nth(error.path, -2) === 'fields') {
+                error.code = fieldNameUnique;
+            }
+            return error;
+        });
+    }) as any) // the type definition of Joi.ValidationErrorFunction is wrong, so we override
+    .prefs({
+        messages: {
+            [modelFileExclusiveErrorCode]: '{{#label}} cannot be used with "file"',
+            [modelIsListItemsRequiredErrorCode]: '{{#label}} is required when "isList" is true',
+            [modelIsListFieldsForbiddenErrorCode]: '{{#label}} is not allowed when "isList" is true',
+            [modelListForbiddenErrorCode]: '{{#label}} is not allowed when "isList" is not true',
+            [fieldNameUnique]: '{{#label}} contains a duplicate field name "{{#value.name}}"'
+        },
+        errors: { wrap: { label: false } }
+    });
+
 const groupModelsIncompatibleError = 'group.models.incompatible';
 
-const modelsSchema = Joi.object<YamlModelMap>()
-    .pattern(modelNamePattern, modelSchema)
-    .custom((models: YamlModelMap, { error }) => {
+const modelsSchema = Joi.array()
+    .items(modelSchema)
+    .custom((models: Model[], { error }) => {
         const groupMap: Record<string, Record<'objectModels' | 'documentModels', string[]>> = {};
 
-        _.forEach(models, (model, modelName) => {
+        _.forEach(models, (model) => {
             const key = model?.type === 'object' ? 'objectModels' : 'documentModels';
             _.forEach(model.groups, (groupName) => {
-                append(groupMap, [groupName, key], modelName);
+                append(groupMap, [groupName, key], model.name);
             });
         });
 
@@ -674,42 +775,10 @@ const modelsSchema = Joi.object<YamlModelMap>()
 
         return models;
     })
-    .error(((errors: Joi.ErrorReport[]): Joi.ErrorReport[] => {
-        return _.map(errors, (error) => {
-            if (error.code === 'object.unknown' && error.path.length === 2 && error.path[0] === 'models') {
-                error.code = modelNamePatternMatchErrorCode;
-            } else if (
-                error.code === 'any.unknown' &&
-                error.path.length === 3 &&
-                error.path[0] === 'models' &&
-                error.path[2] &&
-                ['folder', 'match', 'exclude'].includes(error.path[2])
-            ) {
-                error.code = modelFileExclusiveErrorCode;
-            } else if (error.code === 'any.required' && error.path.length === 3 && error.path[0] === 'models' && error.path[2] === 'items') {
-                error.code = modelIsListItemsRequiredErrorCode;
-            } else if (error.code === 'any.unknown' && error.path.length === 3 && error.path[0] === 'models' && error.path[2] === 'fields') {
-                error.code = modelIsListFieldsForbiddenErrorCode;
-            } else if (error.code === 'object.unknown' && error.path.length === 3 && error.path[0] === 'models' && error.path[2] === 'items') {
-                error.code = modelListForbiddenErrorCode;
-            } else if (error.code === 'array.unique' && error.path.length > 3 && error.path[0] === 'models' && _.nth(error.path, -2) === 'fields') {
-                error.code = fieldNameUnique;
-            }
-            return error;
-        });
-    }) as any) // the type definition of Joi.ValidationErrorFunction is wrong, so we override
     .prefs({
         messages: {
             [groupModelsIncompatibleError]:
-                'Model groups must include models of the same type. The following groups have incompatible models: {{#incompatibleGroups}}',
-            [modelNamePatternMatchErrorCode]:
-                'Invalid model name "{{#key}}" at "{{#label}}". A model name must contain only alphanumeric characters ' +
-                'and underscores, must start with a letter, and end with alphanumeric character.',
-            [modelFileExclusiveErrorCode]: '{{#label}} cannot be used with "file"',
-            [modelIsListItemsRequiredErrorCode]: '{{#label}} is required when "isList" is true',
-            [modelIsListFieldsForbiddenErrorCode]: '{{#label}} is not allowed when "isList" is true',
-            [modelListForbiddenErrorCode]: '{{#label}} is not allowed when "isList" is not true',
-            [fieldNameUnique]: '{{#label}} contains a duplicate field name "{{#value.name}}"'
+                'Model groups must include models of the same type. The following groups have incompatible models: {{#incompatibleGroups}}'
         },
         errors: { wrap: { label: false } }
     });
@@ -745,7 +814,7 @@ const sidebarButtonSchema = Joi.object({
     ]
 });
 
-export const stackbitConfigSchema = Joi.object<StackbitConfig>({
+export const stackbitConfigSchema = Joi.object<Config>({
     stackbitVersion: Joi.string().required(),
     ssgName: Joi.string().valid(...SSG_NAMES),
     ssgVersion: Joi.string(),

package/src/config/config-types.ts

@@ -64,11 +64,13 @@ export interface Config extends Omit<StackbitConfig, 'models' | 'customContentRe
     dirPath: string;
     filePath: string;
     models: Model[];
-    presets?: Record<string, Preset>;
+    presets?: PresetMap;
     internalStackbitRunnerOptions?: SSGRunOptions;
     hcrHandled?: boolean;
 }
 
+export type PresetMap = Record<string, Preset>;
+
 export interface Preset {
     label: string;
     modelName: string;
@@ -91,12 +93,13 @@ export interface SSGRunOptions {
  *** Normalized Model Types ***
  ******************************/
 
-export type Model = ObjectModel | DataModel | PageModel | ConfigModel | ImageModel;
+export type Model = ObjectModel | DataModel | PageModel | ConfigModel;
 
 export type ObjectModel = StackbitConfigObjectModel & BaseModel;
 export type DataModel = DataModelSingle | DataModelList;
 export type PageModel = StackbitConfigPageModel & BaseModel;
 export type ConfigModel = StackbitConfigConfigModel & BaseModel;
+
 export type ImageModel = {
     type: 'image';
     name: '__image_model';
@@ -115,7 +118,7 @@ export interface DataModelList extends StackbitConfigDataModel, BaseModel {
     items: FieldListItems;
 }
 
-type BaseModel = ModelMetadata & { presets?: string[] };
+export type BaseModel = ModelMetadata & { presets?: string[] };
 
 interface ModelMetadata {
     __metadata?: {

package/src/config/config-validator.ts

@@ -2,47 +2,67 @@ import _ from 'lodash';
 import Joi from 'joi';
 import { ContentModelMap } from '@stackbit/types';
 
-import { stackbitConfigSchema, contentModelsSchema } from './config-schema';
+import { contentModelsSchema, stackbitConfigSchema } from './config-schema';
 import { ConfigValidationError } from './config-errors';
-import { RawConfigWithPaths } from './config-loader-utils';
-import { YamlModelMap } from './config-types';
+import { Config, Model } from './config-types';
 
 export interface ConfigValidationResult {
-    value: RawConfigWithPaths;
+    config: Config;
     valid: boolean;
     errors: ConfigValidationError[];
 }
 
-export function validateConfig(config: RawConfigWithPaths): ConfigValidationResult {
-    const validationOptions = { abortEarly: false };
+export function validateConfig(config: Config): ConfigValidationResult {
+    const validationOptions = { abortEarly: false, context: { config: config } };
     const validationResult = stackbitConfigSchema.validate(config, validationOptions);
-    const value = validationResult.value;
+    const validatedConfig: Config = validationResult.value;
     const errors = mapJoiErrorsToConfigValidationErrors(validationResult);
     const valid = _.isEmpty(errors);
-    markInvalidModels(value, errors, 'models');
+    const invalidModelNames = getInvalidModelNames(errors, 'models', config);
+    const validatedModels = validatedConfig.models ?? [];
+    _.forEach(validatedModels, (model): any => {
+        if (invalidModelNames.includes(model.name)) {
+            _.set(model, '__metadata.invalid', true);
+        }
+    });
     return {
-        value,
+        config: validatedConfig,
         valid,
         errors
     };
 }
 
-export function validateContentModels(contentModels: ContentModelMap, models: YamlModelMap): ConfigValidationResult {
+export interface ContentModelsValidationResult {
+    contentModels: ContentModelMap;
+    valid: boolean;
+    errors: ConfigValidationError[];
+}
+
+export function validateContentModels(contentModels: ContentModelMap, models: Model[]): ContentModelsValidationResult {
+    const modelMap: Record<string, Model> = _.keyBy(models, 'name');
+    const config = { contentModels: contentModels };
     const validationResult = contentModelsSchema.validate(
-        { contentModels: contentModels },
+        config,
         {
             abortEarly: false,
             context: {
-                models: models
+                modelMap: modelMap
             }
         }
     );
-    const value = validationResult.value;
+    const validatedConfig: Config = validationResult.value;
     const errors = mapJoiErrorsToConfigValidationErrors(validationResult);
     const valid = _.isEmpty(errors);
-    markInvalidModels(value, errors, 'contentModels');
+    const invalidModelNames = getInvalidModelNames(errors, 'contentModels', config);
+    const validatedContentModels = validatedConfig.contentModels ?? {};
+    _.forEach(validatedContentModels, (contentModel, modelName) => {
+        if (invalidModelNames.includes(modelName)) {
+            _.set(contentModel, '__metadata.invalid', true);
+        }
+    });
+
     return {
-        value,
+        contentModels: validatedContentModels,
         valid,
         errors
     };
@@ -52,35 +72,37 @@ function mapJoiErrorsToConfigValidationErrors(validationResult: Joi.ValidationRe
     const joiErrors = validationResult.error?.details || [];
     return joiErrors.map(
         (validationError): ConfigValidationError => {
+            const normFieldPath = validationError.path.slice();
+            if (validationError.path[0] === 'models' && typeof validationError.path[1] == 'string') {
+                const modelName = validationError.path[1];
+                normFieldPath[1] = _.findIndex(validationResult.value.models, { name: modelName });
+            }
             return new ConfigValidationError({
                 type: validationError.type,
                 message: validationError.message,
                 fieldPath: validationError.path,
+                normFieldPath: normFieldPath,
                 value: validationError.context?.value
             });
         }
     );
 }
 
-function markInvalidModels(config: any, errors: ConfigValidationError[], configKey: string) {
-    const invalidModelNames = getInvalidModelNames(errors, configKey);
-    const models = config[configKey] ?? {};
-    _.forEach(models, (model: any, modelName: string): any => {
-        if (invalidModelNames.includes(modelName)) {
-            _.set(model, '__metadata.invalid', true);
-        }
-    });
-}
-
-function getInvalidModelNames(errors: ConfigValidationError[], configKey: string) {
+function getInvalidModelNames(errors: ConfigValidationError[], configKey: string, value: any) {
     // get array of invalid model names by iterating errors and filtering these
     // having fieldPath starting with ['models', modelName]
     return _.reduce(
         errors,
         (modelNames: string[], error: ConfigValidationError) => {
-            if (error.fieldPath[0] === configKey && typeof error.fieldPath[1] == 'string') {
-                const modelName = error.fieldPath[1];
-                modelNames.push(modelName);
+            if (error.fieldPath[0] === configKey) {
+                if (typeof error.fieldPath[1] == 'string') {
+                    modelNames.push(error.fieldPath[1]);
+                } else if (typeof error.fieldPath[1] == 'number') {
+                    const model = value[configKey][error.fieldPath[1]];
+                    if (model?.name) {
+                        modelNames.push(model?.name);
+                    }
+                }
             }
             return modelNames;
         },