build(definitelytyped): ensure d ts without module can be mocked by definitely typed (#263)

uittorio · web-flow · commit 3ef15168f37e · 2020-03-20T06:51:46.000Z
* build(definitelytyped): ensure d ts without module can be mocked by definitely type
diff --git a/.github/workflows/definitelyTyped.yml b/.github/workflows/definitelyTyped.yml
@@ -27,6 +27,7 @@ jobs:
         run: |
           npm install
           npm run build
+          npm run build:transformer:definitelyTyped
       - name: definitelyTyped
         run: |
           cd definitelyTypedTests
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,5 @@
 node_modules
 dist
+definitelyTypedTests/build
 .idea
 DefinitelyTyped
diff --git a/config/modules/definitelyTypedTransformer/index.ts b/config/modules/definitelyTypedTransformer/index.ts
diff --git a/config/modules/definitelyTypedTransformer/tsconfig.json b/config/modules/definitelyTypedTransformer/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../../definitelyTypedTests/dist"
+  }
+}
diff --git a/config/modules/definitelyTypedTransformer/webpack.functions.js b/config/modules/definitelyTypedTransformer/webpack.functions.js
@@ -0,0 +1,14 @@
+const path = require("path");
+const merge = require("webpack-merge");
+const base = require("../base/webpack.base");
+
+module.exports = merge(base({
+    tsConfigFile: 'config/modules/definitelyTypedTransformer/tsconfig.json'
+}), {
+    entry: {
+        index: './definitelyTypedTests/src/index.ts'
+    },
+    output: {
+        path: path.resolve(__dirname, "../../../definitelyTypedTests/dist")
+    }
+});
diff --git a/config/modules/definitelyTypedTransformer/webpack.js b/config/modules/definitelyTypedTransformer/webpack.js
@@ -0,0 +1,22 @@
+const webpackNodeExternals = require("webpack-node-externals");
+const path = require("path");
+const merge = require("webpack-merge");
+const base = require("../base/webpack.base");
+
+module.exports = merge(base({
+    tsConfigFile: 'config/modules/definitelyTypedTransformer/tsconfig.json'
+}), {
+    target: "node",
+    node: {
+        __dirname: false
+    },
+    externals: [
+        webpackNodeExternals()
+    ],
+    entry: {
+        index: './definitelyTypedTests/src/transformer/index.ts',
+    },
+    output: {
+        path: path.resolve(__dirname, "../../../definitelyTypedTests/dist/transformer"),
+    }
+});
diff --git a/data/definitelyTyped/list.json b/data/definitelyTyped/list.json
@@ -1 +1,2 @@
-[{"id":"756c5f8d-be26-43fc-8831-0a12df4c972e.json","initialDate":"2020-01-11T17:17:58.333Z","lastUpdatedDate":"2020-01-16T00:31:39.270Z","typesProcessed":9999},{"id":"9749238a-cba9-4abd-9fac-f9d0d4ef90e3.json","initialDate":"2020-01-17T20:34:24.904Z","lastUpdatedDate":"2020-02-01T00:40:31.064Z","typesProcessed":9999},{"id":"45e2213b-fa9c-40d1-b066-89413f063ee3.json","initialDate":"2020-02-01T17:11:06.944Z","lastUpdatedDate":"2020-03-07T00:20:59.201Z","typesProcessed":6549},{"id":"532444dd-7414-42ad-8d30-3da2d2e6c9af.json","initialDate":"2020-03-08T08:08:21.638Z","lastUpdatedDate":"2020-03-17T00:55:23.522Z","typesProcessed":3500}]
+[{"id":"756c5f8d-be26-43fc-8831-0a12df4c972e.json","initialDate":"2020-01-11T17:17:58.333Z","lastUpdatedDate":"2020-01-16T00:31:39.270Z","typesProcessed":9999},{"id":"9749238a-cba9-4abd-9fac-f9d0d4ef90e3.json","initialDate":"2020-01-17T20:34:24.904Z","lastUpdatedDate":"2020-02-01T00:40:31.064Z","typesProcessed":9999},{"id":"45e2213b-fa9c-40d1-b066-89413f063ee3.json","initialDate":"2020-02-01T17:11:06.944Z","lastUpdatedDate":"2020-03-07T00:20:59.201Z","typesProcessed":6549},{"id":"532444dd-7414-42ad-8d30-3da2d2e6c9af.json","initialDate":"2020-03-08T08:08:21.638Z","lastUpdatedDate":"2020-03-17T00:55:23.522Z","typesProcessed":3500}]
+
diff --git a/definitelyTypedTests/index.js b/definitelyTypedTests/index.js
@@ -88,7 +88,7 @@ async function run(dir, processId) {
             'noEmit': false,
             'plugins': [
                 {
-                    'transform': '../dist/transformer',
+                    'transform': './dist/transformer',
                     'debug': true
                 }
             ],
@@ -120,10 +120,11 @@ async function run(dir, processId) {
 
     fs.writeFileSync(`tsconfig.types.${processId}.json`, JSON.stringify(config));
     fs.writeFileSync(`${processId}.index.ts`, `
-import pak = require('${typePath}/');
-import { createMock } from '../dist';
 // @ts-ignore
-createMock<typeof pak>();
+import pak = require('${typePath}');
+import { createDefinitelyTypedMock } from './dist';
+// @ts-ignore
+createDefinitelyTypedMock<typeof pak>();
 `);
 
     return execPromise(`npx ttsc --project tsconfig.types.${processId}.json`)
diff --git a/definitelyTypedTests/package-lock.json b/definitelyTypedTests/package-lock.json
diff --git a/definitelyTypedTests/package.json b/definitelyTypedTests/package.json
@@ -17,6 +17,6 @@
   "dependencies": {
     "dotenv": "^8.2.0",
     "ttypescript": "^1.5.8",
-    "typescript": "^3.7.4"
+    "typescript": "^3.8.3"
   }
 }
diff --git a/definitelyTypedTests/src/create-definitely-typed-mock.ts b/definitelyTypedTests/src/create-definitely-typed-mock.ts
@@ -0,0 +1 @@
+export declare function createDefinitelyTypedMock<T>(): T[];
diff --git a/definitelyTypedTests/src/index.ts b/definitelyTypedTests/src/index.ts
@@ -0,0 +1 @@
+export { createDefinitelyTypedMock } from './create-definitely-typed-mock';
diff --git a/definitelyTypedTests/src/transformer/index.ts b/definitelyTypedTests/src/transformer/index.ts
@@ -0,0 +1,2 @@
+import { transformer } from './transformer';
+export default transformer;
diff --git a/definitelyTypedTests/src/transformer/logger.ts b/definitelyTypedTests/src/transformer/logger.ts
@@ -0,0 +1,18 @@
+import { ILogger } from '../../../src/logger/logger.interface';
+import { Logger } from '../../../src/logger/logger';
+
+let logger: ILogger;
+
+export interface TransformerLogger {
+    moduleWithoutValidTypeStatements(moduleName: string): void;
+}
+
+export function DefinitelyTypedTransformerLogger(): TransformerLogger {
+    logger = logger || Logger('DefinitelyTypedTransformer');
+
+    return {
+        moduleWithoutValidTypeStatements(moduleName: string): void {
+            logger.warning(`Cannot find any valid type for this module ${moduleName}`);
+        }
+    };
+}
diff --git a/definitelyTypedTests/src/transformer/transformer.ts b/definitelyTypedTests/src/transformer/transformer.ts
@@ -0,0 +1,66 @@
+import { TypeChecker } from '../../../src/transformer/typeChecker/typeChecker';
+import { getMock } from '../../../src/transformer/mock/mock';
+import {
+    CustomFunction
+} from "../../../src/transformer/matcher/matcher";
+import * as ts from 'typescript';
+import { GetProgram } from "../../../src/transformer/program/program";
+import { baseTransformer } from '../../../src/transformer/base/base';
+import { GetTypeQueryDescriptor } from '../../../src/transformer/descriptor/typeQuery/typeQuery';
+import { Scope } from '../../../src/transformer/scope/scope';
+import { DefinitelyTypedTransformerLogger } from './logger';
+import * as path from 'path';
+
+const customFunctions: CustomFunction[] = [
+    {
+        sourceDts: 'create-definitely-typed-mock.d.ts',
+        sourceUrl: '../create-definitely-typed-mock.d.ts',
+    }
+];
+
+const transformer = baseTransformer(visitNode, customFunctions);
+export { transformer };
+
+function visitNode(node: ts.CallExpression, declaration: ts.FunctionDeclaration): ts.Node {
+    const typeQueryNode: ts.TypeNode = node.typeArguments[0];
+
+    if (isCreateDefinitelyTypedMock(declaration) && ts.isTypeQueryNode(typeQueryNode)) {
+        const typeChecker: ts.TypeChecker = TypeChecker();
+        const typeQuerySymbol: ts.Symbol = typeChecker.getSymbolAtLocation(typeQueryNode.exprName);
+        const typeQuerySymbolDeclaration: ts.ImportEqualsDeclaration = typeQuerySymbol.declarations[0] as ts.ImportEqualsDeclaration;
+        const symbolAlias: ts.Symbol = typeChecker.getSymbolAtLocation(typeQuerySymbolDeclaration.name);
+        const symbol: ts.Symbol = typeChecker.getAliasedSymbol(symbolAlias);
+
+        if (!symbol.declarations) {
+            const moduleName: string =
+                ((typeQuerySymbolDeclaration.moduleReference as ts.ExternalModuleReference).expression as ts.StringLiteral).text;
+            const pathModule =  path.resolve(moduleName);
+            const moduleWithoutExportsFile: ts.SourceFile = GetProgram().getSourceFiles().find((file: ts.SourceFile) =>
+                file.fileName.includes(`${pathModule}/index.d.ts`));
+
+            const compatibleStatements: ts.Statement[] = moduleWithoutExportsFile.statements.filter(
+                (statement: ts.Statement) => statement.kind === ts.SyntaxKind.InterfaceDeclaration
+                    || statement.kind === ts.SyntaxKind.FunctionDeclaration
+                    || statement.kind === ts.SyntaxKind.ClassDeclaration
+            );
+
+            if (compatibleStatements.length > 0) {
+                return ts.createArrayLiteral(compatibleStatements.map((workingStatement: ts.InterfaceDeclaration | ts.FunctionDeclaration | ts.ClassDeclaration) => {
+                    const nodeToMock: ts.TypeReferenceNode = ts.createTypeReferenceNode(workingStatement.name, []);
+                    return getMock(nodeToMock, node);
+                }));
+            }
+            DefinitelyTypedTransformerLogger().moduleWithoutValidTypeStatements(moduleName);
+
+            return node;
+        }
+
+        return GetTypeQueryDescriptor(typeQueryNode, new Scope());
+    }
+
+    return node;
+}
+
+function isCreateDefinitelyTypedMock(declaration: ts.FunctionDeclaration): boolean {
+    return declaration.name && declaration.name.getText() === 'createDefinitelyTypedMock';
+}
diff --git a/package.json b/package.json
@@ -9,6 +9,7 @@
     "build:transformer:debug": "webpack --config config/modules/transformer/webpack.debug.js",
     "build:modules:debug": "webpack --config config/modules/webpack.debug.js",
     "build:debug": "npm run build:modules:debug && npm run build:transformer:debug",
+    "build:transformer:definitelyTyped": "webpack --config config/modules/definitelyTypedTransformer/webpack.functions.js && webpack --config config/modules/definitelyTypedTransformer/webpack.js",
     "test": "npm run test:transformer && npm run test:framework:context && npm run test:framework && npm run test:frameworkDeprecated && npm run test:registerMock && npm run test:unit",
     "test:unit": "karma start config/karma/karma.config.unit.js",
     "test:transformer": "karma start config/karma/karma.config.transformer.js",
diff --git a/src/transformer/base/base.ts b/src/transformer/base/base.ts
@@ -0,0 +1,59 @@
+import * as ts from 'typescript';
+import { SetTsAutoMockOptions, TsAutoMockOptions } from '../../options/options';
+import { SetTypeChecker } from '../typeChecker/typeChecker';
+import { MockDefiner } from '../mockDefiner/mockDefiner';
+import { SetProgram } from '../program/program';
+import { TypescriptHelper } from '../descriptor/helper/helper';
+import {
+  CustomFunction,
+  isFunctionFromThisLibrary,
+} from '../matcher/matcher';
+
+export type Visitor = (node: ts.CallExpression, declaration: ts.FunctionDeclaration) => ts.Node;
+
+export function baseTransformer(visitor: Visitor, customFunctions: CustomFunction[]): (program: ts.Program, options?: TsAutoMockOptions) => ts.TransformerFactory<ts.SourceFile> {
+  return (program: ts.Program, options?: TsAutoMockOptions): ts.TransformerFactory<ts.SourceFile> => {
+    SetTsAutoMockOptions(options);
+    SetTypeChecker(program.getTypeChecker());
+    SetProgram(program);
+
+    return (context: ts.TransformationContext): (file: ts.SourceFile) => ts.SourceFile => (file: ts.SourceFile): ts.SourceFile => {
+      MockDefiner.instance.initFile(file);
+      let sourceFile: ts.SourceFile = visitNodeAndChildren(file, context, visitor, customFunctions);
+
+      sourceFile = ts.updateSourceFileNode(sourceFile, [
+        ...MockDefiner.instance.getTopStatementsForFile(sourceFile),
+        ...sourceFile.statements,
+      ]);
+
+      return sourceFile;
+    };
+  };
+}
+
+function visitNodeAndChildren(node: ts.SourceFile, context: ts.TransformationContext, visitor: Visitor, customFunctions: CustomFunction[]): ts.SourceFile;
+function visitNodeAndChildren(node: ts.Node, context: ts.TransformationContext, visitor: Visitor, customFunctions: CustomFunction[]): ts.Node;
+function visitNodeAndChildren(node: ts.Node, context: ts.TransformationContext, visitor: Visitor, customFunctions: CustomFunction[]): ts.Node {
+  return ts.visitEachChild(visitNode(node, visitor, customFunctions), (childNode: ts.Node) => visitNodeAndChildren(childNode, context, visitor, customFunctions), context);
+}
+
+function visitNode(node: ts.Node, visitor: Visitor, customFunctions: CustomFunction[]): ts.Node {
+  if (!ts.isCallExpression(node)) {
+    return node;
+  }
+
+  const signature: ts.Signature = TypescriptHelper.getSignatureOfCallExpression(node);
+
+  if (!isFunctionFromThisLibrary(signature, customFunctions)) {
+    return node;
+  }
+
+  const nodeToMock: ts.TypeNode = node.typeArguments[0];
+
+  MockDefiner.instance.setFileNameFromNode(nodeToMock);
+  MockDefiner.instance.setTsAutoMockImportIdentifier();
+
+  const declaration: ts.FunctionDeclaration = signature.declaration as ts.FunctionDeclaration;
+
+  return visitor(node, declaration);
+}
diff --git a/src/transformer/descriptor/helper/helper.ts b/src/transformer/descriptor/helper/helper.ts
@@ -87,6 +87,13 @@ export namespace TypescriptHelper {
     return isAlias(alias) ? TypeChecker().getAliasedSymbol(alias) : alias;
   }
 
+
+  export function getSignatureOfCallExpression(node: ts.CallExpression): ts.Signature {
+    const typeChecker: ts.TypeChecker = TypeChecker();
+
+    return typeChecker.getResolvedSignature(node);
+  }
+
   function GetFirstValidDeclaration(declarations: ts.Declaration[]): ts.Declaration {
     return declarations.find((declaration: ts.Declaration) => !ts.isVariableDeclaration(declaration) && !ts.isFunctionDeclaration(declaration)) || declarations[0];
   }
diff --git a/src/transformer/matcher/matcher.ts b/src/transformer/matcher/matcher.ts
@@ -2,19 +2,12 @@ import * as path from 'path';
 import * as ts from 'typescript';
 import { TransformerLogger } from '../logger/transformerLogger';
 
-export function isCreateMock(declaration: ts.FunctionDeclaration): boolean {
-  return declaration.name && declaration.name.getText() === 'createMock';
+export interface CustomFunction {
+  sourceUrl: string;
+  sourceDts: string;
 }
 
-export function isCreateMockList(declaration: ts.FunctionDeclaration): boolean {
-  return declaration.name && declaration.name.getText() === 'createMockList';
-}
-
-export function isRegisterMock(declaration: ts.FunctionDeclaration): boolean {
-  return declaration.name && declaration.name.getText() === 'registerMock';
-}
-
-export function isFromTsAutoMock(signature: ts.Signature): boolean {
+export function isFunctionFromThisLibrary(signature: ts.Signature, customFunctions: CustomFunction[]): boolean {
   if (!isDeclarationDefined(signature)) {
     return false;
   }
@@ -23,27 +16,17 @@ export function isFromTsAutoMock(signature: ts.Signature): boolean {
     return false;
   }
 
-  const createMockTs: string = path.join(__dirname, '../create-mock.d.ts');
-  const createMockListTs: string = path.join(__dirname, '../create-mock-list.d.ts');
-  const registerMockTs: string = path.join(__dirname, '../register-mock.d.ts');
   const fileName: string = signature.declaration.getSourceFile().fileName;
 
-  const isCreateMockUrl: boolean = path.relative(fileName, createMockTs) === '';
-  if (fileName.includes('create-mock.d.ts') && !isCreateMockUrl) {
-    TransformerLogger().unexpectedCreateMock(fileName, createMockTs);
-  }
-
-  const isCreateMockListUrl: boolean = path.relative(fileName, createMockListTs) === '';
-  if (fileName.includes('create-mock-list.d.ts') && !isCreateMockListUrl) {
-    TransformerLogger().unexpectedCreateMock(fileName, createMockListTs);
-  }
-
-  const isRegisterMockUrl: boolean = path.relative(fileName, registerMockTs) === '';
-  if (fileName.includes('register-mock.d.ts') && !isRegisterMockUrl) {
-    TransformerLogger().unexpectedCreateMock(fileName, registerMockTs);
-  }
+  return customFunctions.some((customFunction: CustomFunction) => {
+    const functionUrl: string = path.join(__dirname, customFunction.sourceUrl);
+    const isFileNameFunctionUrl: boolean = path.relative(fileName, functionUrl) === '';
+    if (fileName.includes(customFunction.sourceDts) && !isFileNameFunctionUrl) {
+      TransformerLogger().unexpectedCreateMock(fileName, functionUrl);
+    }
 
-  return isCreateMockUrl || isCreateMockListUrl || isRegisterMockUrl;
+    return isFileNameFunctionUrl;
+  });
 }
 
 function isDeclarationDefined(signature: ts.Signature): boolean {
diff --git a/src/transformer/mockDefiner/mockDefiner.ts b/src/transformer/mockDefiner/mockDefiner.ts
@@ -59,7 +59,7 @@ export class MockDefiner {
     return this._instance;
   }
 
-  public setFileNameFromNode(node: ts.TypeNode): void {
+  public setFileNameFromNode(node: ts.Node): void {
     const thisFile: ts.SourceFile = node.getSourceFile();
     this._fileName = thisFile.fileName;
   }
diff --git a/src/transformer/program/program.ts b/src/transformer/program/program.ts
@@ -0,0 +1,11 @@
+import ts from 'typescript';
+
+let __program: ts.Program;
+
+export function SetProgram(program: ts.Program): void {
+  __program = program;
+}
+
+export function GetProgram(): ts.Program {
+  return __program;
+}
diff --git a/src/transformer/transformer.ts b/src/transformer/transformer.ts

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`		-[{"id":"756c5f8d-be26-43fc-8831-0a12df4c972e.json","initialDate":"2020-01-11T17:17:58.333Z","lastUpdatedDate":"2020-01-16T00:31:39.270Z","typesProcessed":9999},{"id":"9749238a-cba9-4abd-9fac-f9d0d4ef90e3.json","initialDate":"2020-01-17T20:34:24.904Z","lastUpdatedDate":"2020-02-01T00:40:31.064Z","typesProcessed":9999},{"id":"45e2213b-fa9c-40d1-b066-89413f063ee3.json","initialDate":"2020-02-01T17:11:06.944Z","lastUpdatedDate":"2020-03-07T00:20:59.201Z","typesProcessed":6549},{"id":"532444dd-7414-42ad-8d30-3da2d2e6c9af.json","initialDate":"2020-03-08T08:08:21.638Z","lastUpdatedDate":"2020-03-17T00:55:23.522Z","typesProcessed":3500}]
	`1`	+[{"id":"756c5f8d-be26-43fc-8831-0a12df4c972e.json","initialDate":"2020-01-11T17:17:58.333Z","lastUpdatedDate":"2020-01-16T00:31:39.270Z","typesProcessed":9999},{"id":"9749238a-cba9-4abd-9fac-f9d0d4ef90e3.json","initialDate":"2020-01-17T20:34:24.904Z","lastUpdatedDate":"2020-02-01T00:40:31.064Z","typesProcessed":9999},{"id":"45e2213b-fa9c-40d1-b066-89413f063ee3.json","initialDate":"2020-02-01T17:11:06.944Z","lastUpdatedDate":"2020-03-07T00:20:59.201Z","typesProcessed":6549},{"id":"532444dd-7414-42ad-8d30-3da2d2e6c9af.json","initialDate":"2020-03-08T08:08:21.638Z","lastUpdatedDate":"2020-03-17T00:55:23.522Z","typesProcessed":3500}]
	`2`	`+`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,6 @@`
`17`	`17`	`"dependencies": {`
`18`	`18`	`"dotenv": "^8.2.0",`
`19`	`19`	`"ttypescript": "^1.5.8",`
`20`		`- "typescript": "^3.7.4"`
	`20`	`+ "typescript": "^3.8.3"`
`21`	`21`	`}`
`22`	`22`	`}`