@khanacademy/graphql-flow 0.0.1 → 0.2.0

package/src/parser/resolve.js

@@ -0,0 +1,117 @@
+// @flow
+import gql from 'graphql-tag';
+import type {DocumentNode} from 'graphql/language/ast';
+import type {FileResult, Files, Import, Template, Document} from './parse';
+
+export type Resolved = {
+    [key: string]: {
+        document: DocumentNode,
+        raw: Template,
+    },
+};
+
+export const resolveDocuments = (
+    files: Files,
+): {resolved: Resolved, errors: FileResult['errors']} => {
+    const resolved: Resolved = {};
+    const errors: FileResult['errors'] = [];
+    Object.keys(files).forEach((path) => {
+        const file = files[path];
+        file.operations.forEach((op) => {
+            resolveGqlTemplate(op.source, files, errors, resolved, {});
+        });
+        Object.keys(file.locals).forEach((k) => {
+            const local = file.locals[k];
+            if (local.type === 'document') {
+                resolveGqlTemplate(local.source, files, errors, resolved, {});
+            }
+        });
+    });
+    return {resolved, errors};
+};
+
+const resolveImport = (
+    expr: Import,
+    files: Files,
+    errors: FileResult['errors'],
+    seen: {[key: string]: true},
+): ?Document => {
+    if (seen[expr.path]) {
+        errors.push({
+            loc: expr.loc,
+            message: `Circular import ${Object.keys(seen).join(' -> ')} -> ${
+                expr.path
+            }`,
+        });
+        return null;
+    }
+    seen[expr.path] = true;
+    const res = files[expr.path];
+    if (!res) {
+        errors.push({loc: expr.loc, message: `No file ${expr.path}`});
+        return null;
+    }
+    if (!res.exports[expr.name]) {
+        errors.push({
+            loc: expr.loc,
+            message: `${expr.path} has no valid gql export ${expr.name}`,
+        });
+        return null;
+    }
+    const value = res.exports[expr.name];
+    if (value.type === 'import') {
+        return resolveImport(value, files, errors, seen);
+    }
+    return value;
+};
+
+const resolveGqlTemplate = (
+    template: Template,
+    files: Files,
+    errors: FileResult['errors'],
+    resolved: Resolved,
+    seen: {[key: string]: Template},
+): ?DocumentNode => {
+    const key = template.loc.path + ':' + template.loc.line;
+    if (seen[key]) {
+        errors.push({
+            loc: template.loc,
+            message: `Recursive template dependency! ${Object.keys(seen)
+                .map(
+                    (k) =>
+                        k +
+                        ' ~ ' +
+                        seen[k].expressions.length +
+                        ',' +
+                        seen[k].literals.length,
+                )
+                .join(' -> ')} -> ${key}`,
+        });
+        return null;
+    }
+    seen[key] = template;
+    if (resolved[key]) {
+        return resolved[key].document;
+    }
+    const expressions = template.expressions.map((expr) => {
+        if (expr.type === 'import') {
+            const document = resolveImport(expr, files, errors, {});
+            return document
+                ? resolveGqlTemplate(document.source, files, errors, resolved, {
+                      ...seen,
+                  })
+                : null;
+        }
+        return resolveGqlTemplate(expr.source, files, errors, resolved, {
+            ...seen,
+        });
+    });
+    if (expressions.includes(null)) {
+        return null;
+    }
+    resolved[key] = {
+        document: gql(template.literals, ...expressions),
+        raw: template,
+    };
+    return resolved[key].document;
+};

package/src/types.js

@@ -1,5 +1,6 @@
 // @flow
 
+import type {BabelNode} from '@babel/types';
 import type {
     FragmentDefinitionNode,
     IntrospectionEnumType,
@@ -14,9 +15,13 @@ import type {
 export type Selections = $ReadOnlyArray<SelectionNode>;
 
 export type Options = {|
+    regenerateCommand?: string,
     strictNullability?: boolean, // default true
     readOnlyArray?: boolean, // default true
     scalars?: Scalars,
+    splitTypes?: boolean,
+    generatedDirectory?: string,
+    exportAllObjectTypes?: boolean,
 |};
 
 export type Schema = {
@@ -43,6 +48,7 @@ export type Schema = {
 };
 
 export type Config = {
+    path: Array<string>,
     strictNullability: boolean,
     readOnlyArray: boolean,
     fragments: {[key: string]: FragmentDefinitionNode},
@@ -50,5 +56,6 @@ export type Config = {
     schema: Schema,
     scalars: Scalars,
     errors: Array<string>,
+    allObjectTypes: null | {[key: string]: BabelNode},
 };
 export type Scalars = {[key: string]: 'string' | 'number' | 'boolean'};