@luvio/graphql-parser 0.97.1 → 0.99.1

package/src/__tests__/gql.spec.ts

@@ -0,0 +1,684 @@
+import {
+    gql,
+    docMap,
+    astResolver,
+    processSubstitutions,
+    stripLocation,
+    addMetaschemaDirectives,
+    enableAddMetaschemaDirective,
+    disableAddMetaschemaDirective,
+} from '../gql';
+import ast from './ast.json';
+import astNoLoc from './astNoLoc.json';
+
+var mockParse;
+
+jest.mock('graphql/language', () => {
+    const originalModule = jest.requireActual('graphql/language');
+    // we keep the original behavior, just wrapping it with a mock so we can spy
+    mockParse = jest.fn().mockImplementation((source, options) => {
+        return originalModule.parse(source, options);
+    });
+
+    return {
+        __esModule: true,
+        ...originalModule,
+        parse: mockParse,
+    };
+});
+
+const testProcessSubstitution = (literals: any, ...args: any[]) => {
+    return processSubstitutions(literals, args);
+};
+
+beforeEach(() => {
+    jest.clearAllMocks();
+    docMap.clear();
+});
+
+const mockFragment1 = `fragment fragmentName1 on SomeType1 { someField1 }`;
+const mockFragment2 = `fragment fragmentName2 on SomeType2 { someField2 }`;
+const mockTwoFragments = `${mockFragment1} ${mockFragment2}`;
+
+describe('processSubstitutions', () => {
+    it('should return correct operation string when no substitution is present', () => {
+        const result = testProcessSubstitution/* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+
+        expect(result.operationString.trim()).toBe(
+            /* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `.trim()
+        );
+        expect(result.fragments).toStrictEqual([]);
+    });
+
+    it('should substitute strings correctly in the operation string', () => {
+        const field = `Contact`;
+        const subField = `displayName`;
+        const result = testProcessSubstitution/* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                        ${subField}
+                                    }
+                                    ${field}
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+
+        expect(result.operationString.trim()).toBe(
+            /* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                        displayName
+                                    }
+                                    Contact
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `.trim()
+        );
+        expect(result.fragments).toStrictEqual([]);
+    });
+
+    it('should return correct operation string and fragments', () => {
+        const fragment = gql(mockFragment1);
+        const result = testProcessSubstitution/* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                    ...fragmentName1
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            ${fragment}
+        `;
+
+        expect(result.operationString.trim()).toBe(
+            /* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                    ...fragmentName1
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `.trim()
+        );
+
+        expect(result.fragments.length).toBe(1);
+        expect(result.fragments[0].kind).toBe('FragmentDefinition');
+    });
+
+    it('should return correct operation string and fragments when has multiple fragments in one substitute', () => {
+        const fragment = gql(mockTwoFragments);
+        const result = testProcessSubstitution/* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                    ...fragmentName1
+                                    ...fragmentName2
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            ${fragment}
+        `;
+
+        expect(result.operationString.trim()).toBe(
+            /* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                    ...fragmentName1
+                                    ...fragmentName2
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `.trim()
+        );
+
+        expect(result.fragments.length).toBe(2);
+        expect(result.fragments[0].kind).toBe('FragmentDefinition');
+        expect(result.fragments[0].name.value).toBe('fragmentName1');
+        expect(result.fragments[1].kind).toBe('FragmentDefinition');
+        expect(result.fragments[1].name.value).toBe('fragmentName2');
+    });
+
+    it('should return correct operation string and fragments when both type of substitutions are present', () => {
+        const field = `Contact`;
+        const subField = `displayValue`;
+        const fragment1 = gql(mockFragment1);
+        const fragment2 = gql(mockFragment2);
+
+        const result = testProcessSubstitution/* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                        ${subField}
+                                    }
+                                    ${field}
+                                    ...fragmentName1
+                                    ...fragmentName2
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            ${fragment1}
+            ${fragment2}
+        `;
+
+        expect(result.operationString.trim()).toBe(
+            /* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                        displayValue
+                                    }
+                                    Contact
+                                    ...fragmentName1
+                                    ...fragmentName2
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `.trim()
+        );
+        expect(result.fragments.length).toBe(2);
+        expect(result.fragments[0].kind).toBe('FragmentDefinition');
+        expect(result.fragments[1].kind).toBe('FragmentDefinition');
+    });
+
+    it('should throw if the fragment document is not found', () => {
+        expect(() => {
+            return testProcessSubstitution/* GraphQL */ `
+                query accounts {
+                    uiapi {
+                        query {
+                            Account {
+                                edges {
+                                    node {
+                                        Id
+                                        Name {
+                                            value
+                                        }
+                                        ...fragmentName1
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                ${{}}
+            `;
+        }).toThrowError('Invalid substitution fragment');
+    });
+
+    it('should throw if an unsupported substitution is found', () => {
+        expect(() => {
+            return testProcessSubstitution/* GraphQL */ `
+                query accounts {
+                    uiapi {
+                        query {
+                            Account {
+                                edges {
+                                    node {
+                                        Id
+                                        Name {
+                                            value
+                                        }
+                                        ...fragmentName1
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                ${true}
+            `;
+        }).toThrowError('Unsupported substitution type');
+    });
+});
+
+describe('gql', () => {
+    it(`should call the parsing api when response isn't cached`, () => {
+        const ref = gql`
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+        const doc = astResolver(ref);
+
+        expect(mockParse).toHaveBeenCalledTimes(1);
+        expect(doc.kind).toEqual('Document');
+    });
+
+    it(`should call the parsing api when query is passed as an argument and isn't cached`, () => {
+        const ref = gql(/* GraphQL */ `
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `);
+        const doc = astResolver(ref);
+
+        expect(mockParse).toHaveBeenCalledTimes(1);
+        expect(doc.kind).toEqual('Document');
+    });
+
+    it('should get the document from cache when same query is passed again', () => {
+        // Populate doc map cache
+        const ref1 = gql`
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+
+        const ref2 = gql`
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+        const doc1 = astResolver(ref1);
+        const doc2 = astResolver(ref2);
+
+        expect(mockParse).toHaveBeenCalledTimes(1);
+        expect(doc2.kind).toEqual('Document');
+        expect(doc1).toBe(doc2);
+    });
+
+    it('should get the document from cache when we get a semantically similar query again', () => {
+        // Populate doc map cache
+        const ref1 = gql`
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                        displayValue
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+
+        const ref2 = gql`
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    # This is a comment
+                                    Id
+
+                                    Name {
+                                        value
+                                        displayValue
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+        const doc1 = astResolver(ref1);
+        const doc2 = astResolver(ref2);
+
+        expect(mockParse).toHaveBeenCalledTimes(1);
+        expect(doc2.kind).toEqual('Document');
+        expect(doc1).toBe(doc2);
+    });
+
+    it('should return the document with appended substitutions', () => {
+        const field = `Contact`;
+        const fragment = gql(mockFragment1);
+        const ref = gql`
+            query accounts {
+                uiapi {
+                    query {
+                        Account {
+                            edges {
+                                node {
+                                    Id
+                                    Name {
+                                        value
+                                    }
+                                    ${field}
+                                    ...ReusableFragment1
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            ${fragment}
+        `;
+        const doc = astResolver(ref);
+        const fragmentDoc = astResolver(fragment);
+
+        expect(mockParse).toHaveBeenCalledTimes(2);
+        expect(fragmentDoc.kind).toBe('Document');
+        expect(fragmentDoc.definitions.length).toBe(1);
+        expect(doc.kind).toBe('Document');
+        expect(doc.definitions.length).toBe(2);
+        expect(doc.definitions[0].kind).toBe('OperationDefinition');
+        expect(doc.definitions[1].kind).toBe('FragmentDefinition');
+    });
+
+    describe('invalid queries', () => {
+        it('should return null in case of an invalid query - in prod', () => {
+            process.env.NODE_ENV = 'production';
+            try {
+                expect(gql(undefined)).toEqual(null);
+                expect(mockParse).not.toHaveBeenCalled();
+            } finally {
+                process.env.NODE_ENV = 'test';
+            }
+        });
+
+        it('should throw in case of an undefined query', () => {
+            // eslint-disable-next-line no-unused-expressions
+            expect(() => gql(undefined)).toThrowError('Invalid query');
+            expect(mockParse).not.toHaveBeenCalled();
+        });
+
+        it('should throw in case of an invalid query', () => {
+            // eslint-disable-next-line no-unused-expressions
+            expect(() => gql``).toThrowError('Invalid query');
+            expect(mockParse).not.toHaveBeenCalled();
+        });
+
+        it('should return null in case of an invalid query - prod', () => {
+            process.env.NODE_ENV = 'production';
+            try {
+                expect(gql``).toBe(null);
+                expect(mockParse).not.toHaveBeenCalled();
+            } finally {
+                process.env.NODE_ENV = 'test';
+            }
+        });
+
+        it('should throw in case a substitution reference is invalid', () => {
+            const sub = '';
+            expect(
+                () => gql`
+                query accounts {
+                    uiapi {
+                        query {
+                            Account {
+                                edges {
+                                    node {
+                                        Id
+                                        Name {
+                                            value
+                                        }
+                                        ${sub}
+                                        ...someFragment
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            ${{}}
+            `
+            ).toThrow(`Invalid substitution fragment`);
+            expect(mockParse).not.toHaveBeenCalled();
+        });
+
+        it('should return null when in production environment and passed an invalid reference', () => {
+            process.env.NODE_ENV = 'production';
+            try {
+                const ref = gql`
+                    query accounts {
+                        uiapi {
+                            query {
+                                Account {
+                                    edges {
+                                        node {
+                                            Id
+                                            Name {
+                                                value
+                                            }
+                                            ...someFragment
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    ${{}}
+                `;
+
+                expect(ref).toBe(null);
+            } finally {
+                process.env.NODE_ENV = 'test';
+            }
+        });
+
+        it('should return null when in production environment and parsed document is invalid', () => {
+            process.env.NODE_ENV = 'production';
+            try {
+                mockParse.mockImplementation(() => ({}));
+                const ref = gql`
+                    query accounts {
+                        uiapi {
+                            query {
+                                Account {
+                                    edges {
+                                        node {
+                                            Id
+                                            Name {
+                                                value
+                                            }
+                                            ...someFragment
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                `;
+                expect(ref).toBe(null);
+            } finally {
+                process.env.NODE_ENV = 'test';
+            }
+        });
+    });
+});
+
+describe('stripLocation', () => {
+    it('should remove all loc references from the doc', () => {
+        const doc = stripLocation({
+            loc: 1,
+            arr: [{ loc: 2, a: 3 }],
+            obj: { b: 4, loc: {} },
+            noLoc: 5,
+        });
+
+        expect(doc).toStrictEqual({ arr: [{ a: 3 }], obj: { b: 4 }, noLoc: 5 });
+    });
+
+    it('should remove all loc references from the doc and deeply nested objects', () => {
+        const doc = stripLocation(ast);
+
+        expect(doc).toStrictEqual(astNoLoc);
+    });
+});
+
+describe('addMetaschemaDirectives', () => {
+    it('flips', () => {
+        expect(addMetaschemaDirectives).toBe(false);
+        enableAddMetaschemaDirective();
+        expect(addMetaschemaDirectives).toBe(true);
+        disableAddMetaschemaDirective();
+        expect(addMetaschemaDirectives).toBe(false);
+    });
+});