Add babel macro, closes #22

Author: zenflow

lib/index.ts

@@ -4,6 +4,8 @@ import * as commander from "commander";
 import * as fs from "fs";
 import * as path from "path";
 import * as ts from "typescript";
+import {createMacro, MacroError, MacroHandler, Options as MacroOptions} from "babel-plugin-macros";
+import {ordinal} from "./util/ordinal";
 
 // Default format to use for `format` option
 const defaultFormat = "ts"
@@ -326,3 +328,114 @@ export function main() {
     fs.writeFileSync(outPath, generatedCode);
   }
 }
+
+const macroHandler: MacroHandler = params => {
+  const callPaths = params.references["makeCheckers"];
+
+  // Bail out if no calls in this file
+  if (!callPaths || !callPaths.length) {
+    return;
+  }
+
+  const {babel, state: {filename}} = params
+
+  // Rename any bindings to `t` in any parent scope of any call
+  for (const callPath of callPaths) {
+    let scope = callPath.scope;
+    while (true) {
+      if (scope.hasBinding("t")) {
+        scope.rename("t");
+      }
+      if (!scope.parent || (scope.parent === scope)) {
+        break;
+      }
+      scope = scope.parent;
+    }
+  }
+
+  // Add `import * as t from 'ts-interface-checker'` statement
+  const firstStatementPath = callPaths[0].findParent(path => path.isProgram()).get("body.0") as babel.NodePath;
+  firstStatementPath.insertBefore(
+    babel.types.importDeclaration(
+      [babel.types.importNamespaceSpecifier(babel.types.identifier("t"))],
+      babel.types.stringLiteral("ts-interface-checker"),
+    )
+  );
+
+  // Get the user config passed to us by babel-plugin-macros, for use as default options
+  // Note: `config` property is missing in `babelPluginMacros.MacroParams` type definition
+  const defaultOptions = ((params as any).config || {}) as ICompilerOptions
+
+  callPaths.forEach(({parentPath}, callIndex) => {
+    // Determine compiler parameters
+    const getArgValue = getGetArgValue(callIndex, parentPath);
+    const file = path.resolve(filename, "..", getArgValue(0) || path.basename(filename));
+    const options = { ...defaultOptions, ...(getArgValue(1) || {}), format: "js:cjs" };
+
+    // Compile
+    let compiled: string | undefined;
+    try {
+      compiled = Compiler.compile(file, options);
+    } catch (error) {
+      throw macroError(`${error.name}: ${error.message}`)
+    }
+
+    // Get the compiled type suite as AST node
+    const parsed = parse(compiled)!;
+    if (parsed.type !== 'File') throw macroInternalError();
+    if (parsed.program.body[1].type !== 'ExpressionStatement') throw macroInternalError();
+    if (parsed.program.body[1].expression.type !== 'AssignmentExpression') throw macroInternalError();
+    const typeSuiteNode = parsed.program.body[1].expression.right;
+
+    // Build checker suite expression using type suite
+    const checkerSuiteNode = babel.types.callExpression(
+      babel.types.memberExpression(
+        babel.types.identifier("t"),
+        babel.types.identifier("createCheckers"),
+      ),
+      [typeSuiteNode],
+    );
+
+    // Replace call with checker suite expression
+    parentPath.replaceWith(checkerSuiteNode);
+  })
+
+  function parse(code: string) {
+    return babel.parse(code, {configFile: false});
+  }
+  function getGetArgValue (callIndex: number, callExpressionPath: babel.NodePath) {
+    const argPaths = callExpressionPath.get("arguments");
+    if (!Array.isArray(argPaths)) throw macroInternalError()
+    return (argIndex: number): any => {
+      const argPath = argPaths[argIndex];
+      if (!argPath) {
+        return null;
+      }
+      const { confident, value } = argPath.evaluate();
+      if (!confident) {
+        /**
+         * TODO: Could not get following line to work:
+         * const lineSuffix = argPath.node.loc ? ` on line ${argPath.node.loc.start.line}` : ""
+         * Line number displayed is for the intermediary js produced by typescript.
+         * Even with `inputSourceMap: true`, Babel doesn't seem to parse inline sourcemaps in input.
+         * Maybe babel-plugin-macros doesn't support "input -> TS -> babel -> output" pipeline?
+         * Or maybe I'm doing that pipeline wrong?
+         */
+        throw macroError(`Unable to evaluate ${ordinal(argIndex + 1)} argument to ${ordinal(callIndex + 1)} call to makeCheckers()`)
+      }
+      return value
+    }
+  }
+}
+
+function macroError(message: string): MacroError {
+  return new MacroError(`ts-interface-builder/macro: ${message}`)
+}
+
+function macroInternalError(message?: string): MacroError {
+  return macroError(`Internal Error: ${message || 'Check stack trace'}`)
+}
+
+const macroParams: MacroOptions = { configName: "ts-interface-builder" };
+
+export const macro = () => createMacro(macroHandler, macroParams);

lib/util/ordinal.ts

@@ -0,0 +1,18 @@
+export function ordinal (number: number): string {
+    let result = String(number)
+    const n = Math.abs(number)
+    const cent = n % 100
+    const dec = n % 10
+    if (cent >= 10 && cent <= 20) {
+        result += 'th'
+    } else if (dec === 1) {
+        result += 'st'
+    } else if (dec === 2) {
+        result += 'nd'
+    } else if (dec === 3) {
+        result += 'rd'
+    } else {
+        result += 'th'
+    }
+    return result
+}

macro.d.ts

@@ -0,0 +1,3 @@
+import { ICompilerOptions } from "."
+import { ICheckerSuite } from "ts-interface-checker"
+export declare function makeCheckers (modulePath?: string, options?: ICompilerOptions): ICheckerSuite

macro.js

@@ -0,0 +1 @@
+module.exports = require("./dist/index.js").macro()

package.json

@@ -20,9 +20,13 @@
     "type",
     "validate",
     "validator",
-    "check"
+    "check",
+    "babel-plugin-macros"
   ],
   "author": "Dmitry S, Grist Labs",
+  "contributors": [
+    "Matthew Francis Brunetti <[email protected]> (https://github.com/zenflow)"
+  ],
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -33,19 +37,25 @@
   },
   "files": [
     "dist",
-    "bin"
+    "bin",
+    "macro.js",
+    "macro.d.ts"
   ],
   "dependencies": {
+    "babel-plugin-macros": "^2.8.0",
     "commander": "^2.12.2",
     "fs-extra": "^4.0.3",
     "typescript": "^3.0.0"
   },
   "devDependencies": {
+    "@babel/core": "^7.10.5",
+    "@types/babel-plugin-macros": "^2.8.2",
     "@types/fs-extra": "^4.0.5",
     "@types/mocha": "^5.2.7",
     "@types/node": "^8.0.57",
     "fs-extra": "^4.0.3",
     "mocha": "^6.2.0",
+    "ts-interface-checker": "^0.1.12",
     "ts-node": "^4.0.1"
   }
 }

test/fixtures/macro-error-compiling.ts

@@ -0,0 +1,3 @@
+import {makeCheckers} from "../../macro";
+
+makeCheckers("./ignore-index-signature.ts");

test/fixtures/macro-error-evaluating-arguments.ts

@@ -0,0 +1,4 @@
+import {join} from "path"
+import {makeCheckers} from "../../macro";
+
+makeCheckers(join(__dirname, 'foo.ts'));

test/fixtures/macro-locals.js

@@ -0,0 +1,20 @@
+import * as t from "ts-interface-checker";
+export function checkLocalInterface(input) {
+  // shows that t is renamed
+  var _t = t.createCheckers({
+    LocalInterface: t.iface([], {
+      "foo": "number"
+    })
+  });
+
+  _t.LocalInterface.check(input);
+
+  return input;
+}
+
+function _t2(t) {
+  // shows function t is renamed and argument t is not
+  return t;
+}
+
+void _t2;

test/fixtures/macro-locals.ts

@@ -0,0 +1,19 @@
+import {makeCheckers} from "../../macro";
+
+interface LocalInterface {
+  foo: number;
+}
+
+export function checkLocalInterface(input: any): LocalInterface {
+  // shows that t is renamed
+  const t = makeCheckers(undefined, {inlineImports: false});
+  t.LocalInterface.check(input);
+  return input as LocalInterface;
+}
+
+function t(t: any) {
+  // shows function t is renamed and argument t is not
+  return t;
+}
+
+void t

test/fixtures/macro-options.js

@@ -0,0 +1,24 @@
+import * as t from "ts-interface-checker";
+// Note: default options defined in babel plugin options in ../test_macro.ts
+var dir = '.';
+var file = dir + "/imports-parent.ts";
+export var checkersUsingDefaultOptions = t.createCheckers({
+  TypeA: t.iface([], {}),
+  TypeB: t.iface([], {}),
+  TypeC: t.iface([], {}),
+  TypeD: t.iface([], {}),
+  TypeAll: t.iface([], {
+    "a": "TypeA",
+    "b": "TypeB",
+    "c": "TypeC",
+    "d": "TypeD"
+  })
+});
+export var checkersUsingInlineOptions = t.createCheckers({
+  TypeAll: t.iface([], {
+    "a": "TypeA",
+    "b": "TypeB",
+    "c": "TypeC",
+    "d": "TypeD"
+  })
+});