@vendure/dashboard 3.4.1-master-202508050244 → 3.4.1-master-202508070243

package/src/lib/components/shared/value-transformers.ts

@@ -0,0 +1,143 @@
+import { UniversalFieldDefinition } from './universal-field-definition.js';
+
+export type ValueMode = 'native' | 'json-string';
+
+/**
+ * Interface for transforming values between native JavaScript types and JSON strings
+ */
+export interface ValueTransformer {
+    parse: (value: string, fieldDef: UniversalFieldDefinition) => any;
+    serialize: (value: any, fieldDef: UniversalFieldDefinition) => string;
+}
+
+/**
+ * Native value transformer - passes values through unchanged
+ */
+export const nativeValueTransformer: ValueTransformer = {
+    parse: (value: string, fieldDef: UniversalFieldDefinition) => {
+        // For native mode, values are already in their correct JavaScript type
+        return value;
+    },
+    serialize: (value: any, fieldDef: UniversalFieldDefinition) => {
+        // For native mode, values are already in their correct JavaScript type
+        return value;
+    },
+};
+
+/**
+ * JSON string value transformer - converts between JSON strings and native values
+ */
+export const jsonStringValueTransformer: ValueTransformer = {
+    parse: (value: string, fieldDef: UniversalFieldDefinition) => {
+        if (!value) {
+            return getDefaultValue(fieldDef);
+        }
+
+        try {
+            // For JSON string mode, parse the string to get the native value
+            const parsed = JSON.parse(value);
+
+            // Handle special cases for different field types
+            switch (fieldDef.type) {
+                case 'boolean':
+                    return parsed === true || parsed === 'true';
+                case 'int':
+                case 'float':
+                    return typeof parsed === 'number' ? parsed : parseFloat(parsed) || 0;
+                case 'datetime':
+                    return parsed;
+                default:
+                    return parsed;
+            }
+        } catch (error) {
+            // If parsing fails, try to handle as a plain string for certain types
+            switch (fieldDef.type) {
+                case 'boolean':
+                    return value === 'true';
+                case 'int':
+                case 'float':
+                    return parseFloat(value) || 0;
+                default:
+                    return value;
+            }
+        }
+    },
+    serialize: (value: any, fieldDef: UniversalFieldDefinition) => {
+        if (value === null || value === undefined) {
+            return '';
+        }
+
+        // Handle special cases for different field types
+        switch (fieldDef.type) {
+            case 'boolean':
+                return (value === true || value === 'true').toString();
+            case 'int':
+            case 'float':
+                return typeof value === 'number' ? value.toString() : (parseFloat(value) || 0).toString();
+            case 'string':
+                return typeof value === 'string' ? value : JSON.stringify(value);
+            default:
+                // For complex values (arrays, objects), serialize as JSON
+                return typeof value === 'string' ? value : JSON.stringify(value);
+        }
+    },
+};
+
+/**
+ * Get the appropriate value transformer based on the value mode
+ */
+export function getValueTransformer(valueMode: ValueMode): ValueTransformer {
+    switch (valueMode) {
+        case 'native':
+            return nativeValueTransformer;
+        case 'json-string':
+            return jsonStringValueTransformer;
+        default:
+            return nativeValueTransformer;
+    }
+}
+
+/**
+ * Get default value for a field type
+ */
+function getDefaultValue(fieldDef: UniversalFieldDefinition): any {
+    if (fieldDef.list) {
+        return [];
+    }
+
+    switch (fieldDef.type) {
+        case 'string':
+        case 'ID':
+        case 'localeString':
+        case 'localeText':
+            return '';
+        case 'int':
+        case 'float':
+            return 0;
+        case 'boolean':
+            return false;
+        case 'datetime':
+            return '';
+        case 'relation':
+            return fieldDef.list ? [] : null;
+        case 'struct':
+            return fieldDef.list ? [] : {};
+        default:
+            return '';
+    }
+}
+
+/**
+ * Utility to transform a value using the appropriate transformer
+ */
+export function transformValue(
+    value: any,
+    fieldDef: UniversalFieldDefinition,
+    valueMode: ValueMode,
+    direction: 'parse' | 'serialize',
+): any {
+    const transformer = getValueTransformer(valueMode);
+    return direction === 'parse'
+        ? transformer.parse(value, fieldDef)
+        : transformer.serialize(value, fieldDef);
+}

package/src/lib/framework/form-engine/form-schema-tools.spec.ts

@@ -434,6 +434,144 @@ describe('form-schema-tools', () => {
         });
     });
 
+    describe('createFormSchemaFromFields - null constraint handling', () => {
+        it('should handle int custom fields with null min constraint from GraphQL API', () => {
+            const fields = [createMockField('customFields', 'Object', false, false, [])];
+            // Simulate GraphQL API response where min/max are null instead of undefined
+            const customFields = [
+                createMockCustomField('quantity', 'int', {
+                    intMin: null as any, // This comes as null from GraphQL API
+                    intMax: 100,
+                }),
+            ];
+
+            // This test should fail if the bug exists - the schema creation should work
+            // but validation with null constraints should fail
+            expect(() => {
+                const _schema = createFormSchemaFromFields(fields, customFields, false);
+
+                // If the bug exists, this will try to validate against null min value
+                // which would always be false since no number can be >= null
+                const _validData = { customFields: { quantity: 50 } };
+                _schema.parse(_validData);
+            }).not.toThrow();
+
+            // Let's also test that we can create the schema without errors
+            const schema = createFormSchemaFromFields(fields, customFields, false);
+
+            // Should not apply min validation since intMin is null (if bug is fixed)
+            const validData = { customFields: { quantity: -50 } };
+            expect(() => schema.parse(validData)).not.toThrow();
+
+            // Should still apply max validation since intMax is 100
+            const aboveMaxData = { customFields: { quantity: 101 } };
+            expect(() => schema.parse(aboveMaxData)).toThrow();
+        });
+
+        it('should handle int custom fields with null max constraint from GraphQL API', () => {
+            const fields = [createMockField('customFields', 'Object', false, false, [])];
+            // Simulate GraphQL API response where min/max are null instead of undefined
+            const customFields = [
+                createMockCustomField('quantity', 'int', {
+                    intMin: 1,
+                    intMax: null as any, // This comes as null from GraphQL API
+                }),
+            ];
+
+            const schema = createFormSchemaFromFields(fields, customFields, false);
+
+            // Should still apply min validation since intMin is 1
+            const belowMinData = { customFields: { quantity: 0 } };
+            expect(() => schema.parse(belowMinData)).toThrow();
+
+            // Should not apply max validation since intMax is null
+            const validData = { customFields: { quantity: 999999 } };
+            expect(() => schema.parse(validData)).not.toThrow();
+        });
+
+        it('should handle int custom fields with both null min and max constraints from GraphQL API', () => {
+            const fields = [createMockField('customFields', 'Object', false, false, [])];
+            // Simulate GraphQL API response where min/max are both null
+            const customFields = [
+                createMockCustomField('quantity', 'int', {
+                    intMin: null as any, // This comes as null from GraphQL API
+                    intMax: null as any, // This comes as null from GraphQL API
+                }),
+            ];
+
+            const schema = createFormSchemaFromFields(fields, customFields, false);
+
+            // Should not apply any validation since both are null
+            const negativeData = { customFields: { quantity: -999 } };
+            expect(() => schema.parse(negativeData)).not.toThrow();
+
+            const largeData = { customFields: { quantity: 999999 } };
+            expect(() => schema.parse(largeData)).not.toThrow();
+        });
+
+        it('should handle float custom fields with null min constraint from GraphQL API', () => {
+            const fields = [createMockField('customFields', 'Object', false, false, [])];
+            // Simulate GraphQL API response where min/max are null instead of undefined
+            const customFields = [
+                createMockCustomField('weight', 'float', {
+                    floatMin: null as any, // This comes as null from GraphQL API
+                    floatMax: 999.9,
+                }),
+            ];
+
+            const schema = createFormSchemaFromFields(fields, customFields, false);
+
+            // Should not apply min validation since floatMin is null
+            const validData = { customFields: { weight: -50.5 } };
+            expect(() => schema.parse(validData)).not.toThrow();
+
+            // Should still apply max validation since floatMax is 999.9
+            const aboveMaxData = { customFields: { weight: 1000.0 } };
+            expect(() => schema.parse(aboveMaxData)).toThrow();
+        });
+
+        it('should handle float custom fields with null max constraint from GraphQL API', () => {
+            const fields = [createMockField('customFields', 'Object', false, false, [])];
+            // Simulate GraphQL API response where min/max are null instead of undefined
+            const customFields = [
+                createMockCustomField('weight', 'float', {
+                    floatMin: 0.1,
+                    floatMax: null as any, // This comes as null from GraphQL API
+                }),
+            ];
+
+            const schema = createFormSchemaFromFields(fields, customFields, false);
+
+            // Should still apply min validation since floatMin is 0.1
+            const belowMinData = { customFields: { weight: 0.05 } };
+            expect(() => schema.parse(belowMinData)).toThrow();
+
+            // Should not apply max validation since floatMax is null
+            const validData = { customFields: { weight: 999999.99 } };
+            expect(() => schema.parse(validData)).not.toThrow();
+        });
+
+        it('should handle float custom fields with both null min and max constraints from GraphQL API', () => {
+            const fields = [createMockField('customFields', 'Object', false, false, [])];
+            // Simulate GraphQL API response where min/max are both null
+            const customFields = [
+                createMockCustomField('weight', 'float', {
+                    floatMin: null as any, // This comes as null from GraphQL API
+                    floatMax: null as any, // This comes as null from GraphQL API
+                }),
+            ];
+
+            const schema = createFormSchemaFromFields(fields, customFields, false);
+
+            // Should not apply any validation since both are null
+            const negativeData = { customFields: { weight: -999.99 } };
+            expect(() => schema.parse(negativeData)).not.toThrow();
+
+            const largeData = { customFields: { weight: 999999.99 } };
+            expect(() => schema.parse(largeData)).not.toThrow();
+        });
+    });
+
     describe('createFormSchemaFromFields - edge cases', () => {
         it('should handle empty custom field config', () => {
             const fields = [

package/src/lib/framework/form-engine/form-schema-tools.ts

@@ -136,12 +136,12 @@ function createStringValidationSchema(pattern?: string): ZodType {
  */
 function createIntValidationSchema(min?: number, max?: number): ZodType {
     let schema = z.number();
-    if (min !== undefined) {
+    if (min != null) {
         schema = schema.min(min, {
             message: `Value must be at least ${min}`,
         });
     }
-    if (max !== undefined) {
+    if (max != null) {
         schema = schema.max(max, {
             message: `Value must be at most ${max}`,
         });
@@ -159,12 +159,12 @@ function createIntValidationSchema(min?: number, max?: number): ZodType {
  */
 function createFloatValidationSchema(min?: number, max?: number): ZodType {
     let schema = z.number();
-    if (min !== undefined) {
+    if (min != null) {
         schema = schema.min(min, {
             message: `Value must be at least ${min}`,
         });
     }
-    if (max !== undefined) {
+    if (max != null) {
         schema = schema.max(max, {
             message: `Value must be at most ${max}`,
         });