@luvio/graphql-parser 0.62.2

package/src/argument-node.ts

@@ -0,0 +1,18 @@
+import { ArgumentNode } from 'graphql/language';
+import { LuvioArgumentNode } from './ast';
+import { 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

@@ -0,0 +1,200 @@
+import {
+    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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,36 @@
+import { DirectiveNode } from 'graphql/language';
+import { LuvioArgumentNode, LuvioDirectiveNode } from './ast';
+import { transform as transformArgumentNode } from './argument-node';
+import { CUSTOM_DIRECTIVE_CONNECTION, CUSTOM_DIRECTIVE_RESOURCE } from './constants';
+import { 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

@@ -0,0 +1,33 @@
+import { DocumentNode } from 'graphql/language';
+import {
+    LuvioDocumentNode,
+    LuvioDefinitionNode,
+    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

@@ -0,0 +1,72 @@
+import { FieldNode, StringValueNode } from 'graphql/language';
+import { transform as transformArgumentNode } from './argument-node';
+import { 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 { 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;
+}

package/src/fragment-spread-node.ts

@@ -0,0 +1,28 @@
+import { FragmentSpreadNode } from 'graphql/language';
+import { LuvioFragmentSpreadNode } from './ast';
+import { transform as transformDirectiveNode } from './directive-node';
+import { TransformState } from './operation/query';
+
+export function transform(
+    node: FragmentSpreadNode,
+    transformState: TransformState
+): LuvioFragmentSpreadNode {
+    const {
+        kind,
+        name: { value },
+        directives,
+    } = node;
+
+    const luvioNode: LuvioFragmentSpreadNode = {
+        kind,
+        name: value,
+    };
+
+    if (directives !== undefined && directives.length > 0) {
+        luvioNode.directives = directives.map((directive) =>
+            transformDirectiveNode(directive, transformState)
+        );
+    }
+
+    return luvioNode;
+}

package/src/fragment.ts

@@ -0,0 +1,46 @@
+import { FragmentDefinitionNode } from 'graphql/language';
+import { LuvioFieldNode, LuvioFragmentDefinitionNode, LuvioSelectionNode } from './ast';
+import { selectionSetVisitor } from './visitor';
+import { transform as transformDirectiveNode } from './directive-node';
+import { NODE_KIND_OBJECT_FIELD_SELECTION } from './constants';
+
+export function transform(node: FragmentDefinitionNode): LuvioFragmentDefinitionNode {
+    const {
+        kind: nodeKind,
+        name: { value: nodeName },
+        typeCondition: {
+            kind: typeKind,
+            name: { value: typeName },
+        },
+        directives,
+    } = node;
+
+    // dummy root node
+    const fragmentRoot: LuvioFieldNode = {
+        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
+        name: 'fragment',
+        luvioSelections: [],
+    };
+    const currentNodePath: LuvioSelectionNode[] = [fragmentRoot];
+
+    const transformState = { variablesUsed: {} };
+    selectionSetVisitor(node, currentNodePath, transformState);
+
+    const luvioNode: LuvioFragmentDefinitionNode = {
+        kind: nodeKind,
+        name: nodeName,
+        typeCondition: {
+            kind: typeKind,
+            name: typeName,
+        },
+        luvioSelections: fragmentRoot.luvioSelections!,
+    };
+
+    if (directives !== undefined && directives.length > 0) {
+        luvioNode.directives = directives.map((node) =>
+            transformDirectiveNode(node, transformState)
+        );
+    }
+
+    return luvioNode;
+}

package/src/inline-fragment-node.ts

@@ -0,0 +1,31 @@
+import { InlineFragmentNode } from 'graphql/language';
+import { LuvioInlineFragmentNode } from './ast';
+import { transform as transformDirectiveNode } from './directive-node';
+import { TransformState } from './operation/query';
+
+export function transform(
+    node: InlineFragmentNode,
+    transformState: TransformState
+): LuvioInlineFragmentNode {
+    const { kind: nodeKind, typeCondition, directives } = node;
+
+    const luvioNode: LuvioInlineFragmentNode = {
+        kind: nodeKind,
+        luvioSelections: [],
+    };
+
+    if (typeCondition !== undefined) {
+        luvioNode.typeCondition = {
+            kind: typeCondition.kind,
+            name: typeCondition.name.value,
+        };
+    }
+
+    if (directives !== undefined && directives.length > 0) {
+        luvioNode.directives = directives.map((directive) =>
+            transformDirectiveNode(directive, transformState)
+        );
+    }
+
+    return luvioNode;
+}

package/src/main.ts

@@ -0,0 +1,58 @@
+import {
+    parse,
+    BooleanValueNode,
+    FloatValueNode,
+    IntValueNode,
+    StringValueNode,
+} from 'graphql/language';
+import {
+    LuvioDocumentNode,
+    LuvioArgumentNode,
+    LuvioDefinitionNode,
+    LuvioObjectValueNode,
+    LuvioOperationDefinitionNode,
+    LuvioSelectionCustomFieldNode,
+    LuvioSelectionNode,
+    LuvioSelectionObjectFieldNode,
+    LuvioSelectionScalarFieldNode,
+    LuvioValueNode,
+    LuvioFieldNode,
+    LuvioVariableDefinitionNode,
+    LuvioVariableNode,
+    LuvioNamedTypeNode,
+    LuvioListTypeNode,
+    LuvioListValueNode,
+    LuvioTypeNode,
+} from './ast';
+import { transform } from './document';
+
+export function parseAndVisit(source: string): LuvioDocumentNode {
+    // TODO: handle generic <Type>
+    const ast = parse(source);
+    return transform(ast);
+}
+
+// type exports
+export {
+    BooleanValueNode,
+    FloatValueNode,
+    IntValueNode,
+    StringValueNode,
+    LuvioDocumentNode,
+    LuvioArgumentNode,
+    LuvioDefinitionNode,
+    LuvioObjectValueNode,
+    LuvioOperationDefinitionNode,
+    LuvioSelectionCustomFieldNode,
+    LuvioSelectionNode,
+    LuvioSelectionObjectFieldNode,
+    LuvioSelectionScalarFieldNode,
+    LuvioValueNode,
+    LuvioFieldNode,
+    LuvioVariableDefinitionNode,
+    LuvioVariableNode,
+    LuvioNamedTypeNode,
+    LuvioListTypeNode,
+    LuvioListValueNode,
+    LuvioTypeNode,
+};

package/src/operation/index.ts

@@ -0,0 +1,12 @@
+import { OperationDefinitionNode } from 'graphql/language';
+import { LuvioOperationDefinitionNode } from '../ast';
+import { transform as QueryTransform } from './query';
+
+export function transform(node: OperationDefinitionNode): LuvioOperationDefinitionNode {
+    const { operation } = node;
+    if (operation === 'query') {
+        return QueryTransform(node);
+    }
+
+    throw new Error(`Unsupported ${operation} operation. Only query operation is supported`);
+}

package/src/operation/query/index.ts

@@ -0,0 +1,78 @@
+import { OperationDefinitionNode, VariableDefinitionNode } from 'graphql/language';
+import { LuvioFieldNode, LuvioOperationDefinitionNode, LuvioSelectionNode } from '../../ast';
+import { selectionSetVisitor } from '../../visitor';
+import { transform as transformVariableDefinition } from '../../variable-definition';
+import { transform as transformDirectiveNode } from '../../directive-node';
+
+export interface TransformState {
+    variablesUsed: Record<string, true>;
+}
+
+export function transform(node: OperationDefinitionNode): LuvioOperationDefinitionNode {
+    const queryRoot: LuvioFieldNode = {
+        kind: 'ObjectFieldSelection',
+        name: 'query',
+        luvioSelections: [],
+    };
+    const currentNodePath: LuvioSelectionNode[] = [queryRoot];
+
+    const transformState = {
+        variablesUsed: {},
+    };
+    selectionSetVisitor(node, currentNodePath, transformState);
+
+    const operationDefinition: LuvioOperationDefinitionNode = {
+        kind: 'OperationDefinition',
+        operation: 'query',
+        luvioSelections: queryRoot.luvioSelections!,
+    };
+
+    if (node.name !== undefined) {
+        operationDefinition.name = node.name.value;
+    }
+
+    const { variableDefinitions, directives } = node;
+    if (variableDefinitions !== undefined && variableDefinitions.length > 0) {
+        operationDefinition.variableDefinitions = variableDefinitions.map((variableDefinition) =>
+            transformVariableDefinition(variableDefinition, transformState)
+        );
+    }
+
+    if (directives !== undefined && directives.length > 0) {
+        operationDefinition.directives = directives.map((node) =>
+            transformDirectiveNode(node, transformState)
+        );
+    }
+
+    validateVariables(variableDefinitions, transformState);
+
+    return operationDefinition;
+}
+
+function validateVariables(
+    variableDefinitions: readonly VariableDefinitionNode[] | undefined,
+    transformState: TransformState
+) {
+    const variablesDefined: Record<string, true> = {};
+
+    if (variableDefinitions !== undefined) {
+        for (let i = 0, len = variableDefinitions.length; i < len; i++) {
+            const definedVariableName = variableDefinitions[i].variable.name.value;
+            variablesDefined[definedVariableName] = true;
+            if (transformState.variablesUsed[definedVariableName] === undefined) {
+                if (process.env.NODE_ENV !== 'production') {
+                    throw new Error(`Variable $${definedVariableName} was defined but never used.`);
+                }
+            }
+        }
+    }
+
+    const usedVariableKeys = Object.keys(transformState.variablesUsed);
+    for (let i = 0, len = usedVariableKeys.length; i < len; i++) {
+        if (variablesDefined[usedVariableKeys[i]] !== true) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error(`Variable $${usedVariableKeys[i]} was used but never defined.`);
+            }
+        }
+    }
+}

package/src/type-node.ts

@@ -0,0 +1,39 @@
+import { TypeNode } from 'graphql/language';
+import { isListTypeNode, isNamedTypeNode, isNonNullTypeNode, LuvioTypeNode } from './ast';
+import { NODE_KIND_NAMED_TYPE, NODE_KIND_LIST_TYPE, NODE_KIND_NON_NULL_TYPE } from './constants';
+
+export function transform(node: TypeNode): LuvioTypeNode {
+    if (isNamedTypeNode(node)) {
+        return {
+            kind: NODE_KIND_NAMED_TYPE,
+            name: node.name.value,
+        };
+    } else if (isListTypeNode(node)) {
+        return {
+            kind: NODE_KIND_LIST_TYPE,
+            type: transform(node.type),
+        };
+    } else if (isNonNullTypeNode(node)) {
+        if (isNamedTypeNode(node.type)) {
+            return {
+                kind: NODE_KIND_NON_NULL_TYPE,
+                type: {
+                    kind: NODE_KIND_NAMED_TYPE,
+                    name: node.type.name.value,
+                },
+            };
+        } else if (isListTypeNode(node.type)) {
+            return {
+                kind: NODE_KIND_NON_NULL_TYPE,
+                type: {
+                    kind: NODE_KIND_LIST_TYPE,
+                    type: transform(node.type.type),
+                },
+            };
+        } else {
+            throw new Error('Unsupported NonNullTypeNode');
+        }
+    } else {
+        throw new Error('Unsupported TypeNode');
+    }
+}