Address code review feedback

- Update terminology: ipWhitelist/ipBlacklist → allowedIps/blockedIps
- Add validation: minSize <= maxSize
- Add validation: virusScanProvider requires virusScan enabled
- Add validation: transition action requires targetStorageClass
- Add comprehensive tests for all validation rules
- Remove incorrectly placed integration/object-storage.mdx
- All 2238 tests passing

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

content/docs/references/system/object-storage.mdx

@@ -35,8 +35,8 @@ const result = AccessControlConfigSchema.parse(data);
 | **maxAge** | `number` | optional | CORS preflight cache duration in seconds |
 | **corsEnabled** | `boolean` | optional | Enable CORS configuration |
 | **publicAccess** | `object` | optional | Public access control |
-| **ipWhitelist** | `string[]` | optional | Allowed IP addresses/CIDR blocks |
-| **ipBlacklist** | `string[]` | optional | Blocked IP addresses/CIDR blocks |
+| **allowedIps** | `string[]` | optional | Allowed IP addresses/CIDR blocks |
+| **blockedIps** | `string[]` | optional | Blocked IP addresses/CIDR blocks |
 
 ---
 

packages/spec/json-schema/system/AccessControlConfig.json

@@ -84,14 +84,14 @@
           "additionalProperties": false,
           "description": "Public access control"
         },
-        "ipWhitelist": {
+        "allowedIps": {
           "type": "array",
           "items": {
             "type": "string"
           },
           "description": "Allowed IP addresses/CIDR blocks"
         },
-        "ipBlacklist": {
+        "blockedIps": {
           "type": "array",
           "items": {
             "type": "string"

packages/spec/json-schema/system/BucketConfig.json

@@ -161,14 +161,14 @@
               "additionalProperties": false,
               "description": "Public access control"
             },
-            "ipWhitelist": {
+            "allowedIps": {
               "type": "array",
               "items": {
                 "type": "string"
               },
               "description": "Allowed IP addresses/CIDR blocks"
             },
-            "ipBlacklist": {
+            "blockedIps": {
               "type": "array",
               "items": {
                 "type": "string"

packages/spec/json-schema/system/ObjectStorageConfig.json

@@ -248,14 +248,14 @@
                     "additionalProperties": false,
                     "description": "Public access control"
                   },
-                  "ipWhitelist": {
+                  "allowedIps": {
                     "type": "array",
                     "items": {
                       "type": "string"
                     },
                     "description": "Allowed IP addresses/CIDR blocks"
                   },
-                  "ipBlacklist": {
+                  "blockedIps": {
                     "type": "array",
                     "items": {
                       "type": "string"

packages/spec/src/data/field.test.ts

@@ -1331,5 +1331,59 @@ describe('Field Factory Helpers', () => {
         maxVersions: 0,
       })).toThrow();
     });
+
+    it('should reject minSize greater than maxSize', () => {
+      expect(() => FileAttachmentConfigSchema.parse({
+        minSize: 1000,
+        maxSize: 500,
+      })).toThrow();
+      
+      // Verify the specific error message
+      try {
+        FileAttachmentConfigSchema.parse({
+          minSize: 1000,
+          maxSize: 500,
+        });
+      } catch (error: any) {
+        expect(error.issues[0].message).toContain('minSize must be less than or equal to maxSize');
+      }
+    });
+
+    it('should accept valid minSize and maxSize', () => {
+      const config = FileAttachmentConfigSchema.parse({
+        minSize: 500,
+        maxSize: 1000,
+      });
+      
+      expect(config.minSize).toBe(500);
+      expect(config.maxSize).toBe(1000);
+    });
+
+    it('should reject virusScanProvider without virusScan enabled', () => {
+      expect(() => FileAttachmentConfigSchema.parse({
+        virusScan: false,
+        virusScanProvider: 'clamav',
+      })).toThrow();
+      
+      // Verify the specific error message
+      try {
+        FileAttachmentConfigSchema.parse({
+          virusScan: false,
+          virusScanProvider: 'clamav',
+        });
+      } catch (error: any) {
+        expect(error.issues[0].message).toContain('virusScanProvider requires virusScan to be enabled');
+      }
+    });
+
+    it('should accept virusScanProvider when virusScan is enabled', () => {
+      const config = FileAttachmentConfigSchema.parse({
+        virusScan: true,
+        virusScanProvider: 'clamav',
+      });
+      
+      expect(config.virusScan).toBe(true);
+      expect(config.virusScanProvider).toBe('clamav');
+    });
   });
 });

packages/spec/src/data/field.zod.ts

@@ -160,7 +160,7 @@ export const VectorConfigSchema = z.object({
  * Configuration for file and attachment field types
  * 
  * Provides comprehensive file upload capabilities with:
- * - File type restrictions (whitelist/blacklist)
+ * - File type restrictions (allowed/blocked)
  * - File size limits (min/max)
  * - Virus scanning integration
  * - Storage provider integration
@@ -241,6 +241,22 @@ export const FileAttachmentConfigSchema = z.object({
   /** Access Control */
   publicRead: z.boolean().default(false).describe('Allow public read access to uploaded files'),
   presignedUrlExpiry: z.number().min(60).max(604800).default(3600).describe('Presigned URL expiration in seconds (default: 1 hour)'),
+}).refine((data) => {
+  // Validate minSize is less than or equal to maxSize
+  if (data.minSize !== undefined && data.maxSize !== undefined && data.minSize > data.maxSize) {
+    return false;
+  }
+  return true;
+}, {
+  message: 'minSize must be less than or equal to maxSize',
+}).refine((data) => {
+  // Validate virusScanProvider requires virusScan to be enabled
+  if (data.virusScanProvider !== undefined && data.virusScan !== true) {
+    return false;
+  }
+  return true;
+}, {
+  message: 'virusScanProvider requires virusScan to be enabled',
 });
 
 /**

packages/spec/src/system/object-storage.test.ts

@@ -265,14 +265,14 @@ describe('AccessControlConfigSchema', () => {
     expect(config.publicAccess?.allowPublicWrite).toBe(false);
   });
 
-  it('should accept IP whitelist/blacklist', () => {
+  it('should accept IP allow/block lists', () => {
     const config = AccessControlConfigSchema.parse({
-      ipWhitelist: ['192.168.1.0/24', '10.0.0.1'],
-      ipBlacklist: ['1.2.3.4'],
+      allowedIps: ['192.168.1.0/24', '10.0.0.1'],
+      blockedIps: ['1.2.3.4'],
     });
 
-    expect(config.ipWhitelist).toHaveLength(2);
-    expect(config.ipBlacklist).toHaveLength(1);
+    expect(config.allowedIps).toHaveLength(2);
+    expect(config.blockedIps).toHaveLength(1);
   });
 });
 
@@ -342,6 +342,53 @@ describe('LifecyclePolicyRuleSchema', () => {
       daysAfterCreation: 30,
     })).toThrow();
   });
+
+  it('should require targetStorageClass when action is transition', () => {
+    expect(() => LifecyclePolicyRuleSchema.parse({
+      id: 'move_to_glacier',
+      enabled: true,
+      action: 'transition',
+      daysAfterCreation: 30,
+      // missing targetStorageClass
+    })).toThrow();
+    
+    // Verify the specific error message
+    try {
+      LifecyclePolicyRuleSchema.parse({
+        id: 'move_to_glacier',
+        enabled: true,
+        action: 'transition',
+        daysAfterCreation: 30,
+      });
+    } catch (error: any) {
+      expect(error.issues[0].message).toContain('targetStorageClass is required');
+    }
+  });
+
+  it('should accept transition rule with targetStorageClass', () => {
+    const rule = LifecyclePolicyRuleSchema.parse({
+      id: 'move_to_glacier',
+      enabled: true,
+      action: 'transition',
+      daysAfterCreation: 30,
+      targetStorageClass: 'glacier',
+    });
+    
+    expect(rule.action).toBe('transition');
+    expect(rule.targetStorageClass).toBe('glacier');
+  });
+
+  it('should allow delete action without targetStorageClass', () => {
+    const rule = LifecyclePolicyRuleSchema.parse({
+      id: 'delete_old',
+      enabled: true,
+      action: 'delete',
+      daysAfterCreation: 365,
+    });
+    
+    expect(rule.action).toBe('delete');
+    expect(rule.targetStorageClass).toBeUndefined();
+  });
 });
 
 describe('LifecyclePolicyConfigSchema', () => {

packages/spec/src/system/object-storage.zod.ts

@@ -214,8 +214,8 @@ export const AccessControlConfigSchema = z.object({
     allowPublicWrite: z.boolean().default(false).describe('Allow public write access'),
     allowPublicList: z.boolean().default(false).describe('Allow public bucket listing'),
   }).optional().describe('Public access control'),
-  ipWhitelist: z.array(z.string()).optional().describe('Allowed IP addresses/CIDR blocks'),
-  ipBlacklist: z.array(z.string()).optional().describe('Blocked IP addresses/CIDR blocks'),
+  allowedIps: z.array(z.string()).optional().describe('Allowed IP addresses/CIDR blocks'),
+  blockedIps: z.array(z.string()).optional().describe('Blocked IP addresses/CIDR blocks'),
 });
 
 export type AccessControlConfig = z.infer<typeof AccessControlConfigSchema>;
@@ -253,6 +253,14 @@ export const LifecyclePolicyRuleSchema = z.object({
   daysAfterCreation: z.number().min(0).optional().describe('Days after object creation'),
   daysAfterModification: z.number().min(0).optional().describe('Days after last modification'),
   targetStorageClass: StorageClassSchema.optional().describe('Target storage class for transition action'),
+}).refine((data) => {
+  // Validate that transition action has targetStorageClass
+  if (data.action === 'transition' && !data.targetStorageClass) {
+    return false;
+  }
+  return true;
+}, {
+  message: 'targetStorageClass is required when action is "transition"',
 });
 
 export type LifecyclePolicyRule = z.infer<typeof LifecyclePolicyRuleSchema>;