@buildvision/nest-sdk-generator 2.0.0 → 2.2.0

package/src/generator/genmodules.ts

@@ -2,20 +2,58 @@
  * @file Generate SDK modules
  */
 
+import path = require('path')
+
 import { SdkController } from '../analyzer/controller'
 import { SdkModules } from '../analyzer/controllers'
 import { SdkHttpMethod, SdkMethod } from '../analyzer/methods'
 import { SdkMethodParam, getParamResolvedTypes, isParamResolvedType } from '../analyzer/params'
 import { paramsFromRoute, resolveRouteWith, unparseRoute } from '../analyzer/route'
 import { ResolvedTypeDeps, normalizeExternalFilePath } from '../analyzer/typedeps'
+import { config } from '../config'
 import { panic } from '../logging'
 
+export function replaceSuffix(value: string, { addSuffix = '', removeSuffix = '' }: { addSuffix?: string; removeSuffix?: string }) {
+  return value.replace(new RegExp(removeSuffix + '$'), '') + addSuffix
+}
+
+export function controllerExportName(controller: SdkController): string {
+  const suffixReplacement = config.controllerOutput?.exportName ?? {}
+  return replaceSuffix(controller.className, suffixReplacement)
+}
+
+export function controllerFileName(controller: SdkController): { ext: string; name: string } {
+  const { ext, name } = path.parse(controller.path)
+  const suffixReplacement = config.controllerOutput?.fileName ?? {}
+  const fileName = replaceSuffix(name, suffixReplacement)
+  return {
+    name: fileName,
+    ext: ext || '.ts',
+  }
+}
+
+export function controllerRelativePath({
+  controller,
+  inputRelativePath,
+}: {
+  controller: SdkController
+  inputRelativePath: string
+}): string {
+  return path.join(inputRelativePath, controller.path)
+}
+
 /**
  * Generate the SDK's module and controllers files
  * @param modules
  * @returns
  */
-export function generateSdkModules(modules: SdkModules): Map<string, string> {
+export function generateSdkModules({
+  inputRelativePath,
+  modules,
+}: {
+  inputRelativePath: string
+  modules: SdkModules
+}): Map<string, string> {
   /** Generated module files */
   const genFiles = new Map<string, string>()
 
@@ -25,10 +63,11 @@ export function generateSdkModules(modules: SdkModules): Map<string, string> {
   // Iterate over each module
   for (const [moduleName, controllers] of modules) {
     // Iterate over each of the module's controllers
-    for (const [controllerName, controller] of controllers) {
-      genFiles.set(controller.camelClassName + '.ts', generateController(moduleName, controller))
-      indexContent.push(`export { default as ${controller.camelClassName} } from "./${controller.camelClassName}";`)
-    }    
+    for (const [_, controller] of controllers) {
+      const { ext: fileExt, name: fileName } = controllerFileName(controller)
+      genFiles.set(fileName + fileExt, generateController({ moduleName, controller, inputRelativePath }))
+      indexContent.push(`export { default as ${controllerExportName(controller)} } from "./${fileName}";`)
+    }
   }
 
   genFiles.set('index.ts', indexContent.join('\n'))
@@ -36,14 +75,22 @@ export function generateSdkModules(modules: SdkModules): Map<string, string> {
   return genFiles
 }
 
-export function generateController(moduleName: string, controller: SdkController): string {
-  const controllerName = controller.camelClassName
+export function generateController({
+  controller,
+  inputRelativePath,
+  moduleName,
+}: {
+  controller: SdkController
+  inputRelativePath: string
+  moduleName: string
+}): string {
+  const controllerName = controller.className
   /** Generated controller's content */
   const out: string[] = []
 
-  out.push('/// Parent module: ' + moduleName)
-  out.push(`/// Controller: "${controllerName}" registered as "${controller.registrationName}" (${controller.methods.length} routes)`)
-  out.push(`/// File Path: ${controller.path}`)
+  out.push('/// Module: ' + moduleName)
+  out.push(`/// Controller: ${controllerName}`)
+  out.push(`/// File Path: file:///./${controllerRelativePath({ controller, inputRelativePath })}`)
   out.push('')
   out.push('import { request } from "./central";')
 
@@ -53,7 +100,7 @@ export function generateController(moduleName: string, controller: SdkController
 
   // Iterate over each controller
   for (const method of controller.methods.values()) {
-    const { routeParams, queryParams, bodyParams } = method.params
+    const { bodyParams, queryParams, routeParams } = method.params
 
     depsToImport.push(method.returnType)
     depsToImport.push(...getParamResolvedTypes(routeParams))
@@ -99,55 +146,62 @@ export function generateController(moduleName: string, controller: SdkController
       return acc
     },
     { mutations: [] as SdkMethod[], queries: [] as SdkMethod[] }
-  ); 
+  )
 
   out.push(`  queries: {`)
-  
+
   for (const method of queries) {
-    out.push(generateSdkMethod(method, controller))
+    out.push(generateSdkMethod({ method, controller, inputRelativePath }))
   }
 
   out.push('  },')
 
   out.push(`  mutations: {`)
-  
+
   for (const method of mutations) {
-    out.push(generateSdkMethod(method, controller))
+    out.push(generateSdkMethod({ method, controller, inputRelativePath }))
   }
 
   out.push('  },')
 
   out.push('')
   out.push('};')
-  return out.join('\n');
+  return out.join('\n')
 }
 
-export function generateSdkMethod(method: SdkMethod, controller: SdkController): string {
-  const out = [];
-  const ret = method.returnType.resolvedType
-  const promised = ret.startsWith('Promise<') ? ret : `Promise<${ret}>`
-  const paramsType = generateSdkMethodParams(method)
+export function generateSdkMethod({
+  controller,
+  inputRelativePath,
+  method,
+}: {
+  controller: SdkController
+  inputRelativePath: string
+  method: SdkMethod
+}): string {
+  const out = []
 
   out.push('')
-  out.push(`  // ${controller.camelClassName}.${method.name}`)
-  out.push(`  // ${method.httpMethod} @ ${unparseRoute(method.route)}`)
-  out.push(`  // ${controller.path}`)
+  out.push(`  /**`)
+  out.push(`  * ${method.httpMethod} ${unparseRoute(method.route)}`)
+  out.push(`  * ${controller.className}.${method.name}`)
+  out.push(`  * file:///./${controllerRelativePath({ controller, inputRelativePath })}`)
+  out.push(`  */`)
   out.push(`${generateSdkMethodSignature(method)} {`)
   out.push(generateSdkMethodBody(method))
   out.push('  },')
   return out.join('\n')
 }
 
-export function generateSdkMethodSignature(method: SdkMethod, prefix = '    '): string {
+export function generateSdkMethodSignature(method: SdkMethod): string {
   const ret = method.returnType.resolvedType
   const promised = ret.startsWith('Promise<') ? ret : `Promise<${ret}>`
   const paramsType = generateSdkMethodParams(method)
 
-  return `${prefix}${method.name}(${paramsType}): ${promised}`
+  return `${method.name}(${paramsType}): ${promised}`
 }
 
 export function generateSdkMethodParams(method: SdkMethod): string {
-  const { params, httpMethod, name  } = method;
+  const { httpMethod, name, params } = method
 
   if (httpMethod === SdkHttpMethod.Get && params.bodyParams) {
     panic(`${httpMethod} ${name} should not have Body params`)
@@ -156,7 +210,7 @@ export function generateSdkMethodParams(method: SdkMethod): string {
     panic(`${httpMethod} ${name} should not have Query params`)
   }
 
-  const inputTypes = [];
+  const inputTypes = []
 
   if (params.routeParams) {
     inputTypes.push(methodParamsToString(params.routeParams))
@@ -180,9 +234,9 @@ export function generateSdkMethodParams(method: SdkMethod): string {
  * @param method
  * @returns
  */
-export function generateSdkMethodBody(method: SdkMethod, prefix = '    '): string {
+export function generateSdkMethodBody(method: SdkMethod): string {
   const output = []
-  const { route, httpMethod } = method
+  const { httpMethod, route } = method
   const routeParams = paramsFromRoute(route)
   const resolvedRoute = resolveRouteWith(route, (param) => '${' + param + '}')
   const hasAnyParams = method.params.routeParams || method.params.queryParams || method.params.bodyParams
@@ -198,10 +252,9 @@ export function generateSdkMethodBody(method: SdkMethod, prefix = '    '): strin
   }
 
   const isGet = httpMethod === SdkHttpMethod.Get
-  const body = isGet || !hasAnyParams ? "null" : "rest"
-  const query = isGet && hasAnyParams ? "rest" : "{}" 
+  const body = isGet || !hasAnyParams ? 'null' : 'rest'
+  const query = isGet && hasAnyParams ? 'rest' : '{}'
 
-  
   output.push(`return request('${httpMethod}', \`${resolvedRoute}\`, ${body}, ${query})`)
   return output.join('\n')
 }
@@ -215,10 +268,10 @@ export function methodParamsToString(params: SdkMethodParam): string {
     return params.resolvedType
   }
 
-  const output = ["{"]
+  const output = ['{']
   for (const [name, type] of Object.entries(params)) {
     output.push(`${name}: ${type.resolvedType},`)
   }
-  output.push("}")
-  return output.join("\n")
+  output.push('}')
+  return output.join('\n')
 }

package/src/generator/gentypes.ts

@@ -3,6 +3,7 @@
  */
 
 import * as path from 'path'
+
 import { TypesExtractorContent } from '../analyzer/extractor'
 import { normalizeExternalFilePath } from '../analyzer/typedeps'
 

package/src/generator/index.ts

@@ -4,43 +4,47 @@
 
 import * as fs from 'fs'
 import * as path from 'path'
+
 import { SdkContent } from '../analyzer'
 import { normalizeExternalFilePath } from '../analyzer/typedeps'
 import { Config } from '../config'
 import { debug, panic, println } from '../logging'
+
 import { generateSdkModules } from './genmodules'
 import { generateSdkTypeFiles } from './gentypes'
 import { findPrettierConfig, prettify } from './prettier'
 import { defaultSdkInterface } from './sdk-interface'
 
-export default async function generatorCli(config: Config, sdkContent: SdkContent): Promise<void> {
+export default async function generateAPIClient(config: Config, sdkContent: SdkContent): Promise<void> {
   const prettifyOutput = config.prettify !== false
 
   if (!prettifyOutput) {
     debug('NOTE: files will not be prettified with Prettier')
   }
 
-  const output = path.resolve(process.cwd(), config.sdkOutput)
+  const outputPath = path.resolve(process.cwd(), config.sdkOutputPath)
+  const inputPath = path.resolve(process.cwd(), config.apiInputPath)
+  const inputRelativePath = path.relative(outputPath, inputPath)
 
-  if (fs.existsSync(output)) {
+  if (fs.existsSync(outputPath)) {
     if (config.overwriteOldOutputDir === false) {
       panic("Please provide an output directory that doesn't exist yet")
     } else {
-      fs.rmSync(output, { recursive: true })
+      fs.rmSync(outputPath, { recursive: true })
     }
   }
 
-  const outputParentDir = path.dirname(output)
+  const outputParentDir = path.dirname(outputPath)
 
   if (!fs.existsSync(outputParentDir)) {
     panic("Output directory's parent {magentaBright} does not exist.", outputParentDir)
   }
 
-  fs.mkdirSync(output)
+  fs.mkdirSync(outputPath)
 
   const prettierConfig = prettifyOutput ? findPrettierConfig(config) : {}
 
-  const writeScriptTo = (parentDir: null | string, file: string, utf8Content: string) => {
+  const writeScriptTo = async (parentDir: null | string, file: string, utf8Content: string) => {
     if (file.endsWith('.ts')) {
       utf8Content =
         '/// Auto-generated file (nest-sdk-generator)\n' +
@@ -50,35 +54,35 @@ export default async function generatorCli(config: Config, sdkContent: SdkConten
         utf8Content
     }
 
-    const fullPath = path.resolve(output, parentDir ?? '', file)
+    const fullPath = path.resolve(outputPath, parentDir ?? '', file)
     fs.mkdirSync(path.dirname(fullPath), { recursive: true })
-    fs.writeFileSync(
-      fullPath,
-      prettifyOutput ? prettify(utf8Content, prettierConfig, file.endsWith('.json') ? 'json' : 'typescript') : utf8Content,
-      'utf8'
-    )
+
+    const fileContent = prettifyOutput
+      ? await prettify(utf8Content, prettierConfig, file.endsWith('.json') ? 'json' : 'typescript')
+      : utf8Content
+    fs.writeFileSync(fullPath, fileContent, 'utf8')
   }
 
   println('> Generating type files...')
 
   for (const [file, content] of generateSdkTypeFiles(sdkContent.types)) {
-    writeScriptTo('_types', normalizeExternalFilePath(file), content)
+    await writeScriptTo('_types', normalizeExternalFilePath(file), content)
   }
 
   println('> Generating modules...')
-
-  for (const [file, content] of generateSdkModules(sdkContent.modules)) {
-    writeScriptTo(null, file, content)
+  const modules = sdkContent.modules
+  for (const [file, content] of generateSdkModules({ modules, inputRelativePath })) {
+    await writeScriptTo(null, file, content)
   }
 
   const sdkInterfacePath = path.resolve(process.cwd(), config.sdkInterfacePath)
 
   const relativeSdkInterfacePath = path
-    .relative(output, sdkInterfacePath)
+    .relative(outputPath, sdkInterfacePath)
     .replace(/\\/g, '/')
     .replace(/\.([jt]sx?)$/, '')
 
-  writeScriptTo(null, 'central.ts', `export { request } from "${relativeSdkInterfacePath}"`)
+  await writeScriptTo(null, 'central.ts', `export { request } from "${relativeSdkInterfacePath}"`)
 
   if (!fs.existsSync(sdkInterfacePath) && config.generateDefaultSdkInterface !== false) {
     println('├─ Generating default SDK interface...')

package/src/generator/prettier.ts

@@ -3,7 +3,9 @@
  */
 
 import * as fs from 'fs'
+
 import * as prettier from 'prettier'
+
 import { Config } from '../config'
 import { panic } from '../logging'
 import { findFileAbove } from '../utils'
@@ -12,7 +14,7 @@ import { findFileAbove } from '../utils'
  * Find a .prettierrc configuration file in the current directory or above
  */
 export function findPrettierConfig(config: Config): object {
-  let prettierConfigPath = config.prettierConfig ?? findFileAbove('.prettierrc', config.sdkOutput)
+  const prettierConfigPath = config.prettierConfig ?? findFileAbove('.prettierrc', config.sdkOutputPath)
 
   if (!prettierConfigPath) {
     return {}
@@ -38,7 +40,7 @@ export function findPrettierConfig(config: Config): object {
  * @param parser
  * @returns
  */
-export function prettify(source: string, config: object, parser: 'typescript' | 'json'): string {
+export function prettify(source: string, config: object, parser: 'typescript' | 'json'): Promise<string> {
   return prettier.format(source, {
     parser,
     ...config,

package/src/logging.ts

@@ -1,4 +1,5 @@
 import * as chalk from 'chalk'
+
 import { config } from './config'
 
 export function format(message: string, ...params: Array<number | string>): string {
@@ -22,7 +23,7 @@ export function unreachable(message: string, ...params: Array<number | string>):
 
 export function warn(message: string, ...params: Array<number | string>) {
   if (config.verbose) {
-  console.warn(chalk.yellow(format(message, ...params)))
+    console.warn(chalk.yellow(format(message, ...params)))
   }
 }