grats - npm Package Compare versions

Comparing version 0.0.0-main-bbba151a to 0.0.0-main-bd5d99a2

dist/package.json

 {
     "name": "grats",
-    "version": "0.0.2",
+    "version": "0.0.10",
     "main": "dist/src/index.js",
@@ -12,14 +12,15 @@ "bin": "dist/src/cli.js",
     "scripts": {
-        "test": "ts-node --esm src/tests/test.ts",
+        "test": "ts-node src/tests/test.ts",
         "integration-tests": "node src/tests/integration.mjs",
         "build": "tsc --build",
-        "lint": "eslint src/**/*.ts"
+        "format": "prettier . --write",
+        "lint": "eslint src/**/*.ts && prettier . --check"
     },
     "dependencies": {
-        "@graphql-tools/utils": "^9.2.1",
         "commander": "^10.0.0",
         "graphql": "^16.6.0",
-        "typescript": "^4.9.5"
+        "typescript": "^5.0.2"
     },
     "devDependencies": {
+        "@graphql-tools/utils": "^9.2.1",
         "@types/node": "^18.14.6",
@@ -32,2 +33,3 @@ "@typescript-eslint/eslint-plugin": "^5.55.0",
         "path-browserify": "^1.0.1",
+        "prettier": "^2.8.7",
         "process": "^0.11.10",
@@ -38,3 +40,8 @@ "ts-node": "^10.9.1"
         "trailingComma": "all"
+    },
+    "packageManager": "pnpm@8.12.0",
+    "engines": {
+        "node": ">=16 <=21",
+        "pnpm": "^8"
     }
 }

dist/src/cli.d.ts

 #!/usr/bin/env node
-export {};
+import { Location } from "graphql";
+export declare function formatLoc(loc: Location): string;

dist/src/cli.js

@@ -39,7 +39,7 @@ #!/usr/bin/env node
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLoc = void 0;
 var graphql_1 = require("graphql");
 var _1 = require("./");
 var lib_1 = require("./lib");
-var utils_1 = require("@graphql-tools/utils");
 var commander_1 = require("commander");
@@ -49,2 +49,5 @@ var fs_1 = require("fs");
 var package_json_1 = require("../package.json");
+var Locate_1 = require("./Locate");
+var printSchema_1 = require("./printSchema");
+var ts = require("typescript");
 var program = new commander_1.Command();
@@ -55,9 +58,8 @@ program
     .version(package_json_1.version)
-    .option("-o, --output <SCHEMA_FILE>", "Where to write the schema file. Defaults to stdout")
     .option("--tsconfig <TSCONFIG>", "Path to tsconfig.json. Defaults to auto-detecting based on the current working directory")
     .action(function (_a) {
-    var output = _a.output, tsconfig = _a.tsconfig;
+    var tsconfig = _a.tsconfig;
     return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_b) {
-            build(output, tsconfig);
+            build(tsconfig);
             return [2 /*return*/];
@@ -67,12 +69,47 @@ });
 });
+program
+    .command("locate")
+    .argument("<ENTITY>", "GraphQL entity to locate. E.g. `User` or `User.id`")
+    .option("--tsconfig <TSCONFIG>", "Path to tsconfig.json. Defaults to auto-detecting based on the current working directory")
+    .action(function (entity, _a) {
+    var tsconfig = _a.tsconfig;
+    var config = getTsConfig(tsconfig).config;
+    var schema = buildSchema(config);
+    var loc = (0, Locate_1.locate)(schema, entity);
+    if (loc.kind === "ERROR") {
+        console.error(loc.err);
+        process.exit(1);
+    }
+    console.log(formatLoc(loc.value));
+});
 program.parse();
-function build(output, tsconfig) {
-    if (tsconfig && !(0, fs_1.existsSync)(tsconfig)) {
-        console.error("Grats: Could not find tsconfig.json at `".concat(tsconfig, "`."));
+function build(tsconfig) {
+    var _a = getTsConfig(tsconfig), config = _a.config, configPath = _a.configPath;
+    var schema = buildSchema(config);
+    var sortedSchema = (0, graphql_1.lexicographicSortSchema)(schema);
+    var gratsOptions = config.raw.grats;
+    var dest = (0, path_1.resolve)((0, path_1.dirname)(configPath), gratsOptions.tsSchema);
+    var code = (0, printSchema_1.printExecutableSchema)(sortedSchema, gratsOptions, dest);
+    (0, fs_1.writeFileSync)(dest, code);
+    console.error("Grats: Wrote TypeScript schema to `".concat(dest, "`."));
+    var schemaStr = (0, printSchema_1.printGratsSDL)(sortedSchema, gratsOptions);
+    var absOutput = (0, path_1.resolve)((0, path_1.dirname)(configPath), gratsOptions.graphqlSchema);
+    (0, fs_1.writeFileSync)(absOutput, schemaStr);
+    console.error("Grats: Wrote schema to `".concat(absOutput, "`."));
+}
+// Locate and read the tsconfig.json file
+function getTsConfig(tsconfig) {
+    var configPath = tsconfig || ts.findConfigFile(process.cwd(), ts.sys.fileExists);
+    if (configPath == null) {
+        throw new Error("Grats: Could not find tsconfig.json");
+    }
+    var optionsResult = (0, _1.getParsedTsConfig)(configPath);
+    if (optionsResult.kind === "ERROR") {
+        console.error(optionsResult.err.formatDiagnosticsWithColorAndContext());
         process.exit(1);
     }
-    var parsed = (0, _1.getParsedTsConfig)(tsconfig);
-    // FIXME: Validate config!
-    // https://github.com/tsconfig/bases
-    var schemaResult = (0, lib_1.buildSchemaResult)(parsed);
+    return { configPath: configPath, config: optionsResult.value };
+}
+function buildSchema(options) {
+    var schemaResult = (0, lib_1.buildSchemaResult)(options);
     if (schemaResult.kind === "ERROR") {
@@ -82,12 +119,9 @@ console.error(schemaResult.err.formatDiagnosticsWithColorAndContext());
     }
-    var schema = (0, graphql_1.lexicographicSortSchema)(schemaResult.value);
-    var schemaStr = (0, utils_1.printSchemaWithDirectives)(schema, { assumeValid: true });
-    if (output) {
-        var absOutput = (0, path_1.resolve)(process.cwd(), output);
-        (0, fs_1.writeFileSync)(absOutput, schemaStr);
-        console.error("Grats: Wrote schema to `".concat(absOutput, "`."));
-    }
-    else {
-        console.log(schemaStr);
-    }
+    return schemaResult.value;
 }
+// Format a location for printing to the console. Tools like VS Code and iTerm
+// will automatically turn this into a clickable link.
+function formatLoc(loc) {
+    return "".concat(loc.source.name, ":").concat(loc.startToken.line + 1, ":").concat(loc.startToken.column + 1);
+}
+exports.formatLoc = formatLoc;

dist/src/Extractor.d.ts

@@ -1,7 +0,28 @@
-import { DefinitionNode, FieldDefinitionNode, InputValueDefinitionNode, ListTypeNode, NamedTypeNode, Location as GraphQLLocation, NameNode, Token, TypeNode, NonNullTypeNode, StringValueNode, ConstValueNode, ConstDirectiveNode, ConstArgumentNode, EnumValueDefinitionNode, ConstObjectFieldNode, ConstObjectValueNode, ConstListValueNode } from "graphql";
+import { NameNode } from "graphql";
 import { DiagnosticsResult } from "./utils/DiagnosticError";
 import * as ts from "typescript";
-import { TypeContext } from "./TypeContext";
+import { NameDefinition } from "./TypeContext";
 import { ConfigOptions } from "./lib";
-type ArgDefaults = Map<string, ts.Expression>;
+import { GratsDefinitionNode } from "./GraphQLConstructor";
+export declare const LIBRARY_IMPORT_NAME = "grats";
+export declare const LIBRARY_NAME = "Grats";
+export declare const ISSUE_URL = "https://github.com/captbaritone/grats/issues";
+export declare const TYPE_TAG = "gqlType";
+export declare const FIELD_TAG = "gqlField";
+export declare const SCALAR_TAG = "gqlScalar";
+export declare const INTERFACE_TAG = "gqlInterface";
+export declare const ENUM_TAG = "gqlEnum";
+export declare const UNION_TAG = "gqlUnion";
+export declare const INPUT_TAG = "gqlInput";
+export declare const IMPLEMENTS_TAG_DEPRECATED = "gqlImplements";
+export declare const KILLS_PARENT_ON_EXCEPTION_TAG = "killsParentOnException";
+export declare const ALL_TAGS: string[];
+export type ExtractionSnapshot = {
+    readonly definitions: GratsDefinitionNode[];
+    readonly unresolvedNames: Map<ts.Node, NameNode>;
+    readonly nameDefinitions: Map<ts.Node, NameDefinition>;
+    readonly contextReferences: Array<ts.Node>;
+    readonly typesWithTypenameField: Set<string>;
+    readonly interfaceDeclarations: Array<ts.InterfaceDeclaration>;
+};
 /**
@@ -17,83 +38,2 @@ * Extracts GraphQL definitions from TypeScript source code.
  */
-export declare class Extractor {
-    definitions: DefinitionNode[];
-    sourceFile: ts.SourceFile;
-    ctx: TypeContext;
-    configOptions: ConfigOptions;
-    errors: ts.Diagnostic[];
-    constructor(sourceFile: ts.SourceFile, ctx: TypeContext, buildOptions: ConfigOptions);
-    extract(): DiagnosticsResult<DefinitionNode[]>;
-    extractType(node: ts.Node, tag: ts.JSDocTag): void;
-    extractScalar(node: ts.Node, tag: ts.JSDocTag): void;
-    extractInterface(node: ts.Node, tag: ts.JSDocTag): void;
-    extractEnum(node: ts.Node, tag: ts.JSDocTag): void;
-    extractInput(node: ts.Node, tag: ts.JSDocTag): void;
-    extractUnion(node: ts.Node, tag: ts.JSDocTag): void;
-    /** Error handling and location juggling */
-    report(node: ts.Node, message: string): null;
-    reportUnhandled(node: ts.Node, message: string): null;
-    diagnosticAnnotatedLocation(node: ts.Node): {
-        start: number;
-        length: number;
-        filepath: ts.SourceFile;
-    };
-    loc(node: ts.Node): GraphQLLocation;
-    gqlDummyToken(pos: number): Token;
-    /** TypeScript traversals */
-    unionTypeAliasDeclaration(node: ts.TypeAliasDeclaration, tag: ts.JSDocTag): null | undefined;
-    functionDeclarationExtendType(node: ts.FunctionDeclaration, tag: ts.JSDocTag): null | undefined;
-    typeReferenceFromParam(typeParam: ts.ParameterDeclaration): NameNode | null;
-    namedFunctionExportName(node: ts.FunctionDeclaration): ts.Identifier | null;
-    scalarTypeAliasDeclaration(node: ts.TypeAliasDeclaration, tag: ts.JSDocTag): null | undefined;
-    inputTypeAliasDeclaration(node: ts.TypeAliasDeclaration, tag: ts.JSDocTag): null | undefined;
-    collectInputFields(node: ts.TypeAliasDeclaration): Array<InputValueDefinitionNode> | null;
-    collectInputField(node: ts.PropertySignature): InputValueDefinitionNode | null;
-    typeClassDeclaration(node: ts.ClassDeclaration, tag: ts.JSDocTag): null | undefined;
-    typeInterfaceDeclaration(node: ts.InterfaceDeclaration, tag: ts.JSDocTag): null | undefined;
-    typeTypeAliasDeclaration(node: ts.TypeAliasDeclaration, tag: ts.JSDocTag): null | undefined;
-    checkForTypenameProperty(node: ts.ClassDeclaration | ts.InterfaceDeclaration | ts.TypeLiteralNode, expectedName: string): void;
-    isValidTypeNameProperty(member: ts.ClassElement | ts.TypeElement, expectedName: string): boolean;
-    isValidTypenamePropertyDeclaration(node: ts.PropertyDeclaration, expectedName: string): boolean;
-    isValidTypenamePropertySignature(node: ts.PropertySignature, expectedName: string): boolean;
-    isValidTypenamePropertyType(node: ts.TypeNode, expectedName: string): boolean;
-    collectInterfaces(node: ts.ClassDeclaration | ts.InterfaceDeclaration): Array<NamedTypeNode> | null;
-    interfaceInterfaceDeclaration(node: ts.InterfaceDeclaration, tag: ts.JSDocTag): void;
-    collectFields(node: ts.ClassDeclaration | ts.InterfaceDeclaration | ts.TypeLiteralNode): Array<FieldDefinitionNode>;
-    collectArgs(argsParam: ts.ParameterDeclaration): ReadonlyArray<InputValueDefinitionNode> | null;
-    collectArgDefaults(node: ts.ObjectBindingPattern): ArgDefaults;
-    collectConstValue(node: ts.Expression): ConstValueNode | null;
-    collectArrayLiteral(node: ts.ArrayLiteralExpression): ConstListValueNode | null;
-    cellectObjectLiteral(node: ts.ObjectLiteralExpression): ConstObjectValueNode | null;
-    collectObjectField(node: ts.ObjectLiteralElementLike): ConstObjectFieldNode | null;
-    collectArg(node: ts.TypeElement, defaults?: Map<string, ts.Expression> | null): InputValueDefinitionNode | null;
-    enumEnumDeclaration(node: ts.EnumDeclaration, tag: ts.JSDocTag): void;
-    enumTypeAliasDeclaration(node: ts.TypeAliasDeclaration, tag: ts.JSDocTag): void;
-    enumTypeAliasVariants(node: ts.TypeAliasDeclaration): EnumValueDefinitionNode[] | null;
-    collectEnumValues(node: ts.EnumDeclaration): ReadonlyArray<EnumValueDefinitionNode>;
-    entityName(node: ts.ClassDeclaration | ts.MethodDeclaration | ts.MethodSignature | ts.PropertyDeclaration | ts.InterfaceDeclaration | ts.PropertySignature | ts.EnumDeclaration | ts.TypeAliasDeclaration | ts.FunctionDeclaration, tag: ts.JSDocTag): NameNode | null;
-    methodDeclaration(node: ts.MethodDeclaration | ts.MethodSignature): FieldDefinitionNode | null;
-    collectMethodType(node: ts.TypeNode): TypeNode | null;
-    collectPropertyType(node: ts.TypeNode): TypeNode | null;
-    maybeUnwrapePromise(node: ts.TypeNode): ts.TypeNode | null;
-    collectDescription(node: ts.Node): StringValueNode | null;
-    collectDeprecated(node: ts.Node): ConstDirectiveNode | null;
-    property(node: ts.PropertyDeclaration | ts.PropertySignature): FieldDefinitionNode | null;
-    collectType(node: ts.TypeNode): TypeNode | null;
-    typeReference(node: ts.TypeReferenceNode): TypeNode | null;
-    isNullish(node: ts.Node): boolean;
-    expectIdentifier(node: ts.Node): ts.Identifier | null;
-    findTag(node: ts.Node, tagName: string): ts.JSDocTag | null;
-    handleErrorBubbling(parentNode: ts.Node, type: TypeNode): TypeNode;
-    methodNameDirective(nameNode: ts.Node, name: string): ConstDirectiveNode;
-    exportDirective(nameNode: ts.Node, filename: string, functionName: string): ConstDirectiveNode;
-    /** GraphQL AST node helper methods */
-    gqlName(node: ts.Node, value: string): NameNode;
-    gqlNamedType(node: ts.Node, value: string): NamedTypeNode;
-    gqlNonNullType(node: ts.Node, type: TypeNode): NonNullTypeNode;
-    gqlNullableType(type: TypeNode): NamedTypeNode | ListTypeNode;
-    gqlListType(node: ts.Node, type: TypeNode): ListTypeNode;
-    gqlConstArgument(node: ts.Node, name: NameNode, value: ConstValueNode): ConstArgumentNode;
-    gqlConstDirective(node: ts.Node, name: NameNode, args: ReadonlyArray<ConstArgumentNode>): ConstDirectiveNode;
-    gqlString(node: ts.Node, value: string): StringValueNode;
-}
-export {};
+export declare function extract(options: ConfigOptions, sourceFile: ts.SourceFile): DiagnosticsResult<ExtractionSnapshot>;

dist/src/Extractor.js

@@ -13,4 +13,20 @@ "use strict";
 };
-exports.__esModule = true;
-exports.Extractor = void 0;
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = exports.ALL_TAGS = exports.KILLS_PARENT_ON_EXCEPTION_TAG = exports.IMPLEMENTS_TAG_DEPRECATED = exports.INPUT_TAG = exports.UNION_TAG = exports.ENUM_TAG = exports.INTERFACE_TAG = exports.SCALAR_TAG = exports.FIELD_TAG = exports.TYPE_TAG = exports.ISSUE_URL = exports.LIBRARY_NAME = exports.LIBRARY_IMPORT_NAME = void 0;
 var graphql_1 = require("graphql");
@@ -20,24 +36,30 @@ var DiagnosticError_1 = require("./utils/DiagnosticError");
 var TypeContext_1 = require("./TypeContext");
-var serverDirectives_1 = require("./serverDirectives");
-var LIBRARY_IMPORT_NAME = "grats";
-var LIBRARY_NAME = "Grats";
-var ISSUE_URL = "https://github.com/captbaritone/grats/issues";
-var TYPE_TAG = "gqlType";
-var FIELD_TAG = "gqlField";
-var SCALAR_TAG = "gqlScalar";
-var INTERFACE_TAG = "gqlInterface";
-var ENUM_TAG = "gqlEnum";
-var UNION_TAG = "gqlUnion";
-var INPUT_TAG = "gqlInput";
-var KILLS_PARENT_ON_EXCEPTION_TAG = "killsParentOnException";
-var ALL_TAGS = [
-    TYPE_TAG,
-    FIELD_TAG,
-    SCALAR_TAG,
-    INTERFACE_TAG,
-    ENUM_TAG,
-    UNION_TAG,
-    INPUT_TAG,
+var E = require("./Errors");
+var JSDoc_1 = require("./utils/JSDoc");
+var GraphQLConstructor_1 = require("./GraphQLConstructor");
+var gratsRoot_1 = require("./gratsRoot");
+exports.LIBRARY_IMPORT_NAME = "grats";
+exports.LIBRARY_NAME = "Grats";
+exports.ISSUE_URL = "https://github.com/captbaritone/grats/issues";
+exports.TYPE_TAG = "gqlType";
+exports.FIELD_TAG = "gqlField";
+exports.SCALAR_TAG = "gqlScalar";
+exports.INTERFACE_TAG = "gqlInterface";
+exports.ENUM_TAG = "gqlEnum";
+exports.UNION_TAG = "gqlUnion";
+exports.INPUT_TAG = "gqlInput";
+exports.IMPLEMENTS_TAG_DEPRECATED = "gqlImplements";
+exports.KILLS_PARENT_ON_EXCEPTION_TAG = "killsParentOnException";
+// All the tags that start with gql
+exports.ALL_TAGS = [
+    exports.TYPE_TAG,
+    exports.FIELD_TAG,
+    exports.SCALAR_TAG,
+    exports.INTERFACE_TAG,
+    exports.ENUM_TAG,
+    exports.UNION_TAG,
+    exports.INPUT_TAG,
 ];
 var DEPRECATED_TAG = "deprecated";
+var OPERATION_TYPES = new Set(["Query", "Mutation", "Subscription"]);
 /**
@@ -53,10 +75,26 @@ * Extracts GraphQL definitions from TypeScript source code.
  */
+function extract(options, sourceFile) {
+    var extractor = new Extractor(options);
+    return extractor.extract(sourceFile);
+}
+exports.extract = extract;
 var Extractor = /** @class */ (function () {
-    function Extractor(sourceFile, ctx, buildOptions) {
+    function Extractor(buildOptions) {
         this.definitions = [];
+        // Snapshot data
+        this.unresolvedNames = new Map();
+        this.nameDefinitions = new Map();
+        this.contextReferences = [];
+        this.typesWithTypenameField = new Set();
+        this.interfaceDeclarations = [];
         this.errors = [];
-        this.sourceFile = sourceFile;
-        this.ctx = ctx;
         this.configOptions = buildOptions;
+        this.gql = new GraphQLConstructor_1.GraphQLConstructor();
     }
+    Extractor.prototype.markUnresolvedType = function (node, name) {
+        this.unresolvedNames.set(node, name);
+    };
+    Extractor.prototype.recordTypeName = function (node, name, kind) {
+        this.nameDefinitions.set(node, { name: name, kind: kind });
+    };
     // Traverse all nodes, checking each one for its JSDoc tags.
@@ -66,81 +104,73 @@ // If we find a tag we recognize, we extract the relevant information,
     // supported.
-    Extractor.prototype.extract = function () {
+    Extractor.prototype.extract = function (sourceFile) {
         var _this = this;
-        ts.forEachChild(this.sourceFile, function (node) {
-            var e_1, _a, e_2, _b;
-            try {
-                for (var _c = __values(ts.getJSDocTags(node)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var tag = _d.value;
-                    switch (tag.tagName.text) {
-                        case TYPE_TAG:
-                            _this.extractType(node, tag);
-                            break;
-                        case SCALAR_TAG:
-                            _this.extractScalar(node, tag);
-                            break;
-                        case INTERFACE_TAG:
-                            _this.extractInterface(node, tag);
-                            break;
-                        case ENUM_TAG:
-                            _this.extractEnum(node, tag);
-                            break;
-                        case INPUT_TAG:
-                            _this.extractInput(node, tag);
-                            break;
-                        case UNION_TAG:
-                            _this.extractUnion(node, tag);
-                            break;
-                        case FIELD_TAG:
-                            if (ts.isFunctionDeclaration(node)) {
-                                _this.functionDeclarationExtendType(node, tag);
+        (0, JSDoc_1.traverseJSDocTags)(sourceFile, function (node, tag) {
+            var e_1, _a;
+            switch (tag.tagName.text) {
+                case exports.TYPE_TAG:
+                    _this.extractType(node, tag);
+                    break;
+                case exports.SCALAR_TAG:
+                    _this.extractScalar(node, tag);
+                    break;
+                case exports.INTERFACE_TAG:
+                    _this.extractInterface(node, tag);
+                    break;
+                case exports.ENUM_TAG:
+                    _this.extractEnum(node, tag);
+                    break;
+                case exports.INPUT_TAG:
+                    _this.extractInput(node, tag);
+                    break;
+                case exports.UNION_TAG:
+                    _this.extractUnion(node, tag);
+                    break;
+                case exports.FIELD_TAG:
+                    if (ts.isFunctionDeclaration(node)) {
+                        _this.functionDeclarationExtendType(node, tag);
+                    }
+                    else if (!(ts.isParameter(node) ||
+                        ts.isMethodDeclaration(node) ||
+                        ts.isPropertyDeclaration(node) ||
+                        ts.isMethodSignature(node) ||
+                        ts.isPropertySignature(node))) {
+                        // Right now this happens via deep traversal
+                        // Note: Keep this in sync with `collectFields`
+                        _this.reportUnhandled(node, "field", E.fieldTagOnWrongNode());
+                    }
+                    break;
+                case exports.KILLS_PARENT_ON_EXCEPTION_TAG: {
+                    var hasFieldTag = ts.getJSDocTags(node).some(function (t) {
+                        return t.tagName.text === exports.FIELD_TAG;
+                    });
+                    if (!hasFieldTag) {
+                        _this.report(tag.tagName, E.killsParentOnExceptionOnWrongNode());
+                    }
+                    break;
+                }
+                default:
+                    {
+                        var lowerCaseTag = tag.tagName.text.toLowerCase();
+                        if (lowerCaseTag.startsWith("gql")) {
+                            try {
+                                for (var ALL_TAGS_1 = __values(exports.ALL_TAGS), ALL_TAGS_1_1 = ALL_TAGS_1.next(); !ALL_TAGS_1_1.done; ALL_TAGS_1_1 = ALL_TAGS_1.next()) {
+                                    var t = ALL_TAGS_1_1.value;
+                                    if (t.toLowerCase() === lowerCaseTag) {
+                                        _this.report(tag.tagName, E.wrongCasingForGratsTag(tag.tagName.text, t));
+                                        break;
+                                    }
+                                }
                             }
-                            else if (!(ts.isMethodDeclaration(node) ||
-                                ts.isPropertyDeclaration(node) ||
-                                ts.isMethodSignature(node) ||
-                                ts.isPropertySignature(node))) {
-                                // Right now this happens via deep traversal
-                                // Note: Keep this in sync with `collectFields`
-                                _this.reportUnhandled(node, "`@".concat(FIELD_TAG, "` can only be used on method/property declarations or signatures."));
-                            }
-                            break;
-                        case KILLS_PARENT_ON_EXCEPTION_TAG:
-                            var hasFieldTag = ts.getJSDocTags(node).some(function (t) {
-                                return t.tagName.text === FIELD_TAG;
-                            });
-                            if (!hasFieldTag) {
-                                _this.report(tag.tagName, "Unexpected `@".concat(KILLS_PARENT_ON_EXCEPTION_TAG, "`. `@").concat(KILLS_PARENT_ON_EXCEPTION_TAG, "` can only be used in field annotation docblocks. Perhaps you are missing a `@").concat(FIELD_TAG, "` tag?"));
-                            }
-                            break;
-                        default:
-                            var lowerCaseTag = tag.tagName.text.toLowerCase();
-                            if (lowerCaseTag.startsWith("gql")) {
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
                                 try {
-                                    for (var ALL_TAGS_1 = (e_2 = void 0, __values(ALL_TAGS)), ALL_TAGS_1_1 = ALL_TAGS_1.next(); !ALL_TAGS_1_1.done; ALL_TAGS_1_1 = ALL_TAGS_1.next()) {
-                                        var t = ALL_TAGS_1_1.value;
-                                        if (t.toLowerCase() === lowerCaseTag) {
-                                            _this.report(tag.tagName, "Incorrect casing for Grats tag `@".concat(tag.tagName.text, "`. Use `@").concat(t, "` instead."));
-                                            break;
-                                        }
-                                    }
+                                    if (ALL_TAGS_1_1 && !ALL_TAGS_1_1.done && (_a = ALL_TAGS_1.return)) _a.call(ALL_TAGS_1);
                                 }
-                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                                finally {
-                                    try {
-                                        if (ALL_TAGS_1_1 && !ALL_TAGS_1_1.done && (_b = ALL_TAGS_1["return"])) _b.call(ALL_TAGS_1);
-                                    }
-                                    finally { if (e_2) throw e_2.error; }
-                                }
-                                _this.report(tag.tagName, "`@".concat(tag.tagName.text, "` is not a valid Grats tag. Valid tags are: ").concat(ALL_TAGS.map(function (t) { return "`@".concat(t, "`"); }).join(", "), "."));
+                                finally { if (e_1) throw e_1.error; }
                             }
-                            break;
+                            _this.report(tag.tagName, E.invalidGratsTag(tag.tagName.text));
+                        }
                     }
-                }
+                    break;
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c["return"])) _a.call(_c);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
         });
@@ -150,3 +180,10 @@ if (this.errors.length > 0) {
         }
-        return (0, DiagnosticError_1.ok)(this.definitions);
+        return (0, DiagnosticError_1.ok)({
+            definitions: this.definitions,
+            unresolvedNames: this.unresolvedNames,
+            nameDefinitions: this.nameDefinitions,
+            contextReferences: this.contextReferences,
+            typesWithTypenameField: this.typesWithTypenameField,
+            interfaceDeclarations: this.interfaceDeclarations,
+        });
     };
@@ -164,3 +201,3 @@ Extractor.prototype.extractType = function (node, tag) {
         else {
-            this.report(tag, "`@".concat(TYPE_TAG, "` can only be used on class or interface declarations."));
+            this.report(tag, E.invalidTypeTagUsage());
         }
@@ -173,3 +210,3 @@ };
         else {
-            this.report(tag, "`@".concat(SCALAR_TAG, "` can only be used on type alias declarations."));
+            this.report(tag, E.invalidScalarTagUsage());
         }
@@ -182,3 +219,3 @@ };
         else {
-            this.report(tag, "`@".concat(INTERFACE_TAG, "` can only be used on interface declarations."));
+            this.report(tag, E.invalidInterfaceTagUsage());
         }
@@ -194,3 +231,3 @@ };
         else {
-            this.report(tag, "`@".concat(ENUM_TAG, "` can only be used on enum declarations or TypeScript unions."));
+            this.report(tag, E.invalidEnumTagUsage());
         }
@@ -203,3 +240,3 @@ };
         else {
-            this.report(tag, "`@".concat(INPUT_TAG, "` can only be used on type alias declarations."));
+            this.report(tag, E.invalidInputTagUsage());
         }
@@ -212,17 +249,8 @@ };
         else {
-            this.report(tag, "`@".concat(UNION_TAG, "` can only be used on type alias declarations."));
+            this.report(tag, E.invalidUnionTagUsage());
         }
     };
     /** Error handling and location juggling */
-    Extractor.prototype.report = function (node, message) {
-        var start = node.getStart();
-        var length = node.getEnd() - start;
-        this.errors.push({
-            messageText: message,
-            file: this.sourceFile,
-            code: DiagnosticError_1.FAKE_ERROR_CODE,
-            category: ts.DiagnosticCategory.Error,
-            start: start,
-            length: length
-        });
+    Extractor.prototype.report = function (node, message, relatedInformation) {
+        this.errors.push((0, DiagnosticError_1.tsErr)(node, message, relatedInformation));
         return null;
@@ -232,29 +260,10 @@ };
     // Gives the user a path forward if they think we should be able to infer this type.
-    Extractor.prototype.reportUnhandled = function (node, message) {
-        var suggestion = "If you think ".concat(LIBRARY_NAME, " should be able to infer this type, please report an issue at ").concat(ISSUE_URL, ".");
+    Extractor.prototype.reportUnhandled = function (node, positionKind, message, relatedInformation) {
+        var suggestion = "If you think ".concat(exports.LIBRARY_NAME, " should be able to infer this ").concat(positionKind, ", please report an issue at ").concat(exports.ISSUE_URL, ".");
         var completedMessage = "".concat(message, "\n\n").concat(suggestion);
-        this.report(node, completedMessage);
-        return null;
+        return this.report(node, completedMessage, relatedInformation);
     };
-    Extractor.prototype.diagnosticAnnotatedLocation = function (node) {
-        var start = node.getStart();
-        var end = node.getEnd();
-        return { start: start, length: end - start, filepath: this.sourceFile };
-    };
-    // TODO: This is potentially quite expensive, and we only need it if we report
-    // an error at one of these locations. We could consider some trick to return a
-    // proxy object that would lazily compute the line/column info.
-    Extractor.prototype.loc = function (node) {
-        var source = new graphql_1.Source(this.sourceFile.text, this.sourceFile.fileName);
-        var startToken = this.gqlDummyToken(node.getStart());
-        var endToken = this.gqlDummyToken(node.getEnd());
-        return new graphql_1.Location(startToken, endToken, source);
-    };
-    Extractor.prototype.gqlDummyToken = function (pos) {
-        var _a = this.sourceFile.getLineAndCharacterOfPosition(pos), line = _a.line, character = _a.character;
-        return new graphql_1.Token(graphql_1.TokenKind.SOF, pos, pos, line, character, undefined);
-    };
     /** TypeScript traversals */
     Extractor.prototype.unionTypeAliasDeclaration = function (node, tag) {
-        var e_3, _a;
+        var e_2, _a;
         var name = this.entityName(node, tag);
@@ -264,5 +273,5 @@ if (name == null)
         if (!ts.isUnionTypeNode(node.type)) {
-            return this.report(node, "Expected a TypeScript union. `@".concat(UNION_TAG, "` can only be used on TypeScript unions."));
+            return this.report(node, E.expectedUnionTypeNode());
         }
-        var description = this.collectDescription(node.name);
+        var description = this.collectDescription(node);
         var types = [];
@@ -273,24 +282,18 @@ try {
                 if (!ts.isTypeReferenceNode(member)) {
-                    return this.reportUnhandled(member, "Expected `@".concat(UNION_TAG, "` union members to be type references."));
+                    return this.reportUnhandled(member, "union member", E.expectedUnionTypeReference());
                 }
-                var namedType = this.gqlNamedType(member.typeName, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
-                this.ctx.markUnresolvedType(member.typeName, namedType.name);
+                var namedType = this.gql.namedType(member.typeName, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
+                this.markUnresolvedType(member.typeName, namedType.name);
                 types.push(namedType);
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_2) throw e_2.error; }
         }
-        this.ctx.recordTypeName(node.name, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.UNION_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            name: name,
-            types: types
-        });
+        this.recordTypeName(node.name, name, "UNION");
+        this.definitions.push(this.gql.unionTypeDefinition(node, name, types, description));
     };
@@ -303,3 +306,3 @@ Extractor.prototype.functionDeclarationExtendType = function (node, tag) {
         if (typeParam == null) {
-            return this.report(funcName, "Expected `@".concat(FIELD_TAG, "` function to have a first argument representing the type to extend."));
+            return this.report(funcName, E.invalidParentArgForFunctionField());
         }
@@ -313,7 +316,8 @@ var typeName = this.typeReferenceFromParam(typeParam);
         if (node.type == null) {
-            return this.report(funcName, "Expected GraphQL field to have an explicit return type.");
+            return this.report(funcName, E.invalidReturnTypeForFunctionField());
         }
-        var type = this.collectMethodType(node.type);
-        if (type == null)
+        var returnType = this.collectReturnType(node.type);
+        if (returnType == null)
             return null;
+        var type = returnType.type, isStream = returnType.isStream;
         var args = null;
@@ -324,11 +328,21 @@ var argsParam = node.parameters[1];
         }
-        var description = this.collectDescription(funcName);
+        var context = node.parameters[2];
+        if (context != null) {
+            this.validateContextParameter(context);
+        }
+        var description = this.collectDescription(node);
         if (!ts.isSourceFile(node.parent)) {
-            return this.report(node, "Expected `@".concat(FIELD_TAG, "` function to be a top-level declaration."));
+            return this.report(node, E.functionFieldNotTopLevel());
         }
         // TODO: Does this work in the browser?
-        var filename = this.ctx.getDestFilePath(node.parent);
-        var directives = [this.exportDirective(funcName, filename, funcName.text)];
-        if (funcName.text !== name.value) {
-            directives.push(this.methodNameDirective(funcName, funcName.text));
+        var tsModulePath = (0, gratsRoot_1.relativePath)(node.getSourceFile().fileName);
+        var directives = [
+            this.gql.exportedDirective(funcName, {
+                tsModulePath: tsModulePath,
+                exportedFunctionName: funcName.text,
+                argCount: node.parameters.length,
+            }),
+        ];
+        if (isStream) {
+            directives.push(this.gql.asyncIterableDirective(node.type));
         }
@@ -339,29 +353,15 @@ var deprecated = this.collectDeprecated(node);
         }
-        this.definitions.push({
-            kind: graphql_1.Kind.OBJECT_TYPE_EXTENSION,
-            loc: this.loc(node),
-            name: typeName,
-            fields: [
-                {
-                    kind: graphql_1.Kind.FIELD_DEFINITION,
-                    loc: this.loc(node),
-                    description: description || undefined,
-                    name: name,
-                    arguments: args || undefined,
-                    type: this.handleErrorBubbling(node, type),
-                    directives: directives.length === 0 ? undefined : directives
-                },
-            ]
-        });
+        var field = this.gql.fieldDefinition(node, name, this.handleErrorBubbling(node, type), args, directives, description);
+        this.definitions.push(this.gql.abstractFieldDefinition(node, typeName, field));
     };
     Extractor.prototype.typeReferenceFromParam = function (typeParam) {
         if (typeParam.type == null) {
-            return this.report(typeParam, "Expected first argument of a `@".concat(FIELD_TAG, "` function to have an explicit type annotation."));
+            return this.report(typeParam, E.functionFieldParentTypeMissing());
         }
         if (!ts.isTypeReferenceNode(typeParam.type)) {
-            return this.report(typeParam.type, "Expected first argument of a `@".concat(FIELD_TAG, "` function to be typed as a `@").concat(TYPE_TAG, "` type."));
+            return this.report(typeParam.type, E.functionFieldParentTypeNotValid());
         }
         var nameNode = typeParam.type.typeName;
-        var typeName = this.gqlName(nameNode, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
-        this.ctx.markUnresolvedType(nameNode, typeName);
+        var typeName = this.gql.name(nameNode, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
+        this.markUnresolvedType(nameNode, typeName);
         return typeName;
@@ -372,3 +372,3 @@ };
         if (node.name == null) {
-            return this.report(node, "Expected a `@".concat(FIELD_TAG, "` function to be a named function."));
+            return this.report(node, E.functionFieldNotNamed());
         }
@@ -383,6 +383,6 @@ var exportKeyword = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(function (modifier) {
             // TODO: We could support this
-            return this.report(defaultKeyword, "Expected a `@".concat(FIELD_TAG, "` function to be a named export, not a default export."));
+            return this.report(defaultKeyword, E.functionFieldDefaultExport());
         }
         if (exportKeyword == null) {
-            return this.report(node.name, "Expected a `@".concat(FIELD_TAG, "` function to be a named export."));
+            return this.report(node.name, E.functionFieldNotNamedExport());
         }
@@ -395,10 +395,5 @@ return node.name;
             return null;
-        var description = this.collectDescription(node.name);
-        this.ctx.recordTypeName(node.name, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            name: name
-        });
+        var description = this.collectDescription(node);
+        this.recordTypeName(node.name, name, "SCALAR");
+        this.definitions.push(this.gql.scalarTypeDefinition(node, name, description));
     };
@@ -409,18 +404,13 @@ Extractor.prototype.inputTypeAliasDeclaration = function (node, tag) {
             return null;
-        var description = this.collectDescription(node.name);
-        this.ctx.recordTypeName(node.name, name.value);
+        var description = this.collectDescription(node);
+        this.recordTypeName(node.name, name, "INPUT_OBJECT");
         var fields = this.collectInputFields(node);
-        this.definitions.push({
-            kind: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            name: name,
-            fields: fields !== null && fields !== void 0 ? fields : undefined
-        });
+        var deprecatedDirective = this.collectDeprecated(node);
+        this.definitions.push(this.gql.inputObjectTypeDefinition(node, name, fields, deprecatedDirective == null ? null : [deprecatedDirective], description));
     };
     Extractor.prototype.collectInputFields = function (node) {
-        var e_4, _a;
+        var e_3, _a;
         var fields = [];
         if (!ts.isTypeLiteralNode(node.type)) {
-            return this.reportUnhandled(node, "`@".concat(INPUT_TAG, "` can only be used on type literals."));
+            return this.reportUnhandled(node, "input", E.inputTypeNotLiteral());
         }
@@ -431,3 +421,3 @@ try {
                 if (!ts.isPropertySignature(member)) {
-                    this.reportUnhandled(member, "`@".concat(INPUT_TAG, "` types only support property signature members."));
+                    this.reportUnhandled(member, "input field", E.inputTypeFieldNotProperty());
                     continue;
@@ -440,8 +430,8 @@ }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_3) throw e_3.error; }
         }
@@ -455,3 +445,3 @@ return fields.length === 0 ? null : fields;
         if (node.type == null) {
-            return this.report(node, "Input field must have a type annotation.");
+            return this.report(node, E.inputFieldUntyped());
         }
@@ -461,17 +451,10 @@ var inner = this.collectType(node.type);
             return null;
-        var type = node.questionToken == null ? inner : this.gqlNullableType(inner);
-        var description = this.collectDescription(node.name);
-        return {
-            kind: graphql_1.Kind.INPUT_VALUE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            name: this.gqlName(id, id.text),
-            type: type,
-            defaultValue: undefined,
-            directives: undefined
-        };
+        var type = node.questionToken == null ? inner : this.gql.nullableType(inner);
+        var description = this.collectDescription(node);
+        var deprecatedDirective = this.collectDeprecated(node);
+        return this.gql.inputValueDefinition(node, this.gql.name(id, id.text), type, deprecatedDirective == null ? null : [deprecatedDirective], null, description);
     };
     Extractor.prototype.typeClassDeclaration = function (node, tag) {
         if (node.name == null) {
-            return this.report(node, "Unexpected `@".concat(TYPE_TAG, "` annotation on unnamed class declaration."));
+            return this.report(node, E.typeTagOnUnnamedClass());
         }
@@ -481,17 +464,17 @@ var name = this.entityName(node, tag);
             return null;
-        var description = this.collectDescription(node.name);
+        this.validateOperationTypes(node.name, name.value);
+        var description = this.collectDescription(node);
         var fields = this.collectFields(node);
         var interfaces = this.collectInterfaces(node);
-        this.ctx.recordTypeName(node.name, name.value);
+        this.recordTypeName(node.name, name, "TYPE");
         this.checkForTypenameProperty(node, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            directives: undefined,
-            name: name,
-            fields: fields,
-            interfaces: interfaces !== null && interfaces !== void 0 ? interfaces : undefined
-        });
+        this.definitions.push(this.gql.objectTypeDefinition(node, name, fields, interfaces, description));
     };
+    Extractor.prototype.validateOperationTypes = function (node, name) {
+        // TODO: If we start supporting defining operation types using
+        // non-standard names, we will need to update this logic.
+        if (OPERATION_TYPES.has(name)) {
+            this.report(node, E.operationTypeNotUnknown());
+        }
+    };
     Extractor.prototype.typeInterfaceDeclaration = function (node, tag) {
@@ -501,16 +484,9 @@ var name = this.entityName(node, tag);
             return null;
-        var description = this.collectDescription(node.name);
+        this.validateOperationTypes(node.name, name.value);
+        var description = this.collectDescription(node);
         var fields = this.collectFields(node);
         var interfaces = this.collectInterfaces(node);
-        this.ctx.recordTypeName(node.name, name.value);
+        this.recordTypeName(node.name, name, "INTERFACE");
         this.checkForTypenameProperty(node, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            directives: undefined,
-            name: name,
-            fields: fields,
-            interfaces: interfaces !== null && interfaces !== void 0 ? interfaces : undefined
-        });
+        this.definitions.push(this.gql.objectTypeDefinition(node, name, fields, interfaces, description));
     };
@@ -521,21 +497,21 @@ Extractor.prototype.typeTypeAliasDeclaration = function (node, tag) {
             return null;
-        if (!ts.isTypeLiteralNode(node.type)) {
-            this.reportUnhandled(node.type, "Expected `@".concat(TYPE_TAG, "` type to be a type literal. For example: `type Foo = { bar: string }`"));
-            return;
+        var fields = [];
+        var interfaces = null;
+        if (ts.isTypeLiteralNode(node.type)) {
+            this.validateOperationTypes(node.type, name.value);
+            fields = this.collectFields(node.type);
+            interfaces = this.collectInterfaces(node);
+            this.checkForTypenameProperty(node.type, name.value);
         }
-        var description = this.collectDescription(node.name);
-        var fields = this.collectFields(node.type);
-        this.ctx.recordTypeName(node.name, name.value);
-        this.checkForTypenameProperty(node.type, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description !== null && description !== void 0 ? description : undefined,
-            directives: undefined,
-            name: name,
-            fields: fields,
-            // I don't believe there is a reasonable way to specify that a type
-            // implements an interface.
-            interfaces: undefined
-        });
+        else if (node.type.kind === ts.SyntaxKind.UnknownKeyword) {
+            // This is fine, we just don't know what it is. This should be the expected
+            // case for operation types such as `Query`, `Mutation`, and `Subscription`
+            // where there is not strong convention around.
+        }
+        else {
+            return this.report(node.type, E.typeTagOnAliasOfNonObjectOrUnknown());
+        }
+        var description = this.collectDescription(node);
+        this.recordTypeName(node.name, name, "TYPE");
+        this.definitions.push(this.gql.objectTypeDefinition(node, name, fields, interfaces, description));
     };
@@ -548,3 +524,3 @@ Extractor.prototype.checkForTypenameProperty = function (node, expectedName) {
         if (hasTypename) {
-            this.ctx.recordHasTypenameField(expectedName);
+            this.typesWithTypenameField.add(expectedName);
         }
@@ -564,5 +540,4 @@ };
         }
-        this.report(member.name, 
         // TODO: Could show what kind we found, but TS AST does not have node names.
-        "Expected `__typename` to be a property declaration.");
+        this.report(member.name, E.typeNameNotDeclaration());
         return false;
@@ -578,11 +553,11 @@ };
         if (node.initializer == null) {
-            this.report(node.name, "Expected `__typename` property to have an initializer or a string literal type. For example: `__typename = \"MyType\"` or `__typename: \"MyType\";`.");
+            this.report(node.name, E.typeNameMissingInitializer());
             return false;
         }
         if (!ts.isStringLiteral(node.initializer)) {
-            this.report(node.initializer, "Expected `__typename` property initializer to be a string literal. For example: `__typename = \"MyType\"` or `__typename: \"MyType\";`.");
+            this.report(node.initializer, E.typeNameInitializeNotString());
             return false;
         }
         if (node.initializer.text !== expectedName) {
-            this.report(node.initializer, "Expected `__typename` property initializer to be `\"".concat(expectedName, "\"`, found `\"").concat(node.initializer.text, "\"`."));
+            this.report(node.initializer, E.typeNameInitializerWrong(expectedName, node.initializer.text));
             return false;
@@ -594,3 +569,3 @@ }
         if (node.type == null) {
-            this.report(node, "Expected `__typename` property signature to specify the typename as a string literal string type. For example `__typename: \"".concat(expectedName, "\";`"));
+            this.report(node, E.typeNameMissingTypeAnnotation(expectedName));
             return false;
@@ -602,7 +577,7 @@ }
         if (!ts.isLiteralTypeNode(node) || !ts.isStringLiteral(node.literal)) {
-            this.report(node, "Expected `__typename` property signature to specify the typename as a string literal string type. For example `__typename: \"".concat(expectedName, "\";`"));
+            this.report(node, E.typeNameTypeNotStringLiteral(expectedName));
             return false;
         }
         if (node.literal.text !== expectedName) {
-            this.report(node, "Expected `__typename` property to be `\"".concat(expectedName, "\"`"));
+            this.report(node, E.typeNameDoesNotMatchExpected(expectedName));
             return false;
@@ -613,15 +588,40 @@ }
     Extractor.prototype.collectInterfaces = function (node) {
+        this.reportTagInterfaces(node);
+        return ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)
+            ? this.collectHeritageInterfaces(node)
+            : null;
+    };
+    Extractor.prototype.reportTagInterfaces = function (node) {
+        var tag = this.findTag(node, exports.IMPLEMENTS_TAG_DEPRECATED);
+        if (tag == null)
+            return null;
+        if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+            this.report(tag, E.implementsTagOnClass());
+        }
+        if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
+            this.report(tag, E.implementsTagOnInterface());
+        }
+        if (node.kind === ts.SyntaxKind.TypeAliasDeclaration) {
+            this.report(tag, E.implementsTagOnTypeAlias());
+        }
+    };
+    Extractor.prototype.collectHeritageInterfaces = function (node) {
         var _this = this;
         if (node.heritageClauses == null)
             return null;
-        var maybeInterfaces = node.heritageClauses.flatMap(function (clause) {
-            if (clause.token !== ts.SyntaxKind.ImplementsKeyword)
-                return [];
-            return clause.types.map(function (type) {
-                if (!ts.isIdentifier(type.expression)) {
-                    // TODO: Are there valid cases we want to cover here?
-                    return null;
-                }
-                var namedType = _this.gqlNamedType(type.expression, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
-                _this.ctx.markUnresolvedType(type.expression, namedType.name);
+        var maybeInterfaces = node.heritageClauses
+            .filter(function (clause) {
+            if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+                return clause.token === ts.SyntaxKind.ImplementsKeyword;
+            }
+            // Interfaces can only have extends clauses, and those are allowed.
+            return true;
+        })
+            .flatMap(function (clause) {
+            return clause.types
+                .map(function (type) { return type.expression; })
+                .filter(function (expression) { return ts.isIdentifier(expression); })
+                .map(function (expression) {
+                var namedType = _this.gql.namedType(expression, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
+                _this.markUnresolvedType(expression, namedType.name);
                 return namedType;
@@ -636,2 +636,7 @@ });
     };
+    Extractor.prototype.hasGqlTag = function (node) {
+        return ts.getJSDocTags(node).some(function (tag) {
+            return exports.ALL_TAGS.includes(tag.tagName.text);
+        });
+    };
     Extractor.prototype.interfaceInterfaceDeclaration = function (node, tag) {
@@ -642,16 +647,8 @@ var name = this.entityName(node, tag);
         }
-        var description = this.collectDescription(node.name);
+        this.interfaceDeclarations.push(node);
+        var description = this.collectDescription(node);
+        var interfaces = this.collectInterfaces(node);
         var fields = this.collectFields(node);
-        this.ctx.recordTypeName(node.name, name.value);
-        // While GraphQL supports interfaces that extend other interfaces,
-        // TypeScript does not. So we can't support that here either.
-        // In the future we could support classes that act as interfaces through
-        // inheritance.
-        this.definitions.push({
-            kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description || undefined,
-            name: name,
-            fields: fields
-        });
+        this.recordTypeName(node.name, name, "INTERFACE");
+        this.definitions.push(this.gql.interfaceTypeDefinition(node, name, fields, interfaces, description));
     };
@@ -662,5 +659,26 @@ Extractor.prototype.collectFields = function (node) {
         ts.forEachChild(node, function (node) {
+            var e_4, _a;
+            if (ts.isConstructorDeclaration(node)) {
+                try {
+                    // Handle parameter properties
+                    // https://www.typescriptlang.org/docs/handbook/2/classes.html#parameter-properties
+                    for (var _b = __values(node.parameters), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var param = _c.value;
+                        var field = _this.constructorParam(param);
+                        if (field != null) {
+                            fields.push(field);
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
             if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
                 var field = _this.methodDeclaration(node);
-                if (field) {
+                if (field != null) {
                     fields.push(field);
@@ -679,2 +697,54 @@ }
     };
+    Extractor.prototype.constructorParam = function (node) {
+        var tag = this.findTag(node, exports.FIELD_TAG);
+        if (tag == null)
+            return null;
+        if (node.modifiers == null) {
+            return this.report(node, E.parameterWithoutModifiers());
+        }
+        var isParameterProperty = node.modifiers.some(function (modifier) {
+            return modifier.kind === ts.SyntaxKind.PublicKeyword ||
+                modifier.kind === ts.SyntaxKind.PrivateKeyword ||
+                modifier.kind === ts.SyntaxKind.ProtectedKeyword ||
+                modifier.kind === ts.SyntaxKind.ReadonlyKeyword;
+        });
+        if (!isParameterProperty) {
+            return this.report(node, E.parameterWithoutModifiers());
+        }
+        var notPublic = node.modifiers.find(function (modifier) {
+            return modifier.kind === ts.SyntaxKind.PrivateKeyword ||
+                modifier.kind === ts.SyntaxKind.ProtectedKeyword;
+        });
+        if (notPublic != null) {
+            return this.report(notPublic, E.parameterPropertyNotPublic());
+        }
+        var name = this.entityName(node, tag);
+        if (name == null)
+            return null;
+        if (node.type == null) {
+            return this.report(node, E.parameterPropertyMissingType());
+        }
+        var id = node.name;
+        if (ts.isArrayBindingPattern(id) || ts.isObjectBindingPattern(id)) {
+            // TypeScript triggers an error if a binding pattern is used for a
+            // parameter property, so we don't need to report them.
+            // https://www.typescriptlang.org/play?#code/MYGwhgzhAEBiD29oG8BQ1rHgOwgFwCcBXYPeAgCgAciAjEAS2BQDNEBfAShXdXaA
+            return null;
+        }
+        var directives = [];
+        if (id.text !== name.value) {
+            directives = [
+                this.gql.propertyNameDirective(node.name, { name: id.text }),
+            ];
+        }
+        var type = this.collectType(node.type);
+        if (type == null)
+            return null;
+        var deprecated = this.collectDeprecated(node);
+        if (deprecated != null) {
+            directives.push(deprecated);
+        }
+        var description = this.collectDescription(node);
+        return this.gql.fieldDefinition(node, name, this.handleErrorBubbling(node, type), null, directives, description);
+    };
     Extractor.prototype.collectArgs = function (argsParam) {
@@ -685,9 +755,9 @@ var e_5, _a;
         if (argsType == null) {
-            return this.report(argsParam, "Expected GraphQL field arguments to have a TypeScript type. If there are no arguments, you can use `args: never`.");
+            return this.report(argsParam, E.argumentParamIsMissingType());
         }
-        if (argsType.kind === ts.SyntaxKind.NeverKeyword) {
+        if (argsType.kind === ts.SyntaxKind.UnknownKeyword) {
             return [];
         }
         if (!ts.isTypeLiteralNode(argsType)) {
-            return this.report(argsType, "Expected GraphQL field arguments to be typed using a literal object: `{someField: string}`.");
+            return this.report(argsType, E.argumentParamIsNotObject());
         }
@@ -710,3 +780,3 @@ var defaults = null;
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -733,3 +803,3 @@ finally { if (e_5) throw e_5.error; }
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -742,19 +812,20 @@ finally { if (e_6) throw e_6.error; }
         if (ts.isStringLiteral(node)) {
-            return { kind: graphql_1.Kind.STRING, loc: this.loc(node), value: node.text };
+            return this.gql.string(node, node.text);
         }
         else if (ts.isNumericLiteral(node)) {
-            var kind = node.text.includes(".") ? graphql_1.Kind.FLOAT : graphql_1.Kind.INT;
-            return { kind: kind, loc: this.loc(node), value: node.text };
+            return node.text.includes(".")
+                ? this.gql.float(node, node.text)
+                : this.gql.int(node, node.text);
         }
         else if (this.isNullish(node)) {
-            return { kind: graphql_1.Kind.NULL, loc: this.loc(node) };
+            return this.gql.null(node);
         }
         else if (node.kind === ts.SyntaxKind.TrueKeyword) {
-            return { kind: graphql_1.Kind.BOOLEAN, loc: this.loc(node), value: true };
+            return this.gql.boolean(node, true);
         }
         else if (node.kind === ts.SyntaxKind.FalseKeyword) {
-            return { kind: graphql_1.Kind.BOOLEAN, loc: this.loc(node), value: false };
+            return this.gql.boolean(node, false);
         }
         else if (ts.isObjectLiteralExpression(node)) {
-            return this.cellectObjectLiteral(node);
+            return this.collectObjectLiteral(node);
         }
@@ -764,4 +835,3 @@ else if (ts.isArrayLiteralExpression(node)) {
         }
-        this.reportUnhandled(node, "Expected GraphQL field argument default values to be a literal.");
-        return null;
+        return this.reportUnhandled(node, "constant value", E.defaultValueIsNotLiteral());
     };
@@ -787,3 +857,3 @@ Extractor.prototype.collectArrayLiteral = function (node) {
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -795,9 +865,5 @@ finally { if (e_7) throw e_7.error; }
         }
-        return {
-            kind: graphql_1.Kind.LIST,
-            loc: this.loc(node),
-            values: values
-        };
+        return this.gql.list(node, values);
     };
-    Extractor.prototype.cellectObjectLiteral = function (node) {
+    Extractor.prototype.collectObjectLiteral = function (node) {
         var e_8, _a;
@@ -821,3 +887,3 @@ var fields = [];
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -829,14 +895,10 @@ finally { if (e_8) throw e_8.error; }
         }
-        return {
-            kind: graphql_1.Kind.OBJECT,
-            loc: this.loc(node),
-            fields: fields
-        };
+        return this.gql.object(node, fields);
     };
     Extractor.prototype.collectObjectField = function (node) {
         if (!ts.isPropertyAssignment(node)) {
-            return this.reportUnhandled(node, "Expected object literal property to be a property assignment.");
+            return this.reportUnhandled(node, "constant value", E.defaultArgElementIsNotAssignment());
         }
         if (node.name == null) {
-            return this.reportUnhandled(node, "Expected object literal property to have a name.");
+            return this.reportUnhandled(node, "field", E.defaultArgPropertyMissingName());
         }
@@ -848,3 +910,3 @@ var name = this.expectIdentifier(node.name);
         if (initialize == null) {
-            return this.report(node, "Expected object literal property to have an initializer. For example: `{ offset = 10}`.");
+            return this.report(node, E.defaultArgPropertyMissingInitializer());
         }
@@ -854,8 +916,3 @@ var value = this.collectConstValue(initialize);
             return null;
-        return {
-            kind: graphql_1.Kind.OBJECT_FIELD,
-            loc: this.loc(node),
-            name: this.gqlName(node.name, name.text),
-            value: value
-        };
+        return this.gql.constObjectField(node, this.gql.name(node.name, name.text), value);
     };
@@ -865,10 +922,10 @@ Extractor.prototype.collectArg = function (node, defaults) {
             // TODO: How can I create this error?
-            return this.report(node, "Expected GraphQL field argument type to be a property signature.");
+            return this.report(node, E.argIsNotProperty());
         }
         if (!ts.isIdentifier(node.name)) {
             // TODO: How can I create this error?
-            return this.report(node.name, "Expected GraphQL field argument names to be a literal.");
+            return this.report(node.name, E.argNameNotLiteral());
         }
         if (node.type == null) {
-            return this.report(node.name, "Expected GraphQL field argument to have a type.");
+            return this.report(node.name, E.argNotTyped());
         }
@@ -878,6 +935,20 @@ var type = this.collectType(node.type);
             return null;
+        if (type.kind !== graphql_1.Kind.NON_NULL_TYPE && !node.questionToken) {
+            // If a field is passed an argument value, and that argument is not defined in the request,
+            // `graphql-js` will not define the argument property. Therefore we must ensure the argument
+            // is not just nullable, but optional.
+            return this.report(node.name, E.expectedNullableArgumentToBeOptional());
+        }
         if (node.questionToken) {
-            type = this.gqlNullableType(type);
+            // Question mark means we can handle the argument being undefined in the
+            // object literal, but if we are going to type the GraphQL arg as
+            // optional, the code must also be able to handle an explicit null.
+            //
+            // TODO: This will catch { a?: string } but not { a?: string | undefined }.
+            if (type.kind === graphql_1.Kind.NON_NULL_TYPE) {
+                return this.report(node.questionToken, E.nonNullTypeCannotBeOptional());
+            }
+            type = this.gql.nullableType(type);
         }
-        var description = this.collectDescription(node.name);
+        var description = this.collectDescription(node);
         var defaultValue = null;
@@ -890,11 +961,4 @@ if (defaults != null) {
         }
-        return {
-            kind: graphql_1.Kind.INPUT_VALUE_DEFINITION,
-            loc: this.loc(node),
-            description: description || undefined,
-            name: this.gqlName(node.name, node.name.text),
-            type: type,
-            defaultValue: defaultValue || undefined,
-            directives: []
-        };
+        var deprecatedDirective = this.collectDeprecated(node);
+        return this.gql.inputValueDefinition(node, this.gql.name(node.name, node.name.text), type, deprecatedDirective == null ? null : [deprecatedDirective], defaultValue, description);
     };
@@ -906,12 +970,6 @@ Extractor.prototype.enumEnumDeclaration = function (node, tag) {
         }
-        var description = this.collectDescription(node.name);
+        var description = this.collectDescription(node);
         var values = this.collectEnumValues(node);
-        this.ctx.recordTypeName(node.name, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description || undefined,
-            name: name,
-            values: values
-        });
+        this.recordTypeName(node.name, name, "ENUM");
+        this.definitions.push(this.gql.enumTypeDefinition(node, name, values, description));
     };
@@ -926,11 +984,5 @@ Extractor.prototype.enumTypeAliasDeclaration = function (node, tag) {
             return;
-        var description = this.collectDescription(node.name);
-        this.ctx.recordTypeName(node.name, name.value);
-        this.definitions.push({
-            kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
-            loc: this.loc(node),
-            description: description || undefined,
-            name: name,
-            values: values
-        });
+        var description = this.collectDescription(node);
+        this.recordTypeName(node.name, name, "ENUM");
+        this.definitions.push(this.gql.enumTypeDefinition(node, name, values, description));
     };
@@ -947,12 +999,7 @@ Extractor.prototype.enumTypeAliasVariants = function (node) {
             return [
-                {
-                    kind: graphql_1.Kind.ENUM_VALUE_DEFINITION,
-                    name: this.gqlName(node.type.literal, node.type.literal.text),
-                    description: undefined,
-                    loc: this.loc(node)
-                },
+                this.gql.enumValueDefinition(node, this.gql.name(node.type.literal, node.type.literal.text), undefined, null),
             ];
         }
         if (!ts.isUnionTypeNode(node.type)) {
-            this.reportUnhandled(node.type, "Expected `@".concat(ENUM_TAG, "` to be a union type, or a string literal in the edge case of a single value enum."));
+            this.reportUnhandled(node.type, "union", E.enumTagOnInvalidNode());
             return null;
@@ -966,3 +1013,3 @@ }
                     !ts.isStringLiteral(member.literal)) {
-                    this.reportUnhandled(member, "Expected `@".concat(ENUM_TAG, "` enum members to be string literal types. For example: `'foo'`."));
+                    this.reportUnhandled(member, "union member", E.enumVariantNotStringLiteral());
                     continue;
@@ -972,8 +1019,3 @@ }
                 // does not allow comments attached to string literal types.
-                values.push({
-                    kind: graphql_1.Kind.ENUM_VALUE_DEFINITION,
-                    name: this.gqlName(member.literal, member.literal.text),
-                    description: undefined,
-                    loc: this.loc(member)
-                });
+                values.push(this.gql.enumValueDefinition(node, this.gql.name(member.literal, member.literal.text), undefined, null));
             }
@@ -984,3 +1026,3 @@ }
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -999,14 +1041,8 @@ finally { if (e_9) throw e_9.error; }
                     !ts.isStringLiteral(member.initializer)) {
-                    this.reportUnhandled(member, "Expected `@".concat(ENUM_TAG, "` enum members to have string literal initializers. For example: `FOO = 'foo'`."));
+                    this.reportUnhandled(member, "enum value", E.enumVariantMissingInitializer());
                     continue;
                 }
-                var description = this.collectDescription(member.name);
+                var description = this.collectDescription(member);
                 var deprecated = this.collectDeprecated(member);
-                values.push({
-                    kind: graphql_1.Kind.ENUM_VALUE_DEFINITION,
-                    loc: this.loc(member),
-                    description: description || undefined,
-                    name: this.gqlName(member.initializer, member.initializer.text),
-                    directives: deprecated ? [deprecated] : undefined
-                });
+                values.push(this.gql.enumValueDefinition(member, this.gql.name(member.initializer, member.initializer.text), deprecated ? [deprecated] : undefined, description));
             }
@@ -1017,3 +1053,3 @@ }
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -1029,7 +1065,28 @@ finally { if (e_10) throw e_10.error; }
                 // FIXME: Use the _value_'s location not the tag's
-                return this.gqlName(tag, commentName);
+                var locNode = tag;
+                // Test for leading newlines using the raw text
+                var hasLeadingNewlines = /\n/.test(trimTrailingCommentLines(tag.getText()));
+                var hasInternalWhitespace = /\s/.test(commentName);
+                var validationMessage = graphQLNameValidationMessage(commentName);
+                if (hasLeadingNewlines && validationMessage == null) {
+                    // TODO: Offer quick fix.
+                    return this.report(locNode, E.graphQLNameHasLeadingNewlines(commentName, tag.tagName.text));
+                }
+                if (hasLeadingNewlines || hasInternalWhitespace) {
+                    return this.report(locNode, E.graphQLTagNameHasWhitespace(tag.tagName.text));
+                }
+                // No whitespace, but still invalid. We will assume they meant this to
+                // be a GraphQL name but didn't provide a valid identifier.
+                //
+                // NOTE: We can't let GraphQL validation handle this, because it throws rather
+                // than returning a validation message. Presumably because it expects token
+                // validation to be done during lexing/parsing.
+                if (validationMessage !== null) {
+                    return this.report(locNode, validationMessage);
+                }
+                return this.gql.name(locNode, commentName);
             }
         }
         if (node.name == null) {
-            return this.report(node, "Expected GraphQL entity to have a name.");
+            return this.report(node, E.gqlEntityMissingName());
         }
@@ -1039,6 +1096,26 @@ var id = this.expectIdentifier(node.name);
             return null;
-        return this.gqlName(id, id.text);
+        return this.gql.name(id, id.text);
     };
+    // Ensure the type of the ctx param resolves to the declaration
+    // annotated with `@gqlContext`.
+    Extractor.prototype.validateContextParameter = function (node) {
+        if (node.type == null) {
+            return this.report(node, E.expectedTypeAnnotationOnContext());
+        }
+        if (node.type.kind === ts.SyntaxKind.UnknownKeyword) {
+            // If the user just needs to define the argument to get to a later parameter,
+            // they can use `ctx: unknown` to safely avoid triggering a Grats error.
+            return;
+        }
+        if (!ts.isTypeReferenceNode(node.type)) {
+            return this.report(node.type, E.expectedTypeAnnotationOfReferenceOnContext());
+        }
+        // Check for ...
+        if (node.dotDotDotToken != null) {
+            return this.report(node.dotDotDotToken, E.unexpectedParamSpreadForContextParam());
+        }
+        this.contextReferences.push(node.type.typeName);
+    };
     Extractor.prototype.methodDeclaration = function (node) {
-        var tag = this.findTag(node, FIELD_TAG);
+        var tag = this.findTag(node, exports.FIELD_TAG);
         if (tag == null)
@@ -1050,5 +1127,8 @@ return null;
         if (node.type == null) {
-            return this.report(node.name, "Expected GraphQL field to have a type.");
+            return this.report(node.name, E.methodMissingType());
         }
-        var type = this.collectMethodType(node.type);
+        var returnType = this.collectReturnType(node.type);
+        if (returnType == null)
+            return null;
+        var type = returnType.type, isStream = returnType.isStream;
         // We already reported an error
@@ -1062,3 +1142,7 @@ if (type == null)
         }
-        var description = this.collectDescription(node.name);
+        var context = node.parameters[1];
+        if (context != null) {
+            this.validateContextParameter(context);
+        }
+        var description = this.collectDescription(node);
         var id = this.expectIdentifier(node.name);
@@ -1069,4 +1153,9 @@ if (id == null)
         if (id.text !== name.value) {
-            directives = [this.methodNameDirective(node.name, id.text)];
+            directives = [
+                this.gql.propertyNameDirective(node.name, { name: id.text }),
+            ];
         }
+        if (isStream) {
+            directives.push(this.gql.asyncIterableDirective(node.type));
+        }
         var deprecated = this.collectDeprecated(node);
@@ -1076,21 +1165,31 @@ if (deprecated != null) {
         }
-        return {
-            kind: graphql_1.Kind.FIELD_DEFINITION,
-            loc: this.loc(node),
-            description: description || undefined,
-            name: name,
-            arguments: args || undefined,
-            type: this.handleErrorBubbling(node, type),
-            directives: directives.length === 0 ? undefined : directives
-        };
+        return this.gql.fieldDefinition(node, name, this.handleErrorBubbling(node, type), args, directives, description);
     };
-    Extractor.prototype.collectMethodType = function (node) {
-        var inner = this.maybeUnwrapePromise(node);
+    Extractor.prototype.collectReturnType = function (node) {
+        if (ts.isTypeReferenceNode(node)) {
+            var identifier = this.expectIdentifier(node.typeName);
+            if (identifier == null)
+                return null;
+            if (identifier.text == "AsyncIterable") {
+                if (node.typeArguments == null || node.typeArguments.length === 0) {
+                    // TODO: Better error?
+                    return this.report(node, E.promiseMissingTypeArg());
+                }
+                var t_1 = this.collectType(node.typeArguments[0]);
+                if (t_1 == null)
+                    return null;
+                return { type: t_1, isStream: true };
+            }
+        }
+        var inner = this.maybeUnwrapPromise(node);
         if (inner == null)
             return null;
-        return this.collectType(inner);
+        var t = this.collectType(inner);
+        if (t == null)
+            return null;
+        return { type: t, isStream: false };
     };
     Extractor.prototype.collectPropertyType = function (node) {
         // TODO: Handle function types here.
-        var inner = this.maybeUnwrapePromise(node);
+        var inner = this.maybeUnwrapPromise(node);
         if (inner == null)
@@ -1100,3 +1199,3 @@ return null;
     };
-    Extractor.prototype.maybeUnwrapePromise = function (node) {
+    Extractor.prototype.maybeUnwrapPromise = function (node) {
         if (ts.isTypeReferenceNode(node)) {
@@ -1107,4 +1206,4 @@ var identifier = this.expectIdentifier(node.typeName);
             if (identifier.text === "Promise") {
-                if (node.typeArguments == null) {
-                    return this.report(node, "Expected type reference to have type arguments.");
+                if (node.typeArguments == null || node.typeArguments.length === 0) {
+                    return this.report(node, E.promiseMissingTypeArg());
                 }
@@ -1117,16 +1216,12 @@ return node.typeArguments[0];
     Extractor.prototype.collectDescription = function (node) {
-        var symbol = this.ctx.checker.getSymbolAtLocation(node);
-        if (symbol == null) {
-            return this.report(node, "Expected TypeScript to be able to resolve this GraphQL entity to a symbol.");
+        var docs = 
+        // @ts-ignore Exposed as stable in https://github.com/microsoft/TypeScript/pull/53627
+        ts.getJSDocCommentsAndTags(node);
+        var comment = docs
+            .filter(function (doc) { return doc.kind === ts.SyntaxKind.JSDoc; })
+            .map(function (doc) { return doc.comment; })
+            .join("");
+        if (comment) {
+            return this.gql.string(node, comment.trim(), true);
         }
-        var doc = symbol.getDocumentationComment(this.ctx.checker);
-        var description = ts.displayPartsToString(doc);
-        if (description) {
-            return {
-                kind: graphql_1.Kind.STRING,
-                loc: this.loc(node),
-                value: description,
-                block: true
-            };
-        }
         return null;
@@ -1143,15 +1238,9 @@ };
                 // FIXME: Use the _value_'s location not the tag's
-                reason = this.gqlConstArgument(tag, this.gqlName(tag, "reason"), this.gqlString(tag, reasonComment));
+                reason = this.gql.constArgument(tag, this.gql.name(tag, "reason"), this.gql.string(tag, reasonComment));
             }
         }
-        var args = reason == null ? undefined : [reason];
-        return {
-            kind: graphql_1.Kind.DIRECTIVE,
-            loc: this.loc(tag),
-            name: this.gqlName(tag, DEPRECATED_TAG),
-            arguments: args
-        };
+        return this.gql.constDirective(tag.tagName, this.gql.name(node, DEPRECATED_TAG), reason == null ? null : [reason]);
     };
     Extractor.prototype.property = function (node) {
-        var tag = this.findTag(node, FIELD_TAG);
+        var tag = this.findTag(node, exports.FIELD_TAG);
         if (tag == null)
@@ -1163,3 +1252,3 @@ return null;
         if (node.type == null) {
-            this.report(node.name, "Expected GraphQL field to have a type.");
+            this.report(node.name, E.propertyFieldMissingType());
             return null;
@@ -1171,4 +1260,4 @@ }
             return null;
-        var type = node.questionToken == null ? inner : this.gqlNullableType(inner);
-        var description = this.collectDescription(node.name);
+        var type = node.questionToken == null ? inner : this.gql.nullableType(inner);
+        var description = this.collectDescription(node);
         var directives = [];
@@ -1183,14 +1272,10 @@ var id = this.expectIdentifier(node.name);
         if (id.text !== name.value) {
-            directives = [this.methodNameDirective(node.name, id.text)];
+            directives = [
+                this.gql.propertyNameDirective(node.name, { name: id.text }),
+            ];
         }
-        return {
-            kind: graphql_1.Kind.FIELD_DEFINITION,
-            loc: this.loc(node),
-            description: description || undefined,
-            name: name,
-            arguments: undefined,
-            type: this.handleErrorBubbling(node, type),
-            directives: directives.length === 0 ? undefined : directives
-        };
+        return this.gql.fieldDefinition(node, name, this.handleErrorBubbling(node, type), null, directives, description);
     };
+    // TODO: Support separate modes for input and output types
+    // For input nodes and field may only be optional if `null` is a valid value.
     Extractor.prototype.collectType = function (node) {
@@ -1208,9 +1293,8 @@ var _this = this;
                 return null;
-            return this.gqlNonNullType(node, this.gqlListType(node, element));
+            return this.gql.nonNullType(node, this.gql.listType(node, element));
         }
         else if (ts.isUnionTypeNode(node)) {
             var types = node.types.filter(function (type) { return !_this.isNullish(type); });
-            if (types.length !== 1) {
-                this.report(node, "Expected exactly one non-nullish type.");
-                return null;
+            if (types.length === 0) {
+                return this.report(node, E.expectedOneNonNullishType());
             }
@@ -1220,6 +1304,15 @@ var type = this.collectType(types[0]);
                 return null;
+            if (types.length > 1) {
+                var _a = __read(types), first = _a[0], rest = _a.slice(1);
+                // FIXME: If each of `rest` matches `first` this should be okay.
+                var incompatibleVariants = rest.map(function (tsType) {
+                    return (0, DiagnosticError_1.tsRelated)(tsType, "Other non-nullish type");
+                });
+                this.report(first, E.expectedOneNonNullishType(), incompatibleVariants);
+                return null;
+            }
             if (node.types.length > 1) {
-                return this.gqlNullableType(type);
+                return this.gql.nullableType(type);
             }
-            return this.gqlNonNullType(node, type);
+            return this.gql.nonNullType(node, type);
         }
@@ -1230,15 +1323,15 @@ else if (ts.isParenthesizedTypeNode(node)) {
         else if (node.kind === ts.SyntaxKind.StringKeyword) {
-            return this.gqlNonNullType(node, this.gqlNamedType(node, "String"));
+            return this.gql.nonNullType(node, this.gql.namedType(node, "String"));
         }
         else if (node.kind === ts.SyntaxKind.BooleanKeyword) {
-            return this.gqlNonNullType(node, this.gqlNamedType(node, "Boolean"));
+            return this.gql.nonNullType(node, this.gql.namedType(node, "Boolean"));
         }
         else if (node.kind === ts.SyntaxKind.NumberKeyword) {
-            return this.report(node, "Unexpected number type. GraphQL supports both Int and Float, making `number` ambiguous. Instead, import the `Int` or `Float` type from `".concat(LIBRARY_IMPORT_NAME, "` and use that. e.g. `import { Int, Float } from \"").concat(LIBRARY_IMPORT_NAME, "\";`."));
+            return this.report(node, E.ambiguousNumberType());
         }
         else if (ts.isTypeLiteralNode(node)) {
-            return this.report(node, "Unexpected type literal. You may want to define a named GraphQL type elsewhere and reference it here.");
+            return this.report(node, E.unsupportedTypeLiteral());
         }
         // TODO: Better error message. This is okay if it's a type reference, but everything else is not.
-        this.reportUnhandled(node, "Unknown GraphQL type.");
+        this.reportUnhandled(node, "type", E.unknownGraphQLType());
         return null;
@@ -1256,3 +1349,3 @@ };
                 if (node.typeArguments == null) {
-                    return this.report(node, "Expected type reference to have type arguments.");
+                    return this.report(node, E.pluralTypeMissingParameter());
                 }
@@ -1262,3 +1355,3 @@ var element = this.collectType(node.typeArguments[0]);
                     return null;
-                return this.gqlNonNullType(node, this.gqlListType(node, element));
+                return this.gql.nonNullType(node, this.gql.listType(node, element));
             }
@@ -1270,5 +1363,5 @@ default: {
                 // A later pass will resolve the type.
-                var namedType = this.gqlNamedType(node, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
-                this.ctx.markUnresolvedType(node.typeName, namedType.name);
-                return this.gqlNonNullType(node, namedType);
+                var namedType = this.gql.namedType(node, TypeContext_1.UNRESOLVED_REFERENCE_NAME);
+                this.markUnresolvedType(node.typeName, namedType.name);
+                return this.gql.nonNullType(node, namedType);
             }
@@ -1293,12 +1386,24 @@ }
         }
-        return this.report(node, "Expected an identifier.");
+        return this.report(node, E.expectedIdentifier());
     };
     Extractor.prototype.findTag = function (node, tagName) {
-        var _a;
-        return ((_a = ts
+        var tags = ts
             .getJSDocTags(node)
-            .find(function (tag) { return tag.tagName.escapedText === tagName; })) !== null && _a !== void 0 ? _a : null);
+            .filter(function (tag) { return tag.tagName.escapedText === tagName; });
+        if (tags.length === 0) {
+            return null;
+        }
+        if (tags.length > 1) {
+            var additionalTags = tags.slice(1).map(function (tag) {
+                return (0, DiagnosticError_1.tsRelated)(tag, "Additional tag");
+            });
+            var message = tagName === exports.IMPLEMENTS_TAG_DEPRECATED
+                ? E.duplicateInterfaceTag()
+                : E.duplicateTag(tagName);
+            return this.report(tags[0], message, additionalTags);
+        }
+        return tags[0];
     };
     // It is a GraphQL best practice to model all fields as nullable. This allows
-    // the server to handle field level exections by simply returning null for
+    // the server to handle field level executions by simply returning null for
     // that field.
@@ -1308,9 +1413,9 @@ // https://graphql.org/learn/best-practices/#nullability
         var tags = ts.getJSDocTags(parentNode);
-        var killsParentOnExceptions = tags.find(function (tag) { return tag.tagName.text === KILLS_PARENT_ON_EXCEPTION_TAG; });
+        var killsParentOnExceptions = tags.find(function (tag) { return tag.tagName.text === exports.KILLS_PARENT_ON_EXCEPTION_TAG; });
         if (killsParentOnExceptions) {
             if (!this.configOptions.nullableByDefault) {
-                this.report(killsParentOnExceptions.tagName, "Unexpected `@".concat(KILLS_PARENT_ON_EXCEPTION_TAG, "` tag. `@").concat(KILLS_PARENT_ON_EXCEPTION_TAG, "` is only supported when the Grats config `nullableByDefault` is enabled."));
+                this.report(killsParentOnExceptions.tagName, E.killsParentOnExceptionWithWrongConfig());
             }
             if (type.kind !== graphql_1.Kind.NON_NULL_TYPE) {
-                this.report(killsParentOnExceptions.tagName, "Unexpected `@".concat(KILLS_PARENT_ON_EXCEPTION_TAG, "` tag. `@").concat(KILLS_PARENT_ON_EXCEPTION_TAG, "` is unnessesary on fields that are already nullable."));
+                this.report(killsParentOnExceptions.tagName, E.killsParentOnExceptionOnNullable());
             }
@@ -1320,55 +1425,21 @@ return type;
         if (this.configOptions.nullableByDefault) {
-            return this.gqlNullableType(type);
+            return this.gql.nullableType(type);
         }
         return type;
     };
-    Extractor.prototype.methodNameDirective = function (nameNode, name) {
-        return this.gqlConstDirective(nameNode, this.gqlName(nameNode, serverDirectives_1.METHOD_NAME_DIRECTIVE), [
-            this.gqlConstArgument(nameNode, this.gqlName(nameNode, serverDirectives_1.METHOD_NAME_ARG), this.gqlString(nameNode, name)),
-        ]);
-    };
-    Extractor.prototype.exportDirective = function (nameNode, filename, functionName) {
-        return this.gqlConstDirective(nameNode, this.gqlName(nameNode, serverDirectives_1.EXPORTED_DIRECTIVE), [
-            this.gqlConstArgument(nameNode, this.gqlName(nameNode, serverDirectives_1.EXPORTED_FILENAME_ARG), this.gqlString(nameNode, filename)),
-            this.gqlConstArgument(nameNode, this.gqlName(nameNode, serverDirectives_1.EXPORTED_FUNCTION_NAME_ARG), this.gqlString(nameNode, functionName)),
-        ]);
-    };
-    /** GraphQL AST node helper methods */
-    Extractor.prototype.gqlName = function (node, value) {
-        return { kind: graphql_1.Kind.NAME, loc: this.loc(node), value: value };
-    };
-    Extractor.prototype.gqlNamedType = function (node, value) {
-        return {
-            kind: graphql_1.Kind.NAMED_TYPE,
-            loc: this.loc(node),
-            name: this.gqlName(node, value)
-        };
-    };
-    Extractor.prototype.gqlNonNullType = function (node, type) {
-        if (type.kind === graphql_1.Kind.NON_NULL_TYPE) {
-            return type;
-        }
-        return { kind: graphql_1.Kind.NON_NULL_TYPE, loc: this.loc(node), type: type };
-    };
-    Extractor.prototype.gqlNullableType = function (type) {
-        var inner = type;
-        while (inner.kind === graphql_1.Kind.NON_NULL_TYPE) {
-            inner = inner.type;
-        }
-        return inner;
-    };
-    Extractor.prototype.gqlListType = function (node, type) {
-        return { kind: graphql_1.Kind.LIST_TYPE, loc: this.loc(node), type: type };
-    };
-    Extractor.prototype.gqlConstArgument = function (node, name, value) {
-        return { kind: graphql_1.Kind.ARGUMENT, loc: this.loc(node), name: name, value: value };
-    };
-    Extractor.prototype.gqlConstDirective = function (node, name, args) {
-        return { kind: graphql_1.Kind.DIRECTIVE, loc: this.loc(node), name: name, arguments: args };
-    };
-    Extractor.prototype.gqlString = function (node, value) {
-        return { kind: graphql_1.Kind.STRING, loc: this.loc(node), value: value };
-    };
     return Extractor;
 }());
-exports.Extractor = Extractor;
+function graphQLNameValidationMessage(name) {
+    try {
+        (0, graphql_1.assertName)(name);
+        return null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
+// Trims any number of whitespace-only lines including any lines that simply
+// contain a `*` surrounded by whitespace.
+function trimTrailingCommentLines(text) {
+    return text.replace(/(\s*\n\s*\*?\s*)+$/, "");
+}

dist/src/gratsRoot.d.ts

@@ -1,3 +0,2 @@
-import * as ts from "typescript";
-export declare function getRelativeOutputPath(options: ts.ParsedCommandLine, sourceFile: ts.SourceFile): string;
+export declare function relativePath(absolute: string): string;
 export declare function resolveRelativePath(relativePath: string): string;

dist/src/gratsRoot.js

 "use strict";
-exports.__esModule = true;
-exports.resolveRelativePath = exports.getRelativeOutputPath = void 0;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelativePath = exports.relativePath = void 0;
 var path_1 = require("path");
-var ts = require("typescript");
 // Grats parses TypeScript files and finds resolvers. If the field resolver is a
@@ -13,16 +12,7 @@ // named export, Grats needs to be able to import that file during execution.
 // step and the runtime can agree on. This path is that thing.
-var gratsRoot = __dirname;
-function getRelativeOutputPath(options, sourceFile) {
-    var fileNames = ts.getOutputFileNames(options, sourceFile.fileName, true);
-    // ts.getOutputFileNames returns a list of files that includes both the .d.ts
-    // and .js files.
-    var jsFileNames = fileNames.filter(function (fileName) { return fileName.endsWith(".js"); });
-    if (jsFileNames.length !== 1) {
-        throw new Error("Grats: Expected ts.getOutputFileNames to return exactly one `.js` file. " +
-            "Found ".concat(jsFileNames.length, "}. This is a bug in Grats. I'd appreciate it if ") +
-            "you could open an issue.");
-    }
-    return (0, path_1.relative)(gratsRoot, fileNames[0]);
+var gratsRoot = (0, path_1.join)(__dirname, "../..");
+function relativePath(absolute) {
+    return (0, path_1.relative)(gratsRoot, absolute);
 }
-exports.getRelativeOutputPath = getRelativeOutputPath;
+exports.relativePath = relativePath;
 function resolveRelativePath(relativePath) {
@@ -29,0 +19,0 @@ return (0, path_1.resolve)(gratsRoot, relativePath);

dist/src/index.d.ts

@@ -1,10 +0,7 @@
-import { GraphQLSchema } from "graphql";
-import * as ts from "typescript";
+import { ParsedCommandLineGrats } from "./lib";
+import { ReportableDiagnostics, Result } from "./utils/DiagnosticError";
+export { printSDLWithoutDirectives } from "./printSchema";
 export * from "./Types";
 export * from "./lib";
-type RuntimeOptions = {
-    emitSchemaFile?: string;
-};
-export declare function extractGratsSchemaAtRuntime(runtimeOptions: RuntimeOptions): GraphQLSchema;
-export declare function buildSchemaFromSDL(sdl: string): GraphQLSchema;
-export declare function getParsedTsConfig(configPath?: string): ts.ParsedCommandLine;
+export { codegen } from "./codegen";
+export declare function getParsedTsConfig(configFile: string): Result<ParsedCommandLineGrats, ReportableDiagnostics>;

dist/src/index.js

@@ -16,40 +16,15 @@ "use strict";
 };
-exports.__esModule = true;
-exports.getParsedTsConfig = exports.buildSchemaFromSDL = exports.extractGratsSchemaAtRuntime = void 0;
-var graphql_1 = require("graphql");
-var utils_1 = require("@graphql-tools/utils");
-var fs = require("fs");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsedTsConfig = exports.codegen = exports.printSDLWithoutDirectives = void 0;
 var ts = require("typescript");
 var lib_1 = require("./lib");
+var DiagnosticError_1 = require("./utils/DiagnosticError");
+var printSchema_1 = require("./printSchema");
+Object.defineProperty(exports, "printSDLWithoutDirectives", { enumerable: true, get: function () { return printSchema_1.printSDLWithoutDirectives; } });
 __exportStar(require("./Types"), exports);
 __exportStar(require("./lib"), exports);
-// Build an executable schema from a set of files. Note that if extraction
-// fails, this function will exit the process and print a helpful error
-// message.
-function extractGratsSchemaAtRuntime(runtimeOptions) {
-    var _a;
-    var parsedTsConfig = getParsedTsConfig();
-    var schemaResult = (0, lib_1.buildSchemaResult)(parsedTsConfig);
-    if (schemaResult.kind === "ERROR") {
-        console.error(schemaResult.err.formatDiagnosticsWithColorAndContext());
-        process.exit(1);
-    }
-    var runtimeSchema = schemaResult.value;
-    if (runtimeOptions.emitSchemaFile) {
-        runtimeSchema = (0, graphql_1.lexicographicSortSchema)(runtimeSchema);
-        var sdl = (0, utils_1.printSchemaWithDirectives)(runtimeSchema, { assumeValid: true });
-        var filePath = (_a = runtimeOptions.emitSchemaFile) !== null && _a !== void 0 ? _a : "./schema.graphql";
-        fs.writeFileSync(filePath, sdl);
-    }
-    return runtimeSchema;
-}
-exports.extractGratsSchemaAtRuntime = extractGratsSchemaAtRuntime;
-function buildSchemaFromSDL(sdl) {
-    var schema = (0, graphql_1.buildSchema)(sdl);
-    return (0, lib_1.applyServerDirectives)(schema);
-}
-exports.buildSchemaFromSDL = buildSchemaFromSDL;
+var codegen_1 = require("./codegen");
+Object.defineProperty(exports, "codegen", { enumerable: true, get: function () { return codegen_1.codegen; } });
 // #FIXME: Report diagnostics instead of throwing!
-function getParsedTsConfig(configPath) {
-    var configFile = configPath || ts.findConfigFile(process.cwd(), ts.sys.fileExists);
+function getParsedTsConfig(configFile) {
     if (!configFile) {
@@ -61,7 +36,10 @@ throw new Error("Grats: Could not find tsconfig.json");
     var parsed = ts.getParsedCommandLineOfConfigFile(configFile, undefined, configFileHost);
-    if (!parsed || parsed.errors.length > 0) {
-        throw new Error("Grats: Could not parse tsconfig.json");
+    if (!parsed) {
+        throw new Error("Grats: Could not locate tsconfig.json");
     }
-    return parsed;
+    if (parsed.errors.length > 0) {
+        return (0, DiagnosticError_1.err)(DiagnosticError_1.ReportableDiagnostics.fromDiagnostics(parsed.errors));
+    }
+    return (0, DiagnosticError_1.ok)((0, lib_1.validateGratsOptions)(parsed));
 }
 exports.getParsedTsConfig = getParsedTsConfig;

dist/src/lib.d.ts

@@ -1,10 +0,13 @@
-import { GraphQLSchema } from "graphql";
-import { Result, ReportableDiagnostics } from "./utils/DiagnosticError";
+import { DocumentNode, GraphQLSchema } from "graphql";
+import { DiagnosticsResult, Result, ReportableDiagnostics } from "./utils/DiagnosticError";
 import * as ts from "typescript";
-export { applyServerDirectives } from "./serverDirectives";
-export type ConfigOptions = {
-    nullableByDefault?: boolean;
-    reportTypeScriptTypeErrors?: boolean;
-};
-export declare function buildSchemaResult(options: ts.ParsedCommandLine): Result<GraphQLSchema, ReportableDiagnostics>;
-export declare function buildSchemaResultWithHost(options: ts.ParsedCommandLine, compilerHost: ts.CompilerHost): Result<GraphQLSchema, ReportableDiagnostics>;
+import { ExtractionSnapshot } from "./Extractor";
+import { ParsedCommandLineGrats } from "./gratsConfig";
+export * from "./gratsConfig";
+export declare function buildSchemaResult(options: ParsedCommandLineGrats): Result<GraphQLSchema, ReportableDiagnostics>;
+export declare function buildSchemaResultWithHost(options: ParsedCommandLineGrats, compilerHost: ts.CompilerHost): Result<GraphQLSchema, ReportableDiagnostics>;
+/**
+ * Given a merged snapshot representing the whole program, construct a GraphQL
+ * schema document with metadata directives attached.
+ */
+export declare function docFromSnapshot(program: ts.Program, host: ts.CompilerHost, snapshot: ExtractionSnapshot): DiagnosticsResult<DocumentNode>;

dist/src/lib.js

 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -24,2 +13,5 @@ if (k2 === undefined) k2 = k;
 }));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __values = (this && this.__values) || function(o) {
@@ -36,13 +28,36 @@ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
 };
-exports.__esModule = true;
-exports.buildSchemaResultWithHost = exports.buildSchemaResult = exports.applyServerDirectives = void 0;
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.docFromSnapshot = exports.buildSchemaResultWithHost = exports.buildSchemaResult = void 0;
 var graphql_1 = require("graphql");
 var DiagnosticError_1 = require("./utils/DiagnosticError");
 var ts = require("typescript");
-var Extractor_1 = require("./Extractor");
 var TypeContext_1 = require("./TypeContext");
 var validate_1 = require("graphql/validation/validate");
-var serverDirectives_1 = require("./serverDirectives");
-var serverDirectives_2 = require("./serverDirectives");
-__createBinding(exports, serverDirectives_2, "applyServerDirectives");
+var validateTypenames_1 = require("./validations/validateTypenames");
+var snapshotsFromProgram_1 = require("./transforms/snapshotsFromProgram");
+var validateMergedInterfaces_1 = require("./validations/validateMergedInterfaces");
+var validateContextReferences_1 = require("./validations/validateContextReferences");
+var metadataDirectives_1 = require("./metadataDirectives");
+var helpers_1 = require("./utils/helpers");
+var addInterfaceFields_1 = require("./transforms/addInterfaceFields");
+var filterNonGqlInterfaces_1 = require("./transforms/filterNonGqlInterfaces");
+var resolveTypes_1 = require("./transforms/resolveTypes");
+var validateAsyncIterable_1 = require("./validations/validateAsyncIterable");
+__exportStar(require("./gratsConfig"), exports);
 // Construct a schema, using GraphQL schema language
@@ -59,89 +74,24 @@ // Exported for tests that want to intercept diagnostic errors.
 function buildSchemaResultWithHost(options, compilerHost) {
-    var gratsOptions = parseGratsOptions(options);
-    var schemaResult = extractSchema(options, gratsOptions, compilerHost);
+    var schemaResult = extractSchema(options, compilerHost);
     if (schemaResult.kind === "ERROR") {
         return (0, DiagnosticError_1.err)(new DiagnosticError_1.ReportableDiagnostics(compilerHost, schemaResult.err));
     }
-    return (0, DiagnosticError_1.ok)((0, serverDirectives_1.applyServerDirectives)(schemaResult.value));
+    return (0, DiagnosticError_1.ok)(schemaResult.value);
 }
 exports.buildSchemaResultWithHost = buildSchemaResultWithHost;
-// TODO: Make this return diagnostics
-function parseGratsOptions(options) {
-    var _a, _b;
-    var gratsOptions = __assign({}, ((_b = (_a = options.raw) === null || _a === void 0 ? void 0 : _a.grats) !== null && _b !== void 0 ? _b : {}));
-    if (gratsOptions.nullableByDefault === undefined) {
-        gratsOptions.nullableByDefault = true;
+function extractSchema(options, host) {
+    var program = ts.createProgram(options.fileNames, options.options, host);
+    var snapshotsResult = (0, snapshotsFromProgram_1.snapshotsFromProgram)(program, options);
+    if (snapshotsResult.kind === "ERROR") {
+        return snapshotsResult;
     }
-    else if (typeof gratsOptions.nullableByDefault !== "boolean") {
-        throw new Error("Grats: The Grats config option `nullableByDefault` must be a boolean if provided.");
+    var snapshot = reduceSnapshots(snapshotsResult.value);
+    var docResult = docFromSnapshot(program, host, snapshot);
+    if (docResult.kind === "ERROR") {
+        return docResult;
     }
-    if (gratsOptions.reportTypeScriptTypeErrors === undefined) {
-        gratsOptions.reportTypeScriptTypeErrors = false;
-    }
-    else if (typeof gratsOptions.reportTypeScriptTypeErrors !== "boolean") {
-        throw new Error("Grats: The Grats config option `reportTypeScriptTypeErrors` must be a boolean if provided");
-    }
-    // FIXME: Check for unknown options
-    return gratsOptions;
+    return buildSchemaFromDocumentNode(docResult.value, snapshot.typesWithTypenameField);
 }
-function extractSchema(options, gratsOptions, host) {
-    var e_1, _a, e_2, _b;
-    var program = ts.createProgram(options.fileNames, options.options, host);
-    var checker = program.getTypeChecker();
-    var ctx = new TypeContext_1.TypeContext(options, checker, host);
-    var definitions = Array.from(serverDirectives_1.DIRECTIVES_AST.definitions);
-    try {
-        for (var _c = __values(program.getSourceFiles()), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var sourceFile = _d.value;
-            // If the file doesn't contain any GraphQL definitions, skip it.
-            if (!/@gql/i.test(sourceFile.text)) {
-                continue;
-            }
-            if (gratsOptions.reportTypeScriptTypeErrors) {
-                // If the user asked for us to report TypeScript errors, then we'll report them.
-                var typeErrors = ts.getPreEmitDiagnostics(program, sourceFile);
-                if (typeErrors.length > 0) {
-                    return (0, DiagnosticError_1.err)(typeErrors);
-                }
-            }
-            else {
-                // Otherwise, we will only report syntax errors, since they will prevent us from
-                // extracting any GraphQL definitions.
-                var syntaxErrors = program.getSyntacticDiagnostics(sourceFile);
-                if (syntaxErrors.length > 0) {
-                    // It's not very helpful to report multiple syntax errors, so just report
-                    // the first one.
-                    return (0, DiagnosticError_1.err)([syntaxErrors[0]]);
-                }
-            }
-            var extractor = new Extractor_1.Extractor(sourceFile, ctx, gratsOptions);
-            var extractedResult = extractor.extract();
-            if (extractedResult.kind === "ERROR")
-                return extractedResult;
-            try {
-                for (var _e = (e_2 = void 0, __values(extractedResult.value)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var definition = _f.value;
-                    definitions.push(definition);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_b = _e["return"])) _b.call(_e);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_d && !_d.done && (_a = _c["return"])) _a.call(_c);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    var docResult = ctx.resolveTypes({ kind: graphql_1.Kind.DOCUMENT, definitions: definitions });
-    if (docResult.kind === "ERROR")
-        return docResult;
-    var doc = docResult.value;
+// Given a SDL AST, build and validate a GraphQLSchema.
+function buildSchemaFromDocumentNode(doc, typesWithTypenameField) {
     // TODO: Currently this does not detect definitions that shadow builtins
@@ -165,3 +115,3 @@ // (`String`, `Int`, etc). However, if we pass a second param (extending an
     }
-    var typenameDiagnostics = validateTypename(schema, ctx);
+    var typenameDiagnostics = (0, validateTypenames_1.validateTypenames)(schema, typesWithTypenameField);
     if (typenameDiagnostics.length > 0)
@@ -171,22 +121,85 @@ return (0, DiagnosticError_1.err)(typenameDiagnostics);
 }
-function validateTypename(schema, ctx) {
-    var e_3, _a, e_4, _b;
-    var _c, _d;
-    var typenameDiagnostics = [];
-    var abstractTypes = Object.values(schema.getTypeMap()).filter(graphql_1.isAbstractType);
+/**
+ * Given a merged snapshot representing the whole program, construct a GraphQL
+ * schema document with metadata directives attached.
+ */
+function docFromSnapshot(program, host, snapshot) {
+    var e_1, _a, e_2, _b;
+    var checker = program.getTypeChecker();
+    var ctx = new TypeContext_1.TypeContext(checker, host);
+    // Validate the snapshot
+    var mergedResult = (0, DiagnosticError_1.combineResults)((0, validateMergedInterfaces_1.validateMergedInterfaces)(checker, snapshot.interfaceDeclarations), (0, validateContextReferences_1.validateContextReferences)(ctx, snapshot.contextReferences));
+    if (mergedResult.kind === "ERROR") {
+        return mergedResult;
+    }
     try {
-        for (var abstractTypes_1 = __values(abstractTypes), abstractTypes_1_1 = abstractTypes_1.next(); !abstractTypes_1_1.done; abstractTypes_1_1 = abstractTypes_1.next()) {
-            var type = abstractTypes_1_1.value;
-            // TODO: If we already implement resolveType, we don't need to check implementors
-            var typeImplementors = schema.getPossibleTypes(type).filter(graphql_1.isType);
+        // Propagate snapshot data to type context
+        for (var _c = __values(snapshot.unresolvedNames), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), node = _e[0], typeName = _e[1];
+            ctx.markUnresolvedType(node, typeName);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var _f = __values(snapshot.nameDefinitions), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var _h = __read(_g.value, 2), node = _h[0], definition = _h[1];
+            ctx.recordTypeName(node, definition.name, definition.kind);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    // Fixup the schema SDL
+    var definitions = Array.from(metadataDirectives_1.DIRECTIVES_AST.definitions);
+    (0, helpers_1.extend)(definitions, snapshot.definitions);
+    // If you define a field on an interface using the functional style, we need to add
+    // that field to each concrete type as well. This must be done after all types are created,
+    // but before we validate the schema.
+    var definitionsResult = (0, addInterfaceFields_1.addInterfaceFields)(ctx, definitions);
+    if (definitionsResult.kind === "ERROR") {
+        return definitionsResult;
+    }
+    var filteredDoc = (0, filterNonGqlInterfaces_1.filterNonGqlInterfaces)(ctx, {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: definitionsResult.value,
+    });
+    var docResult = (0, resolveTypes_1.resolveTypes)(ctx, filteredDoc);
+    if (docResult.kind === "ERROR")
+        return docResult;
+    var doc = docResult.value;
+    var subscriptionsValidationResult = (0, validateAsyncIterable_1.validateAsyncIterable)(doc);
+    if (subscriptionsValidationResult.kind === "ERROR") {
+        return subscriptionsValidationResult;
+    }
+    return (0, DiagnosticError_1.ok)(doc);
+}
+exports.docFromSnapshot = docFromSnapshot;
+// Given a list of snapshots, merge them into a single snapshot.
+function reduceSnapshots(snapshots) {
+    var e_3, _a, e_4, _b, e_5, _c, e_6, _d, e_7, _e, e_8, _f, e_9, _g;
+    var result = {
+        definitions: [],
+        nameDefinitions: new Map(),
+        unresolvedNames: new Map(),
+        contextReferences: [],
+        typesWithTypenameField: new Set(),
+        interfaceDeclarations: [],
+    };
+    try {
+        for (var snapshots_1 = __values(snapshots), snapshots_1_1 = snapshots_1.next(); !snapshots_1_1.done; snapshots_1_1 = snapshots_1.next()) {
+            var snapshot = snapshots_1_1.value;
             try {
-                for (var typeImplementors_1 = (e_4 = void 0, __values(typeImplementors)), typeImplementors_1_1 = typeImplementors_1.next(); !typeImplementors_1_1.done; typeImplementors_1_1 = typeImplementors_1.next()) {
-                    var implementor = typeImplementors_1_1.value;
-                    if (!ctx.hasTypename.has(implementor.name)) {
-                        var loc = (_d = (_c = implementor.astNode) === null || _c === void 0 ? void 0 : _c.name) === null || _d === void 0 ? void 0 : _d.loc;
-                        if (loc == null) {
-                            throw new Error("Grats expected the parsed type `".concat(implementor.name, "` to have location information. This is a bug in Grats. Please report it."));
-                        }
-                        typenameDiagnostics.push((0, DiagnosticError_1.diagnosticAtGraphQLLocation)("Missing __typename on `".concat(implementor.name, "`. The type `").concat(type.name, "` is used in a union or interface, so it must have a `__typename` field."), loc));
-                    }
+                for (var _h = (e_4 = void 0, __values(snapshot.definitions)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var definition = _j.value;
+                    result.definitions.push(definition);
                 }
@@ -197,6 +210,71 @@ }
                 try {
-                    if (typeImplementors_1_1 && !typeImplementors_1_1.done && (_b = typeImplementors_1["return"])) _b.call(typeImplementors_1);
+                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
                 }
                 finally { if (e_4) throw e_4.error; }
             }
+            try {
+                for (var _k = (e_5 = void 0, __values(snapshot.nameDefinitions)), _l = _k.next(); !_l.done; _l = _k.next()) {
+                    var _m = __read(_l.value, 2), node = _m[0], definition = _m[1];
+                    result.nameDefinitions.set(node, definition);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            try {
+                for (var _o = (e_6 = void 0, __values(snapshot.unresolvedNames)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                    var _q = __read(_p.value, 2), node = _q[0], typeName = _q[1];
+                    result.unresolvedNames.set(node, typeName);
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_p && !_p.done && (_d = _o.return)) _d.call(_o);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            try {
+                for (var _r = (e_7 = void 0, __values(snapshot.contextReferences)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                    var contextReference = _s.value;
+                    result.contextReferences.push(contextReference);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            try {
+                for (var _t = (e_8 = void 0, __values(snapshot.typesWithTypenameField)), _u = _t.next(); !_u.done; _u = _t.next()) {
+                    var typeName = _u.value;
+                    result.typesWithTypenameField.add(typeName);
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_u && !_u.done && (_f = _t.return)) _f.call(_t);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            try {
+                for (var _v = (e_9 = void 0, __values(snapshot.interfaceDeclarations)), _w = _v.next(); !_w.done; _w = _v.next()) {
+                    var interfaceDeclaration = _w.value;
+                    result.interfaceDeclarations.push(interfaceDeclaration);
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_w && !_w.done && (_g = _v.return)) _g.call(_v);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
         }
@@ -207,7 +285,7 @@ }
         try {
-            if (abstractTypes_1_1 && !abstractTypes_1_1.done && (_a = abstractTypes_1["return"])) _a.call(abstractTypes_1);
+            if (snapshots_1_1 && !snapshots_1_1.done && (_a = snapshots_1.return)) _a.call(snapshots_1);
         }
         finally { if (e_3) throw e_3.error; }
     }
-    return typenameDiagnostics;
+    return result;
 }

dist/src/tests/test.js

@@ -60,31 +60,45 @@ "use strict";
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 var path = require("path");
 var TestRunner_1 = require("./TestRunner");
 var lib_1 = require("../lib");
+var ts = require("typescript");
+var graphql_1 = require("graphql");
+var commander_1 = require("commander");
+var Locate_1 = require("../Locate");
+var DiagnosticError_1 = require("../utils/DiagnosticError");
+var fs_1 = require("fs");
+var codegen_1 = require("../codegen");
 var utils_1 = require("@graphql-tools/utils");
-function main() {
-    return __awaiter(this, void 0, void 0, function () {
-        var write, filter, filterRegex, failures, testDirs_1, testDirs_1_1, _a, fixturesDir_1, transformer, runner, e_1_1;
-        var e_1, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+var jest_diff_1 = require("jest-diff");
+var printSchema_1 = require("../printSchema");
+var program = new commander_1.Command();
+program
+    .name("grats-tests")
+    .description("Run Grats' internal tests")
+    .option("-w, --write", "Write the actual output of the test to the expected output files. Useful for updating tests.")
+    .option("-f, --filter <FILTER_REGEX>", "A regex to filter the tests to run. Only tests with a file path matching the regex will be run.")
+    .action(function (_a) {
+    var filter = _a.filter, write = _a.write;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var filterRegex, failures, testDirs_1, testDirs_1_1, _b, fixturesDir_1, transformer, testFilePattern, ignoreFilePattern, runner, e_1_1;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
-                    write = process.argv.some(function (arg) { return arg === "--write"; });
-                    filter = process.argv.find(function (arg) { return arg.startsWith("--filter="); });
-                    filterRegex = filter != null ? filter.slice(9) : null;
+                    filterRegex = filter !== null && filter !== void 0 ? filter : null;
                     failures = false;
-                    _c.label = 1;
+                    _d.label = 1;
                 case 1:
-                    _c.trys.push([1, 6, 7, 8]);
+                    _d.trys.push([1, 6, 7, 8]);
                     testDirs_1 = __values(testDirs), testDirs_1_1 = testDirs_1.next();
-                    _c.label = 2;
+                    _d.label = 2;
                 case 2:
                     if (!!testDirs_1_1.done) return [3 /*break*/, 5];
-                    _a = testDirs_1_1.value, fixturesDir_1 = _a.fixturesDir, transformer = _a.transformer;
-                    runner = new TestRunner_1["default"](fixturesDir_1, write, filterRegex, transformer);
+                    _b = testDirs_1_1.value, fixturesDir_1 = _b.fixturesDir, transformer = _b.transformer, testFilePattern = _b.testFilePattern, ignoreFilePattern = _b.ignoreFilePattern;
+                    runner = new TestRunner_1.default(fixturesDir_1, !!write, filterRegex, testFilePattern, ignoreFilePattern, transformer);
                     return [4 /*yield*/, runner.run()];
                 case 3:
-                    failures = !(_c.sent()) || failures;
-                    _c.label = 4;
+                    failures = !(_d.sent()) || failures;
+                    _d.label = 4;
                 case 4:
@@ -95,3 +109,3 @@ testDirs_1_1 = testDirs_1.next();
                 case 6:
-                    e_1_1 = _c.sent();
+                    e_1_1 = _d.sent();
                     e_1 = { error: e_1_1 };
@@ -101,3 +115,3 @@ return [3 /*break*/, 8];
                     try {
-                        if (testDirs_1_1 && !testDirs_1_1.done && (_b = testDirs_1["return"])) _b.call(testDirs_1);
+                        if (testDirs_1_1 && !testDirs_1_1.done && (_c = testDirs_1.return)) _c.call(testDirs_1);
                     }
@@ -114,11 +128,16 @@ finally { if (e_1) throw e_1.error; }
     });
-}
+});
+var gratsDir = path.join(__dirname, "../..");
 var fixturesDir = path.join(__dirname, "fixtures");
+var integrationFixturesDir = path.join(__dirname, "integrationFixtures");
 var testDirs = [
     {
         fixturesDir: fixturesDir,
+        testFilePattern: /\.ts$/,
+        ignoreFilePattern: null,
         transformer: function (code, fileName) {
             var firstLine = code.split("\n")[0];
             var options = {
-                nullableByDefault: true
+                nullableByDefault: true,
+                schemaHeader: null,
             };
@@ -130,21 +149,115 @@ if (firstLine.startsWith("// {")) {
             }
-            var files = ["".concat(fixturesDir, "/").concat(fileName), "src/Types.ts"];
-            var parsedOptions = {
+            var files = [
+                "".concat(fixturesDir, "/").concat(fileName),
+                path.join(__dirname, "../Types.ts"),
+            ];
+            var parsedOptions = (0, lib_1.validateGratsOptions)({
                 options: {},
                 raw: {
-                    grats: options
+                    grats: options,
                 },
                 errors: [],
-                fileNames: files
-            };
-            var schemaResult = (0, lib_1.buildSchemaResult)(parsedOptions);
+                fileNames: files,
+            });
+            // https://stackoverflow.com/a/66604532/1263117
+            var compilerHost = ts.createCompilerHost(parsedOptions.options, 
+            /* setParentNodes this is needed for finding jsDocs */
+            true);
+            var schemaResult = (0, lib_1.buildSchemaResultWithHost)(parsedOptions, compilerHost);
             if (schemaResult.kind === "ERROR") {
                 return schemaResult.err.formatDiagnosticsWithContext();
             }
-            return (0, utils_1.printSchemaWithDirectives)(schemaResult.value, {
-                assumeValid: true
+            // We run codegen here just ensure that it doesn't throw.
+            var executableSchema = (0, codegen_1.codegen)(schemaResult.value, "".concat(fixturesDir, "/").concat(fileName));
+            var LOCATION_REGEX = /^\/\/ Locate: (.*)/;
+            var locationMatch = code.match(LOCATION_REGEX);
+            if (locationMatch != null) {
+                var locResult = (0, Locate_1.locate)(schemaResult.value, locationMatch[1].trim());
+                if (locResult.kind === "ERROR") {
+                    return locResult.err;
+                }
+                return new DiagnosticError_1.ReportableDiagnostics(compilerHost, [
+                    (0, DiagnosticError_1.gqlErr)(locResult.value, "Located here"),
+                ]).formatDiagnosticsWithContext();
+            }
+            else {
+                var sdl = (0, utils_1.printSchemaWithDirectives)(schemaResult.value, {
+                    assumeValid: true,
+                });
+                return "-- SDL --\n".concat(sdl, "\n-- TypeScript --\n").concat(executableSchema);
+            }
+        },
+    },
+    {
+        fixturesDir: integrationFixturesDir,
+        testFilePattern: /index.ts$/,
+        ignoreFilePattern: /schema.ts$/,
+        transformer: function (code, fileName) { return __awaiter(void 0, void 0, void 0, function () {
+            var filePath, schemaPath, options, files, parsedOptions, schemaResult, tsSchema, server, schemaModule, actualSchema, schemaDiff, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        filePath = "".concat(integrationFixturesDir, "/").concat(fileName);
+                        schemaPath = path.join(path.dirname(filePath), "schema.ts");
+                        options = {
+                            nullableByDefault: true,
+                        };
+                        files = [filePath, path.join(__dirname, "../Types.ts")];
+                        parsedOptions = (0, lib_1.validateGratsOptions)({
+                            options: {
+                                // Required to enable ts-node to locate function exports
+                                rootDir: gratsDir,
+                                outDir: "dist",
+                                configFilePath: "tsconfig.json",
+                            },
+                            raw: {
+                                grats: options,
+                            },
+                            errors: [],
+                            fileNames: files,
+                        });
+                        schemaResult = (0, lib_1.buildSchemaResult)(parsedOptions);
+                        if (schemaResult.kind === "ERROR") {
+                            throw new Error(schemaResult.err.formatDiagnosticsWithContext());
+                        }
+                        tsSchema = (0, codegen_1.codegen)(schemaResult.value, schemaPath);
+                        (0, fs_1.writeFileSync)(schemaPath, tsSchema);
+                        return [4 /*yield*/, Promise.resolve("".concat(filePath)).then(function (s) { return require(s); })];
+                    case 1:
+                        server = _a.sent();
+                        if (server.query == null || typeof server.query !== "string") {
+                            throw new Error("Expected `".concat(filePath, "` to export a query text as `query`"));
+                        }
+                        return [4 /*yield*/, Promise.resolve("".concat(schemaPath)).then(function (s) { return require(s); })];
+                    case 2:
+                        schemaModule = _a.sent();
+                        actualSchema = schemaModule.getSchema();
+                        schemaDiff = compareSchemas(actualSchema, schemaResult.value);
+                        if (schemaDiff) {
+                            console.log(schemaDiff);
+                            // TODO: Make this an actual test failure, not an error
+                            throw new Error("The codegen schema does not match the SDL schema.");
+                        }
+                        return [4 /*yield*/, (0, graphql_1.graphql)({
+                                schema: actualSchema,
+                                source: server.query,
+                                variableValues: server.variables,
+                            })];
+                    case 3:
+                        data = _a.sent();
+                        return [2 /*return*/, JSON.stringify(data, null, 2)];
+                }
             });
-        }
+        }); },
     },
 ];
-main();
+// Returns null if the schemas are equal, otherwise returns a string diff.
+function compareSchemas(actual, expected) {
+    var actualSDL = (0, printSchema_1.printSDLWithoutDirectives)(actual);
+    var expectedSDL = (0, printSchema_1.printSDLWithoutDirectives)(expected);
+    if (actualSDL === expectedSDL) {
+        return null;
+    }
+    return (0, jest_diff_1.diff)(expectedSDL, actualSDL);
+}
+program.parse();

dist/src/tests/TestRunner.d.ts

@@ -15,3 +15,3 @@ type Transformer = (code: string, filename: string) => Promise<string> | string;
     _transformer: Transformer;
-    constructor(fixturesDir: string, write: boolean, filter: string | null, transformer: Transformer);
+    constructor(fixturesDir: string, write: boolean, filter: string | null, testFilePattern: RegExp, ignoreFilePattern: RegExp | null, transformer: Transformer);
     run(): Promise<boolean>;
@@ -18,0 +18,0 @@ _testFixture(fixture: string): Promise<void>;

dist/src/tests/TestRunner.js

@@ -49,3 +49,3 @@ "use strict";
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 var fs = require("fs");
@@ -60,3 +60,3 @@ var path = require("path");
 var TestRunner = /** @class */ (function () {
-    function TestRunner(fixturesDir, write, filter, transformer) {
+    function TestRunner(fixturesDir, write, filter, testFilePattern, ignoreFilePattern, transformer) {
         var e_1, _a;
@@ -74,9 +74,10 @@ this._testFixtures = [];
                 var fileName = _c.value;
-                if (fileName.endsWith(".ts")) {
+                if (testFilePattern.test(fileName)) {
                     this._testFixtures.push(fileName);
-                    if (filterRegex != null && !fileName.match(filterRegex)) {
+                    var filePath = path.join(fixturesDir, fileName);
+                    if (filterRegex != null && !filePath.match(filterRegex)) {
                         this._skip.add(fileName);
                     }
                 }
-                else {
+                else if (!ignoreFilePattern || !ignoreFilePattern.test(fileName)) {
                     this._otherFiles.add(fileName);
@@ -89,3 +90,3 @@ }
             try {
-                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
@@ -123,3 +124,3 @@ finally { if (e_1) throw e_1.error; }
                         try {
-                            if (_b && !_b.done && (_g = _a["return"])) _g.call(_a);
+                            if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
                         }
@@ -149,3 +150,3 @@ finally { if (e_2) throw e_2.error; }
                                     try {
-                                        if (_d && !_d.done && (_h = _c["return"])) _h.call(_c);
+                                        if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
                                     }
@@ -166,3 +167,3 @@ finally { if (e_3) throw e_3.error; }
                                     try {
-                                        if (_f && !_f.done && (_j = _e["return"])) _j.call(_e);
+                                        if (_f && !_f.done && (_j = _e.return)) _j.call(_e);
                                     }
@@ -189,3 +190,3 @@ finally { if (e_4) throw e_4.error; }
                         if (this._otherFiles.has(expectedFileName)) {
-                            this._otherFiles["delete"](expectedFileName);
+                            this._otherFiles.delete(expectedFileName);
                         }
@@ -245,3 +246,3 @@ else {
 }());
-exports["default"] = TestRunner;
+exports.default = TestRunner;
 function readdirSyncRecursive(dir) {
@@ -264,3 +265,3 @@ var e_6, _a, e_7, _b;
                     try {
-                        if (_f && !_f.done && (_b = _e["return"])) _b.call(_e);
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                     }
@@ -278,3 +279,3 @@ finally { if (e_7) throw e_7.error; }
         try {
-            if (_d && !_d.done && (_a = _c["return"])) _a.call(_c);
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
@@ -281,0 +282,0 @@ finally { if (e_6) throw e_6.error; }

dist/src/TypeContext.d.ts

@@ -1,5 +0,9 @@
-import { DocumentNode, NameNode } from "graphql";
+import { NameNode } from "graphql";
 import * as ts from "typescript";
 import { DiagnosticResult, DiagnosticsResult } from "./utils/DiagnosticError";
 export declare const UNRESOLVED_REFERENCE_NAME = "__UNRESOLVED_REFERENCE__";
+export type NameDefinition = {
+    name: NameNode;
+    kind: "TYPE" | "INTERFACE" | "UNION" | "SCALAR" | "INPUT_OBJECT" | "ENUM";
+};
 /**
@@ -20,14 +24,12 @@ * Used to track TypeScript references.
     host: ts.CompilerHost;
-    _options: ts.ParsedCommandLine;
-    _symbolToName: Map<ts.Symbol, string>;
+    _symbolToName: Map<ts.Symbol, NameDefinition>;
     _unresolvedTypes: Map<NameNode, ts.Symbol>;
-    hasTypename: Set<string>;
-    constructor(options: ts.ParsedCommandLine, checker: ts.TypeChecker, host: ts.CompilerHost);
-    recordTypeName(node: ts.Node, name: string): void;
-    recordHasTypenameField(name: string): void;
+    constructor(checker: ts.TypeChecker, host: ts.CompilerHost);
+    recordTypeName(node: ts.Node, name: NameNode, kind: NameDefinition["kind"]): void;
     markUnresolvedType(node: ts.Node, name: NameNode): void;
-    resolveTypes(doc: DocumentNode): DiagnosticsResult<DocumentNode>;
+    findSymbolDeclaration(startSymbol: ts.Symbol): ts.Declaration | null;
+    resolveSymbol(startSymbol: ts.Symbol): ts.Symbol;
     resolveNamedType(unresolved: NameNode): DiagnosticResult<NameNode>;
-    validateInterfaceImplementorsHaveTypenameField(): DiagnosticResult<null>;
-    getDestFilePath(sourceFile: ts.SourceFile): string;
+    unresolvedNameIsGraphQL(unresolved: NameNode): boolean;
+    getNameDefinition(nameNode: NameNode): DiagnosticsResult<NameDefinition>;
 }

dist/src/TypeContext.js

@@ -13,8 +13,7 @@ "use strict";
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeContext = exports.UNRESOLVED_REFERENCE_NAME = void 0;
-var graphql_1 = require("graphql");
 var ts = require("typescript");
 var DiagnosticError_1 = require("./utils/DiagnosticError");
-var gratsRoot_1 = require("./gratsRoot");
+var E = require("./Errors");
 exports.UNRESOLVED_REFERENCE_NAME = "__UNRESOLVED_REFERENCE__";
@@ -34,11 +33,11 @@ /**
 var TypeContext = /** @class */ (function () {
-    function TypeContext(options, checker, host) {
+    function TypeContext(checker, host) {
         this._symbolToName = new Map();
         this._unresolvedTypes = new Map();
-        this.hasTypename = new Set();
-        this._options = options;
         this.checker = checker;
         this.host = host;
     }
-    TypeContext.prototype.recordTypeName = function (node, name) {
+    // Record that a GraphQL construct of type `kind` with the name `name` is
+    // declared at `node`.
+    TypeContext.prototype.recordTypeName = function (node, name, kind) {
         var symbol = this.checker.getSymbolAtLocation(node);
@@ -53,7 +52,5 @@ if (symbol == null) {
         }
-        this._symbolToName.set(symbol, name);
+        this._symbolToName.set(symbol, { name: name, kind: kind });
     };
-    TypeContext.prototype.recordHasTypenameField = function (name) {
-        this.hasTypename.add(name);
-    };
+    // Record that a type reference `node`
     TypeContext.prototype.markUnresolvedType = function (node, name) {
@@ -65,25 +62,23 @@ var symbol = this.checker.getSymbolAtLocation(node);
         }
-        if (symbol.flags & ts.SymbolFlags.Alias) {
-            // Follow any aliases to get the real type declaration.
-            symbol = this.checker.getAliasedSymbol(symbol);
-        }
-        this._unresolvedTypes.set(name, symbol);
+        this._unresolvedTypes.set(name, this.resolveSymbol(symbol));
     };
-    TypeContext.prototype.resolveTypes = function (doc) {
-        var _this = this;
-        var errors = [];
-        var newDoc = (0, graphql_1.visit)(doc, {
-            Name: function (t) {
-                var namedTypeResult = _this.resolveNamedType(t);
-                if (namedTypeResult.kind === "ERROR") {
-                    errors.push(namedTypeResult.err);
-                    return t;
-                }
-                return namedTypeResult.value;
+    TypeContext.prototype.findSymbolDeclaration = function (startSymbol) {
+        var _a;
+        var symbol = this.resolveSymbol(startSymbol);
+        var declaration = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0];
+        return declaration !== null && declaration !== void 0 ? declaration : null;
+    };
+    // Follow symbol aliases until we find the original symbol. Accounts for
+    // cyclical aliases.
+    TypeContext.prototype.resolveSymbol = function (startSymbol) {
+        var symbol = startSymbol;
+        var visitedSymbols = new Set();
+        while (ts.SymbolFlags.Alias & symbol.flags) {
+            if (visitedSymbols.has(symbol)) {
+                throw new Error("Cyclical alias detected. Breaking resolution.");
             }
-        });
-        if (errors.length > 0) {
-            return (0, DiagnosticError_1.err)(errors);
+            visitedSymbols.add(symbol);
+            symbol = this.checker.getAliasedSymbol(symbol);
         }
-        return (0, DiagnosticError_1.ok)(newDoc);
+        return symbol;
     };
@@ -99,23 +94,32 @@ TypeContext.prototype.resolveNamedType = function (unresolved) {
         }
-        var name = this._symbolToName.get(symbol);
-        if (name == null) {
+        var nameDefinition = this._symbolToName.get(symbol);
+        if (nameDefinition == null) {
             if (unresolved.loc == null) {
                 throw new Error("Expected namedType to have a location.");
             }
-            return (0, DiagnosticError_1.err)({
-                messageText: "This type is not a valid GraphQL type. Did you mean to annotate it's definition with a `/** @gql */` tag such as `/** @gqlType */` or `/** @gqlInput **/`?",
-                start: unresolved.loc.start,
-                length: unresolved.loc.end - unresolved.loc.start,
-                category: ts.DiagnosticCategory.Error,
-                code: DiagnosticError_1.FAKE_ERROR_CODE,
-                file: ts.createSourceFile(unresolved.loc.source.name, unresolved.loc.source.body, ts.ScriptTarget.Latest)
-            });
+            return (0, DiagnosticError_1.err)((0, DiagnosticError_1.gqlErr)(unresolved.loc, E.unresolvedTypeReference()));
         }
-        return (0, DiagnosticError_1.ok)(__assign(__assign({}, unresolved), { value: name }));
+        return (0, DiagnosticError_1.ok)(__assign(__assign({}, unresolved), { value: nameDefinition.name.value }));
     };
-    TypeContext.prototype.validateInterfaceImplementorsHaveTypenameField = function () {
-        return (0, DiagnosticError_1.ok)(null);
+    TypeContext.prototype.unresolvedNameIsGraphQL = function (unresolved) {
+        var symbol = this._unresolvedTypes.get(unresolved);
+        return symbol != null && this._symbolToName.has(symbol);
     };
-    TypeContext.prototype.getDestFilePath = function (sourceFile) {
-        return (0, gratsRoot_1.getRelativeOutputPath)(this._options, sourceFile);
+    // TODO: Merge this with resolveNamedType
+    TypeContext.prototype.getNameDefinition = function (nameNode) {
+        var typeNameResult = this.resolveNamedType(nameNode);
+        if (typeNameResult.kind === "ERROR") {
+            return (0, DiagnosticError_1.err)([typeNameResult.err]);
+        }
+        var symbol = this._unresolvedTypes.get(nameNode);
+        if (symbol == null) {
+            // This should have already been handled by resolveNamedType
+            throw new Error("Expected to find unresolved type.");
+        }
+        var nameDefinition = this._symbolToName.get(symbol);
+        if (nameDefinition == null) {
+            // This should have already been handled by resolveNamedType
+            throw new Error("Expected to find name definition.");
+        }
+        return (0, DiagnosticError_1.ok)(nameDefinition);
     };
@@ -122,0 +126,0 @@ return TypeContext;

dist/src/Types.js

 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });

dist/src/utils/DiagnosticError.d.ts

@@ -16,6 +16,9 @@ import { GraphQLError, Location, Source } from "graphql";
 export declare function err<E>(err: E): Err<E>;
+export declare function collectResults<T>(results: DiagnosticsResult<T>[]): DiagnosticsResult<T[]>;
+export declare function combineResults<T, U>(result1: DiagnosticsResult<T>, result2: DiagnosticsResult<U>): DiagnosticsResult<[T, U]>;
 export declare class ReportableDiagnostics {
-    _host: ts.CompilerHost;
+    _host: ts.FormatDiagnosticsHost;
     _diagnostics: ts.Diagnostic[];
-    constructor(host: ts.CompilerHost, diagnostics: ts.Diagnostic[]);
+    constructor(host: ts.FormatDiagnosticsHost, diagnostics: ts.Diagnostic[]);
+    static fromDiagnostics(diagnostics: ts.Diagnostic[]): ReportableDiagnostics;
     formatDiagnosticsWithColorAndContext(): string;
@@ -26,4 +29,7 @@ formatDiagnosticsWithContext(): string;
 export declare function graphQlErrorToDiagnostic(error: GraphQLError): ts.Diagnostic;
-export declare function diagnosticAtGraphQLLocation(message: string, loc: Location): ts.Diagnostic;
+export declare function gqlErr(loc: Location, message: string, relatedInformation?: ts.DiagnosticRelatedInformation[]): ts.Diagnostic;
+export declare function gqlRelated(loc: Location, message: string): ts.DiagnosticRelatedInformation;
+export declare function tsErr(node: ts.Node, message: string, relatedInformation?: ts.DiagnosticRelatedInformation[]): ts.Diagnostic;
+export declare function tsRelated(node: ts.Node, message: string): ts.DiagnosticRelatedInformation;
 export declare function graphqlSourceToSourceFile(source: Source): ts.SourceFile;
 export {};

dist/src/utils/DiagnosticError.js

 "use strict";
-exports.__esModule = true;
-exports.graphqlSourceToSourceFile = exports.diagnosticAtGraphQLLocation = exports.graphQlErrorToDiagnostic = exports.FAKE_ERROR_CODE = exports.ReportableDiagnostics = exports.err = exports.ok = void 0;
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlSourceToSourceFile = exports.tsRelated = exports.tsErr = exports.gqlRelated = exports.gqlErr = exports.graphQlErrorToDiagnostic = exports.FAKE_ERROR_CODE = exports.ReportableDiagnostics = exports.combineResults = exports.collectResults = exports.err = exports.ok = void 0;
 var ts = require("typescript");
@@ -13,2 +49,43 @@ function ok(value) {
 exports.err = err;
+function collectResults(results) {
+    var e_1, _a;
+    var errors = [];
+    var values = [];
+    try {
+        for (var results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
+            var result = results_1_1.value;
+            if (result.kind === "ERROR") {
+                errors.push.apply(errors, __spreadArray([], __read(result.err), false));
+            }
+            else {
+                values.push(result.value);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (errors.length > 0) {
+        return err(errors);
+    }
+    return ok(values);
+}
+exports.collectResults = collectResults;
+function combineResults(result1, result2) {
+    if (result1.kind === "ERROR" && result2.kind === "ERROR") {
+        return err(__spreadArray(__spreadArray([], __read(result1.err), false), __read(result2.err), false));
+    }
+    if (result1.kind === "ERROR") {
+        return result1;
+    }
+    if (result2.kind === "ERROR") {
+        return result2;
+    }
+    return ok([result1.value, result2.value]);
+}
+exports.combineResults = combineResults;
 var ReportableDiagnostics = /** @class */ (function () {
@@ -19,2 +96,12 @@ function ReportableDiagnostics(host, diagnostics) {
     }
+    // If you don't have a host, for example if you error while parsing the
+    // tsconfig, you can use this method and one will be created for you.
+    ReportableDiagnostics.fromDiagnostics = function (diagnostics) {
+        var formatHost = {
+            getCanonicalFileName: function (path) { return path; },
+            getCurrentDirectory: ts.sys.getCurrentDirectory,
+            getNewLine: function () { return ts.sys.newLine; },
+        };
+        return new ReportableDiagnostics(formatHost, diagnostics);
+    };
     ReportableDiagnostics.prototype.formatDiagnosticsWithColorAndContext = function () {
@@ -33,3 +120,3 @@ var formatted = ts.formatDiagnosticsWithColorAndContext(this._diagnostics, this._host);
 exports.ReportableDiagnostics = ReportableDiagnostics;
-// A madeup error code that we use to fake a TypeScript error code.
+// A made-up error code that we use to fake a TypeScript error code.
 // We pick a very random number to avoid collisions with real error messages.
@@ -45,2 +132,3 @@ exports.FAKE_ERROR_CODE = 349389149282;
 function graphQlErrorToDiagnostic(error) {
+    var e_2, _a;
     var position = error.positions[0];
@@ -50,2 +138,34 @@ if (position == null) {
     }
+    // Start with baseline location information
+    var start = position;
+    var length = 1;
+    var relatedInformation;
+    // Nodes have actual ranges (not just a single position), so we we have one
+    // (or more!) use that instead.
+    if (error.nodes != null && error.nodes.length > 0) {
+        var _b = __read(error.nodes), node = _b[0], rest = _b.slice(1);
+        if (node.loc != null) {
+            start = node.loc.start;
+            length = node.loc.end - node.loc.start;
+            if (rest.length > 0) {
+                relatedInformation = [];
+                try {
+                    for (var rest_1 = __values(rest), rest_1_1 = rest_1.next(); !rest_1_1.done; rest_1_1 = rest_1.next()) {
+                        var relatedNode = rest_1_1.value;
+                        if (relatedNode.loc == null) {
+                            continue;
+                        }
+                        relatedInformation.push(gqlRelated(relatedNode.loc, "Related location"));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (rest_1_1 && !rest_1_1.done && (_a = rest_1.return)) _a.call(rest_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+    }
     var sourceFile;
@@ -60,9 +180,9 @@ if (error.source != null) {
         category: ts.DiagnosticCategory.Error,
-        start: position,
-        // FIXME: Improve ranges
-        length: 1
+        start: start,
+        length: length,
+        relatedInformation: relatedInformation,
     };
 }
 exports.graphQlErrorToDiagnostic = graphQlErrorToDiagnostic;
-function diagnosticAtGraphQLLocation(message, loc) {
+function gqlErr(loc, message, relatedInformation) {
     return {
@@ -74,6 +194,44 @@ messageText: message,
         start: loc.start,
-        length: loc.end - loc.start
+        length: loc.end - loc.start,
+        relatedInformation: relatedInformation,
     };
 }
-exports.diagnosticAtGraphQLLocation = diagnosticAtGraphQLLocation;
+exports.gqlErr = gqlErr;
+function gqlRelated(loc, message) {
+    return {
+        category: ts.DiagnosticCategory.Message,
+        code: exports.FAKE_ERROR_CODE,
+        messageText: message,
+        file: graphqlSourceToSourceFile(loc.source),
+        start: loc.start,
+        length: loc.end - loc.start,
+    };
+}
+exports.gqlRelated = gqlRelated;
+function tsErr(node, message, relatedInformation) {
+    var start = node.getStart();
+    var length = node.getEnd() - start;
+    var sourceFile = node.getSourceFile();
+    return {
+        messageText: message,
+        file: sourceFile,
+        code: exports.FAKE_ERROR_CODE,
+        category: ts.DiagnosticCategory.Error,
+        start: start,
+        length: length,
+        relatedInformation: relatedInformation,
+    };
+}
+exports.tsErr = tsErr;
+function tsRelated(node, message) {
+    return {
+        category: ts.DiagnosticCategory.Message,
+        code: 0,
+        file: node.getSourceFile(),
+        start: node.getStart(),
+        length: node.getWidth(),
+        messageText: message,
+    };
+}
+exports.tsRelated = tsRelated;
 function graphqlSourceToSourceFile(source) {
@@ -80,0 +238,0 @@ return ts.createSourceFile(source.name, source.body, ts.ScriptTarget.Latest);

package.json

 {
   "name": "grats",
-  "version": "0.0.0-main-bbba151a",
+  "version": "0.0.0-main-bd5d99a2",
   "main": "dist/src/index.js",
@@ -12,8 +12,8 @@ "bin": "dist/src/cli.js",
   "dependencies": {
-    "@graphql-tools/utils": "^9.2.1",
     "commander": "^10.0.0",
     "graphql": "^16.6.0",
-    "typescript": "^4.9.5"
+    "typescript": "^5.0.2"
   },
   "devDependencies": {
+    "@graphql-tools/utils": "^9.2.1",
     "@types/node": "^18.14.6",
@@ -26,2 +26,3 @@ "@typescript-eslint/eslint-plugin": "^5.55.0",
     "path-browserify": "^1.0.1",
+    "prettier": "^2.8.7",
     "process": "^0.11.10",
@@ -33,8 +34,14 @@ "ts-node": "^10.9.1"
   },
+  "packageManager": "pnpm@8.12.0",
+  "engines": {
+    "node": ">=16 <=21",
+    "pnpm": "^8"
+  },
   "scripts": {
-    "test": "ts-node --esm src/tests/test.ts",
+    "test": "ts-node src/tests/test.ts",
     "integration-tests": "node src/tests/integration.mjs",
     "build": "tsc --build",
-    "lint": "eslint src/**/*.ts"
+    "format": "prettier . --write",
+    "lint": "eslint src/**/*.ts && prettier . --check"
   }
 }

README.md

@@ -1,5 +0,1 @@
-# -=[  EXPERIMENTAL PRE ALPHA ]=-
-
-**This is currently a proof of concept. It won't yet work on any real projects.**
-
 # Grats: Implementation-First GraphQL for TypeScript
@@ -9,44 +5,28 @@
 
-Grats is a tool for statically infering GraphQL schema from your vanilla
-TypeScript code.
+_Beta Software: Grats is largely stable and being used in production in multiple places. If you encounter any issues, dont hesitate to let us know._
 
-Just write your types and resolvers as regular TypeScript and annotate your
-types and fields with simple JSDoc tags. From there, Grats can extract your
-GraphQL schema automatically by statically analyzing your code and its types. No
-convoluted directive APIs to remember. No need to define your Schema at
-runtime with verbose builder APIs. 
+**What if building a GraphQL server were as simple as just writing functions?**
 
-By making your TypeScript implementation the source of truth, you entirely
-remove the question of mismatches between your implementation and your GraphQL
-schema definition. Your implementation _is_ the schema definition!
+When you write your GraphQL server in TypeScript, your fields and resolvers
+are _already_ annotated with type information. _Grats leverages your existing
+type annotations to automatically extract an executable GraphQL schema from your
+generic TypeScript resolver code._
 
+By making your TypeScript implementation the source of truth, you never have to
+worry about validating that your implementation matches your schema. Your
+implementation _is_ your schema!
+
 ## Example
 
+Here's what it looks like to define a User type with a greeting field using Grats:
+
 ```ts
 /** @gqlType */
-export default class Query {
+class User {
   /** @gqlField */
-  me(): UserResolver {
-    return new UserResolver();
-  }
-  /** 
-   * @gqlField
-   * @deprecated Please use `me` instead.
-   */
-  viewer(): UserResolver {
-    return new UserResolver();
-  }
-}
+  name: string;
 
-/**
- * A user in our kick-ass system!
- * @gqlType User
- */
-class UserResolver {
   /** @gqlField */
-  name: string = 'Alice';
-
-  /** @gqlField */
-  greeting(args: { salutation: string }): string {
-    return `${args.salutation}, ${this.name}`;
+  greet(args: { greeting: string }): string {
+    return `${args.greeting}, ${this.name}`;
   }
@@ -56,432 +36,13 @@ }
 
-Extracts the following GraphQL schema:
+After running `npx grats`, you'll find a `schema.ts` module that exports an executable schema, and a `schema.graphql` file contins your GraphQL schema definition:
 
 ```graphql
-type Query {
-  me: User
-  viewer: User @deprecated(reason: "Please use `me` instead.")
-}
-
-"""A user in our kick-ass system!"""
 type User {
   name: String
-  greeting(salutation: String!): String
+  greet(greeting: String!): String
 }
 ```
 
-**Give it a try in the [online playground](https://capt.dev/grats-sandbox)!**
+That's just the begining! To learn more, **Read the docs: https://grats.capt.dev/**
 
-## Quick Start
-
-For dev mode or small projects, Grats offers a runtime extraction mode. This is
-the easiest way to get started with Grats, although you may find that it causes
-a slow startup time. For larger projects, you probably want to use the build
-mode (documentation to come).
-
-```sh
-npm install express express-graphql grats
-```
-
-**Ensure your project has a `tsconfig.json` file.**
-
-```ts
-import * as express from "express";
-import { graphqlHTTP } from "express-graphql";
-import { extractGratsSchemaAtRuntime } from "grats";
-
-/** @gqlType */
-class Query {
-  /** @gqlField */
-  hello(): string {
-    return "Hello world!";
-  }
-}
-
-const app = express();
-
-// At runtime Grats will parse your TypeScript project (including this file!) and
-// extract the GraphQL schema.
-const schema = extractGratsSchemaAtRuntime({
-  emitSchemaFile: "./schema.graphql",
-});
-
-app.use(
-  "/graphql",
-  graphqlHTTP({ schema, rootValue: new Query(), graphiql: true }),
-);
-app.listen(4000);
-console.log("Running a GraphQL API server at http://localhost:4000/graphql");
-```
-
-Try it out on [CodeSandbox](https://capt.dev/grats-sandbox)!
-
-## Configuration
-
-Grats has a few configuration options. They can be set in your project's
-`tsconfig.json` file:
-
-```json5
-{
-  "grats": {
-    // Should all fields be typed as nullable in accordance with GraphQL best
-    // practices?
-    // https://graphql.org/learn/best-practices/#nullability
-    // 
-    // Individual fileds can declare themselves as nonnullable by adding the
-    // docblock tag `@killsParentOnException`.
-    "nullableByDefault": true, // Default: true
-
-    // Should Grats error if it encounters a TypeScript type error?
-    // Note that Grats will always error if it encounters a TypeScript syntax
-    // error.
-    "reportTypeScriptTypeErrors": false, // Default: false
-  },
-  "compilerOptions": {
-    // ... TypeScript config...
-  }
-}
-```
-
-## API Usage
-
-In order for Grats to extract GraphQL schema from your code, simply mark which
-TypeScript structures should be included in the schema by marking them with
-special JSDoc tags such as `/** @gqlType */` or `/** @gqlField */`.
-
-Any comment text preceding the JSDoc `@` tag will be used as that element's description.
-
-**Note that JSDocs must being with `/**` (two asterix).** However, they may be consolidated into a single line.
-
-The following JSDoc tags are supported:
-
-* [`@gqlType`](#gqltype)
-* [`@gqlInterface`](#gqlinterface)
-* [`@gqlField`](#gqlfield)
-* [`@gqlUnion`](#gqlunion)
-* [`@gqlScalar`](#gqlscalar)
-* [`@gqlEnum`](#gqlenum)
-* [`@gqlInput`](#gqlinput)
-
-Each tag maps directly to a concept in the GraphQL [Schema Definition
-Language](https://graphql.org/learn/schema/) (SDL). The documentation below aims
-to be complete, but our hope is that you feel empowered to just slap one of
-these docblock tags on the relevent TypeScript class/type/method/etc in your
-code, and let Grats' helpful error messages guide you.
-
-### @gqlType
-
-GraphQL types can be defined by placing a `@gqlType` docblock directly before a:
-
-* Class declaration
-* Interface declaration
-* Type alias of a literal type
-
-```ts
-/**
- * Here I can write a description of my type that will be included in the schema.
- * @gqlType <optional name of the type, if different from class name>
- */
-class MyClass {
-  /** @gqlField */
-  someField: string;
-}
-```
-
-```ts
-/** @gqlType */
-interface MyType {
-  /** @gqlField */
-  someField: string;
-}
-```
-
-```ts
-/** @gqlType */
-type MyType = {
-  /** @gqlField */
-  someField: string;
-}
-```
-
-Note: If your type implements a GraphQL interface or is a member of a GraphQL
-union, Grats will remind you to add a `__typename: "MyType"` property to your
-class or interface.
-
-### @gqlInterface
-
-GraphQL interfaces can be defined by placing a `@gqlInterface` docblock directly before an:
-
-* Interface declaration
-
-```ts
-/**
- * A description of my interface.
- * @gqlInterface <optional name of the type, if different from class name>
- */
-interface MyClass {
-  /** @gqlField */
-  someField: string;
-}
-```
-
-All `@gqlType` types which implement the interface in TypeScript will
-automatically implement it in GraphQL as well.
-
-**Note**: Types declared using type literals `type MyType = { ... }` cannot yet
-implement interfaces. For now, you must use a class declarations for types which
-implement interfaces.
-
-### @gqlField
-
-You can define GraphQL fields by placing a `@gqlField` directly before a:
-
-* Method declaration
-* Method signature
-* Property declaration
-* Property signature
-* Function declaration (with named export)
-
-```ts
-/**
- * A description of some field.
- * @gqlField <optional name of the field, if different from property name>
- */
-someField: string;
-
-/** @gqlField */
-myField(): string {
-  return "Hello World";
-}
-```
-
-#### Field nullability
-
-**Note**: By default, Grats makes all fields nullable in keeping with [GraphQL
-*best practices](https://graphql.org/learn/best-practices/#nullability). This
-*behavior can be changed by setting the config option `nullableByDefault` to
-`false`.
-
-With `nullableByDefault` _enabled_, you may declare an individual field as
-nonnullable adding the docblock tag `@killsParentOnException`.  This will cause
-the field to be typed as non-nullable, but _it comes at a price_.  Should the
-resolver throw, the error will bubble up to the first nullable parent. If
-`@killsParentOnException` is used too liberally, small errors can take down huge
-portions of your query.
-
-Dissabling `nullableByDefault` is equivilent to marking all nonnullable fields
-with `@killsParentOnException`.
-
-```ts
-/**
- * @gqlField 
- * @killsParentOnException
- */
-myField(): string {
-  return this.someOtherMethod();
-}
-```
-
-#### Field arguments
-
-If you wish to define arguments for a field, define your argument types inline:
-
-```ts
-/** @gqlField */
-myField(args: { greeting: string }): string {
-  return `${args.greeting} World`;
-}
-```
-
-Default values for arguments can be defined by using the `=` operator with destructuring:
-
-```ts
-/** @gqlField */
-myField({ greeting = "Hello" }: { greeting: string }): string {
-  return `${greeting} World`;
-}
-```
-
-```ts
-/** @gqlField */
-myField({ greeting = { salutation: "Sup" } }: { greeting: GreetingConfig }): string {
-  return `${greeting.salutation} World`;
-}
-```
-
-#### Field descriptions
-
-Arguments can be given descriptions by using the `/**` syntax:
-
-```ts
-/** @gqlField */
-myField(args: { 
-  /** A description of the greeting argument */
-  greeting: string
-}): string {
-  return `${args.greeting} World`;
-}
-```
-
-#### Deprecated fields
-
-To mark a field as deprecated, use the `@deprecated` JSDoc tag:
-
-```ts
-/** 
- * @gqlField
- * @deprecated Please use myNewField instead.
- */
-myOldField(): string {
-  return "Hello World";
-}
-```
-
-#### Functional style fields
-
-Sometimes you want to add a computed field to a non-class type, or extend base
-types like `Query` or `Mutation` from another file. Both of these usecases are
-enabled by placing a `@gqlField` before an exported function declaration.
-
-In this case, the function should expect an instance of the base type as the
-first argument, and an object representing the GraphQL field arguments as the
-second argument. The function should return the value of the field.
-
-Extending Query:
-
-```ts
-/** @gqlField */
-export function userById(_: Query, args: {id: string}): User {
-  return DB.getUserById(args.id);
-}
-```
-
-Extending Mutation:
-
-```ts
-/** @gqlField */
-export function deleteUser(_: Mutation, args: {id: string}): boolean {
-  return DB.deleteUser(args.id);
-}
-```
-
-Note that Grats will use the type of the first argument to determine which type
-is being extended. So, as seen in the previous examples, even if you don't need
-access to the instance you should still define a typed first argument.
-
-### @gqlUnion
-
-GraphQL unions can be defined by placing a `@gqlUnion` docblock directly before a:
-
-* Type alias of a union of object types
-
-```ts
-/** 
- * A description of my union.
- * @gqlUnion <optional name of the union, if different from type name>
- */
-type MyUnion = User | Post;
-```
-
-### @gqlScalar
-
-GraphQL custom sclars can be defined by placing a `@gqlScalar` docblock directly before a:
-
-* Type alias declaration
-
-```ts
-/** 
- * A description of my custom scalar.
- * @gqlScalar <optional name of the scalar, if different from type name>
- */
-type MyCustomString = string;
-```
-
-Note: For the built-in GraphQL scalars that don't have a corresponding TypeScript type, Grats ships with type aliases you can import. You may be promted to use one of these by Grat if you try to use `number` in a positon from which Grat needs to infer a GraphQL type.
-
-```ts
-import { Float, Int, ID } from "grats";
-
-/** @gqlType */
-class Math {
-  id: ID;
-  /** @gqlField */
-  round(args: {float: Float}): Int {
-    return Math.round(args.float);
-  }
-}
-```
-
-### @gqlEnum
-
-GraphQL enums can be defined by placing a `@gqlEnum` docblock directly before a:
-
-* TypeScript enum declaration
-* Type alias of a union of string literals
-
-```ts
-/** 
- * A description of my enum.
- * @gqlEnum <optional name of the enum, if different from type name>
- */
-enum MyEnum {
-  /** A description of my variant */
-  OK = "OK",
-  /** A description of my other variant */
-  ERROR = "ERROR"
-}
-```
-
-Note that the values of the enum are used as the GraphQL enum values, and must
-be string literals.
-
-To mark a variants as deprecated, use the `@deprecated` JSDoc tag directly before it:
-
-```ts
-/** @gqlEnum */
-enum MyEnum {
-  OK = "OK"
-  /** @deprecated Please use OK instead. */
-  OKAY = "OKAY"
-  ERROR = "ERROR"
-}
-```
-
-We also support defining enums using a union of string literals, however there
-are some limitations to this approach:
-
-* You cannot add descriptions to enum values
-* You cannot mark enum values as deprecated
-
-This is due to the fact that TypeScript does not see JSDoc comments as
-"attaching" to string literal types.
-
-```ts
-/** @gqlEnum */
-type MyEnum = "OK" | "ERROR";
-```
-
-### @gqlInput
-
-GraphQL input types can be defined by placing a `@gqlInput` docblock directly before a:
-
-* Type alias declaration
-
-```ts
-/** 
- * Description of my input type
- * @gqlInput <optional name of the input, if different from type name>
- */
-type MyInput = {
-  name: string;
-  age: number;
-};
-```
-
-## Example
-
-See `examples/express-graphql/` in the repo root for a working example. Here we
-run the static analysis at startup time. Nice for development, but not ideal for
-production where you would want to cache the schema and write it to disk for
-other tools to see.
-
 ## Contributing
@@ -491,49 +52,11 @@
 
-# FAQ
-
-## Why would I _not_ want to use Grats
-
-Because Grats relies on static analysis to infer types, it requires that your
-GraphQL fields use types that can be statically analyzed.  This means that you
-can't use complex derived types in positions where Grats needs to be able to
-infer the type. For example, field arguments and return values. 
-
-Currently, Grats does not have a great way to handle the case where you want to
-expose structures that are not owned by your codebase. For example, if you want
-to expose a field that returns a type from a third-party library, or a type that
-is generated by some other codegen tool. Today, your best option is to define a
-wrapper resolver class.
-
-## Why use comments and not decorators?
-
-Using decorators to signal that a class/method/etc should be included in the 
-schema would have some advantages:
-
-* The syntax is well defined, so it:
-  * Can be checked/documented by TypeScript types
-  * Formatted with tools like Prettier
-* Would not require custom parsing/validaiton rules
-
-However, it also has some disadvantages:
-
-* The feature is technically "experimental" in TypeScript and may change in the future.
-* Decorators cannot be applied to types, so it would precude the ability to
-  define GraphQL constructs using types (e.g. interfaces, unions, etc).
-* Decorators cannot be applied to parameters, so it would preclude the ability
-  to define GraphQL constructs using parameters (e.g. field arguments).
-* Decorators are a runtime construct, which means they must be imported and give
-  the impression that they might have some runtime behavior. This is not the
-  case for Grats, which is purely a static analysis tool.
-
-Given these tradeoffs, we've decided to use comments instead of decorators.
-
 # Acknowledgements
 
-* [@mofeiZ](https://github.com/mofeiZ) and [@alunyov](https://github/alunyov) for their Relay hack-week project exploring a similar idea.
-* [@josephsavona](https://github.com/josephsavona) for input on the design of [Relay Resolvers](https://relay.dev/docs/guides/relay-resolvers/) which inspired this project.
-* [@bradzacher](https://github.com/bradzacher) for tips on how to handle TypeScript ASTs.
-* Everyone who worked on Meta's Hack GraphQL server, the developer experince of which inspired this project.
-* A number of other projects which seem to have explored similar ideas in the past:
-  * [ts2gql](https://github.com/convoyinc/ts2gql)
-  * [ts2graphql](https://github.com/cevek/ts2graphql)
-  * [typegraphql-reflection-poc](https://github.com/MichalLytek/typegraphql-reflection-poc)
+- [@mofeiZ](https://github.com/mofeiZ) and [@alunyov](https://github/alunyov) for their Relay hack-week project exploring a similar idea.
+- [@josephsavona](https://github.com/josephsavona) for input on the design of [Relay Resolvers](https://relay.dev/docs/guides/relay-resolvers/) which inspired this project.
+- [@bradzacher](https://github.com/bradzacher) for tips on how to handle TypeScript ASTs.
+- Everyone who worked on Meta's Hack GraphQL server, the developer experince of which inspired this project.
+- A number of other projects which seem to have explored similar ideas in the past:
+  - [ts2gql](https://github.com/convoyinc/ts2gql)
+  - [ts2graphql](https://github.com/cevek/ts2graphql)
+  - [typegraphql-reflection-poc](https://github.com/MichalLytek/typegraphql-reflection-poc)

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

280393

increased by99.08%

Dependency count

3

decreased by-25%

Number of package files

107

increased by328%

Lines of code

6148

increased by132%

Worsened metrics

Dev dependency count

11

increased by22.22%

Number of lines in readme file

60

decreased by-88.83%

Number of low supply chain risk alerts

6

increased by20%

Dependency changes

• + Addedtypescript@5.7.3(transitive)

• - Removed@graphql-tools/utils@^9.2.1

• - Removed@graphql-tools/utils@9.2.1(transitive)

• - Removed@graphql-typed-document-node/core@3.2.0(transitive)

• - Removedtslib@2.8.1(transitive)

• - Removedtypescript@4.9.5(transitive)

• Updatedtypescript@^5.0.2