@khanacademy/graphql-flow 1.2.0 → 3.0.0

package/src/parser/resolve.js

@@ -1,119 +0,0 @@
-// @flow
-import gql from 'graphql-tag';
-import {getPathWithExtension} from './utils';
-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 => {
-    const absPath: string = getPathWithExtension(expr.path);
-    if (seen[absPath]) {
-        errors.push({
-            loc: expr.loc,
-            message: `Circular import ${Object.keys(seen).join(
-                ' -> ',
-            )} -> ${absPath}`,
-        });
-        return null;
-    }
-    seen[absPath] = true;
-    const res = files[absPath];
-    if (!res) {
-        errors.push({loc: expr.loc, message: `No file ${absPath}`});
-        return null;
-    }
-    if (!res.exports[expr.name]) {
-        errors.push({
-            loc: expr.loc,
-            message: `${absPath} 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/parser/utils.js

@@ -1,25 +0,0 @@
-// @flow
-import fs from 'fs';
-
-export const getPathWithExtension = (pathWithoutExtension: string): string => {
-    if (
-        /\.(less|css|png|gif|jpg|jpeg|js|jsx|ts|tsx|mjs)$/.test(
-            pathWithoutExtension,
-        )
-    ) {
-        return pathWithoutExtension;
-    }
-    if (fs.existsSync(pathWithoutExtension + '.js')) {
-        return pathWithoutExtension + '.js';
-    }
-    if (fs.existsSync(pathWithoutExtension + '.jsx')) {
-        return pathWithoutExtension + '.jsx';
-    }
-    if (fs.existsSync(pathWithoutExtension + '.tsx')) {
-        return pathWithoutExtension + '.tsx';
-    }
-    if (fs.existsSync(pathWithoutExtension + '.ts')) {
-        return pathWithoutExtension + '.ts';
-    }
-    throw new Error("Can't find file at " + pathWithoutExtension);
-};

package/src/schemaFromIntrospectionData.js

@@ -1,68 +0,0 @@
-// @flow
-/**
- * Takes the introspectionQuery response and parses it into the "Schema"
- * type that we use to look up types, interfaces, etc.
- */
-import type {IntrospectionQuery} from 'graphql';
-import type {Schema} from './types';
-
-export const schemaFromIntrospectionData = (
-    schema: IntrospectionQuery,
-): Schema => {
-    const result: Schema = {
-        interfacesByName: {},
-        typesByName: {},
-        inputObjectsByName: {},
-        unionsByName: {},
-        enumsByName: {},
-    };
-
-    schema.__schema.types.forEach((type) => {
-        if (type.kind === 'ENUM') {
-            result.enumsByName[type.name] = type;
-            return;
-        }
-        if (type.kind === 'UNION') {
-            result.unionsByName[type.name] = type;
-            return;
-        }
-        if (type.kind === 'INTERFACE') {
-            result.interfacesByName[type.name] = {
-                ...type,
-                possibleTypesByName: {},
-                fieldsByName: {},
-            };
-            type.possibleTypes.forEach(
-                (p) =>
-                    (result.interfacesByName[type.name].possibleTypesByName[
-                        p.name
-                    ] = true),
-            );
-            type.fields.forEach((field) => {
-                result.interfacesByName[type.name].fieldsByName[field.name] =
-                    field;
-            });
-            return;
-        }
-        if (type.kind === 'INPUT_OBJECT') {
-            result.inputObjectsByName[type.name] = type;
-            return;
-        }
-        if (type.kind === 'SCALAR') {
-            return;
-        }
-        result.typesByName[type.name] = {
-            ...type,
-            fieldsByName: {},
-        };
-        if (!type.fields) {
-            return;
-        }
-
-        type.fields.forEach((field) => {
-            result.typesByName[type.name].fieldsByName[field.name] = field;
-        });
-    });
-
-    return result;
-};

package/src/types.js

@@ -1,88 +0,0 @@
-// @flow
-
-import type {BabelNode} from '@babel/types';
-import type {
-    FragmentDefinitionNode,
-    IntrospectionEnumType,
-    IntrospectionField,
-    IntrospectionInputObjectType,
-    IntrospectionInterfaceType,
-    IntrospectionObjectType,
-    IntrospectionUnionType,
-    SelectionNode,
-} from 'graphql';
-
-export type Selections = $ReadOnlyArray<SelectionNode>;
-
-export type GenerateConfig = {|
-    schemaFilePath: string,
-    match?: Array<RegExp | string>,
-    exclude?: Array<RegExp | string>,
-
-    typeScript?: boolean,
-    scalars?: Scalars,
-    strictNullability?: boolean,
-    /**
-     * The command that users should run to regenerate the types files.
-     */
-    regenerateCommand?: string,
-    readOnlyArray?: boolean,
-    splitTypes?: boolean,
-    generatedDirectory?: string,
-    exportAllObjectTypes?: boolean,
-    typeFileName?: string,
-    experimentalEnums?: boolean,
-    omitFileExtensions?: boolean,
-|};
-
-export type CrawlConfig = {
-    root: string,
-    pragma?: string,
-    loosePragma?: string,
-    ignorePragma?: string,
-    dumpOperations?: string,
-};
-
-export type Config = {
-    crawl: CrawlConfig,
-    generate: GenerateConfig | Array<GenerateConfig>,
-};
-
-export type Schema = {
-    interfacesByName: {
-        [key: string]: IntrospectionInterfaceType & {
-            fieldsByName: {[key: string]: IntrospectionField},
-            possibleTypesByName: {[key: string]: boolean},
-        },
-    },
-    inputObjectsByName: {
-        [key: string]: IntrospectionInputObjectType,
-    },
-    typesByName: {
-        [key: string]: IntrospectionObjectType & {
-            fieldsByName: {[key: string]: IntrospectionField},
-        },
-    },
-    unionsByName: {
-        [key: string]: IntrospectionUnionType,
-    },
-    enumsByName: {
-        [key: string]: IntrospectionEnumType,
-    },
-};
-
-export type Context = {
-    path: Array<string>,
-    strictNullability: boolean,
-    readOnlyArray: boolean,
-    fragments: {[key: string]: FragmentDefinitionNode},
-
-    schema: Schema,
-    scalars: Scalars,
-    errors: Array<string>,
-    allObjectTypes: null | {[key: string]: BabelNode},
-    typeScript: boolean,
-
-    experimentalEnumsMap?: {[key: string]: BabelNode}, // index signature that is populated with declarations
-};
-export type Scalars = {[key: string]: 'string' | 'number' | 'boolean'};

package/src/utils.js

@@ -1,50 +0,0 @@
-// @flow
-
-import * as babelTypes from '@babel/types';
-import {BabelNodeObjectTypeProperty} from '@babel/types';
-
-export const liftLeadingPropertyComments = (
-    property: BabelNodeObjectTypeProperty,
-): BabelNodeObjectTypeProperty => {
-    return transferLeadingComments(property.value, property);
-};
-
-export const maybeAddDescriptionComment = <T: babelTypes.BabelNode>(
-    description: ?string,
-    node: T,
-): T => {
-    if (description) {
-        addCommentAsLineComments(description, node);
-    }
-    return node;
-};
-
-export function addCommentAsLineComments(
-    description: string,
-    res: babelTypes.BabelNode,
-) {
-    if (res.leadingComments?.length) {
-        res.leadingComments[0].value += '\n\n---\n\n' + description;
-    } else {
-        babelTypes.addComment(
-            res,
-            'leading',
-            '* ' + description,
-            false, // this specifies that it's a block comment, not a line comment
-        );
-    }
-}
-
-export const transferLeadingComments = <T: babelTypes.BabelNode>(
-    source: babelTypes.BabelNode,
-    dest: T,
-): T => {
-    if (source.leadingComments?.length) {
-        dest.leadingComments = [
-            ...(dest.leadingComments || []),
-            ...source.leadingComments,
-        ];
-        source.leadingComments = [];
-    }
-    return dest;
-};