Support module aliases with --baseQuery (#29)

* smart import path
* Add test to assert TSCONFIG_FILE_NOT_FOUND is thrown

Co-authored-by: Matt Sutkowski <[email protected]>

Author: kahirokunn

package-lock.json

@@ -22,6 +22,7 @@
     "@babel/preset-typescript": "^7.12.7",
     "@rtk-incubator/rtk-query": "^0.2.0",
     "@types/commander": "^2.12.2",
+    "@types/glob-to-regexp": "^0.4.0",
     "@types/jest": "^26.0.20",
     "@types/lodash": "^4.14.165",
     "@types/node": "^14.14.12",
@@ -41,6 +42,7 @@
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.0.2",
     "commander": "^6.2.0",
+    "glob-to-regexp": "^0.4.1",
     "oazapfts": "npm:@phryneas/experimental-oazapfts@^0.1.1-0",
     "swagger2openapi": "^7.0.4",
     "ts-morph": "^9.1.0",

package.json

@@ -8,7 +8,8 @@ import program from 'commander';
 const meta = require('../../package.json');
 import { generateApi } from '../generate';
 import { GenerationOptions } from '../types';
-import { isValidUrl, prettify } from '../utils';
+import { isValidUrl, MESSAGES, prettify } from '../utils';
+import { getCompilerOptions } from '../utils/getTsConfig';
 
 program
   .version(meta.version)
@@ -20,7 +21,8 @@ program
   .option('--responseSuffix <name>', 'pass response suffix')
   .option('--baseUrl <url>', 'pass baseUrl')
   .option('-h, --hooks', 'generate React Hooks')
-  .option('--file <filename>', 'output file name (ex: generated.api.ts)')
+  .option('-c, --config <path>', 'pass tsconfig path for resolve path alias')
+  .option('-f, --file <filename>', 'output file name (ex: generated.api.ts)')
   .parse(process.argv);
 
 if (program.args.length === 0) {
@@ -39,26 +41,46 @@ if (program.args.length === 0) {
     'baseUrl',
     'hooks',
     'file',
+    'config',
   ] as const;
 
-  const generateApiOptions = options.reduce(
-    (s, key) =>
-      program[key]
-        ? {
-            ...s,
-            [key]: program[key],
-          }
-        : s,
-    {} as GenerationOptions
-  );
+  const outputFile = program['file'];
+  let tsConfigFilePath = program['config'];
+
+  if (tsConfigFilePath) {
+    tsConfigFilePath = path.resolve(tsConfigFilePath);
+    if (!fs.existsSync(tsConfigFilePath)) {
+      throw Error(MESSAGES.TSCONFIG_FILE_NOT_FOUND);
+    }
+  }
+
+  const compilerOptions = getCompilerOptions(tsConfigFilePath);
+
+  const generateApiOptions = {
+    ...options.reduce(
+      (s, key) =>
+        program[key]
+          ? {
+              ...s,
+              [key]: program[key],
+            }
+          : s,
+      {} as GenerationOptions
+    ),
+    outputFile,
+    compilerOptions,
+  };
   generateApi(schemaAbsPath, generateApiOptions)
     .then(async (sourceCode) => {
       const outputFile = program['file'];
       if (outputFile) {
-        fs.writeFileSync(`${process.cwd()}/${outputFile}`, await prettify(outputFile, sourceCode));
+        fs.writeFileSync(path.resolve(process.cwd(), outputFile), await prettify(outputFile, sourceCode));
       } else {
         console.log(await prettify(null, sourceCode));
       }
     })
-    .catch((err) => console.error(err));
+    .catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
 }

src/bin/cli.ts

@@ -1,6 +1,5 @@
 import * as ts from 'typescript';
-import * as fs from 'fs';
-import chalk from 'chalk';
+import * as path from 'path';
 import { camelCase } from 'lodash';
 import ApiGenerator, {
   getOperationName,
@@ -12,15 +11,16 @@ import { createQuestionToken, keywordType } from 'oazapfts/lib/codegen/tscodegen
 import { OpenAPIV3 } from 'openapi-types';
 import { generateReactHooks } from './generators/react-hooks';
 import { GenerationOptions, OperationDefinition } from './types';
-import { capitalize, getOperationDefinitions, getV3Doc, isQuery, MESSAGES, stripFileExtension } from './utils';
+import { capitalize, getOperationDefinitions, getV3Doc, isQuery, MESSAGES } from './utils';
 import { removeUndefined } from './utils/removeUndefined';
 import {
   generateCreateApiCall,
-  generateImportNode,
   generateEndpointDefinition,
   generateStringLiteralArray,
   ObjectPropertyDefinitions,
 } from './codegen';
+import { generateSmartImportNode } from './generators/smart-import-node';
+import { generateImportNode } from './generators/import-node';
 
 const { factory } = ts;
 
@@ -30,7 +30,7 @@ function defaultIsDataResponse(code: string) {
 }
 
 let customBaseQueryNode: ts.ImportDeclaration | undefined;
-let baseQueryFn: string, filePath: string;
+let moduleName: string;
 
 export async function generateApi(
   spec: string,
@@ -42,7 +42,9 @@ export async function generateApi(
     responseSuffix = 'ApiResponse',
     baseUrl,
     hooks,
+    outputFile,
     isDataResponse = defaultIsDataResponse,
+    compilerOptions,
   }: GenerationOptions
 ) {
   const v3Doc = await getV3Doc(spec);
@@ -80,76 +82,37 @@ export async function generateApi(
    * 3. If there is a not a seperator, file presence + default export existence is verified.
    */
 
-  function fnExportExists(path: string, fnName: string) {
-    const fileName = `${process.cwd()}/${path}`;
-
-    const sourceFile = ts.createSourceFile(
-      fileName,
-      fs.readFileSync(fileName).toString(),
-      ts.ScriptTarget.ES2015,
-      /*setParentNodes */ true
-    );
-
-    let found = false;
-
-    ts.forEachChild(sourceFile, (node) => {
-      const text = node.getText();
-      if (ts.isExportAssignment(node)) {
-        if (text.includes(fnName)) {
-          found = true;
-        }
-      } else if (ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isExportDeclaration(node)) {
-        if (text.includes(fnName) && text.includes('export')) {
-          found = true;
-        }
-      } else if (ts.isExportAssignment(node)) {
-        if (text.includes(`export ${fnName}`)) {
-          found = true;
-        }
-      }
-    });
-
-    return found;
+  if (outputFile) {
+    outputFile = path.resolve(process.cwd(), outputFile);
   }
 
   // If a baseQuery was specified as an arg, we try to parse and resolve it. If not, fallback to `fetchBaseQuery` or throw when appropriate.
+
+  let targetName = 'default';
   if (baseQuery !== 'fetchBaseQuery') {
     if (baseQuery.includes(':')) {
       // User specified a named function
-      [filePath, baseQueryFn] = baseQuery.split(':');
+      [moduleName, baseQuery] = baseQuery.split(':');
 
-      if (!baseQueryFn || !fnExportExists(filePath, baseQueryFn)) {
+      if (!baseQuery) {
         throw new Error(MESSAGES.NAMED_EXPORT_MISSING);
-      } else if (!fs.existsSync(filePath)) {
-        throw new Error(MESSAGES.FILE_NOT_FOUND);
       }
-
-      customBaseQueryNode = generateImportNode(stripFileExtension(filePath), {
-        [baseQueryFn]: baseQueryFn,
-      });
+      targetName = baseQuery;
     } else {
-      filePath = baseQuery;
-      baseQueryFn = 'fetchBaseQuery';
-
-      if (!fs.existsSync(filePath)) {
-        throw new Error(MESSAGES.FILE_NOT_FOUND);
-      } else if (!fnExportExists(filePath, 'default')) {
-        throw new Error(MESSAGES.DEFAULT_EXPORT_MISSING);
-      }
-
-      console.warn(chalk`
-        {yellow.bold A custom baseQuery was specified without a named function. We're going to import the default as {underline customBaseQuery}}
-        `);
-
-      baseQueryFn = 'customBaseQuery';
-
-      customBaseQueryNode = generateImportNode(stripFileExtension(filePath), {
-        default: baseQueryFn,
-      });
+      moduleName = baseQuery;
+      baseQuery = 'customBaseQuery';
     }
+
+    customBaseQueryNode = generateSmartImportNode({
+      moduleName,
+      containingFile: outputFile,
+      targetName,
+      targetAlias: baseQuery,
+      compilerOptions,
+    });
   }
 
-  const baseQueryCall = factory.createCallExpression(factory.createIdentifier(baseQueryFn || baseQuery), undefined, [
+  const baseQueryCall = factory.createCallExpression(factory.createIdentifier(baseQuery), undefined, [
     factory.createObjectLiteralExpression(
       [
         factory.createPropertyAssignment(
@@ -197,28 +160,6 @@ export async function generateApi(
 
   return sourceCode;
 
-  function generateImportNode(pkg: string, namedImports: Record<string, string>, defaultImportName?: string) {
-    return factory.createImportDeclaration(
-      undefined,
-      undefined,
-      factory.createImportClause(
-        false,
-        defaultImportName !== undefined ? factory.createIdentifier(defaultImportName) : undefined,
-        factory.createNamedImports(
-          Object.entries(namedImports)
-            .filter((args) => args[1])
-            .map(([propertyName, name]) =>
-              factory.createImportSpecifier(
-                name === propertyName ? undefined : factory.createIdentifier(propertyName),
-                factory.createIdentifier(name as string)
-              )
-            )
-        )
-      ),
-      factory.createStringLiteral(pkg)
-    );
-  }
-
   function generateEntityTypes(_: { operationDefinitions: OperationDefinition[]; v3Doc: OpenAPIV3.Document }) {
     return generateStringLiteralArray([]); // TODO
   }

src/generate.ts

@@ -0,0 +1,25 @@
+import * as ts from 'typescript';
+
+const { factory } = ts;
+
+export function generateImportNode(pkg: string, namedImports: Record<string, string>, defaultImportName?: string) {
+  return factory.createImportDeclaration(
+    undefined,
+    undefined,
+    factory.createImportClause(
+      false,
+      defaultImportName !== undefined ? factory.createIdentifier(defaultImportName) : undefined,
+      factory.createNamedImports(
+        Object.entries(namedImports)
+          .filter((args) => args[1])
+          .map(([propertyName, name]) =>
+            factory.createImportSpecifier(
+              name === propertyName ? undefined : factory.createIdentifier(propertyName),
+              factory.createIdentifier(name as string)
+            )
+          )
+      )
+    ),
+    factory.createStringLiteral(pkg)
+  );
+}

src/generators/import-node.ts

@@ -0,0 +1,52 @@
+import * as ts from 'typescript';
+import * as fs from 'fs';
+
+import { MESSAGES, stripFileExtension } from '../utils';
+import { isModuleInsidePathAlias } from '../utils/isModuleInsidePathAlias';
+import { generateImportNode } from './import-node';
+import { fnExportExists } from '../utils/fnExportExists';
+import { resolveImportPath } from '../utils/resolveImportPath';
+
+type SmartGenerateImportNode = {
+  moduleName: string;
+  containingFile?: string;
+  targetName: string;
+  targetAlias: string;
+  compilerOptions?: ts.CompilerOptions;
+};
+export const generateSmartImportNode = ({
+  moduleName,
+  containingFile,
+  targetName,
+  targetAlias,
+  compilerOptions,
+}: SmartGenerateImportNode): ts.ImportDeclaration => {
+  if (fs.existsSync(moduleName)) {
+    if (fnExportExists(moduleName, targetName)) {
+      return generateImportNode(
+        stripFileExtension(containingFile ? resolveImportPath(moduleName, containingFile) : moduleName),
+        {
+          [targetName]: targetAlias,
+        }
+      );
+    }
+
+    if (targetName === 'default') {
+      throw new Error(MESSAGES.DEFAULT_EXPORT_MISSING);
+    }
+    throw new Error(MESSAGES.NAMED_EXPORT_MISSING);
+  }
+
+  if (!compilerOptions) {
+    throw new Error(MESSAGES.FILE_NOT_FOUND);
+  }
+
+  // maybe moduleName is path alias
+  if (isModuleInsidePathAlias(compilerOptions, moduleName)) {
+    return generateImportNode(stripFileExtension(moduleName), {
+      [targetName]: targetAlias,
+    });
+  }
+
+  throw new Error(MESSAGES.FILE_NOT_FOUND);
+};

src/generators/smart-import-node.ts

@@ -1,3 +1,4 @@
+import * as ts from 'typescript';
 import { OpenAPIV3 } from 'openapi-types';
 
 export type OperationDefinition = {
@@ -17,5 +18,7 @@ export type GenerationOptions = {
   responseSuffix?: string;
   baseUrl?: string;
   hooks?: boolean;
+  outputFile?: string;
+  compilerOptions?: ts.CompilerOptions;
   isDataResponse?(code: string, response: OpenAPIV3.ResponseObject, allResponses: OpenAPIV3.ResponsesObject): boolean;
 };