@luvio/graphql-parser 0.126.0 → 0.126.2

package/src/__tests__/metaschema.spec.ts

@@ -1,230 +0,0 @@
-import { gql, referenceMap } from '../gql';
-import { metaschemaMapper } from '../metaschema';
-
-describe('metaschema mapper', () => {
-    it('should produce a equivalent metaschema AST when called with the legacy AST', () => {
-        const ref1 = gql`
-            query {
-                uiapi {
-                    query {
-                        Account(where: { Name: { like: "Account1" } }) @connection {
-                            edges {
-                                node @resource(type: "Record") {
-                                    Name {
-                                        value
-                                        displayValue
-                                    }
-                                }
-                            }
-                            ...conFragment
-                        }
-                    }
-                }
-            }
-
-            fragment conFragment on AccountConnection {
-                edges {
-                    node @resource(type: "Record") {
-                        CreatedBy @resource(type: "Record") {
-                            Id
-                            Name {
-                                value
-                                displayValue
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-
-        const doc1 = referenceMap.get(ref1);
-
-        const ref2 = gql`
-            query {
-                uiapi {
-                    query {
-                        Account(where: { Name: { like: "Account1" } })
-                            @category(name: "recordQuery") {
-                            edges {
-                                node {
-                                    Name {
-                                        value
-                                        displayValue
-                                    }
-                                }
-                            }
-                            ...conFragment
-                        }
-                    }
-                }
-            }
-
-            fragment conFragment on AccountConnection {
-                edges {
-                    node {
-                        CreatedBy @category(name: "parentRelationship") {
-                            Id
-                            Name {
-                                value
-                                displayValue
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc2 = referenceMap.get(ref2);
-
-        metaschemaMapper(doc1);
-
-        expect(doc1).toStrictEqual(doc2);
-    });
-
-    it('should produce a equivalent metaschema AST when query has multiple entities', () => {
-        const ref1 = gql`
-            query {
-                uiapi {
-                    query {
-                        TimeSheet @connection {
-                            edges {
-                                node @resource(type: "Record") {
-                                    CreatedBy @resource(type: "Record") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        User @connection {
-                            edges {
-                                node @resource(type: "Record") {
-                                    CreatedBy @resource(type: "Record") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc1 = referenceMap.get(ref1);
-
-        const ref2 = gql`
-            query {
-                uiapi {
-                    query {
-                        TimeSheet @category(name: "recordQuery") {
-                            edges {
-                                node {
-                                    CreatedBy @category(name: "parentRelationship") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        User @category(name: "recordQuery") {
-                            edges {
-                                node {
-                                    CreatedBy @category(name: "parentRelationship") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc2 = referenceMap.get(ref2);
-
-        metaschemaMapper(doc1);
-
-        expect(doc1).toStrictEqual(doc2);
-    });
-
-    it('should leave any non - legacy directives intact', () => {
-        const ref1 = gql`
-            query myQuery($var1: Boolean!, $var2: Boolean!) {
-                uiapi {
-                    query {
-                        TimeSheet @include(if: $var1) @connection {
-                            edges {
-                                node @resource(type: "Record") {
-                                    CreatedBy @resource(type: "Record") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        User @connection @skip(if: $var2) {
-                            edges {
-                                node @resource(type: "Record") {
-                                    CreatedBy @resource(type: "Record") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc1 = referenceMap.get(ref1);
-
-        const ref2 = gql`
-            query myQuery($var1: Boolean!, $var2: Boolean!) {
-                uiapi {
-                    query {
-                        TimeSheet @include(if: $var1) @category(name: "recordQuery") {
-                            edges {
-                                node {
-                                    CreatedBy @category(name: "parentRelationship") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        User @category(name: "recordQuery") @skip(if: $var2) {
-                            edges {
-                                node {
-                                    CreatedBy @category(name: "parentRelationship") {
-                                        Email {
-                                            value
-                                            displayValue
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-        const doc2 = referenceMap.get(ref2);
-
-        metaschemaMapper(doc1);
-
-        expect(doc1).toStrictEqual(doc2);
-    });
-});

package/src/__tests__/type-node.spec.ts

@@ -1,82 +0,0 @@
-import { NamedTypeNode, TypeNode } from 'graphql/language';
-import { transform } from '../type-node';
-
-describe('Luvio GraphQL TypeNode transform', () => {
-    it('returns LuvioTypeNode when input is GraphQL NamedTypeNode', () => {
-        expect(
-            transform({
-                kind: 'NamedType',
-                name: {
-                    kind: 'Name',
-                    value: 'test',
-                },
-            })
-        ).toStrictEqual({
-            kind: 'NamedType',
-            name: 'test',
-        });
-    });
-
-    it('returns LuvioTypeNode when input is GraphQL ListTypeNode', () => {
-        expect(
-            transform({
-                kind: 'ListType',
-                type: {
-                    kind: 'NamedType',
-                    name: {
-                        kind: 'Name',
-                        value: 'test',
-                    },
-                },
-            })
-        ).toStrictEqual({
-            kind: 'ListType',
-            type: {
-                kind: 'NamedType',
-                name: 'test',
-            },
-        });
-    });
-
-    it('returns LuvioTypeNode when input is GraphQL NonNullTypeNode', () => {
-        expect(
-            transform({
-                kind: 'NonNullType',
-                type: {
-                    kind: 'NamedType',
-                    name: {
-                        kind: 'Name',
-                        value: 'test',
-                    },
-                },
-            })
-        ).toStrictEqual({
-            kind: 'NonNullType',
-            type: {
-                kind: 'NamedType',
-                name: 'test',
-            },
-        });
-    });
-
-    it('throws when input is unsupported TypeNode', () => {
-        expect(() =>
-            transform({
-                kind: 'Unknown',
-                name: 'test',
-            } as unknown as TypeNode)
-        ).toThrowError('Unsupported TypeNode');
-    });
-
-    it('throws when input is unsupported NonNullTypeNode', () => {
-        expect(() =>
-            transform({
-                kind: 'NonNullType',
-                type: {
-                    kind: 'Unknown',
-                    name: 'test',
-                } as unknown as NamedTypeNode,
-            })
-        ).toThrowError('Unsupported NonNullTypeNode');
-    });
-});

package/src/argument-node.ts

@@ -1,18 +0,0 @@
-import type { ArgumentNode } from 'graphql/language';
-import type { LuvioArgumentNode } from './ast';
-import type { TransformState } from './operation/query';
-import { transform as transformValueNode } from './value-node';
-
-export function transform(node: ArgumentNode, transformState: TransformState): LuvioArgumentNode {
-    const {
-        kind,
-        name: { value: nodeName },
-        value: nodeValue,
-    } = node;
-    const valueNode = transformValueNode(nodeValue, transformState);
-    return {
-        kind,
-        name: nodeName,
-        value: valueNode,
-    };
-}

package/src/ast.ts

@@ -1,200 +0,0 @@
-import type {
-    DocumentNode,
-    OperationDefinitionNode,
-    FieldNode,
-    ArgumentNode,
-    IntValueNode,
-    ListValueNode,
-    ObjectValueNode,
-    FloatValueNode,
-    StringValueNode,
-    BooleanValueNode,
-    NullValueNode,
-    EnumValueNode,
-    VariableNode,
-    DirectiveNode,
-    VariableDefinitionNode,
-    NonNullTypeNode,
-    ListTypeNode,
-    NamedTypeNode,
-    FragmentSpreadNode,
-    InlineFragmentNode,
-    FragmentDefinitionNode,
-    DefinitionNode,
-    TypeNode,
-} from 'graphql/language';
-
-/**
- * Luvio specific custom GraphQL AST
- *
- * - Omit Location
- * - flatten NameNode for easier value access
- * - Add luvioSelections for custom selections
- * - LuvioSelectionCustomFieldNode for fields with custom client side directives
- */
-
-/* Document */
-export interface LuvioDocumentNode extends Omit<DocumentNode, 'loc' | 'definitions'> {
-    definitions: LuvioDefinitionNode[];
-}
-
-export type LuvioDefinitionNode = LuvioOperationDefinitionNode | LuvioFragmentDefinitionNode;
-
-export interface LuvioOperationDefinitionNode
-    extends Omit<
-        OperationDefinitionNode,
-        'loc' | 'name' | 'variableDefinitions' | 'directives' | 'selectionSet'
-    > {
-    name?: string;
-    variableDefinitions?: LuvioVariableDefinitionNode[];
-    directives?: LuvioDirectiveNode[];
-    luvioSelections: LuvioSelectionNode[];
-}
-
-export interface LuvioVariableDefinitionNode
-    extends Omit<
-        VariableDefinitionNode,
-        'loc' | 'variable' | 'type' | 'defaultValue' | 'directives'
-    > {
-    variable: LuvioVariableNode;
-    type: LuvioTypeNode;
-    defaultValue?: LuvioValueNode;
-    directives?: LuvioDirectiveNode[];
-}
-
-export interface LuvioVariableNode extends Omit<VariableNode, 'loc' | 'name'> {
-    name: string;
-}
-
-export type LuvioSelectionNode = LuvioFieldNode | LuvioFragmentSpreadNode | LuvioInlineFragmentNode;
-
-export type LuvioFieldNode =
-    | LuvioSelectionScalarFieldNode
-    | LuvioSelectionObjectFieldNode
-    | LuvioSelectionCustomFieldNode;
-
-export interface LuvioArgumentNode extends Omit<ArgumentNode, 'loc' | 'name' | 'value'> {
-    name: string;
-    value: LuvioValueNode;
-}
-
-/* Fragments */
-export interface LuvioFragmentSpreadNode
-    extends Omit<FragmentSpreadNode, 'loc' | 'name' | 'directives'> {
-    name: string;
-    directives?: LuvioDirectiveNode[];
-}
-
-export interface LuvioInlineFragmentNode
-    extends Omit<InlineFragmentNode, 'loc' | 'typeCondition' | 'directives' | 'selectionSet'> {
-    typeCondition?: LuvioNamedTypeNode;
-    directives?: LuvioDirectiveNode[];
-    luvioSelections: LuvioSelectionNode[];
-}
-
-export interface LuvioFragmentDefinitionNode
-    extends Omit<
-        FragmentDefinitionNode,
-        'loc' | 'name' | 'variableDefinitions' | 'typeCondition' | 'directives' | 'selectionSet'
-    > {
-    name: string;
-    // Note: fragment variable definitions are experimental and may be changed
-    // or removed in the future.
-    variableDefinitions?: LuvioVariableDefinitionNode[];
-    typeCondition: LuvioNamedTypeNode;
-    directives?: LuvioDirectiveNode[];
-    luvioSelections: LuvioSelectionNode[];
-}
-
-/* Values */
-export type LuvioValueNode =
-    | LuvioVariableNode
-    | IntValueNode
-    | FloatValueNode
-    | StringValueNode
-    | BooleanValueNode
-    | NullValueNode
-    | EnumValueNode
-    | LuvioListValueNode
-    | LuvioObjectValueNode;
-
-export interface LuvioListValueNode extends Omit<ListValueNode, 'loc' | 'values'> {
-    values: LuvioValueNode[];
-}
-
-export interface LuvioObjectValueNode extends Omit<ObjectValueNode, 'loc' | 'fields'> {
-    fields: {
-        [name: string]: LuvioValueNode;
-    };
-}
-
-/* Directives */
-export interface LuvioDirectiveNode extends Omit<DirectiveNode, 'loc' | 'name' | 'arguments'> {
-    name: string;
-    arguments?: LuvioArgumentNode[];
-}
-
-/* Type Reference */
-export type LuvioTypeNode = LuvioNamedTypeNode | LuvioListTypeNode | LuvioNonNullTypeNode;
-
-export interface LuvioNamedTypeNode extends Omit<NamedTypeNode, 'loc' | 'name'> {
-    name: string;
-}
-
-export interface LuvioListTypeNode extends Omit<ListTypeNode, 'loc' | 'type'> {
-    type: LuvioTypeNode;
-}
-
-export interface LuvioNonNullTypeNode extends Omit<NonNullTypeNode, 'loc' | 'type'> {
-    type: LuvioNamedTypeNode | LuvioListTypeNode;
-}
-
-/* Custom Selection Fields */
-export interface LuvioSelectionScalarFieldNode
-    extends Omit<
-        FieldNode,
-        'kind' | 'loc' | 'alias' | 'name' | 'arguments' | 'directives' | 'selectionSet'
-    > {
-    kind: 'ScalarFieldSelection';
-    alias?: string;
-    name: string;
-}
-
-export interface LuvioSelectionObjectFieldNode
-    extends Omit<
-        FieldNode,
-        'kind' | 'loc' | 'alias' | 'name' | 'arguments' | 'directives' | 'selectionSet'
-    > {
-    kind: 'ObjectFieldSelection';
-    alias?: string;
-    name: string;
-    arguments?: LuvioArgumentNode[];
-    directives?: LuvioDirectiveNode[];
-    luvioSelections?: LuvioSelectionNode[];
-}
-
-export interface LuvioSelectionCustomFieldNode extends Omit<LuvioSelectionObjectFieldNode, 'kind'> {
-    kind: 'CustomFieldSelection';
-    type: string;
-}
-
-/* Util Functions */
-export function isOperationDefinitionNode(input: DefinitionNode): input is OperationDefinitionNode {
-    return input.kind === 'OperationDefinition';
-}
-
-export function isFragmentDefinitionNode(input: DefinitionNode): input is FragmentDefinitionNode {
-    return input.kind === 'FragmentDefinition';
-}
-
-export function isNamedTypeNode(input: TypeNode): input is NamedTypeNode {
-    return input.kind === 'NamedType';
-}
-
-export function isListTypeNode(input: TypeNode): input is ListTypeNode {
-    return input.kind === 'ListType';
-}
-
-export function isNonNullTypeNode(input: TypeNode): input is NonNullTypeNode {
-    return input.kind === 'NonNullType';
-}

package/src/constants.ts

@@ -1,14 +0,0 @@
-export const CUSTOM_DIRECTIVE_CONNECTION = 'connection';
-export const CUSTOM_DIRECTIVE_RESOURCE = 'resource';
-
-export const NODE_KIND_CUSTOM_FIELD_SELECTION = 'CustomFieldSelection';
-export const NODE_KIND_FIELD = 'Field';
-export const NODE_KIND_FRAGMENT_SPREAD = 'FragmentSpread';
-export const NODE_KIND_INLINE_FRAGMENT = 'InlineFragment';
-export const NODE_KIND_LIST_TYPE = 'ListType';
-export const NODE_KIND_NAMED_TYPE = 'NamedType';
-export const NODE_KIND_NON_NULL_TYPE = 'NonNullType';
-export const NODE_KIND_OBJECT_FIELD_SELECTION = 'ObjectFieldSelection';
-export const NODE_KIND_SCALAR_FIELD_SELECTION = 'ScalarFieldSelection';
-
-export const NODE_TYPE_CONNECTION = 'Connection';

package/src/directive-node.ts

@@ -1,36 +0,0 @@
-import type { DirectiveNode } from 'graphql/language';
-import type { LuvioArgumentNode, LuvioDirectiveNode } from './ast';
-import { transform as transformArgumentNode } from './argument-node';
-import { CUSTOM_DIRECTIVE_CONNECTION, CUSTOM_DIRECTIVE_RESOURCE } from './constants';
-import type { TransformState } from './operation/query';
-
-export function transform(node: DirectiveNode, transformState: TransformState): LuvioDirectiveNode {
-    const {
-        kind,
-        name: { value: nodeName },
-        arguments: nodeArguments,
-    } = node;
-    const ret: LuvioDirectiveNode = {
-        kind,
-        name: nodeName,
-    };
-
-    if (nodeArguments !== undefined && nodeArguments.length > 0) {
-        let returnArguments: LuvioArgumentNode[] = [];
-        for (var index = 0; index < nodeArguments.length; index++) {
-            const argumentNode = nodeArguments[index];
-            const value = transformArgumentNode(argumentNode, transformState);
-            returnArguments.push(value);
-        }
-        ret.arguments = returnArguments;
-    }
-
-    return ret;
-}
-
-export function isCustomDirective(node: DirectiveNode): boolean {
-    return (
-        node.name.value === CUSTOM_DIRECTIVE_CONNECTION ||
-        node.name.value === CUSTOM_DIRECTIVE_RESOURCE
-    );
-}

package/src/document.ts

@@ -1,29 +0,0 @@
-import type { DocumentNode } from 'graphql/language';
-import type { LuvioDocumentNode, LuvioDefinitionNode } from './ast';
-import { isOperationDefinitionNode, isFragmentDefinitionNode } from './ast';
-import { transform as operationDefinitionTransform } from './operation';
-import { transform as fragmentDefinitionTransform } from './fragment';
-
-export function transform(root: DocumentNode): LuvioDocumentNode {
-    const { kind, definitions } = root;
-    const luvioDefinitions: LuvioDefinitionNode[] = [];
-    for (let i = 0; i < definitions.length; i++) {
-        const definition = definitions[i];
-        if (isOperationDefinitionNode(definition)) {
-            luvioDefinitions.push(operationDefinitionTransform(definition));
-        } else if (isFragmentDefinitionNode(definition)) {
-            luvioDefinitions.push(fragmentDefinitionTransform(definition));
-        } else {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(
-                    `Unsupported ${definition.kind} definition. Only OperationDefinition and FragmentDefinition are supported in a GraphQL Document`
-                );
-            }
-        }
-    }
-
-    return {
-        kind,
-        definitions: luvioDefinitions,
-    };
-}

package/src/field-node.ts

@@ -1,72 +0,0 @@
-import type { FieldNode, StringValueNode } from 'graphql/language';
-import { transform as transformArgumentNode } from './argument-node';
-import type { LuvioArgumentNode, LuvioFieldNode } from './ast';
-import {
-    CUSTOM_DIRECTIVE_CONNECTION,
-    CUSTOM_DIRECTIVE_RESOURCE,
-    NODE_KIND_CUSTOM_FIELD_SELECTION,
-    NODE_KIND_OBJECT_FIELD_SELECTION,
-    NODE_KIND_SCALAR_FIELD_SELECTION,
-    NODE_TYPE_CONNECTION,
-} from './constants';
-import { isCustomDirective, transform as transformDirectiveNode } from './directive-node';
-import type { TransformState } from './operation/query';
-
-export function transform(node: FieldNode, transformState: TransformState): LuvioFieldNode {
-    const { name, alias, arguments: fieldArgs, selectionSet, directives } = node;
-
-    let luvioNode: LuvioFieldNode = {
-        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
-        name: name.value,
-        luvioSelections: [],
-    };
-
-    if (selectionSet === undefined || selectionSet.selections.length === 0) {
-        luvioNode = {
-            kind: NODE_KIND_SCALAR_FIELD_SELECTION,
-            name: name.value,
-        };
-    } else {
-        // object or custom field node
-        if (directives !== undefined && directives.length > 0) {
-            const customDirectiveNode = directives.find(isCustomDirective);
-            if (customDirectiveNode === undefined) {
-                // transform non client-side directives
-                luvioNode.directives = directives.map((directive) =>
-                    transformDirectiveNode(directive, transformState)
-                );
-            } else {
-                if (customDirectiveNode.name.value === CUSTOM_DIRECTIVE_CONNECTION) {
-                    luvioNode = {
-                        kind: NODE_KIND_CUSTOM_FIELD_SELECTION,
-                        name: name.value,
-                        type: NODE_TYPE_CONNECTION,
-                        luvioSelections: [],
-                    };
-                } else if (customDirectiveNode.name.value === CUSTOM_DIRECTIVE_RESOURCE) {
-                    luvioNode = {
-                        kind: NODE_KIND_CUSTOM_FIELD_SELECTION,
-                        name: name.value,
-                        type: (customDirectiveNode!.arguments![0].value as StringValueNode).value,
-                        luvioSelections: [],
-                    };
-                }
-            }
-        }
-
-        if (fieldArgs !== undefined && fieldArgs.length > 0) {
-            const returnArguments: LuvioArgumentNode[] = [];
-            for (var index = 0; index < fieldArgs.length; index++) {
-                const value = transformArgumentNode(fieldArgs[index], transformState);
-                returnArguments.push(value);
-            }
-            luvioNode.arguments = returnArguments;
-        }
-    }
-
-    if (alias !== undefined) {
-        luvioNode.alias = alias.value;
-    }
-
-    return luvioNode;
-}