@buildvision/nest-sdk-generator 1.2.2 → 2.1.0

package/src/bin.ts

@@ -1,30 +1,28 @@
 #!/usr/bin/env node
 
 import * as path from 'path'
+
 import { analyzerCli } from './analyzer'
 import { config, configPath } from './config'
-import generatorCli from './generator'
+import generateAPIClient from './generator'
 import { println } from './logging'
+import generateRTKQueryEndpoints from './rtk-query-generator'
 
 async function main() {
   const started = Date.now()
 
   process.chdir(path.dirname(path.resolve(configPath)))
 
-  switch (process.argv[3]) {
-    case '--analyze':
-      await analyzerCli(config)
-      break
+  const sdkContent = await analyzerCli(config)
+
+  const outputType = process.argv[3]
 
-    case '--generate':
-    case undefined:
-      const sdkContent = await analyzerCli(config)
-      await generatorCli(config, sdkContent)
-      break
+  if (outputType === '--generate') {
+    await generateAPIClient(config, sdkContent)
+  }
 
-    default:
-      console.error('ERROR: Unknown action provided (must be either "--analyze" or "--generate")')
-      process.exit(1)
+  if (outputType === '--generate-rtk') {
+    await generateRTKQueryEndpoints(config, sdkContent)
   }
 
   println('{green}', '@ Done in ' + ((Date.now() - started) / 1000).toFixed(2) + 's')

package/src/config.ts

@@ -1,29 +1,32 @@
-import chalk = require('chalk')
 import * as fs from 'fs'
 import * as path from 'path'
 
+import chalk = require('chalk')
+
 /**
  * The configuration file's content
  * For details on what these options do, see the project's README
  */
 export interface Config {
-  /** Enable verbose mode */
-  readonly verbose?: boolean
-
-  /** Disable colored output */
-  readonly noColor?: boolean
-
   /** Path to the API's source directory */
   readonly apiInputPath: string
 
-  /** Path to generate the SDK at */
-  readonly sdkOutput: string
+  readonly controllerOutput?: {
+    exportName?: {
+      addSuffix?: string
+      removeSuffix?: string
+    }
+    fileName?: {
+      addSuffix?: string
+      removeSuffix?: string
+    }
+  }
 
-  /** Path to the SDK interface file */
-  readonly sdkInterfacePath: string
+  /** If the SDK interface file does not exist yet, create one automatically (enabled by default) */
+  readonly generateDefaultSdkInterface?: boolean
 
-  /** List of magic types */
-  readonly magicTypes?: MagicType[]
+  /** Write generation timestamp in each TypeScript file (enabled by default) */
+  readonly generateTimestamps?: boolean
 
   /** Show a JSON output */
   readonly jsonOutput?: string
@@ -31,23 +34,31 @@ export interface Config {
   /** Prettify the JSON output */
   readonly jsonPrettyOutput?: boolean
 
-  /** Prettify the generated files (enabled by default) */
-  readonly prettify?: boolean
+  /** List of magic types */
+  readonly magicTypes?: MagicType[]
+
+  /** Disable colored output */
+  readonly noColor?: boolean
+
+  /** If the output directory already exists, overwrite it (enabled by default) */
+  readonly overwriteOldOutputDir?: boolean
 
   /** Path to Prettier's configuration file */
   readonly prettierConfig?: string
 
-  /** Path to custom tsconfig file */
-  readonly tsconfigFile?: string
+  /** Prettify the generated files (enabled by default) */
+  readonly prettify?: boolean
 
-  /** If the output directory already exists, overwrite it (enabled by default) */
-  readonly overwriteOldOutputDir?: boolean
+  /** Path to the SDK interface file */
+  readonly sdkInterfacePath: string
 
-  /** If the SDK interface file does not exist yet, create one automatically (enabled by default) */
-  readonly generateDefaultSdkInterface?: boolean
+  /** Path to generate the SDK at */
+  readonly sdkOutputPath: string
+  /** Path to custom tsconfig file */
+  readonly tsconfigFile?: string
 
-  /** Write generation timestamp in each TypeScript file (enabled by default) */
-  readonly generateTimestamps?: boolean
+  /** Enable verbose mode */
+  readonly verbose?: boolean
 }
 
 /**
@@ -55,8 +66,8 @@ export interface Config {
  */
 export interface MagicType {
   readonly nodeModuleFilePath: string
-  readonly typeName: string
   readonly placeholderContent: string
+  readonly typeName: string
 }
 
 /**

package/src/generator/genmodules.ts

@@ -2,180 +2,231 @@
  * @file Generate SDK modules
  */
 
-import * as path from 'path'
+import path = require('path')
+
+import { SdkController } from '../analyzer/controller'
 import { SdkModules } from '../analyzer/controllers'
 import { SdkHttpMethod, SdkMethod } from '../analyzer/methods'
-import { SdkMethodParams } from '../analyzer/params'
-import { resolveRouteWith, unparseRoute } from '../analyzer/route'
+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>()
 
+  /** Index file content: Exports all controllers */
+  const indexContent: 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) {
-      /** Generated controller's content */
-      const out: string[] = []
+    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}";`)
+    }
+  }
 
-      out.push('/// Parent module: ' + moduleName)
-      out.push(`/// Controller: "${controllerName}" registered as "${controller.registrationName}" (${controller.methods.length} routes)`)
-      out.push('')
-      out.push('import { request } from "../central";')
+  genFiles.set('index.ts', indexContent.join('\n'))
 
-      const imports = new Map<string, string[]>()
+  return genFiles
+}
 
-      const depsToImport = new Array<ResolvedTypeDeps>()
+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('/// Module: ' + moduleName)
+  out.push(`/// Controller: ${controllerName}`)
+  out.push(`/// File Path: file:///./${controllerRelativePath({ controller, inputRelativePath })}`)
+  out.push('')
+  out.push('import { request } from "./central";')
 
-      // Iterate over each controller
-      for (const method of controller.methods.values()) {
-        const { parameters: args, query, body } = method.params
+  const imports = new Map<string, string[]>()
 
-        depsToImport.push(method.returnType)
+  const depsToImport = new Array<ResolvedTypeDeps>()
 
-        if (args) {
-          depsToImport.push(...args.values())
-        }
+  // Iterate over each controller
+  for (const method of controller.methods.values()) {
+    const { bodyParams, queryParams, routeParams } = method.params
 
-        if (query) {
-          depsToImport.push(...query.values())
-        }
+    depsToImport.push(method.returnType)
+    depsToImport.push(...getParamResolvedTypes(routeParams))
+    depsToImport.push(...getParamResolvedTypes(queryParams))
+    depsToImport.push(...getParamResolvedTypes(bodyParams))
+  }
 
-        if (body) {
-          if (body.full) {
-            depsToImport.push(body.type)
-          } else {
-            depsToImport.push(...body.fields.values())
-          }
-        }
+  // Build the imports list
+  for (const dep of depsToImport) {
+    for (const [file, types] of dep.dependencies) {
+      let imported = imports.get(file)
+
+      if (!imported) {
+        imported = []
+        imports.set(file, imported)
       }
 
-      // Build the imports list
-      for (const dep of depsToImport) {
-        for (const [file, types] of dep.dependencies) {
-          let imported = imports.get(file)
-
-          if (!imported) {
-            imported = []
-            imports.set(file, imported)
-          }
-
-          for (const typ of types) {
-            if (!imported.includes(typ)) {
-              imported.push(typ)
-            }
-          }
+      for (const typ of types) {
+        if (!imported.includes(typ)) {
+          imported.push(typ)
         }
       }
+    }
+  }
 
-      for (const [file, types] of imports) {
-        out.push(
-          `import type { ${types.join(', ')} } from "../_types/${normalizeExternalFilePath(file.replace(/\\/g, '/')).replace(/\\/g, '/')}";`
-        )
-      }
+  for (const [file, types] of imports) {
+    out.push(
+      `import type { ${types.join(', ')} } from "../_types/${normalizeExternalFilePath(file.replace(/\\/g, '/')).replace(/\\/g, '/')}";`
+    )
+  }
 
-      out.push('')
-      out.push(`export default {`)
-
-      const { mutations, queries } = controller.methods.reduce(
-        (acc, method) => {
-          if (method.httpMethod === SdkHttpMethod.Get) {
-            acc.queries.push(method)
-          } else {
-            acc.mutations.push(method)
-          }
-
-          return acc
-        },
-        { mutations: [] as SdkMethod[], queries: [] as SdkMethod[] }
-      ); 
-
-      out.push(`  queries: {`)
-      
-      for (const method of queries) {
-        out.push(generateSdkMethod(method))
+  out.push('')
+  out.push(`export default {`)
+
+  const { mutations, queries } = controller.methods.reduce(
+    (acc, method) => {
+      if (method.httpMethod === SdkHttpMethod.Get) {
+        acc.queries.push(method)
+      } else {
+        acc.mutations.push(method)
       }
 
-      out.push('  },')
+      return acc
+    },
+    { mutations: [] as SdkMethod[], queries: [] as SdkMethod[] }
+  )
 
-      out.push(`  mutations: {`)
-      
-      for (const method of mutations) {
-        out.push(generateSdkMethod(method))
-      }
+  out.push(`  queries: {`)
 
-      out.push('  },')
+  for (const method of queries) {
+    out.push(generateSdkMethod({ method, controller, inputRelativePath }))
+  }
 
-      out.push('')
-      out.push('};')
+  out.push('  },')
 
-      genFiles.set(path.join(moduleName, controller.camelClassName + '.ts'), out.join('\n'))
-    }
+  out.push(`  mutations: {`)
 
-    /** Generated module's content */
-    const moduleContent: string[] = []
+  for (const method of mutations) {
+    out.push(generateSdkMethod({ method, controller, inputRelativePath }))
+  }
 
-    moduleContent.push('/// Module name: ' + moduleName)
-    moduleContent.push('')
+  out.push('  },')
 
-    for (const controller of controllers.keys()) {
-      moduleContent.push(`export { default as ${controller} } from "./${controller}";`)
-    }
+  out.push('')
+  out.push('};')
+  return out.join('\n')
+}
 
-    // Generate the SDK module file
-    genFiles.set(path.join(moduleName, 'index.ts'), moduleContent.join('\n'))
-  }
+export function generateSdkMethod({
+  controller,
+  inputRelativePath,
+  method,
+}: {
+  controller: SdkController
+  inputRelativePath: string
+  method: SdkMethod
+}): string {
+  const out = []
 
-  return genFiles
+  out.push('')
+  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 generateSdkMethod(method: SdkMethod): string {
-  const out = [];
+export function generateSdkMethodSignature(method: SdkMethod): string {
   const ret = method.returnType.resolvedType
   const promised = ret.startsWith('Promise<') ? ret : `Promise<${ret}>`
+  const paramsType = generateSdkMethodParams(method)
 
-  out.push('')
-  out.push(`  // ${method.httpMethod} @ ${unparseRoute(method.route)}`)
-  out.push(`  ${method.name}(${generateSdkMethodParams(method.params)}): ${promised} {`)
-  out.push(generateCentralRequest(method).replace(/^/gm, '    '))
-  out.push('  },')
-  return out.join('\n')
+  return `${method.name}(${paramsType}): ${promised}`
 }
 
-/**
- * Generate the method parameters for a given SDK method
- * @param params
- * @returns
- */
-export function generateSdkMethodParams(params: SdkMethodParams): string {
-  // List of parameters (e.g. `id` in `/get/:id`, analyzed from the usages of the `@Param` decorator)
-  const parameters = params.parameters ? [...params.parameters].map(([name, type]) => `${name}: ${type.resolvedType}`) : []
-
-  // List of query values (e.g. `id` in `?id=xxx`, analyzed from the usages of the `@Query` decorator)
-  const query = params.query ? [...params.query].map(([name, type]) => `${name}: ${type.resolvedType}`) : []
-
-  // Body's content (type used with the `@Body` decorator)
-  const body = params.body
-    ? params.body.full
-      ? params.body.type.resolvedType
-      : '{ ' + [...params.body.fields].map(([name, type]) => `${name}: ${type.resolvedType}`).join(', ') + ' }'
-    : null
-
-  // The ternary conditions below are made to eclipse useless parameters
-  // For instance, if we're not expecting any query nor body, these two parameters can be omitted when calling the method
-  return [
-    `params: {${' ' + parameters.join(', ') + ' '}}${parameters.length === 0 && !body && query.length === 0 ? ' = {}' : ''}`,
-    `body: ${body ?? '{}'}${!body && query.length === 0 ? ' = {}' : ''}`,
-    `query: {${' ' + query.join(', ') + ' '}}${query.length === 0 ? ' = {}' : ''}`,
-  ].join(', ')
+export function generateSdkMethodParams(method: SdkMethod): string {
+  const { httpMethod, name, params } = method
+
+  if (httpMethod === SdkHttpMethod.Get && params.bodyParams) {
+    panic(`${httpMethod} ${name} should not have Body params`)
+  }
+  if (httpMethod !== SdkHttpMethod.Get && params.queryParams) {
+    panic(`${httpMethod} ${name} should not have Query params`)
+  }
+
+  const inputTypes = []
+
+  if (params.routeParams) {
+    inputTypes.push(methodParamsToString(params.routeParams))
+  }
+
+  if (params.queryParams) {
+    inputTypes.push(methodParamsToString(params.queryParams))
+  }
+
+  if (params.bodyParams) {
+    inputTypes.push(methodParamsToString(params.bodyParams))
+  }
+
+  const mergedInputType = inputTypes.join(' &\n')
+
+  return mergedInputType ? `params: ${mergedInputType}` : ''
 }
 
 /**
@@ -183,12 +234,44 @@ export function generateSdkMethodParams(params: SdkMethodParams): string {
  * @param method
  * @returns
  */
-export function generateCentralRequest(method: SdkMethod): string {
-  const resolvedRoute = resolveRouteWith(method.route, (param) => '${params.' + param + '}')
+export function generateSdkMethodBody(method: SdkMethod): string {
+  const output = []
+  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
 
   if (resolvedRoute instanceof Error) {
     panic('Internal error: failed to resolve route: ' + resolvedRoute.message)
   }
+  const routeParamsSpread = routeParams.length > 0 ? `${routeParams.join(', ')},` : ''
+
+  // Destructure parameters if they exist
+  if (hasAnyParams) {
+    output.push(`const { ${routeParamsSpread} ...rest } = params`)
+  }
 
-  return `return request('${method.httpMethod}', \`${resolvedRoute}\`, body, query)`
+  const isGet = httpMethod === SdkHttpMethod.Get
+  const body = isGet || !hasAnyParams ? 'null' : 'rest'
+  const query = isGet && hasAnyParams ? 'rest' : '{}'
+
+  output.push(`return request('${httpMethod}', \`${resolvedRoute}\`, ${body}, ${query})`)
+  return output.join('\n')
+}
+
+export function methodParamsToString(params: SdkMethodParam): string {
+  if (params === null) {
+    return ''
+  }
+
+  if (isParamResolvedType(params)) {
+    return params.resolvedType
+  }
+
+  const output = ['{']
+  for (const [name, type] of Object.entries(params)) {
+    output.push(`${name}: ${type.resolvedType},`)
+  }
+  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,47 +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 {
-      if (!fs.existsSync(path.join(output, 'central.ts'))) {
-        panic("Provided output path exists but doesn't seem to contain an SDK output. Please check the output directory.")
-      } 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' +
@@ -54,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...')