First test passed at transforming Relay Classic nodes

Author: kastermester

transform/src/BindingsAtNode.ts

@@ -0,0 +1,126 @@
+import * as ts from 'typescript';
+export type Bindings = Map<string, BindingInfo>;
+export const enum BindingKind {
+  Local,
+  Module,
+  Import,
+  Require,
+  Export
+}
+export interface BindingInfo {
+  kind: BindingKind;
+}
+export function bindingsAtNode(node: ts.Node): Bindings {
+  const bindings = new Map<string, BindingInfo>();
+
+  function findInitializerBindings(initializer: ts.ForInitializer) {
+    if (ts.isVariableDeclarationList(initializer)) {
+      initializer.declarations.forEach(decl => {
+        processBinding(decl.name, BindingKind.Local);
+      });
+    }
+  }
+
+  function determineBindingKindFromInitializer(initializer: ts.Expression | undefined): BindingKind {
+    if (initializer == null) {
+      return BindingKind.Local;
+    }
+    if (ts.isCallExpression(initializer) && ts.isIdentifier(initializer.expression) && initializer.expression.text === 'require') {
+      return BindingKind.Require;
+    }
+    return BindingKind.Local;
+  }
+
+  function findStatementsBindings(block: ts.Block | ts.SourceFile) {
+    block.statements.forEach(stmt => {
+      if (ts.isClassDeclaration(stmt)) {
+        if (stmt.name) {
+          addBinding(stmt.name.text, BindingKind.Local);
+        }
+        return;
+      }
+      if (ts.isExportDeclaration(stmt)) {
+        if (stmt.exportClause) {
+          stmt.exportClause.elements.forEach(element => {
+            addBinding(element.name.text, BindingKind.Export);
+          });
+        }
+        if (stmt.name) {
+          addBinding(stmt.name.text, BindingKind.Export);
+        }
+        return;
+      }
+      if (ts.isImportDeclaration(stmt) && stmt.importClause != null) {
+        const namedBindings = stmt.importClause.namedBindings;
+        if (namedBindings == null) {
+          return;
+        }
+        if (ts.isNamespaceImport(namedBindings)) {
+          addBinding(namedBindings.name.text, BindingKind.Import);
+        } else {
+          namedBindings.elements.forEach(element => {
+            addBinding((element.propertyName || element.name).text, BindingKind.Import);
+          });
+        }
+        return;
+      }
+      if (ts.isVariableStatement(stmt)) {
+        stmt.declarationList.declarations.forEach(decl => {
+          processBinding(decl.name, determineBindingKindFromInitializer(decl.initializer));
+        });
+        return;
+      }
+      // One can declare named functions in tons of weird ways that will end up in scope that this won't catch
+      // the same goes for var declarations deep within the code structure.
+      if (ts.isExpressionStatement(stmt) && ts.isFunctionExpression(stmt.expression)) {
+        if (stmt.expression.name != null) {
+          addBinding(stmt.expression.name.text, BindingKind.Local);
+        }
+        return;
+      }
+    });
+  }
+
+  function addBinding(name: string, kind: BindingKind) {
+    if (!bindings.has(name)) {
+      bindings.set(name, { kind: kind });
+    }
+  }
+
+  function processBinding(binding: ts.Identifier | ts.ArrayBindingPattern | ts.ObjectBindingPattern, kind: BindingKind) {
+    if (ts.isIdentifier(binding)) {
+      addBinding(binding.text, kind);
+      return;
+    }
+    if (ts.isArrayBindingPattern(binding)) {
+      binding.elements.forEach(element => {
+        if (ts.isBindingElement(element)) {
+          processBinding(element.name, kind);
+        }
+      });
+      return;
+    }
+    binding.elements.forEach(element => {
+      if (ts.isBindingElement(element)) {
+        processBinding(element.name, kind);
+      }
+    });
+  }
+
+  while (node.parent != null) {
+    const parent = node.parent;
+    if (ts.isBlock(parent) || ts.isSourceFile(parent)) {
+      findStatementsBindings(parent);
+      continue;
+    }
+
+    if (ts.isForStatement(parent) && parent.initializer != null) {
+      findInitializerBindings(parent.initializer);
+      continue;
+    }
+    if (ts.isForOfStatement(parent)) {
+      findInitializerBindings(parent.initializer);
+    }
+  }
+  return bindings;
+}

transform/src/Options.ts

@@ -1,5 +1,8 @@
 import { GraphQLSchema, buildClientSchema, buildASTSchema, parse } from "graphql";
 import * as fs from 'fs';
+import * as path from 'path';
+import { RelayQLTransformer } from "./RelayQLTransformer";
+import { SCHEMA_EXTENSION } from "./GraphQLRelayDirective";
 
 export interface Options {
 	artifactDirectory?: string;
@@ -13,7 +16,7 @@ export interface Options {
 export interface NormalizedOptions {
 	artifactDirectory?: string;
 	compat?: boolean;
-	schema?: GraphQLSchema;
+	relayQLTransformer?: RelayQLTransformer;
 	isDevVariable?: string;
 	buildCommand?: string;
 	isDevelopment?: boolean;
@@ -23,7 +26,7 @@ const dotJsonLength = '.json'.length;
 const dotGraphQLLength = '.graphql'.length;
 
 export function readGraphQLSchema(schemaPath: string): GraphQLSchema {
-	const contents = fs.readFileSync(schemaPath, { encoding: 'utf8' });
+	const contents = fs.readFileSync(path.resolve(schemaPath), { encoding: 'utf8' });
 	if (schemaPath.substring(schemaPath.length - dotJsonLength) === '.json') {
 		const json = JSON.parse(contents);
 		if (json.__schema) {
@@ -34,14 +37,20 @@ export function readGraphQLSchema(schemaPath: string): GraphQLSchema {
 		}
 		throw new Error('Expected data file to contain a JSON encoded GraphQLSchema');
 	} else if (schemaPath.substring(schemaPath.length - dotGraphQLLength) === '.graphql') {
-		return buildASTSchema(parse(contents));
+		return buildASTSchema(parse(SCHEMA_EXTENSION + "\n" + contents));
 	}
 	throw new Error('Unsupported file. schema option only supports json and graphql file extensions');
 }
 
 export function normalizeOptions(options: Options): NormalizedOptions {
+	const { schema, ...opts } = options;
 	return {
-		...options,
-		schema: options.schema ? readGraphQLSchema(options.schema) : undefined,
+		...opts,
+		relayQLTransformer: options.schema ? new RelayQLTransformer(readGraphQLSchema(options.schema), {
+			inputArgumentName: 'input',
+			snakeCase: false,
+			substituteVariables: true,
+			validator: null,
+		}) : undefined,
 	};
 }

transform/src/RelayQLTransformer.ts

@@ -1,6 +1,7 @@
 import { RelayQLPrinter } from "./RelayQLPrinter";
 
 import * as util from "util";
+import * as path from "path";
 import * as ts from "typescript";
 
 import {
@@ -53,6 +54,15 @@ type TextTransformOptions = {
   tagName: string,
 };
 
+function sanitizeDocumentName(str: string): string {
+  const basename = path.basename(str);
+  const firstDot = basename.indexOf('.');
+  if (firstDot < 0) {
+    return basename;
+  }
+  return basename.substr(0, firstDot);
+}
+
 /**
  * Transforms a TemplateLiteral node into a RelayQLDefinition, which is then
  * transformed into a TS AST via RelayQLPrinter.
@@ -71,10 +81,10 @@ export class RelayQLTransformer {
     options: TextTransformOptions,
   ): Printable {
     const {
-    substitutions,
+      substitutions,
       templateText,
       variableNames,
-  } = this.processTemplateLiteral(node, options.documentName);
+    } = this.processTemplateLiteral(node, options.documentName);
     const documentText = this.processTemplateText(templateText, options);
     const definition = this.processDocumentText(documentText, options);
 
@@ -143,6 +153,7 @@ export class RelayQLTransformer {
   ): string {
     const pattern = /^(fragment|mutation|query|subscription)\s*(\w*)?([\s\S]*)/;
     const matches = pattern.exec(templateText);
+    const sanitizedDocumentName = sanitizeDocumentName(documentName);
     if (!matches) {
       throw new Error(util.format(
         "You supplied a GraphQL document named `%s` with invalid syntax. It " +
@@ -156,7 +167,7 @@ export class RelayQLTransformer {
     // Allow `fragment on Type {...}`.
     if (type === 'fragment' && name === 'on') {
       name =
-        documentName + (propName ? '_' + capitalize(propName) : '') + 'RelayQL';
+        sanitizedDocumentName + (propName ? '_' + capitalize(propName) : '') + 'RelayQL';
       rest = 'on' + rest;
     }
     const definitionName = capitalize(name);
@@ -170,6 +181,7 @@ export class RelayQLTransformer {
     documentText: string,
     { documentName, enableValidation }: TextTransformOptions,
   ): RelayQLDefinition<any> {
+    console.log(documentText);
     const document = parse(new Source(documentText, documentName));
     const validationErrors = enableValidation
       ? this.validateDocument(document, documentName)

transform/src/compileRelayQLTag.ts

@@ -0,0 +1,28 @@
+import { createTransformError } from "./createTransformError";
+import * as ts from "typescript";
+import { NormalizedOptions } from "./Options";
+import { RelayQLTransformer } from "./RelayQLTransformer";
+
+/**
+ * Given all the metadata about a found RelayQL tag, compile it and return
+ * the resulting TS AST.
+ */
+export function compileRelayQLTag(
+	ctx: ts.TransformationContext,
+	options: NormalizedOptions,
+	transformer: RelayQLTransformer,
+	node: ts.TaggedTemplateExpression,
+	documentName: string,
+	propName: string | null,
+	tagName: string,
+	enableValidation: boolean,
+): ts.Expression {
+	const result = transformer.transform(node, {
+		documentName,
+		propName,
+		tagName,
+		enableValidation,
+	});
+	ts.setSourceMapRange(result, ts.getSourceMapRange(node));
+	return result;
+}