@jmruthers/pace-core 0.2.7 → 0.5.1

package/src/utils/__tests__/schemaUtils.unit.test.ts

@@ -1,441 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import { pickSchema, combineSchemas } from '../schemaUtils';
-
-describe('schemaUtils', () => {
-  describe('pickSchema', () => {
-    it('should create a subset schema with selected keys', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email(),
-        age: z.number().min(0),
-        isActive: z.boolean()
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['name', 'email']);
-
-      // Test valid data
-      const validData = { name: 'John Doe', email: 'john@example.com' };
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-
-      // Test that the schema only includes selected fields
-      expect(subsetSchema.shape).toHaveProperty('name');
-      expect(subsetSchema.shape).toHaveProperty('email');
-      expect(subsetSchema.shape).not.toHaveProperty('age');
-      expect(subsetSchema.shape).not.toHaveProperty('isActive');
-    });
-
-    it('should handle single key selection', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email(),
-        age: z.number()
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['name']);
-
-      const validData = { name: 'John Doe' };
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-      expect(Object.keys(subsetSchema.shape)).toHaveLength(1);
-      expect(subsetSchema.shape).toHaveProperty('name');
-    });
-
-    it('should handle all keys selection', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email(),
-        age: z.number()
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['name', 'email', 'age']);
-
-      const validData = { name: 'John Doe', email: 'john@example.com', age: 30 };
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-      expect(Object.keys(subsetSchema.shape)).toHaveLength(3);
-    });
-
-    it('should handle empty keys array', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email()
-      });
-
-      const subsetSchema = pickSchema(originalSchema, []);
-
-      const validData = {};
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-      expect(Object.keys(subsetSchema.shape)).toHaveLength(0);
-    });
-
-    it('should handle keys that do not exist in original schema', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email()
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['name', 'nonexistent']);
-
-      const validData = { name: 'John Doe' };
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-      expect(subsetSchema.shape).toHaveProperty('name');
-      expect(subsetSchema.shape).not.toHaveProperty('nonexistent');
-    });
-
-    it('should preserve validation rules from original schema', () => {
-      const originalSchema = z.object({
-        name: z.string().min(2),
-        email: z.string().email(),
-        age: z.number().min(18).max(120)
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['name', 'email', 'age']);
-
-      // Test valid data
-      const validData = { name: 'John', email: 'john@example.com', age: 25 };
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-
-      // Test validation errors
-      expect(() => subsetSchema.parse({ name: 'J', email: 'invalid-email', age: 15 }))
-        .toThrow();
-    });
-
-    it('should handle complex nested schemas', () => {
-      const originalSchema = z.object({
-        user: z.object({
-          name: z.string(),
-          email: z.string().email()
-        }),
-        settings: z.object({
-          notifications: z.boolean()
-        }),
-        metadata: z.object({
-          createdAt: z.date(),
-          updatedAt: z.date()
-        })
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['user', 'settings']);
-
-      const validData = {
-        user: { name: 'John', email: 'john@example.com' },
-        settings: { notifications: true }
-      };
-
-      const result = subsetSchema.parse(validData);
-      expect(result).toEqual(validData);
-      expect(subsetSchema.shape).toHaveProperty('user');
-      expect(subsetSchema.shape).toHaveProperty('settings');
-      expect(subsetSchema.shape).not.toHaveProperty('metadata');
-    });
-
-    it('should handle optional fields', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email(),
-        phone: z.string().optional(),
-        address: z.string().optional()
-      });
-
-      const subsetSchema = pickSchema(originalSchema, ['name', 'phone']);
-
-      // Test with optional field present
-      const dataWithPhone = { name: 'John', phone: '123-456-7890' };
-      const result1 = subsetSchema.parse(dataWithPhone);
-      expect(result1).toEqual(dataWithPhone);
-
-      // Test with optional field missing
-      const dataWithoutPhone = { name: 'John' };
-      const result2 = subsetSchema.parse(dataWithoutPhone);
-      expect(result2).toEqual(dataWithoutPhone);
-    });
-  });
-
-  describe('combineSchemas', () => {
-    it('should combine multiple schemas into one', () => {
-      const schema1 = z.object({
-        name: z.string(),
-        email: z.string().email()
-      });
-
-      const schema2 = z.object({
-        age: z.number(),
-        isActive: z.boolean()
-      });
-
-      const schema3 = z.object({
-        role: z.string(),
-        permissions: z.array(z.string())
-      });
-
-      const combinedSchema = combineSchemas([schema1, schema2, schema3]);
-
-      const validData = {
-        name: 'John Doe',
-        email: 'john@example.com',
-        age: 30,
-        isActive: true,
-        role: 'admin',
-        permissions: ['read', 'write']
-      };
-
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-    });
-
-    it('should handle single schema', () => {
-      const schema = z.object({
-        name: z.string(),
-        email: z.string().email()
-      });
-
-      const combinedSchema = combineSchemas([schema]);
-
-      const validData = { name: 'John', email: 'john@example.com' };
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-    });
-
-    it('should handle empty array', () => {
-      const combinedSchema = combineSchemas([]);
-
-      const validData = {};
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-    });
-
-    it('should handle overlapping field names by merging', () => {
-      const schema1 = z.object({
-        name: z.string(),
-        email: z.string().email()
-      });
-
-      const schema2 = z.object({
-        name: z.string().min(2), // Different validation
-        age: z.number()
-      });
-
-      const combinedSchema = combineSchemas([schema1, schema2]);
-
-      // The last schema's validation for overlapping fields should take precedence
-      const validData = { name: 'John', email: 'john@example.com', age: 30 };
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-
-      // Should fail with short name due to schema2's validation
-      expect(() => combinedSchema.parse({ name: 'J', email: 'john@example.com', age: 30 }))
-        .toThrow();
-    });
-
-    it('should preserve validation rules from all schemas', () => {
-      const schema1 = z.object({
-        name: z.string().min(2),
-        email: z.string().email()
-      });
-
-      const schema2 = z.object({
-        age: z.number().min(18),
-        isActive: z.boolean()
-      });
-
-      const combinedSchema = combineSchemas([schema1, schema2]);
-
-      // Test valid data
-      const validData = { name: 'John', email: 'john@example.com', age: 25, isActive: true };
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-
-      // Test validation errors
-      expect(() => combinedSchema.parse({ name: 'J', email: 'invalid', age: 15, isActive: true }))
-        .toThrow();
-    });
-
-    it('should handle complex nested schemas', () => {
-      const userSchema = z.object({
-        user: z.object({
-          name: z.string(),
-          email: z.string().email()
-        })
-      });
-
-      const settingsSchema = z.object({
-        settings: z.object({
-          notifications: z.boolean()
-        })
-      });
-
-      const metadataSchema = z.object({
-        metadata: z.object({
-          createdAt: z.date(),
-          updatedAt: z.date()
-        })
-      });
-
-      const combinedSchema = combineSchemas([userSchema, settingsSchema, metadataSchema]);
-
-      const validData = {
-        user: { name: 'John', email: 'john@example.com' },
-        settings: { notifications: true },
-        metadata: { createdAt: new Date(), updatedAt: new Date() }
-      };
-
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-    });
-
-    it('should handle optional fields across schemas', () => {
-      const schema1 = z.object({
-        name: z.string(),
-        email: z.string().email()
-      });
-
-      const schema2 = z.object({
-        phone: z.string().optional(),
-        address: z.string().optional()
-      });
-
-      const combinedSchema = combineSchemas([schema1, schema2]);
-
-      // Test with all fields
-      const dataWithAll = { name: 'John', email: 'john@example.com', phone: '123-456-7890', address: '123 Main St' };
-      const result1 = combinedSchema.parse(dataWithAll);
-      expect(result1).toEqual(dataWithAll);
-
-      // Test with optional fields missing
-      const dataWithoutOptional = { name: 'John', email: 'john@example.com' };
-      const result2 = combinedSchema.parse(dataWithoutOptional);
-      expect(result2).toEqual(dataWithoutOptional);
-    });
-
-    it('should handle array and union types', () => {
-      const schema1 = z.object({
-        tags: z.array(z.string()),
-        status: z.enum(['active', 'inactive'])
-      });
-
-      const schema2 = z.object({
-        permissions: z.array(z.string()),
-        role: z.union([z.literal('admin'), z.literal('user')])
-      });
-
-      const combinedSchema = combineSchemas([schema1, schema2]);
-
-      const validData = {
-        tags: ['javascript', 'react'],
-        status: 'active',
-        permissions: ['read', 'write'],
-        role: 'admin'
-      };
-
-      const result = combinedSchema.parse(validData);
-      expect(result).toEqual(validData);
-    });
-  });
-
-  describe('Integration tests', () => {
-    it('should work together in a realistic scenario', () => {
-      // Create base user schema
-      const userSchema = z.object({
-        name: z.string().min(2),
-        email: z.string().email(),
-        age: z.number().min(18)
-      });
-
-      // Create profile schema
-      const profileSchema = z.object({
-        bio: z.string().optional(),
-        avatar: z.string().url().optional(),
-        preferences: z.object({
-          notifications: z.boolean()
-        })
-      });
-
-      // Create settings schema
-      const settingsSchema = z.object({
-        settings: z.object({
-          language: z.string(),
-          timezone: z.string()
-        })
-      });
-
-      // Pick specific fields from user schema
-      const userSubset = pickSchema(userSchema, ['name', 'email']);
-
-      // Combine profile and settings schemas
-      const combinedProfileSettings = combineSchemas([profileSchema, settingsSchema]);
-
-      // Test user subset
-      const userData = { name: 'John Doe', email: 'john@example.com' };
-      const userResult = userSubset.parse(userData);
-      expect(userResult).toEqual(userData);
-
-      // Test combined profile and settings
-      const profileSettingsData = {
-        bio: 'Software developer',
-        avatar: 'https://example.com/avatar.jpg',
-        preferences: { notifications: true },
-        settings: { language: 'en', timezone: 'UTC' }
-      };
-      const profileSettingsResult = combinedProfileSettings.parse(profileSettingsData);
-      expect(profileSettingsResult).toEqual(profileSettingsData);
-    });
-
-    it('should handle form validation scenarios', () => {
-      // Basic form fields
-      const basicFields = z.object({
-        firstName: z.string().min(1, 'First name is required'),
-        lastName: z.string().min(1, 'Last name is required'),
-        email: z.string().email('Invalid email format')
-      });
-
-      // Optional fields
-      const optionalFields = z.object({
-        phone: z.string().optional(),
-        company: z.string().optional(),
-        website: z.string().url().optional()
-      });
-
-      // Advanced fields
-      const advancedFields = z.object({
-        preferences: z.object({
-          newsletter: z.boolean(),
-          marketing: z.boolean()
-        }),
-        metadata: z.object({
-          source: z.string(),
-          campaign: z.string().optional()
-        })
-      });
-
-      // Pick only basic fields for simple form
-      const simpleFormSchema = pickSchema(basicFields, ['firstName', 'lastName', 'email']);
-
-      // Combine all fields for complete form
-      const completeFormSchema = combineSchemas([basicFields, optionalFields, advancedFields]);
-
-      // Test simple form
-      const simpleFormData = { firstName: 'John', lastName: 'Doe', email: 'john@example.com' };
-      const simpleResult = simpleFormSchema.parse(simpleFormData);
-      expect(simpleResult).toEqual(simpleFormData);
-
-      // Test complete form
-      const completeFormData = {
-        firstName: 'John',
-        lastName: 'Doe',
-        email: 'john@example.com',
-        phone: '123-456-7890',
-        company: 'Acme Corp',
-        website: 'https://example.com',
-        preferences: { newsletter: true, marketing: false },
-        metadata: { source: 'website', campaign: 'summer2024' }
-      };
-      const completeResult = completeFormSchema.parse(completeFormData);
-      expect(completeResult).toEqual(completeFormData);
-    });
-  });
-});