@firecms/core 3.0.1 → 3.1.0-canary.1df3b2c

package/src/form/validation.ts

@@ -14,8 +14,8 @@ import { enumToObjectEntries, getValueInPath, hydrateRegExp, isPropertyBuilder }
 // Add custom unique function for array values
 declare module "yup" {
     // tslint:disable-next-line
-    interface ArraySchema<T> {
-        uniqueInArray(mapper: (a: T) => T, message: string): ArraySchema<T>;
+    interface ArraySchema<TIn extends any[] | null | undefined, TContext, TDefault = undefined, TFlags extends yup.Flags = ""> {
+        uniqueInArray(mapper: (a: any) => any, message: string): ArraySchema<TIn, TContext, TDefault, TFlags>;
     }
 }
 yup.addMethod(yup.array, "uniqueInArray", function (
@@ -50,12 +50,21 @@ export function getYupEntitySchema<M extends Record<string, any>>(
     const objectSchema: any = {};
     Object.entries(properties as Record<string, ResolvedProperty>)
         .forEach(([name, property]) => {
-            objectSchema[name] = mapPropertyToYup({
-                property: property as ResolvedProperty<any>,
-                customFieldValidator,
-                name,
-                entityId
-            });
+            try {
+                objectSchema[name] = mapPropertyToYup({
+                    property: property as ResolvedProperty<any>,
+                    customFieldValidator,
+                    name,
+                    entityId
+                });
+            } catch (e: any) {
+                console.error(`Error creating validation schema for property ${name}:`, e);
+                objectSchema[name] = yup.mixed().test(
+                    "validation-error",
+                    `Validation error: ${e?.message ?? "Unknown error"}`,
+                    () => false
+                );
+            }
         });
     return yup.object().shape(objectSchema);
 }
@@ -65,7 +74,12 @@ export function mapPropertyToYup<T extends CMSType>(propertyContext: PropertyCon
     const property = propertyContext.property;
     if (isPropertyBuilder(property)) {
         console.error("Error in property", propertyContext);
-        throw Error("Trying to create a yup mapping from a property builder. Please use resolved properties only");
+        // Return a permissive schema with an error message instead of crashing
+        return yup.mixed().test(
+            "property-builder-error",
+            "Invalid property configuration: property builder should be resolved",
+            () => false
+        );
     }
 
     if (property.dataType === "string") {
@@ -85,60 +99,93 @@ export function mapPropertyToYup<T extends CMSType>(propertyContext: PropertyCon
     } else if (property.dataType === "reference") {
         return getYupReferenceSchema(propertyContext as PropertyContext<EntityReference>);
     }
-    console.error("Unsupported data type in yup mapping", property)
-    throw Error("Unsupported data type in yup mapping");
+
+    // Log the error but don't crash the form - return a permissive schema with an error message
+    console.error("Unsupported data type in yup mapping", property);
+    const dataType = (property as any).dataType ?? "unknown";
+    return yup.mixed().test(
+        "unsupported-data-type",
+        `Unsupported data type: ${dataType}`,
+        () => false
+    );
 }
 
 export function getYupMapObjectSchema({
-                                          property,
-                                          entityId,
-                                          customFieldValidator,
-                                          name
-                                      }: PropertyContext<Record<string, any>>): ObjectSchema<any> {
+    property,
+    entityId,
+    customFieldValidator,
+    name
+}: PropertyContext<Record<string, any>>): ObjectSchema<any> {
     const objectSchema: any = {};
     const validation = property.validation;
     if (property.properties)
         Object.entries(property.properties).forEach(([childName, childProperty]: [string, ResolvedProperty]) => {
-            objectSchema[childName] = mapPropertyToYup<any>({
-                property: childProperty,
-                parentProperty: property as ResolvedMapProperty,
-                customFieldValidator,
-                name: `${name}[${childName}]`,
-                entityId
-            });
+            try {
+                objectSchema[childName] = mapPropertyToYup<any>({
+                    property: childProperty,
+                    parentProperty: property as ResolvedMapProperty,
+                    customFieldValidator,
+                    name: `${name}[${childName}]`,
+                    entityId
+                });
+            } catch (e: any) {
+                console.error(`Error creating validation schema for property ${childName}:`, e);
+                objectSchema[childName] = yup.mixed().test(
+                    "validation-error",
+                    `Validation error: ${e?.message ?? "Unknown error"}`,
+                    () => false
+                );
+            }
         });
 
     const shape = yup.object().shape(objectSchema);
     if (validation?.required) {
-        return shape.required(validation?.requiredMessage ? validation.requiredMessage : "Required").nullable(true);
+        // In yup v0.x, .required().nullable(true) allowed null values
+        // To match this behavior: reject undefined but allow null
+        return shape.nullable().test(
+            "required",
+            validation?.requiredMessage ? validation.requiredMessage : "Required",
+            (value) => value !== undefined
+        ) as any;
     }
-    return yup.object().shape(shape.fields).default(undefined).notRequired().nullable(true);
+    return yup.object().shape(shape.fields).default(undefined).nullable().optional() as any;
 }
 
 function getYupStringSchema({
-                                property,
-                                parentProperty,
-                                customFieldValidator,
-                                name,
-                                entityId
-                            }: PropertyContext<string>): StringSchema {
-    let collection: StringSchema<any> = yup.string();
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<string>): StringSchema {
+    let schema: StringSchema<any> = yup.string().nullable();
     const validation = property.validation;
+
     if (property.enumValues) {
-        if (validation?.required)
-            collection = collection.required(validation?.requiredMessage ? validation.requiredMessage : "Required");
+        if (validation?.required) {
+            schema = schema.test(
+                "required",
+                validation?.requiredMessage ? validation.requiredMessage : "Required",
+                (value) => value !== undefined && value !== null && value !== ""
+            );
+        }
         const entries = enumToObjectEntries(property.enumValues);
-        collection = collection.oneOf(
+        schema = schema.oneOf(
             (validation?.required ? entries : [...entries, null])
                 .map((enumValueConfig) => enumValueConfig?.id ?? null)
-        ).nullable(true);
+        );
     }
+
     if (validation) {
-        collection = validation.required
-            ? collection.required(validation?.requiredMessage ? validation.requiredMessage : "Required").nullable(true)
-            : collection.notRequired().nullable(true);
+        if (validation.required) {
+            schema = schema.test(
+                "required",
+                validation?.requiredMessage ? validation.requiredMessage : "Required",
+                (value) => value !== undefined && value !== null && value !== ""
+            );
+        }
         if (validation.unique && customFieldValidator && name)
-            collection = collection.test("unique", "This value already exists and should be unique",
+            schema = schema.test("unique", "This value already exists and should be unique",
                 (value, context) =>
                     customFieldValidator({
                         name,
@@ -147,46 +194,49 @@ function getYupStringSchema({
                         value,
                         entityId
                     }));
-        if (validation.min || validation.min === 0) collection = collection.min(validation.min, `${property.name} must be min ${validation.min} characters long`);
-        if (validation.max || validation.max === 0) collection = collection.max(validation.max, `${property.name} must be max ${validation.max} characters long`);
+        if (validation.min || validation.min === 0) schema = schema.min(validation.min, `${property.name} must be min ${validation.min} characters long`);
+        if (validation.max || validation.max === 0) schema = schema.max(validation.max, `${property.name} must be max ${validation.max} characters long`);
         if (validation.matches) {
             const regExp = typeof validation.matches === "string" ? hydrateRegExp(validation.matches) : validation.matches;
             if (regExp) {
-                collection = collection.matches(regExp, validation.matchesMessage ? { message: validation.matchesMessage } : undefined)
+                schema = schema.matches(regExp, validation.matchesMessage ? { message: validation.matchesMessage } : undefined)
             }
         }
-        if (validation.trim) collection = collection.trim();
-        if (validation.lowercase) collection = collection.lowercase();
-        if (validation.uppercase) collection = collection.uppercase();
-        if (property.email) collection = collection.email(`${property.name} must be an email`);
+        if (validation.trim) schema = schema.trim();
+        if (validation.lowercase) schema = schema.lowercase();
+        if (validation.uppercase) schema = schema.uppercase();
+        if (property.email) schema = schema.email(`${property.name} must be an email`);
         if (property.url) {
             if (!property.storage || property.storage?.storeUrl) {
-                collection = collection.url(`${property.name} must be a url`);
+                schema = schema.url(`${property.name} must be a url`);
             } else {
                 console.warn(`Property ${property.name} has a url validation but its storage configuration is not set to store urls`);
             }
         }
-    } else {
-        collection = collection.notRequired().nullable(true);
     }
-    return collection;
+    return schema;
 }
 
 function getYupNumberSchema({
-                                property,
-                                parentProperty,
-                                customFieldValidator,
-                                name,
-                                entityId
-                            }: PropertyContext<number>): NumberSchema {
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<number>): NumberSchema {
     const validation = property.validation;
-    let collection: NumberSchema<any> = yup.number().typeError("Must be a number");
+    let schema: NumberSchema<any> = yup.number().nullable().typeError("Must be a number");
+
     if (validation) {
-        collection = validation.required
-            ? collection.required(validation.requiredMessage ? validation.requiredMessage : "Required").nullable(true)
-            : collection.notRequired().nullable(true);
+        if (validation.required) {
+            schema = schema.test(
+                "required",
+                validation.requiredMessage ? validation.requiredMessage : "Required",
+                (value) => value !== undefined && value !== null
+            );
+        }
         if (validation.unique && customFieldValidator && name)
-            collection = collection.test("unique",
+            schema = schema.test("unique",
                 "This value already exists and should be unique",
                 (value) => customFieldValidator({
                     name,
@@ -195,30 +245,29 @@ function getYupNumberSchema({
                     value,
                     entityId
                 }));
-        if (validation.min || validation.min === 0) collection = collection.min(validation.min, `${property.name} must be higher or equal to ${validation.min}`);
-        if (validation.max || validation.max === 0) collection = collection.max(validation.max, `${property.name} must be lower or equal to ${validation.max}`);
-        if (validation.lessThan || validation.lessThan === 0) collection = collection.lessThan(validation.lessThan, `${property.name} must be higher than ${validation.lessThan}`);
-        if (validation.moreThan || validation.moreThan === 0) collection = collection.moreThan(validation.moreThan, `${property.name} must be lower than ${validation.moreThan}`);
-        if (validation.positive) collection = collection.positive(`${property.name} must be positive`);
-        if (validation.negative) collection = collection.negative(`${property.name} must be negative`);
-        if (validation.integer) collection = collection.integer(`${property.name} must be an integer`);
-    } else {
-        collection = collection.notRequired().nullable(true);
+        if (validation.min || validation.min === 0) schema = schema.min(validation.min, `${property.name} must be higher or equal to ${validation.min}`);
+        if (validation.max || validation.max === 0) schema = schema.max(validation.max, `${property.name} must be lower or equal to ${validation.max}`);
+        if (validation.lessThan || validation.lessThan === 0) schema = schema.lessThan(validation.lessThan, `${property.name} must be higher than ${validation.lessThan}`);
+        if (validation.moreThan || validation.moreThan === 0) schema = schema.moreThan(validation.moreThan, `${property.name} must be lower than ${validation.moreThan}`);
+        if (validation.positive) schema = schema.positive(`${property.name} must be positive`);
+        if (validation.negative) schema = schema.negative(`${property.name} must be negative`);
+        if (validation.integer) schema = schema.integer(`${property.name} must be an integer`);
     }
-    return collection;
+    return schema;
 }
 
 function getYupGeoPointSchema({
-                                  property,
-                                  parentProperty,
-                                  customFieldValidator,
-                                  name,
-                                  entityId
-                              }: PropertyContext<GeoPoint>): AnySchema {
-    let collection: ObjectSchema<any> = yup.object();
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<GeoPoint>): AnySchema {
+    let schema: ObjectSchema<any> = yup.object().nullable() as ObjectSchema<any>;
     const validation = property.validation;
+
     if (validation?.unique && customFieldValidator && name)
-        collection = collection.test("unique",
+        schema = schema.test("unique",
             "This value already exists and should be unique",
             (value) => customFieldValidator({
                 name,
@@ -228,31 +277,38 @@ function getYupGeoPointSchema({
                 entityId
             }));
     if (validation?.required) {
-        collection = collection.required(validation.requiredMessage).nullable(true);
-    } else {
-        collection = collection.notRequired().nullable(true);
+        schema = schema.test(
+            "required",
+            validation.requiredMessage ? validation.requiredMessage : "Required",
+            (value) => value !== undefined && value !== null
+        );
     }
-    return collection;
+    return schema;
 }
 
 function getYupDateSchema({
-                              property,
-                              parentProperty,
-                              customFieldValidator,
-                              name,
-                              entityId
-                          }: PropertyContext<Date>): AnySchema | DateSchema {
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<Date>): AnySchema | DateSchema {
     if (property.autoValue) {
-        return yup.object().nullable();
+        return yup.date().nullable();
     }
-    let collection: DateSchema<any> = yup.date();
+    let schema: DateSchema<any> = yup.date().nullable();
     const validation = property.validation;
+
     if (validation) {
-        collection = validation.required
-            ? collection.required(validation?.requiredMessage ? validation.requiredMessage : "Required")
-            : collection.notRequired();
+        if (validation.required) {
+            schema = schema.test(
+                "required",
+                validation?.requiredMessage ? validation.requiredMessage : "Required",
+                (value) => value !== undefined && value !== null
+            );
+        }
         if (validation.unique && customFieldValidator && name)
-            collection = collection.test("unique",
+            schema = schema.test("unique",
                 "This value already exists and should be unique",
                 (value) => customFieldValidator({
                     name,
@@ -261,31 +317,32 @@ function getYupDateSchema({
                     value,
                     entityId
                 }));
-        if (validation.min) collection = collection.min(validation.min, `${property.name} must be after ${validation.min}`);
-        if (validation.max) collection = collection.max(validation.max, `${property.name} must be before ${validation.min}`);
-    } else {
-        collection = collection.notRequired();
+        if (validation.min) schema = schema.min(validation.min, `${property.name} must be after ${validation.min}`);
+        if (validation.max) schema = schema.max(validation.max, `${property.name} must be before ${validation.min}`);
     }
-    return collection
-        .transform((v: any) => (v instanceof Date ? v : null))
-        .nullable();
+    return schema.transform((v: any) => (v instanceof Date ? v : null));
 }
 
 function getYupReferenceSchema({
-                                   property,
-                                   parentProperty,
-                                   customFieldValidator,
-                                   name,
-                                   entityId
-                               }: PropertyContext<EntityReference>): AnySchema {
-    let collection: ObjectSchema<any> = yup.object();
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<EntityReference>): AnySchema {
+    let schema: ObjectSchema<any> = yup.object().nullable() as ObjectSchema<any>;
     const validation = property.validation;
+
     if (validation) {
-        collection = validation.required
-            ? collection.required(validation?.requiredMessage ? validation.requiredMessage : "Required").nullable(true)
-            : collection.notRequired().nullable(true);
+        if (validation.required) {
+            schema = schema.test(
+                "required",
+                validation?.requiredMessage ? validation.requiredMessage : "Required",
+                (value) => value !== undefined && value !== null
+            );
+        }
         if (validation.unique && customFieldValidator && name)
-            collection = collection.test("unique",
+            schema = schema.test("unique",
                 "This value already exists and should be unique",
                 (value) => customFieldValidator({
                     name,
@@ -294,27 +351,30 @@ function getYupReferenceSchema({
                     value,
                     entityId
                 }));
-    } else {
-        collection = collection.notRequired().nullable(true);
     }
-    return collection;
+    return schema;
 }
 
 function getYupBooleanSchema({
-                                 property,
-                                 parentProperty,
-                                 customFieldValidator,
-                                 name,
-                                 entityId
-                             }: PropertyContext<boolean>): BooleanSchema {
-    let collection: BooleanSchema<any> = yup.boolean();
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<boolean>): BooleanSchema {
+    let schema: BooleanSchema<any> = yup.boolean().nullable();
     const validation = property.validation;
+
     if (validation) {
-        collection = validation.required
-            ? collection.required(validation?.requiredMessage ? validation.requiredMessage : "Required").nullable(true)
-            : collection.notRequired().nullable(true);
+        if (validation.required) {
+            schema = schema.test(
+                "required",
+                validation?.requiredMessage ? validation.requiredMessage : "Required",
+                (value) => value !== undefined && value !== null
+            );
+        }
         if (validation.unique && customFieldValidator && name)
-            collection = collection.test("unique",
+            schema = schema.test("unique",
                 "This value already exists and should be unique",
                 (value) => customFieldValidator({
                     name,
@@ -323,10 +383,8 @@ function getYupBooleanSchema({
                     value,
                     entityId
                 }));
-    } else {
-        collection = collection.notRequired().nullable(true);
     }
-    return collection;
+    return schema;
 }
 
 function hasUniqueInArrayModifier(property: ResolvedProperty): boolean | [string, ResolvedProperty][] {
@@ -340,25 +398,38 @@ function hasUniqueInArrayModifier(property: ResolvedProperty): boolean | [string
 }
 
 function getYupArraySchema({
-                               property,
-                               parentProperty,
-                               customFieldValidator,
-                               name,
-                               entityId
-                           }: PropertyContext<any[]>): AnySchema<any> {
+    property,
+    parentProperty,
+    customFieldValidator,
+    name,
+    entityId
+}: PropertyContext<any[]>): AnySchema<any> {
 
-    let arraySchema: ArraySchema<any> = yup.array();
+    let arraySchema: any = yup.array().nullable();
 
     if (property.of) {
         if (Array.isArray(property.of)) {
-            const yupProperties = (property.of as ResolvedProperty[]).map((p, index) => ({
-                [`${name}[${index}]`]: mapPropertyToYup({
-                    property: p as ResolvedProperty<any>,
-                    parentProperty: property,
-                    entityId
-                })
-            })).reduce((a, b) => ({ ...a, ...b }), {});
-            return yup.array().of(
+            const yupProperties = (property.of as ResolvedProperty[]).map((p, index) => {
+                try {
+                    return {
+                        [`${name}[${index}]`]: mapPropertyToYup({
+                            property: p as ResolvedProperty<any>,
+                            parentProperty: property,
+                            entityId
+                        })
+                    };
+                } catch (e: any) {
+                    console.error(`Error creating validation schema for array item ${index}:`, e);
+                    return {
+                        [`${name}[${index}]`]: yup.mixed().test(
+                            "validation-error",
+                            `Validation error: ${e?.message ?? "Unknown error"}`,
+                            () => false
+                        )
+                    };
+                }
+            }).reduce((a, b) => ({ ...a, ...b }), {});
+            return yup.array().nullable().of(
                 yup.mixed().test(
                     "Dynamic object validation",
                     "Dynamic object validation error",
@@ -369,20 +440,28 @@ function getYupArraySchema({
                 )
             );
         } else {
-            arraySchema = arraySchema.of(mapPropertyToYup({
-                property: property.of,
-                parentProperty: property,
-                entityId
-            }));
+            try {
+                arraySchema = arraySchema.of(mapPropertyToYup({
+                    property: property.of,
+                    parentProperty: property,
+                    entityId
+                }));
+            } catch (e: any) {
+                console.error(`Error creating validation schema for array of property:`, e);
+                arraySchema = arraySchema.of(yup.mixed().test(
+                    "validation-error",
+                    `Validation error: ${e?.message ?? "Unknown error"}`,
+                    () => false
+                ));
+            }
             const arrayUniqueFields = hasUniqueInArrayModifier(property.of);
             if (arrayUniqueFields) {
                 if (typeof arrayUniqueFields === "boolean") {
-                    arraySchema = arraySchema.uniqueInArray(v => v, `${property.name} should have unique values within the array`);
+                    arraySchema = arraySchema.uniqueInArray((v: any) => v, `${property.name} should have unique values within the array`);
                 } else if (Array.isArray(arrayUniqueFields)) {
                     arrayUniqueFields.forEach(([name, childProperty]) => {
-                            arraySchema = arraySchema.uniqueInArray(v => v && v[name], `${property.name} → ${childProperty.name ?? name}: should have unique values within the array`);
-                        }
-                    );
+                        arraySchema = arraySchema.uniqueInArray((v: any) => v && v[name], `${property.name} → ${childProperty.name ?? name}: should have unique values within the array`);
+                    });
                 }
             }
         }
@@ -390,13 +469,19 @@ function getYupArraySchema({
     const validation = property.validation;
 
     if (validation) {
-        arraySchema = validation.required
-            ? arraySchema.required(validation?.requiredMessage ? validation.requiredMessage : "Required").nullable(true)
-            : arraySchema.notRequired().nullable(true);
+        if (validation.required) {
+            arraySchema = arraySchema.test(
+                "required",
+                validation?.requiredMessage ? validation.requiredMessage : "Required",
+                (value: any) => value !== undefined && value !== null && value.length > 0
+            );
+        }
         if (validation.min || validation.min === 0) arraySchema = arraySchema.min(validation.min, `${property.name} should be min ${validation.min} entries long`);
         if (validation.max) arraySchema = arraySchema.max(validation.max, `${property.name} should be max ${validation.max} entries long`);
-    } else {
-        arraySchema = arraySchema.notRequired().nullable(true);
+        // Handle uniqueInArray at the array level (in addition to the of.validation check above)
+        if (validation.uniqueInArray) {
+            arraySchema = arraySchema.uniqueInArray((v: any) => v, `${property.name} should have unique values within the array`);
+        }
     }
     return arraySchema;
 }

package/src/hooks/useBreadcrumbsController.tsx

@@ -9,16 +9,34 @@ export interface BreadcrumbsController {
     set: (props: {
         breadcrumbs: BreadcrumbEntry[];
     }) => void;
+    /**
+     * Update the count for a specific breadcrumb by ID.
+     */
+    updateCount: (id: string, count: number | null | undefined) => void;
 }
 
+
 /**
  * @group Hooks and utilities
  */
 export interface BreadcrumbEntry {
     title: string;
     url: string;
+    /**
+     * Optional entity count for collection breadcrumbs.
+     * - undefined: not applicable (e.g., entity breadcrumb, custom view)
+     * - null: loading
+     * - number: loaded count
+     */
+    count?: number | null;
+    /**
+     * Unique identifier for this breadcrumb (e.g., collection path).
+     * Used to update count without replacing entire breadcrumb array.
+     */
+    id?: string;
 }
 
+
 /**
  * Hook to retrieve the BreadcrumbsController.
  *