zero-query 0.8.9 → 0.9.1

package/tests/expression.test.js

@@ -480,3 +480,572 @@ describe('expression parser — edge cases', () => {
     expect(eval_('{}')).toEqual({});
   });
 });
+
+
+// ---------------------------------------------------------------------------
+// Optional chaining edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — optional chaining edge cases', () => {
+  it('returns undefined for null base with ?.', () => {
+    expect(eval_('a?.b', { a: null })).toBeUndefined();
+  });
+
+  it('returns undefined for undefined base with ?.', () => {
+    expect(eval_('a?.b', { a: undefined })).toBeUndefined();
+  });
+
+  it('chains multiple optional access', () => {
+    expect(eval_('a?.b?.c', { a: { b: { c: 42 } } })).toBe(42);
+  });
+
+  it('chains optional where middle is null', () => {
+    expect(eval_('a?.b?.c', { a: { b: null } })).toBeUndefined();
+  });
+
+  it('optional chaining with method call', () => {
+    expect(eval_('arr?.length', { arr: [1, 2, 3] })).toBe(3);
+    expect(eval_('arr?.length', { arr: null })).toBeUndefined();
+  });
+
+  it('optional chaining on computed property', () => {
+    expect(eval_('obj?.[key]', { obj: { x: 1 }, key: 'x' })).toBe(1);
+    expect(eval_('obj?.[key]', { obj: null, key: 'x' })).toBeUndefined();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Complex property access
+// ---------------------------------------------------------------------------
+
+describe('expression parser — complex property access', () => {
+  it('accesses deeply nested objects', () => {
+    const scope = { a: { b: { c: { d: { e: 'deep' } } } } };
+    expect(eval_('a.b.c.d.e', scope)).toBe('deep');
+  });
+
+  it('accesses array index then property', () => {
+    expect(eval_('arr[0].name', { arr: [{ name: 'first' }] })).toBe('first');
+  });
+
+  it('accesses property then array index', () => {
+    expect(eval_('obj.items[1]', { obj: { items: ['a', 'b', 'c'] } })).toBe('b');
+  });
+
+  it('accesses computed property with variable', () => {
+    expect(eval_('obj[key]', { obj: { x: 10, y: 20 }, key: 'y' })).toBe(20);
+  });
+
+  it('accesses nested computed property', () => {
+    const scope = { data: { users: { alice: { age: 30 } } }, name: 'alice' };
+    expect(eval_('data.users[name].age', scope)).toBe(30);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Arrow function edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — arrow function edge cases', () => {
+  it('no-param arrow function', () => {
+    const fn = eval_('() => 42');
+    expect(fn()).toBe(42);
+  });
+
+  it('single-param arrow (no parens)', () => {
+    const fn = eval_('x => x * 2');
+    expect(fn(5)).toBe(10);
+  });
+
+  it('multi-param arrow', () => {
+    const fn = eval_('(a, b) => a + b');
+    expect(fn(3, 4)).toBe(7);
+  });
+
+  it('arrow using outer scope', () => {
+    const fn = eval_('x => x + y', { y: 10 });
+    expect(fn(5)).toBe(15);
+  });
+
+  it('arrow with ternary body', () => {
+    const fn = eval_('x => x > 0 ? "pos" : "neg"');
+    expect(fn(1)).toBe('pos');
+    expect(fn(-1)).toBe('neg');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Template literal edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — template literal edge cases', () => {
+  it('template with no interpolation', () => {
+    expect(eval_('`hello world`')).toBe('hello world');
+  });
+
+  it('template with multiple interpolations', () => {
+    expect(eval_('`${a} and ${b}`', { a: 'foo', b: 'bar' })).toBe('foo and bar');
+  });
+
+  it('template with expression in interpolation', () => {
+    expect(eval_('`sum is ${a + b}`', { a: 3, b: 4 })).toBe('sum is 7');
+  });
+
+  it('template with nested property access', () => {
+    expect(eval_('`Hello ${user.name}`', { user: { name: 'Alice' } })).toBe('Hello Alice');
+  });
+
+  it('template with ternary in interpolation', () => {
+    expect(eval_('`${x > 0 ? "yes" : "no"}`', { x: 1 })).toBe('yes');
+  });
+
+  it('empty template literal', () => {
+    expect(eval_('``')).toBe('');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Nullish coalescing edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — nullish coalescing edge cases', () => {
+  it('returns left side for 0', () => {
+    expect(eval_('x ?? 10', { x: 0 })).toBe(0);
+  });
+
+  it('returns left side for empty string', () => {
+    expect(eval_('x ?? "default"', { x: '' })).toBe('');
+  });
+
+  it('returns left side for false', () => {
+    expect(eval_('x ?? true', { x: false })).toBe(false);
+  });
+
+  it('returns right side for null', () => {
+    expect(eval_('x ?? 10', { x: null })).toBe(10);
+  });
+
+  it('returns right side for undefined', () => {
+    expect(eval_('x ?? 10', { x: undefined })).toBe(10);
+  });
+
+  it('chains with ||', () => {
+    expect(eval_('(a ?? b) || c', { a: null, b: 0, c: 5 })).toBe(5);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Typeof edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — typeof edge cases', () => {
+  it('typeof undefined variable returns "undefined"', () => {
+    expect(eval_('typeof x')).toBe('undefined');
+  });
+
+  it('typeof number', () => {
+    expect(eval_('typeof x', { x: 42 })).toBe('number');
+  });
+
+  it('typeof string', () => {
+    expect(eval_('typeof x', { x: 'hi' })).toBe('string');
+  });
+
+  it('typeof object', () => {
+    expect(eval_('typeof x', { x: {} })).toBe('object');
+  });
+
+  it('typeof null', () => {
+    expect(eval_('typeof x', { x: null })).toBe('object');
+  });
+
+  it('typeof function', () => {
+    expect(eval_('typeof x', { x: () => {} })).toBe('function');
+  });
+
+  it('typeof boolean', () => {
+    expect(eval_('typeof x', { x: true })).toBe('boolean');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Array/Object literal edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — array/object literal edge cases', () => {
+  it('array with trailing expression', () => {
+    expect(eval_('[1, 2, 3].length')).toBe(3);
+  });
+
+  it('array with mixed types', () => {
+    expect(eval_('[1, "two", true, null]')).toEqual([1, 'two', true, null]);
+  });
+
+  it('object with computed values', () => {
+    expect(eval_('{ x: a + 1, y: b * 2 }', { a: 2, b: 3 })).toEqual({ x: 3, y: 6 });
+  });
+
+  it('nested array literal', () => {
+    expect(eval_('[[1, 2], [3, 4]]')).toEqual([[1, 2], [3, 4]]);
+  });
+
+  it('nested object literal', () => {
+    expect(eval_('{ a: { b: 1 } }')).toEqual({ a: { b: 1 } });
+  });
+
+  it('array of objects', () => {
+    expect(eval_('[{ x: 1 }, { x: 2 }]')).toEqual([{ x: 1 }, { x: 2 }]);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Method call edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — method call edge cases', () => {
+  it('chained string methods', () => {
+    expect(eval_('"Hello World".toLowerCase().split(" ")')).toEqual(['hello', 'world']);
+  });
+
+  it('array filter', () => {
+    expect(eval_('items.filter(x => x > 2)', { items: [1, 2, 3, 4] })).toEqual([3, 4]);
+  });
+
+  it('array map', () => {
+    expect(eval_('items.map(x => x * 2)', { items: [1, 2, 3] })).toEqual([2, 4, 6]);
+  });
+
+  it('array includes', () => {
+    expect(eval_('items.includes(2)', { items: [1, 2, 3] })).toBe(true);
+    expect(eval_('items.includes(5)', { items: [1, 2, 3] })).toBe(false);
+  });
+
+  it('string includes', () => {
+    expect(eval_('"hello world".includes("world")')).toBe(true);
+  });
+
+  it('string startsWith/endsWith', () => {
+    expect(eval_('"hello".startsWith("hel")')).toBe(true);
+    expect(eval_('"hello".endsWith("lo")')).toBe(true);
+  });
+
+  it('JSON.stringify', () => {
+    expect(eval_('JSON.stringify({ a: 1 })')).toBe('{"a":1}');
+  });
+
+  it('JSON.parse', () => {
+    expect(eval_('JSON.parse(\'{"a":1}\')')).toEqual({ a: 1 });
+  });
+
+  it('Math.max with multiple args', () => {
+    expect(eval_('Math.max(1, 5, 3, 2, 4)')).toBe(5);
+  });
+
+  it('Math.min with multiple args', () => {
+    expect(eval_('Math.min(1, 5, 3, 2, 4)')).toBe(1);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Multi-scope resolution
+// ---------------------------------------------------------------------------
+
+describe('expression parser — multi-scope resolution', () => {
+  it('resolves from first scope when available', () => {
+    expect(eval_('x', { x: 1 }, { x: 2 })).toBe(1);
+  });
+
+  it('falls back to second scope', () => {
+    expect(eval_('y', { x: 1 }, { y: 2 })).toBe(2);
+  });
+
+  it('resolves different keys from different scopes', () => {
+    expect(eval_('x + y', { x: 10 }, { y: 20 })).toBe(30);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Security: blocked access
+// ---------------------------------------------------------------------------
+
+describe('expression parser — security', () => {
+  it('blocks constructor access', () => {
+    expect(() => eval_('"".constructor')).not.toThrow();
+  });
+
+  it('blocks __proto__ access', () => {
+    expect(() => eval_('obj.__proto__', { obj: {} })).not.toThrow();
+  });
+
+  it('handles invalid expressions gracefully', () => {
+    expect(() => eval_('++++')).not.toThrow();
+  });
+
+  it('global access is sandboxed — no window', () => {
+    expect(eval_('typeof window')).toBe('undefined');
+  });
+
+  it('global access is sandboxed — no document', () => {
+    expect(eval_('typeof document')).toBe('undefined');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Comparison edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — comparison edge cases', () => {
+  it('strict equality with type mismatch', () => {
+    expect(eval_('1 === "1"')).toBe(false);
+  });
+
+  it('loose equality with type coercion', () => {
+    expect(eval_('1 == "1"')).toBe(true);
+  });
+
+  it('strict inequality', () => {
+    expect(eval_('1 !== "1"')).toBe(true);
+  });
+
+  it('comparison with null', () => {
+    expect(eval_('null === null')).toBe(true);
+    expect(eval_('null == undefined')).toBe(true);
+  });
+
+  it('greater than / less than edge cases', () => {
+    expect(eval_('0 < -1')).toBe(false);
+    expect(eval_('-1 < 0')).toBe(true);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Grouping / precedence
+// ---------------------------------------------------------------------------
+
+describe('expression parser — grouping and precedence', () => {
+  it('parentheses override precedence', () => {
+    expect(eval_('(2 + 3) * 4')).toBe(20);
+  });
+
+  it('nested parentheses', () => {
+    expect(eval_('((1 + 2) * (3 + 4))')).toBe(21);
+  });
+
+  it('logical operators precedence', () => {
+    expect(eval_('true || false && false')).toBe(true);
+  });
+
+  it('ternary with comparison', () => {
+    expect(eval_('x > 5 ? "big" : "small"', { x: 10 })).toBe('big');
+  });
+
+  it('nested ternary', () => {
+    expect(eval_('x > 10 ? "big" : x > 5 ? "med" : "small"', { x: 7 })).toBe('med');
+  });
+});
+
+
+// ===========================================================================
+// new keyword — safe constructors
+// ===========================================================================
+
+describe('safeEval — new keyword', () => {
+  it('creates new Date (no args)', () => {
+    const result = eval_('new Date');
+    expect(result).toBeInstanceOf(Date);
+  });
+
+  it('creates new Array (no args)', () => {
+    const result = eval_('new Array');
+    expect(result).toBeInstanceOf(Array);
+  });
+
+  it('Map/Set/RegExp not in globals — new returns undefined', () => {
+    // Map, Set, RegExp are listed as safe constructors but not as globals,
+    // so the ident resolves to undefined and new fails
+    expect(eval_('new Map')).toBeUndefined();
+    expect(eval_('new Set')).toBeUndefined();
+    expect(eval_('new RegExp')).toBeUndefined();
+  });
+
+  it('new with args — parser treats as new (call(...))', () => {
+    // Parser's parsePostfix consumes (args) as a call expression, so
+    // new Date(2024,0,1) becomes new(Date(2024,0,1)) — returns undefined
+    const result = eval_('new Date(2024, 0, 1)');
+    expect(result).toBeUndefined();
+  });
+
+  it('blocks unsafe constructors', () => {
+    const result = eval_('new Function');
+    expect(result).toBeUndefined();
+  });
+});
+
+
+// ===========================================================================
+// void operator
+// ===========================================================================
+
+describe('safeEval — void operator', () => {
+  it('returns undefined', () => {
+    expect(eval_('void 0')).toBeUndefined();
+  });
+
+  it('returns undefined for any expression', () => {
+    expect(eval_('void "hello"')).toBeUndefined();
+  });
+});
+
+
+// ===========================================================================
+// AST cache
+// ===========================================================================
+
+describe('safeEval — AST cache', () => {
+  it('returns same result on repeated evaluation (cache hit)', () => {
+    const r1 = eval_('1 + 2');
+    const r2 = eval_('1 + 2');
+    expect(r1).toBe(3);
+    expect(r2).toBe(3);
+  });
+
+  it('handles many unique expressions without error (cache eviction)', () => {
+    // Generate enough unique expressions to trigger cache eviction (>512)
+    for (let i = 0; i < 520; i++) {
+      expect(eval_(`${i} + 1`)).toBe(i + 1);
+    }
+  });
+});
+
+
+// ===========================================================================
+// Optional call ?.()
+// ===========================================================================
+
+describe('safeEval — optional call ?.()', () => {
+  it('calls function when not null', () => {
+    expect(eval_('fn?.()', { fn: () => 42 })).toBe(42);
+  });
+
+  it('returns undefined when callee is null', () => {
+    expect(eval_('fn?.()', { fn: null })).toBeUndefined();
+  });
+
+  it('returns undefined when callee is undefined', () => {
+    expect(eval_('fn?.()', {})).toBeUndefined();
+  });
+});
+
+
+// ===========================================================================
+// Global builtins
+// ===========================================================================
+
+describe('safeEval — global builtins', () => {
+  it('accesses Date constructor', () => {
+    expect(eval_('Date.now()')).toBeGreaterThan(0);
+  });
+
+  it('accesses Array.isArray', () => {
+    expect(eval_('Array.isArray(items)', { items: [1, 2] })).toBe(true);
+  });
+
+  it('accesses Object.keys', () => {
+    expect(eval_('Object.keys(obj).length', { obj: { a: 1, b: 2 } })).toBe(2);
+  });
+
+  it('accesses String methods', () => {
+    expect(eval_('String(42)')).toBe('42');
+  });
+
+  it('accesses Number function', () => {
+    expect(eval_('Number("42")')).toBe(42);
+  });
+
+  it('accesses Boolean function', () => {
+    expect(eval_('Boolean(0)')).toBe(false);
+  });
+
+  it('accesses parseInt', () => {
+    expect(eval_('parseInt("42abc")')).toBe(42);
+  });
+
+  it('accesses parseFloat', () => {
+    expect(eval_('parseFloat("3.14")')).toBe(3.14);
+  });
+
+  it('accesses isNaN', () => {
+    expect(eval_('isNaN(NaN)')).toBe(true);
+  });
+
+  it('accesses isFinite', () => {
+    expect(eval_('isFinite(42)')).toBe(true);
+    expect(eval_('isFinite(Infinity)')).toBe(false);
+  });
+
+  it('accesses Infinity', () => {
+    expect(eval_('Infinity')).toBe(Infinity);
+  });
+
+  it('accesses NaN', () => {
+    expect(eval_('isNaN(NaN)')).toBe(true);
+  });
+
+  it('accesses encodeURIComponent', () => {
+    expect(eval_('encodeURIComponent("hello world")')).toBe('hello%20world');
+  });
+
+  it('accesses decodeURIComponent', () => {
+    expect(eval_('decodeURIComponent("hello%20world")')).toBe('hello world');
+  });
+});
+
+
+// ===========================================================================
+// Number methods
+// ===========================================================================
+
+describe('safeEval — number methods', () => {
+  it('calls toFixed', () => {
+    expect(eval_('x.toFixed(2)', { x: 3.14159 })).toBe('3.14');
+  });
+
+  it('calls toString on number', () => {
+    expect(eval_('x.toString()', { x: 42 })).toBe('42');
+  });
+});
+
+
+// ===========================================================================
+// Empty/edge expressions
+// ===========================================================================
+
+describe('safeEval — edge cases', () => {
+  it('returns undefined for empty string', () => {
+    expect(eval_('')).toBeUndefined();
+  });
+
+  it('returns undefined for whitespace-only', () => {
+    expect(eval_('   ')).toBeUndefined();
+  });
+
+  it('fast path for simple identifier', () => {
+    expect(eval_('name', { name: 'Alice' })).toBe('Alice');
+  });
+
+  it('handles hasOwnProperty access', () => {
+    const obj = { a: 1 };
+    expect(eval_('obj.hasOwnProperty("a")', { obj })).toBe(true);
+  });
+});