@coast/core-utils 0.0.25 → 0.0.29

package/src/test/JsonPathTest.ts

@@ -0,0 +1,516 @@
+import { safeExpect } from '@paradoxical-io/common-test';
+
+import { JsonPath } from '../JsonPath';
+
+const TEST_PATHS = {
+    FOO_BAR_BAZ: 'foo.bar.baz',
+    FOO_BAR_BAZ_FORMATTED: '$.foo.bar.baz',
+    FOO_BAR_FORMATTED: '$.foo.bar',
+    FOO_FORMATTED: '$.foo',
+    FOO: 'foo',
+    BAR_BAZ_HYPHENATED: 'bar-baz',
+    FOO_BAR_BAZ_HYPHENATED: 'foo.bar-baz',
+    BAR_BAZ_HYPHENATED_FORMATTED: "$.foo['bar-baz']",
+    BAR_BAZ_QUX_FORMATTED: "$.foo['bar-baz'].qux",
+    FOO_BAR_BAZ_QUX_FORMATTED: '$.foo.bar.baz.qux',
+    SIMPLE_FOO_BAR: 'foo.bar',
+} as const;
+
+describe('JsonPath', () => {
+    describe('constructor', () => {
+        it('creates a JsonPath with a given value', () => {
+            const path = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+            safeExpect(path.value).toEqual(TEST_PATHS.FOO_BAR_FORMATTED);
+        });
+    });
+
+    describe('fromString', () => {
+        describe('simple paths', () => {
+            it('converts a simple dot-notation path', () => {
+                const path = JsonPath.fromString(TEST_PATHS.FOO_BAR_BAZ);
+                safeExpect(path.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_FORMATTED);
+            });
+
+            it('converts a single segment path', () => {
+                const path = JsonPath.fromString(TEST_PATHS.FOO);
+                safeExpect(path.value).toEqual(TEST_PATHS.FOO_FORMATTED);
+            });
+
+            it('converts a two segment path', () => {
+                const path = JsonPath.fromString(TEST_PATHS.SIMPLE_FOO_BAR);
+                safeExpect(path.value).toEqual(TEST_PATHS.FOO_BAR_FORMATTED);
+            });
+
+            it('returns the path unchanged if it already starts with $', () => {
+                const path = JsonPath.fromString(TEST_PATHS.FOO_BAR_FORMATTED);
+                safeExpect(path.value).toEqual(TEST_PATHS.FOO_BAR_FORMATTED);
+            });
+
+            it('handles paths with underscores', () => {
+                const path = JsonPath.fromString('foo_bar.baz_qux');
+                safeExpect(path.value).toEqual('$.foo_bar.baz_qux');
+            });
+
+            it('handles paths with mixed case', () => {
+                const path = JsonPath.fromString('FooBar.BazQux');
+                safeExpect(path.value).toEqual('$.FooBar.BazQux');
+            });
+        });
+
+        describe('numeric segments', () => {
+            it('uses bracket notation for segments starting with numbers', () => {
+                const path = JsonPath.fromString('foo.123bar');
+                safeExpect(path.value).toEqual("$.foo['123bar']");
+            });
+
+            it('uses bracket notation for purely numeric segments', () => {
+                const path = JsonPath.fromString('foo.123');
+                safeExpect(path.value).toEqual("$.foo['123']");
+            });
+
+            it('uses bracket notation for array index notation', () => {
+                const path = JsonPath.fromString('foo.0.bar');
+                safeExpect(path.value).toEqual("$.foo['0'].bar");
+            });
+
+            it('handles multiple numeric segments', () => {
+                const path = JsonPath.fromString('foo.123.456.bar');
+                safeExpect(path.value).toEqual("$.foo['123']['456'].bar");
+            });
+        });
+
+        describe('special characters', () => {
+            it('uses bracket notation for segments with hyphens', () => {
+                const path = JsonPath.fromString(TEST_PATHS.FOO_BAR_BAZ_HYPHENATED);
+                safeExpect(path.value).toEqual(TEST_PATHS.BAR_BAZ_HYPHENATED_FORMATTED);
+            });
+
+            it('uses bracket notation for segments with spaces', () => {
+                const path = JsonPath.fromString('foo.bar baz');
+                safeExpect(path.value).toEqual("$.foo['bar baz']");
+            });
+
+            it('uses bracket notation for segments with dots', () => {
+                const path = JsonPath.fromString('foo.bar.baz.qux');
+                safeExpect(path.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('uses bracket notation for segments with special characters', () => {
+                const path = JsonPath.fromString('foo.bar@baz');
+                safeExpect(path.value).toEqual("$.foo['bar@baz']");
+            });
+
+            it('uses bracket notation for segments with dollar signs', () => {
+                const path = JsonPath.fromString('foo.$bar');
+                safeExpect(path.value).toEqual("$.foo['$bar']");
+            });
+
+            it('uses bracket notation for segments with brackets', () => {
+                const path = JsonPath.fromString('foo.[bar]');
+                safeExpect(path.value).toEqual("$.foo['[bar]']");
+            });
+
+            it('uses bracket notation for segments with parentheses', () => {
+                const path = JsonPath.fromString('foo.(bar)');
+                safeExpect(path.value).toEqual("$.foo['(bar)']");
+            });
+
+            it('uses bracket notation for segments with slashes', () => {
+                const path = JsonPath.fromString('foo.bar/baz');
+                safeExpect(path.value).toEqual("$.foo['bar/baz']");
+            });
+
+            it('uses bracket notation for segments with colons', () => {
+                const path = JsonPath.fromString('foo.bar:baz');
+                safeExpect(path.value).toEqual("$.foo['bar:baz']");
+            });
+
+            it('uses bracket notation for segments with commas', () => {
+                const path = JsonPath.fromString('foo.bar,baz');
+                safeExpect(path.value).toEqual("$.foo['bar,baz']");
+            });
+
+            it('uses bracket notation for segments with semicolons', () => {
+                const path = JsonPath.fromString('foo.bar;baz');
+                safeExpect(path.value).toEqual("$.foo['bar;baz']");
+            });
+
+            it('uses bracket notation for segments with quotes', () => {
+                const path = JsonPath.fromString('foo.bar"baz');
+                safeExpect(path.value).toEqual("$.foo['bar\"baz']");
+            });
+
+            it('uses bracket notation for segments with apostrophes', () => {
+                const path = JsonPath.fromString("foo.bar'baz");
+                safeExpect(path.value).toEqual("$.foo['bar'baz']");
+            });
+
+            it('uses bracket notation for segments with asterisks', () => {
+                const path = JsonPath.fromString('foo.bar*baz');
+                safeExpect(path.value).toEqual("$.foo['bar*baz']");
+            });
+
+            it('uses bracket notation for segments with plus signs', () => {
+                const path = JsonPath.fromString('foo.bar+baz');
+                safeExpect(path.value).toEqual("$.foo['bar+baz']");
+            });
+
+            it('uses bracket notation for segments with equals signs', () => {
+                const path = JsonPath.fromString('foo.bar=baz');
+                safeExpect(path.value).toEqual("$.foo['bar=baz']");
+            });
+        });
+
+        describe('UUID segments', () => {
+            it('uses bracket notation for UUID segments', () => {
+                const path = JsonPath.fromString('foo.123e4567-e89b-12d3-a456-426614174000');
+                safeExpect(path.value).toEqual("$.foo['123e4567-e89b-12d3-a456-426614174000']");
+            });
+
+            it('uses bracket notation for uppercase UUID segments', () => {
+                const path = JsonPath.fromString('foo.123E4567-E89B-12D3-A456-426614174000');
+                safeExpect(path.value).toEqual("$.foo['123E4567-E89B-12D3-A456-426614174000']");
+            });
+
+            it('uses bracket notation for mixed case UUID segments', () => {
+                const path = JsonPath.fromString('foo.123e4567-E89B-12d3-A456-426614174000');
+                safeExpect(path.value).toEqual("$.foo['123e4567-E89B-12d3-A456-426614174000']");
+            });
+
+            it('handles UUIDs in the middle of a path', () => {
+                const path = JsonPath.fromString('foo.123e4567-e89b-12d3-a456-426614174000.bar');
+                safeExpect(path.value).toEqual("$.foo['123e4567-e89b-12d3-a456-426614174000'].bar");
+            });
+
+            it('handles multiple UUIDs in a path', () => {
+                const path = JsonPath.fromString(
+                    'foo.123e4567-e89b-12d3-a456-426614174000.bar.987fcdeb-51a2-43e1-9876-543210fedcba'
+                );
+
+                safeExpect(path.value).toEqual(
+                    "$.foo['123e4567-e89b-12d3-a456-426614174000'].bar['987fcdeb-51a2-43e1-9876-543210fedcba']"
+                );
+            });
+        });
+
+        describe('complex paths', () => {
+            it('handles paths with mixed regular and special segments', () => {
+                const path = JsonPath.fromString('foo.bar-baz.qux');
+                safeExpect(path.value).toEqual(TEST_PATHS.BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('handles paths with multiple special character segments', () => {
+                const path = JsonPath.fromString('foo.bar-baz.qux-quux');
+                safeExpect(path.value).toEqual("$.foo['bar-baz']['qux-quux']");
+            });
+
+            it('handles paths with numeric and special character segments', () => {
+                const path = JsonPath.fromString('foo.123.bar-baz');
+                safeExpect(path.value).toEqual("$.foo['123']['bar-baz']");
+            });
+
+            it('handles paths with UUIDs and special character segments', () => {
+                const path = JsonPath.fromString('foo.123e4567-e89b-12d3-a456-426614174000.bar-baz');
+                safeExpect(path.value).toEqual("$.foo['123e4567-e89b-12d3-a456-426614174000']['bar-baz']");
+            });
+
+            it('handles long paths with many segments', () => {
+                const path = JsonPath.fromString('a.b.c.d.e.f.g.h.i.j');
+                safeExpect(path.value).toEqual('$.a.b.c.d.e.f.g.h.i.j');
+            });
+
+            it('handles paths with consecutive special segments', () => {
+                const path = JsonPath.fromString('foo.bar-baz.qux-quux.hello-world');
+                safeExpect(path.value).toEqual("$.foo['bar-baz']['qux-quux']['hello-world']");
+            });
+        });
+
+        describe('edge cases', () => {
+            it('handles empty string gracefully', () => {
+                const path = JsonPath.fromString('');
+                safeExpect(path.value).toEqual('$.');
+            });
+
+            it('handles path that is just $', () => {
+                const path = JsonPath.fromString('$');
+                safeExpect(path.value).toEqual('$');
+            });
+
+            it('handles path starting with $ and having segments', () => {
+                const path = JsonPath.fromString(TEST_PATHS.FOO_BAR_BAZ_FORMATTED);
+                safeExpect(path.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_FORMATTED);
+            });
+
+            it('handles path with special characters already in bracket notation', () => {
+                const path = JsonPath.fromString(TEST_PATHS.BAR_BAZ_HYPHENATED_FORMATTED);
+                safeExpect(path.value).toEqual(TEST_PATHS.BAR_BAZ_HYPHENATED_FORMATTED);
+            });
+        });
+    });
+
+    describe('appendPath', () => {
+        describe('appending JsonPath instances', () => {
+            it('appends a JsonPath to another JsonPath', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+                const path2 = new JsonPath('$.baz.qux');
+                const result = path1.appendPath(path2);
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('appends a simple JsonPath', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const path2 = new JsonPath('$.bar');
+                const result = path1.appendPath(path2);
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_FORMATTED);
+            });
+
+            it('appends a JsonPath with bracket notation', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+                const path2 = new JsonPath("$['baz-qux']");
+                const result = path1.appendPath(path2);
+                safeExpect(result.value).toEqual("$.foo.bar['baz-qux']");
+            });
+
+            it('appends to a path with bracket notation', () => {
+                const path1 = new JsonPath(TEST_PATHS.BAR_BAZ_HYPHENATED_FORMATTED);
+                const path2 = new JsonPath('$.qux');
+                const result = path1.appendPath(path2);
+                safeExpect(result.value).toEqual(TEST_PATHS.BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('appends a complex path to another complex path', () => {
+                const path1 = new JsonPath(TEST_PATHS.BAR_BAZ_HYPHENATED_FORMATTED);
+                const path2 = new JsonPath("$.qux['hello-world']");
+                const result = path1.appendPath(path2);
+                safeExpect(result.value).toEqual("$.foo['bar-baz'].qux['hello-world']");
+            });
+        });
+
+        describe('appending string paths', () => {
+            it('appends a string path to a JsonPath', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+                const result = path1.appendPath('baz.qux');
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('appends a simple string path', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const result = path1.appendPath('bar');
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_FORMATTED);
+            });
+
+            it('converts and appends a string path with special characters', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+                const result = path1.appendPath('baz-qux');
+                safeExpect(result.value).toEqual("$.foo.bar['baz-qux']");
+            });
+
+            it('converts and appends a string path with numbers', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+                const result = path1.appendPath('123.baz');
+                safeExpect(result.value).toEqual("$.foo.bar['123'].baz");
+            });
+
+            it('converts and appends a string path with UUIDs', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const result = path1.appendPath('123e4567-e89b-12d3-a456-426614174000');
+                safeExpect(result.value).toEqual("$.foo['123e4567-e89b-12d3-a456-426614174000']");
+            });
+
+            it('appends a multi-segment string path', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const result = path1.appendPath('bar.baz.qux');
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('appends a string path that already starts with $', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const result = path1.appendPath('$.bar.baz');
+                safeExpect(result.value).toEqual('$.foo.bar.baz');
+            });
+        });
+
+        describe('chaining multiple appends', () => {
+            it('chains multiple appendPath calls', () => {
+                const path = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const result = path.appendPath('bar').appendPath('baz').appendPath('qux');
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('chains appends with mixed types', () => {
+                const path = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const path2 = new JsonPath('$.bar');
+                const result = path.appendPath(path2).appendPath('baz').appendPath(new JsonPath('$.qux'));
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_BAZ_QUX_FORMATTED);
+            });
+
+            it('chains appends with special characters', () => {
+                const path = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+                const result = path.appendPath('bar-baz').appendPath('qux').appendPath('hello-world');
+                safeExpect(result.value).toEqual("$.foo['bar-baz'].qux['hello-world']");
+            });
+        });
+
+        describe('edge cases', () => {
+            it('appends an empty string', () => {
+                const path1 = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+                const result = path1.appendPath('');
+                safeExpect(result.value).toEqual('$.foo.bar.');
+            });
+
+            it('appends to root path', () => {
+                const path1 = new JsonPath('$');
+                const result = path1.appendPath(TEST_PATHS.SIMPLE_FOO_BAR);
+                safeExpect(result.value).toEqual(TEST_PATHS.FOO_BAR_FORMATTED);
+            });
+
+            it('appends to path ending with bracket notation', () => {
+                const path1 = new JsonPath(TEST_PATHS.BAR_BAZ_HYPHENATED_FORMATTED);
+                const result = path1.appendPath('qux.quux');
+                safeExpect(result.value).toEqual("$.foo['bar-baz'].qux.quux");
+            });
+        });
+    });
+
+    describe('toString', () => {
+        it('returns the string representation of the path', () => {
+            const path = new JsonPath(TEST_PATHS.FOO_BAR_BAZ_FORMATTED);
+            safeExpect(path.toString()).toEqual(TEST_PATHS.FOO_BAR_BAZ_FORMATTED);
+        });
+
+        it('returns the string representation of a path with bracket notation', () => {
+            const path = new JsonPath(TEST_PATHS.BAR_BAZ_QUX_FORMATTED);
+            safeExpect(path.toString()).toEqual(TEST_PATHS.BAR_BAZ_QUX_FORMATTED);
+        });
+
+        it('returns the string representation of a complex path', () => {
+            const path = new JsonPath("$.foo['123'].bar['456-abc']");
+            safeExpect(path.toString()).toEqual("$.foo['123'].bar['456-abc']");
+        });
+
+        it('returns the same value as the value property', () => {
+            const path = new JsonPath(TEST_PATHS.FOO_BAR_FORMATTED);
+            safeExpect(path.toString()).toEqual(path.value);
+        });
+    });
+
+    describe('integration tests', () => {
+        it('handles a real-world workflow path', () => {
+            const path = JsonPath.fromString('workflowTemplate.components.textField.value');
+            safeExpect(path.value).toEqual('$.workflowTemplate.components.textField.value');
+        });
+
+        it('handles a path with UUID identifiers', () => {
+            const path = JsonPath.fromString(
+                'channels.123e4567-e89b-12d3-a456-426614174000.workflowTemplates.987fcdeb-51a2-43e1-9876-543210fedcba'
+            );
+
+            safeExpect(path.value).toEqual(
+                "$.channels['123e4567-e89b-12d3-a456-426614174000'].workflowTemplates['987fcdeb-51a2-43e1-9876-543210fedcba']"
+            );
+        });
+
+        it('handles a path with array indices', () => {
+            const path = JsonPath.fromString('items.0.name');
+            safeExpect(path.value).toEqual("$.items['0'].name");
+        });
+
+        it('handles building a path incrementally', () => {
+            const base = JsonPath.fromString('workflowEntity');
+            const withComponent = base.appendPath('components');
+            const withField = withComponent.appendPath('date-field');
+            const withValue = withField.appendPath('value');
+
+            safeExpect(withValue.value).toEqual("$.workflowEntity.components['date-field'].value");
+        });
+
+        it('handles error paths with field names', () => {
+            const path = JsonPath.fromString('validation.errors.email-address.message');
+            safeExpect(path.value).toEqual("$.validation.errors['email-address'].message");
+        });
+
+        it('handles deeply nested object paths', () => {
+            const path = JsonPath.fromString('a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p');
+            safeExpect(path.value).toEqual('$.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p');
+        });
+
+        it('handles mixed notation in real-world scenario', () => {
+            const base = JsonPath.fromString('workflow.123e4567-e89b-12d3-a456-426614174000');
+            const result = base.appendPath('components.my-field.settings');
+
+            safeExpect(result.value).toEqual(
+                "$.workflow['123e4567-e89b-12d3-a456-426614174000'].components['my-field'].settings"
+            );
+        });
+    });
+
+    describe('RFC 9535 compliance', () => {
+        it('never produces dot before bracket notation', () => {
+            const testCases = [
+                { input: TEST_PATHS.FOO_BAR_BAZ_HYPHENATED, invalid: ".['", description: 'hyphenated segment' },
+                { input: 'foo.123', invalid: ".['", description: 'numeric segment' },
+                { input: 'foo.bar baz', invalid: ".['", description: 'segment with space' },
+                { input: 'foo.$bar', invalid: ".['", description: 'segment with dollar' },
+            ];
+
+            testCases.forEach(({ input, invalid, description }) => {
+                const path = JsonPath.fromString(input);
+                safeExpect(path.value).not.toContain(invalid);
+
+                if (path.value.includes(invalid)) {
+                    throw new Error(`Path "${input}" (${description}) produced invalid syntax: ${path.value}`);
+                }
+            });
+        });
+
+        it('produces valid bracket notation without preceding dots', () => {
+            const path = JsonPath.fromString('foo.bar-baz.qux');
+            safeExpect(path.value).toEqual(TEST_PATHS.BAR_BAZ_QUX_FORMATTED);
+            safeExpect(path.value.includes(".['")).toEqual(false);
+        });
+
+        it('produces paths that work with jsonpath library', () => {
+            const validPaths = [
+                JsonPath.fromString(TEST_PATHS.FOO_BAR_BAZ).value,
+                JsonPath.fromString(TEST_PATHS.FOO_BAR_BAZ_HYPHENATED).value,
+                JsonPath.fromString('foo.123.bar').value,
+                JsonPath.fromString('foo.123e4567-e89b-12d3-a456-426614174000').value,
+            ];
+
+            validPaths.forEach((path) => {
+                safeExpect(path.startsWith('$')).toEqual(true);
+                safeExpect(path.includes('.[')).toEqual(false);
+            });
+        });
+
+        it('handles first segment with special characters correctly', () => {
+            const path = JsonPath.fromString('123-start.foo');
+            safeExpect(path.value).toEqual("$['123-start'].foo");
+            safeExpect(path.value).not.toEqual("$.['123-start'].foo");
+        });
+
+        it('uses consistent notation throughout path', () => {
+            const path = JsonPath.fromString('foo.bar-baz.qux.hello-world.end');
+            const expected = "$.foo['bar-baz'].qux['hello-world'].end";
+            safeExpect(path.value).toEqual(expected);
+
+            safeExpect(path.value.includes(".['")).toEqual(false);
+            safeExpect(path.value.includes('][')).toEqual(false);
+        });
+
+        it('appended paths maintain RFC compliance', () => {
+            const base = new JsonPath(TEST_PATHS.FOO_FORMATTED);
+            const appended = base.appendPath(TEST_PATHS.BAR_BAZ_HYPHENATED).appendPath('qux');
+
+            safeExpect(appended.value).toEqual(TEST_PATHS.BAR_BAZ_QUX_FORMATTED);
+            safeExpect(appended.value.includes(".['")).toEqual(false);
+        });
+
+        it('handles complex real-world paths in RFC-compliant way', () => {
+            const path = JsonPath.fromString('workflowTemplate.components.email-field.validation.pattern');
+
+            safeExpect(path.value).toEqual("$.workflowTemplate.components['email-field'].validation.pattern");
+            safeExpect(path.value.includes(".['")).toEqual(false);
+        });
+    });
+});