@startsimpli/funnels 0.1.4 → 0.1.6

package/src/core/field-resolver.test.ts

@@ -0,0 +1,541 @@
+/**
+ * @startsimpli/funnels - Field Resolver Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  resolveField,
+  setField,
+  hasField,
+  getFields,
+} from './field-resolver';
+
+describe('resolveField', () => {
+  describe('simple paths', () => {
+    it('resolves top-level string field', () => {
+      const entity = { name: 'John Doe' };
+      expect(resolveField(entity, 'name')).toBe('John Doe');
+    });
+
+    it('resolves top-level number field', () => {
+      const entity = { age: 30, score: 85.5 };
+      expect(resolveField(entity, 'age')).toBe(30);
+      expect(resolveField(entity, 'score')).toBe(85.5);
+    });
+
+    it('resolves top-level boolean field', () => {
+      const entity = { active: true, verified: false };
+      expect(resolveField(entity, 'active')).toBe(true);
+      expect(resolveField(entity, 'verified')).toBe(false);
+    });
+
+    it('resolves top-level date field', () => {
+      const date = new Date('2024-01-01');
+      const entity = { created_at: date };
+      expect(resolveField(entity, 'created_at')).toBe(date);
+    });
+
+    it('resolves top-level null field', () => {
+      const entity = { value: null };
+      expect(resolveField(entity, 'value')).toBe(null);
+    });
+  });
+
+  describe('nested paths', () => {
+    it('resolves nested object fields', () => {
+      const entity = {
+        firm: {
+          name: 'Sequoia Capital',
+          stage: 'Series A',
+        },
+      };
+      expect(resolveField(entity, 'firm.name')).toBe('Sequoia Capital');
+      expect(resolveField(entity, 'firm.stage')).toBe('Series A');
+    });
+
+    it('resolves deeply nested paths', () => {
+      const entity = {
+        company: {
+          address: {
+            city: {
+              name: 'San Francisco',
+              zipCode: '94102',
+            },
+          },
+        },
+      };
+      expect(resolveField(entity, 'company.address.city.name')).toBe('San Francisco');
+      expect(resolveField(entity, 'company.address.city.zipCode')).toBe('94102');
+    });
+
+    it('resolves nested number fields preserving type', () => {
+      const entity = {
+        metrics: {
+          revenue: 1000000,
+          growth_rate: 0.25,
+        },
+      };
+      expect(resolveField(entity, 'metrics.revenue')).toBe(1000000);
+      expect(resolveField(entity, 'metrics.growth_rate')).toBe(0.25);
+    });
+  });
+
+  describe('array access', () => {
+    it('resolves array elements by index', () => {
+      const entity = {
+        tags: ['active', 'qualified', 'enterprise'],
+      };
+      expect(resolveField(entity, 'tags[0]')).toBe('active');
+      expect(resolveField(entity, 'tags[1]')).toBe('qualified');
+      expect(resolveField(entity, 'tags[2]')).toBe('enterprise');
+    });
+
+    it('resolves nested array objects', () => {
+      const entity = {
+        investors: [
+          { name: 'Alice', email: 'alice@example.com' },
+          { name: 'Bob', email: 'bob@example.com' },
+        ],
+      };
+      expect(resolveField(entity, 'investors[0].name')).toBe('Alice');
+      expect(resolveField(entity, 'investors[0].email')).toBe('alice@example.com');
+      expect(resolveField(entity, 'investors[1].name')).toBe('Bob');
+    });
+
+    it('resolves deeply nested array paths', () => {
+      const entity = {
+        data: {
+          items: [
+            { values: [10, 20, 30] },
+            { values: [40, 50, 60] },
+          ],
+        },
+      };
+      expect(resolveField(entity, 'data.items[0].values[1]')).toBe(20);
+      expect(resolveField(entity, 'data.items[1].values[2]')).toBe(60);
+    });
+
+    it('returns undefined for out-of-bounds array index', () => {
+      const entity = { tags: ['a', 'b'] };
+      expect(resolveField(entity, 'tags[5]')).toBe(undefined);
+    });
+  });
+
+  describe('missing paths', () => {
+    it('returns undefined for missing top-level field', () => {
+      const entity = { name: 'John' };
+      expect(resolveField(entity, 'doesNotExist')).toBe(undefined);
+    });
+
+    it('returns undefined for missing nested field', () => {
+      const entity = { firm: { name: 'Acme' } };
+      expect(resolveField(entity, 'firm.missing')).toBe(undefined);
+    });
+
+    it('returns undefined for deeply missing field', () => {
+      const entity = { a: { b: { c: 'value' } } };
+      expect(resolveField(entity, 'a.b.c.d.e.f')).toBe(undefined);
+    });
+
+    it('returns undefined when intermediate path is null', () => {
+      const entity = { firm: null };
+      expect(resolveField(entity, 'firm.stage')).toBe(undefined);
+    });
+
+    it('returns undefined when intermediate path is undefined', () => {
+      const entity = { firm: undefined };
+      expect(resolveField(entity, 'firm.stage')).toBe(undefined);
+    });
+  });
+
+  describe('null safety', () => {
+    it('returns undefined for null entity', () => {
+      expect(resolveField(null, 'name')).toBe(undefined);
+    });
+
+    it('returns undefined for undefined entity', () => {
+      expect(resolveField(undefined, 'name')).toBe(undefined);
+    });
+
+    it('returns undefined for empty path', () => {
+      const entity = { name: 'John' };
+      expect(resolveField(entity, '')).toBe(undefined);
+    });
+
+    it('returns undefined for whitespace-only path', () => {
+      const entity = { name: 'John' };
+      expect(resolveField(entity, '   ')).toBe(undefined);
+    });
+  });
+
+  describe('type preservation', () => {
+    it('preserves number types', () => {
+      const entity = { count: 42, pi: 3.14159 };
+      expect(resolveField(entity, 'count')).toBe(42);
+      expect(typeof resolveField(entity, 'count')).toBe('number');
+      expect(resolveField(entity, 'pi')).toBe(3.14159);
+    });
+
+    it('preserves boolean types', () => {
+      const entity = { isActive: true, isVerified: false };
+      expect(resolveField(entity, 'isActive')).toBe(true);
+      expect(typeof resolveField(entity, 'isActive')).toBe('boolean');
+      expect(resolveField(entity, 'isVerified')).toBe(false);
+    });
+
+    it('preserves date objects', () => {
+      const date = new Date('2024-01-01');
+      const entity = { created: date };
+      const result = resolveField(entity, 'created');
+      expect(result).toBe(date);
+      expect(result instanceof Date).toBe(true);
+    });
+
+    it('preserves arrays', () => {
+      const entity = { tags: ['a', 'b', 'c'] };
+      const result = resolveField(entity, 'tags');
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toEqual(['a', 'b', 'c']);
+    });
+
+    it('preserves objects', () => {
+      const obj = { stage: 'Seed', aum: 100000 };
+      const entity = { firm: obj };
+      const result = resolveField(entity, 'firm');
+      expect(typeof result).toBe('object');
+      expect(result).toEqual(obj);
+    });
+  });
+
+  describe('complex real-world examples', () => {
+    it('resolves investor entity fields', () => {
+      const investor = {
+        id: '123',
+        name: 'John Doe',
+        email: 'john@example.com',
+        firm: {
+          id: 'firm-456',
+          name: 'Sequoia Capital',
+          stage: 'Series A',
+          aum_usd: 100000000,
+        },
+        tags: ['active', 'qualified', 'enterprise'],
+        profile: {
+          linkedin_url: 'https://linkedin.com/in/johndoe',
+          bio: 'Venture capitalist',
+        },
+        metrics: {
+          response_rate: 0.85,
+          deal_count: 12,
+        },
+        created_at: new Date('2024-01-01'),
+      };
+
+      expect(resolveField(investor, 'name')).toBe('John Doe');
+      expect(resolveField(investor, 'firm.name')).toBe('Sequoia Capital');
+      expect(resolveField(investor, 'firm.aum_usd')).toBe(100000000);
+      expect(resolveField(investor, 'tags[0]')).toBe('active');
+      expect(resolveField(investor, 'profile.linkedin_url')).toBe('https://linkedin.com/in/johndoe');
+      expect(resolveField(investor, 'metrics.response_rate')).toBe(0.85);
+      expect(resolveField(investor, 'created_at')).toBeInstanceOf(Date);
+    });
+
+    it('resolves recipe entity fields', () => {
+      const recipe = {
+        id: 'recipe-789',
+        title: 'Chocolate Chip Cookies',
+        cuisine: 'American',
+        ingredients: [
+          { name: 'flour', amount: '2 cups' },
+          { name: 'sugar', amount: '1 cup' },
+          { name: 'chocolate chips', amount: '2 cups' },
+        ],
+        steps: [
+          { order: 1, instruction: 'Mix dry ingredients' },
+          { order: 2, instruction: 'Add wet ingredients' },
+        ],
+        metadata: {
+          prep_time_minutes: 15,
+          cook_time_minutes: 12,
+          servings: 24,
+        },
+      };
+
+      expect(resolveField(recipe, 'title')).toBe('Chocolate Chip Cookies');
+      expect(resolveField(recipe, 'ingredients[0].name')).toBe('flour');
+      expect(resolveField(recipe, 'ingredients[2].amount')).toBe('2 cups');
+      expect(resolveField(recipe, 'steps[1].instruction')).toBe('Add wet ingredients');
+      expect(resolveField(recipe, 'metadata.prep_time_minutes')).toBe(15);
+    });
+  });
+});
+
+describe('setField', () => {
+  describe('simple paths', () => {
+    it('sets top-level field', () => {
+      const entity: any = { name: 'John' };
+      setField(entity, 'email', 'john@example.com');
+      expect(entity.email).toBe('john@example.com');
+    });
+
+    it('updates existing field', () => {
+      const entity: any = { name: 'John' };
+      setField(entity, 'name', 'Jane');
+      expect(entity.name).toBe('Jane');
+    });
+  });
+
+  describe('nested paths', () => {
+    it('creates nested object if missing', () => {
+      const entity: any = { name: 'John' };
+      setField(entity, 'firm.stage', 'Series A');
+      expect(entity.firm).toBeDefined();
+      expect(entity.firm.stage).toBe('Series A');
+    });
+
+    it('creates deeply nested path', () => {
+      const entity: any = {};
+      setField(entity, 'company.address.city.name', 'San Francisco');
+      expect(entity.company.address.city.name).toBe('San Francisco');
+    });
+
+    it('updates nested field without affecting siblings', () => {
+      const entity: any = {
+        firm: { name: 'Acme', stage: 'Seed' },
+      };
+      setField(entity, 'firm.stage', 'Series A');
+      expect(entity.firm.name).toBe('Acme');
+      expect(entity.firm.stage).toBe('Series A');
+    });
+  });
+
+  describe('array paths', () => {
+    it('creates array and sets element', () => {
+      const entity: any = {};
+      setField(entity, 'tags[0]', 'active');
+      expect(Array.isArray(entity.tags)).toBe(true);
+      expect(entity.tags[0]).toBe('active');
+    });
+
+    it('sets array element in existing array', () => {
+      const entity: any = { tags: ['a', 'b', 'c'] };
+      setField(entity, 'tags[1]', 'updated');
+      expect(entity.tags).toEqual(['a', 'updated', 'c']);
+    });
+
+    it('sets nested array object field', () => {
+      const entity: any = {
+        investors: [{ name: 'Alice' }, { name: 'Bob' }],
+      };
+      setField(entity, 'investors[0].email', 'alice@example.com');
+      expect(entity.investors[0].email).toBe('alice@example.com');
+      expect(entity.investors[1].email).toBe(undefined);
+    });
+  });
+
+  describe('error handling', () => {
+    it('throws on null entity', () => {
+      expect(() => setField(null, 'name', 'value')).toThrow(
+        'Cannot set field on null or undefined entity'
+      );
+    });
+
+    it('throws on undefined entity', () => {
+      expect(() => setField(undefined, 'name', 'value')).toThrow(
+        'Cannot set field on null or undefined entity'
+      );
+    });
+
+    it('throws on empty path', () => {
+      const entity = {};
+      expect(() => setField(entity, '', 'value')).toThrow(
+        'Field path cannot be empty'
+      );
+    });
+
+    it('throws on whitespace-only path', () => {
+      const entity = {};
+      expect(() => setField(entity, '   ', 'value')).toThrow(
+        'Field path cannot be empty'
+      );
+    });
+  });
+
+  describe('type preservation', () => {
+    it('sets number values', () => {
+      const entity: any = {};
+      setField(entity, 'count', 42);
+      setField(entity, 'rate', 0.85);
+      expect(entity.count).toBe(42);
+      expect(entity.rate).toBe(0.85);
+    });
+
+    it('sets boolean values', () => {
+      const entity: any = {};
+      setField(entity, 'active', true);
+      setField(entity, 'verified', false);
+      expect(entity.active).toBe(true);
+      expect(entity.verified).toBe(false);
+    });
+
+    it('sets date values', () => {
+      const entity: any = {};
+      const date = new Date('2024-01-01');
+      setField(entity, 'created', date);
+      expect(entity.created).toBe(date);
+      expect(entity.created instanceof Date).toBe(true);
+    });
+  });
+
+  describe('tag assignment use case', () => {
+    it('adds tags to entity', () => {
+      const entity: any = { name: 'John' };
+      setField(entity, 'tags', ['qualified', 'enterprise']);
+      expect(entity.tags).toEqual(['qualified', 'enterprise']);
+    });
+
+    it('updates specific tag in array', () => {
+      const entity: any = { tags: ['a', 'b', 'c'] };
+      setField(entity, 'tags[1]', 'updated');
+      expect(entity.tags).toEqual(['a', 'updated', 'c']);
+    });
+  });
+});
+
+describe('hasField', () => {
+  it('returns true for existing field', () => {
+    const entity = { name: 'John' };
+    expect(hasField(entity, 'name')).toBe(true);
+  });
+
+  it('returns true for nested field', () => {
+    const entity = { firm: { stage: 'Seed' } };
+    expect(hasField(entity, 'firm.stage')).toBe(true);
+  });
+
+  it('returns true for array element', () => {
+    const entity = { tags: ['a', 'b'] };
+    expect(hasField(entity, 'tags[0]')).toBe(true);
+  });
+
+  it('returns false for missing field', () => {
+    const entity = { name: 'John' };
+    expect(hasField(entity, 'email')).toBe(false);
+  });
+
+  it('returns false for missing nested field', () => {
+    const entity = { firm: { name: 'Acme' } };
+    expect(hasField(entity, 'firm.stage')).toBe(false);
+  });
+
+  it('returns false for out-of-bounds array index', () => {
+    const entity = { tags: ['a', 'b'] };
+    expect(hasField(entity, 'tags[5]')).toBe(false);
+  });
+
+  it('returns false for null field value', () => {
+    const entity = { value: null };
+    // Note: null is a defined value, not undefined
+    expect(hasField(entity, 'value')).toBe(true);
+  });
+
+  it('returns false for undefined field value', () => {
+    const entity = { value: undefined };
+    expect(hasField(entity, 'value')).toBe(false);
+  });
+});
+
+describe('getFields', () => {
+  it('resolves multiple fields at once', () => {
+    const entity = {
+      name: 'John',
+      email: 'john@example.com',
+      firm: { stage: 'Seed' },
+      tags: ['active'],
+    };
+
+    const result = getFields(entity, [
+      'name',
+      'email',
+      'firm.stage',
+      'tags[0]',
+    ]);
+
+    expect(result).toEqual({
+      name: 'John',
+      email: 'john@example.com',
+      'firm.stage': 'Seed',
+      'tags[0]': 'active',
+    });
+  });
+
+  it('includes undefined for missing fields', () => {
+    const entity = { name: 'John' };
+    const result = getFields(entity, ['name', 'email', 'firm.stage']);
+
+    expect(result).toEqual({
+      name: 'John',
+      email: undefined,
+      'firm.stage': undefined,
+    });
+  });
+
+  it('handles empty field list', () => {
+    const entity = { name: 'John' };
+    const result = getFields(entity, []);
+    expect(result).toEqual({});
+  });
+
+  it('preserves types for all fields', () => {
+    const entity = {
+      str: 'text',
+      num: 42,
+      bool: true,
+      date: new Date('2024-01-01'),
+    };
+
+    const result = getFields(entity, ['str', 'num', 'bool', 'date']);
+
+    expect(result.str).toBe('text');
+    expect(result.num).toBe(42);
+    expect(result.bool).toBe(true);
+    expect(result.date).toBeInstanceOf(Date);
+  });
+});
+
+describe('Prototype Pollution Prevention', () => {
+  it('resolveField blocks __proto__ segment', () => {
+    const entity = { name: 'John' };
+    const result = resolveField(entity, '__proto__.polluted');
+    expect(result).toBeUndefined();
+  });
+
+  it('resolveField blocks constructor segment', () => {
+    const entity = { name: 'John' };
+    const result = resolveField(entity, 'constructor.name');
+    expect(result).toBeUndefined();
+  });
+
+  it('resolveField blocks prototype segment', () => {
+    const entity = { name: 'John' };
+    const result = resolveField(entity, 'prototype.polluted');
+    expect(result).toBeUndefined();
+  });
+
+  it('setField blocks __proto__ from polluting Object prototype', () => {
+    const entity: Record<string, any> = {};
+    // Attempting __proto__.polluted must not pollute Object.prototype
+    expect(() => setField(entity, '__proto__.polluted', 'evil')).toThrow();
+    expect((Object.prototype as any).polluted).toBeUndefined();
+  });
+
+  it('setField blocks constructor from prototype pollution', () => {
+    const entity: Record<string, any> = {};
+    expect(() => setField(entity, 'constructor.prototype.polluted', 'evil')).toThrow();
+  });
+
+  it('hasField returns false for __proto__ path', () => {
+    const entity = { name: 'John' };
+    expect(hasField(entity, '__proto__')).toBe(false);
+  });
+});