[WIP] Work on using external modules

TODO.md

@@ -0,0 +1,8 @@
+- [x] SDL should extend type for external types - I guess marking types in SDL
+  - [ ] can't generate graphql-js stuff, don't want to do it for externs - don't support graphql-js for this?
+- [ ] all imported types (so support interfaces etc)
+- [ ] Read SDL to actually do validation
+  - [ ] reenable global validations
+- [ ] "modular" mode? like no full schema, but parts of schema but with full validation by resolving it?
+- [ ] all tests to add fixtures for metadata/resolver map
+- [ ] pluggable module resolution - too many variables there, use filepath by default, let users customize it

src/Errors.ts

@@ -602,3 +602,7 @@ export function noTypesDefined() {
 export function tsConfigNotFound(cwd: string) {
   return `Grats: Could not find \`tsconfig.json\` searching in ${cwd}.\n\nSee https://www.typescriptlang.org/download/ for instructors on how to add TypeScript to your project. Then run \`npx tsc --init\` to create a \`tsconfig.json\` file.`;
 }
+
+export function noModuleInGqlExternal() {
+  return `Grats: @gqlExternal must include a module name in double quotes. For example: /** @gqlExternal "myModule" */`;
+}

src/Extractor.ts

@@ -58,6 +58,8 @@ export const INFO_TAG = "gqlInfo";
 export const IMPLEMENTS_TAG_DEPRECATED = "gqlImplements";
 export const KILLS_PARENT_ON_EXCEPTION_TAG = "killsParentOnException";
 
+export const EXTERNAL_TAG = "gqlExternal";
+
 // All the tags that start with gql
 export const ALL_TAGS = [
   TYPE_TAG,
@@ -67,6 +69,7 @@ export const ALL_TAGS = [
   ENUM_TAG,
   UNION_TAG,
   INPUT_TAG,
+  EXTERNAL_TAG,
 ];
 
 const DEPRECATED_TAG = "deprecated";
@@ -131,12 +134,12 @@ class Extractor {
     node: ts.DeclarationStatement,
     name: NameNode,
     kind: NameDefinition["kind"],
+    externalImportPath: string | null = null,
   ): void {
-    this.nameDefinitions.set(node, { name, kind });
+    this.nameDefinitions.set(node, { name, kind, externalImportPath });
   }
 
-  // Traverse all nodes, checking each one for its JSDoc tags.
-  // If we find a tag we recognize, we extract the relevant information,
+  // Traverse all nodes, checking each one for its JSDoc tags.  // If we find a tag we recognize, we extract the relevant information,
   // reporting an error if it is attached to a node where that tag is not
   // supported.
   extract(sourceFile: ts.SourceFile): DiagnosticsResult<ExtractionSnapshot> {
@@ -254,6 +257,12 @@ class Extractor {
           }
           break;
         }
+        case EXTERNAL_TAG:
+          if (!this.hasTag(node, TYPE_TAG)) {
+            this.report(tag.tagName, E.specifiedByOnWrongNode());
+          }
+          break;
+
         default:
           {
             const lowerCaseTag = tag.tagName.text.toLowerCase();
@@ -980,6 +989,7 @@ class Extractor {
     let interfaces: NamedTypeNode[] | null = null;
 
     let hasTypeName = false;
+    let externalImportPath: string | null = null;
 
     if (ts.isTypeLiteralNode(node.type)) {
       this.validateOperationTypes(node.type, name.value);
@@ -990,24 +1000,33 @@ class Extractor {
       // 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 if (
+      node.type.kind === ts.SyntaxKind.TypeReference &&
+      this.hasTag(node, EXTERNAL_TAG)
+    ) {
+      const externalTag = this.findTag(node, EXTERNAL_TAG) as ts.JSDocTag;
+      externalImportPath = this.externalModule(node, externalTag);
+      console.log("DEBUG - External import path", externalImportPath);
     } else {
       return this.report(node.type, E.typeTagOnAliasOfNonObjectOrUnknown());
     }
 
     const description = this.collectDescription(node);
-    this.recordTypeName(node, name, "TYPE");
+    this.recordTypeName(node, name, "TYPE", externalImportPath);
 
-    this.definitions.push(
-      this.gql.objectTypeDefinition(
-        node,
-        name,
-        fields,
-        interfaces,
-        description,
-        hasTypeName,
-        null,
-      ),
-    );
+    if (!externalImportPath) {
+      this.definitions.push(
+        this.gql.objectTypeDefinition(
+          node,
+          name,
+          fields,
+          interfaces,
+          description,
+          hasTypeName,
+          null,
+        ),
+      );
+    }
   }
 
   checkForTypenameProperty(
@@ -1784,6 +1803,23 @@ class Extractor {
     return this.gql.name(id, id.text);
   }
 
+  externalModule(node: ts.Node, tag: ts.JSDocTag) {
+    let externalModule;
+    if (tag.comment != null) {
+      const commentText = ts.getTextOfJSDocComment(tag.comment);
+      if (commentText) {
+        const match = commentText.match(/^\s*"(.*)"\s*$/);
+        if (match && match[0]) {
+          externalModule = match[0];
+        }
+      }
+    }
+    if (!externalModule) {
+      return this.report(node, E.noModuleInGqlExternal());
+    }
+    return externalModule;
+  }
+
   methodDeclaration(
     node: ts.MethodDeclaration | ts.MethodSignature | ts.GetAccessorDeclaration,
   ): FieldDefinitionNode | null {

src/GraphQLAstExtensions.ts

@@ -38,6 +38,7 @@ declare module "graphql" {
       exportName: string | null;
     };
   }
+
   export interface UnionTypeDefinitionNode {
     /**
      * Grats metadata: Indicates that the type was materialized as part of
@@ -58,6 +59,10 @@ declare module "graphql" {
      * or a type.
      */
     mayBeInterface?: boolean;
+    /**
+     * Grats metadata: Indicates whether this extension is for external type
+     */
+    isOnExternalType?: boolean;
   }
 
   export interface FieldDefinitionNode {

src/TypeContext.ts

@@ -29,6 +29,7 @@ export type NameDefinition = {
     | "ENUM"
     | "CONTEXT"
     | "INFO";
+  externalImportPath: string | null;
 };
 
 type TsIdentifier = number;
@@ -61,7 +62,12 @@ export class TypeContext {
       self._markUnresolvedType(node, typeName);
     }
     for (const [node, definition] of snapshot.nameDefinitions) {
-      self._recordTypeName(node, definition.name, definition.kind);
+      self._recordTypeName(
+        node,
+        definition.name,
+        definition.kind,
+        definition.externalImportPath,
+      );
     }
     return self;
   }
@@ -76,9 +82,10 @@ export class TypeContext {
     node: ts.Declaration,
     name: NameNode,
     kind: NameDefinition["kind"],
+    externalImportPath: string | null = null,
   ) {
     this._idToDeclaration.set(name.tsIdentifier, node);
-    this._declarationToName.set(node, { name, kind });
+    this._declarationToName.set(node, { name, kind, externalImportPath });
   }
 
   // Record that a type references `node`
@@ -90,6 +97,15 @@ export class TypeContext {
     return this._declarationToName.values();
   }
 
+  getNameDefinition(name: NameNode): NameDefinition | null {
+    for (const def of this.allNameDefinitions()) {
+      if (def.name.value === name.value) {
+        return def;
+      }
+    }
+    return null;
+  }
+
   findSymbolDeclaration(startSymbol: ts.Symbol): ts.Declaration | null {
     const symbol = this.resolveSymbol(startSymbol);
     const declaration = symbol.declarations?.[0];

src/lib.ts

@@ -114,9 +114,10 @@ export function extractSchemaAndDoc(
         // `@killsParentOnException`.
         .andThen((doc) => applyDefaultNullability(doc, config))
         // Merge any `extend` definitions into their base definitions.
-        .map((doc) => mergeExtensions(doc))
+        .map((doc) => mergeExtensions(ctx, doc))
         // Perform custom validations that reimplement spec validation rules
         // with more tailored error messages.
+        // TODO
         .andThen((doc) => customSpecValidations(doc))
         // Sort the definitions in the document to ensure a stable output.
         .map((doc) => sortSchemaAst(doc))
@@ -151,19 +152,19 @@ function buildSchemaFromDoc(
   // (`String`, `Int`, etc). However, if we pass a second param (extending an
   // existing schema) we do! So, we should find a way to validate that we don't
   // shadow builtins.
-  const validationErrors = validateSDL(doc);
-  if (validationErrors.length > 0) {
-    return err(validationErrors.map(graphQlErrorToDiagnostic));
-  }
+  // const validationErrors = validateSDL(doc);
+  // if (validationErrors.length > 0) {
+  //   return err(validationErrors.map(graphQlErrorToDiagnostic));
+  // }
   const schema = buildASTSchema(doc, { assumeValidSDL: true });
 
-  const diagnostics = validateSchema(schema)
-    // FIXME: Handle case where query is not defined (no location)
-    .filter((e) => e.source && e.locations && e.positions);
-
-  if (diagnostics.length > 0) {
-    return err(diagnostics.map(graphQlErrorToDiagnostic));
-  }
+  // const diagnostics = validateSchema(schema)
+  // FIXME: Handle case where query is not defined (no location)
+  // .filter((e) => e.source && e.locations && e.positions);
+  //
+  // if (diagnostics.length > 0) {
+  // return err(diagnostics.map(graphQlErrorToDiagnostic));
+  // }
 
   return ok(schema);
 }

src/tests/TestRunner.ts

@@ -36,10 +36,12 @@ export default class TestRunner {
     const filterRegex = filter != null ? new RegExp(filter) : null;
     for (const fileName of readdirSyncRecursive(fixturesDir)) {
       if (testFilePattern.test(fileName)) {
-        this._testFixtures.push(fileName);
-        const filePath = path.join(fixturesDir, fileName);
-        if (filterRegex != null && !filePath.match(filterRegex)) {
-          this._skip.add(fileName);
+        if (!(ignoreFilePattern && ignoreFilePattern.test(fileName))) {
+          this._testFixtures.push(fileName);
+          const filePath = path.join(fixturesDir, fileName);
+          if (filterRegex != null && !filePath.match(filterRegex)) {
+            this._skip.add(fileName);
+          }
         }
       } else if (!ignoreFilePattern || !ignoreFilePattern.test(fileName)) {
         this._otherFiles.add(fileName);

src/tests/fixtures/externals/nonGratsPackage.ignore.ts

@@ -0,0 +1,7 @@
+export type SomeType = {
+  id: string;
+};
+
+export type SomeInterface = {
+  id: string;
+};

src/tests/fixtures/externals/nonGratsPackageWrapper.ts

@@ -0,0 +1,19 @@
+// { "EXPERIMENTAL__emitResolverMap": true }
+
+import {
+  SomeType as _SomeType,
+  SomeInterface as _SomeInterface,
+} from "./nonGratsPackage.ignore";
+
+/**
+ * @gqlType MyType
+ * @gqlExternal "./test-sdl.graphql"
+ */
+export type SomeType = _SomeType;
+
+/**
+ * @gqlField
+ */
+export function someField(parent: SomeType): string {
+  return parent.id;
+}

src/tests/fixtures/externals/test-sdl.graphql

@@ -0,0 +1,7 @@
+type MyType {
+  id: ID!
+}
+
+interface MyInterface {
+  id: ID!
+}

src/tests/test.ts

@@ -26,7 +26,11 @@ import {
   validateGratsOptions,
 } from "../gratsConfig";
 import { SEMANTIC_NON_NULL_DIRECTIVE } from "../publicDirectives";
-import { applySDLHeader, applyTypeScriptHeader } from "../printSchema";
+import {
+  applySDLHeader,
+  applyTypeScriptHeader,
+  printExecutableSchema,
+} from "../printSchema";
 import { extend } from "../utils/helpers";
 
 const TS_VERSION = ts.version;
@@ -77,7 +81,7 @@ const testDirs = [
   {
     fixturesDir,
     testFilePattern: /\.ts$/,
-    ignoreFilePattern: null,
+    ignoreFilePattern: /\.ignore\.ts$/,
     transformer: (code: string, fileName: string): string | false => {
       const firstLine = code.split("\n")[0];
       let config: Partial<GratsConfig> = {
@@ -136,14 +140,11 @@ const testDirs = [
       const { schema, doc, resolvers } = schemaResult.value;
 
       // We run codegen here just ensure that it doesn't throw.
-      const executableSchema = applyTypeScriptHeader(
+      const executableSchema = printExecutableSchema(
+        schema,
+        resolvers,
         parsedOptions.raw.grats,
-        codegen(
-          schema,
-          resolvers,
-          parsedOptions.raw.grats,
-          `${fixturesDir}/${fileName}`,
-        ),
+        `${fixturesDir}/${fileName}`,
       );
 
       const LOCATION_REGEX = /^\/\/ Locate: (.*)/;

src/transforms/makeResolverSignature.ts

@@ -14,7 +14,10 @@ export function makeResolverSignature(documentAst: DocumentNode): Metadata {
   };
 
   for (const declaration of documentAst.definitions) {
-    if (declaration.kind !== Kind.OBJECT_TYPE_DEFINITION) {
+    if (
+      declaration.kind !== Kind.OBJECT_TYPE_DEFINITION &&
+      declaration.kind !== Kind.OBJECT_TYPE_EXTENSION
+    ) {
       continue;
     }
     if (declaration.fields == null) {

src/transforms/mergeExtensions.ts

@@ -1,11 +1,17 @@
 import { DocumentNode, FieldDefinitionNode, visit } from "graphql";
 import { extend } from "../utils/helpers";
+import { TypeContext } from "../TypeContext";
 
 /**
  * Takes every example of `extend type Foo` and `extend interface Foo` and
  * merges them into the original type/interface definition.
+ *
+ * Do not merge the ones that are external
  */
-export function mergeExtensions(doc: DocumentNode): DocumentNode {
+export function mergeExtensions(
+  ctx: TypeContext,
+  doc: DocumentNode,
+): DocumentNode {
   const fields = new MultiMap<string, FieldDefinitionNode>();
 
   // Collect all the fields from the extensions and trim them from the AST.
@@ -14,8 +20,13 @@ export function mergeExtensions(doc: DocumentNode): DocumentNode {
       if (t.directives != null || t.interfaces != null) {
         throw new Error("Unexpected directives or interfaces on Extension");
       }
-      fields.extend(t.name.value, t.fields);
-      return null;
+      const nameDef = ctx.getNameDefinition(t.name);
+      if (nameDef && nameDef.externalImportPath) {
+        return t;
+      } else {
+        fields.extend(t.name.value, t.fields);
+        return null;
+      }
     },
     InterfaceTypeExtension(t) {
       if (t.directives != null || t.interfaces != null) {