@buildvision/nest-sdk-generator 2.0.0 → 2.2.0

package/src/analyzer/params.ts

@@ -3,37 +3,38 @@
  */
 
 import { ClassDeclaration, Decorator, MethodDeclaration, Node, ParameterDeclaration, Type } from 'ts-morph'
+
 import { debug, panic } from '../logging'
+
 import { SdkHttpMethod } from './methods'
-import { Route, paramsFromRoute } from './route'
+import { paramsFromRoute, Route } from './route'
 import { ResolvedTypeDeps, resolveTypeDependencies } from './typedeps'
 
 /**
  * Type of a parameter that must be passed to an SDK method: Body, Query or Route Param
  * Supports accessing parameters individually by key or as a whole object
- * 
+ *
  * EXAMPLE
- * 
+ *
  * Controller Method:
- * 
+ *
  * getStuff(@Query('email') email: string, @Query('companyId'): CompanyId)
- * 
+ *
  * SDK Method Param:
  * { email: string, companyId: CompanyId }
- * 
+ *
  * OR
- * 
+ *
  * Controller Method:
  * type EmailAndCompanyId = { email: string, companyId: CompanyId }
  * getStuff(@Query(): EmailAndCompanyId)
- * 
+ *
  * SDK Method Param:
  * EmailAndCompanyId
  */
 
-
-export type SdkMethodParam =  SdkMethodParamMap | ResolvedTypeDeps | null;
-export type SdkMethodParamMap = { [key: string]: ResolvedTypeDeps };
+export type SdkMethodParam = SdkMethodParamMap | ResolvedTypeDeps | null
+export type SdkMethodParamMap = { [key: string]: ResolvedTypeDeps }
 
 export const isParamResolvedType = (param: SdkMethodParam): param is ResolvedTypeDeps => {
   if (param === null) {
@@ -56,36 +57,35 @@ export const getParamResolvedTypes = (param: SdkMethodParam): ResolvedTypeDeps[]
  * SDK interface for a controller's method's parameters
  */
 export interface SdkMethodParams {
-  routeParams: SdkMethodParam,
-  queryParams: SdkMethodParam,
-  bodyParams:  SdkMethodParam,
-  context: MethodContext,
+  bodyParams: SdkMethodParam
+  context: MethodContext
+  queryParams: SdkMethodParam
+  routeParams: SdkMethodParam
 }
 
 export type MethodContext = {
-  controllerClass: ClassDeclaration,
-  method: MethodDeclaration,
-  httpMethod: SdkHttpMethod,
-  route: Route,
-  filePath: string,
-  absoluteSrcPath: string,
+  absoluteSrcPath: string
+  controllerClass: ClassDeclaration
+  filePath: string
+  httpMethod: SdkHttpMethod
+  method: MethodDeclaration
+  route: Route
 }
 
 export enum ArgDecorator {
+  Body = 'Body',
   Param = 'Param',
   Query = 'Query',
-  Body = 'Body',
 }
 
 export type DecoratedArg = {
-  arg: ParameterDeclaration,
-  argParamKey: string | null,
-  decorator: Decorator,
-  decoratorType: ArgDecorator,
-  context: MethodContext,
+  arg: ParameterDeclaration
+  argParamKey: string | null
+  context: MethodContext
+  decorator: Decorator
+  decoratorType: ArgDecorator
 }
 
-
 /**
  * Generate a SDK interface for a controller's method's parameters
  * @param httpMethod The method's HTTP method
@@ -95,11 +95,9 @@ export type DecoratedArg = {
  * @param absoluteSrcPath Absolute path to the source directory
  * @returns A SDK interface for the method's parameters
  */
-export function extractParams(
-  context: MethodContext
-): SdkMethodParams {
-  const { route, filePath } = context
-  const { Param, Query, Body } = extractDecoratedArgs(context)
+export function extractParams(context: MethodContext): SdkMethodParams {
+  const { httpMethod, route } = context
+  const { Body, Param, Query } = extractDecoratedArgs(context)
   const resolvedParams: SdkMethodParams = {
     routeParams: mergeDecoratedArgs(Param),
     queryParams: mergeDecoratedArgs(Query),
@@ -107,37 +105,54 @@ export function extractParams(
     context,
   }
 
+  /**
+   * Validate Body Params are not used in GET requests
+   */
+  if (httpMethod === SdkHttpMethod.Get && resolvedParams.bodyParams) {
+    panicWithContext(`${httpMethod} request should not have @Body params, use @Query params instead`, context)
+  }
+
+  /**
+   * Validate Query Params are not used in non-GET requests
+   */
+  if (httpMethod !== SdkHttpMethod.Get && resolvedParams.queryParams) {
+    panicWithContext(`${httpMethod} request should not have @Query params, use @Body params instead`, context)
+  }
+
   /**
    * Validate Route Params exist in route URL
    */
   const { routeParams } = resolvedParams
   if (routeParams) {
-    const allowedRouteParams = new Set(paramsFromRoute(route)) 
-    const usedRouteParams = routeParams instanceof Type ? 
-      // If routeParams was resolved to a single type, assume there's only one decorated argument
-      Param[0].arg.getType().getProperties().map((prop) => prop.getName()) :
-      // If routeParams was resolved to a map, assume the keys are the route params
-      Object.keys(routeParams)
-    
+    const allowedRouteParams = new Set(paramsFromRoute(route))
+    const usedRouteParams =
+      routeParams instanceof Type
+        ? // If routeParams was resolved to a single type, assume there's only one decorated argument
+          Param[0].arg
+            .getType()
+            .getProperties()
+            .map((prop) => prop.getName())
+        : // If routeParams was resolved to a map, assume the keys are the route params
+          Object.keys(routeParams)
+
     for (const usedParam of usedRouteParams) {
       if (!allowedRouteParams.has(usedParam)) {
-          panicWithContext(`Route param ${usedParam} does not appear in route URL`, context)
-        }
+        panicWithContext(`Route param ${usedParam} does not appear in route URL`, context)
+      }
     }
   }
 
-  
   return resolvedParams
 }
 
 export function extractDecoratedArgs(context: MethodContext): Record<ArgDecorator, DecoratedArg[]> {
-    const decoratedArgs = {
-      [ArgDecorator.Param]: [] as DecoratedArg[],
-      [ArgDecorator.Query]: [] as DecoratedArg[],
-      [ArgDecorator.Body]: [] as DecoratedArg[],
-    }
+  const decoratedArgs = {
+    [ArgDecorator.Param]: [] as DecoratedArg[],
+    [ArgDecorator.Query]: [] as DecoratedArg[],
+    [ArgDecorator.Body]: [] as DecoratedArg[],
+  }
 
-  const { method, filePath, controllerClass } = context
+  const { controllerClass, method } = context
   const args = method.getParameters()
 
   for (const arg of args) {
@@ -181,17 +196,19 @@ export function extractDecoratedArgs(context: MethodContext): Record<ArgDecorato
   return decoratedArgs
 }
 
-export function extractArgParamKey(context: MethodContext & {  
-  arg: ParameterDeclaration,
-  decorator: Decorator,
-}): string | null {
-  const { decorator, controllerClass, method, arg } = context
+export function extractArgParamKey(
+  context: MethodContext & {
+    arg: ParameterDeclaration
+    decorator: Decorator
+  }
+): string | null {
+  const { arg, controllerClass, decorator, method } = context
   const decoratorArgs = decorator.getArguments()
 
   if (decoratorArgs.length > 1) {
     panic(
-        `${controllerClass.getName()} ${method.getName()} ${decorator.getName()}() ${arg.getName()} argument decorator has multiple parameters`
-      )
+      `${controllerClass.getName()} ${method.getName()} ${decorator.getName()}() ${arg.getName()} argument decorator has multiple parameters`
+    )
   } else if (decoratorArgs.length === 0) {
     return null
   }
@@ -204,10 +221,7 @@ export function extractArgParamKey(context: MethodContext & {
 
   const paramKey = decoratorArg.getLiteralText()
   if (paramKey in {}) {
-    panicWithContext(
-      `${decorator.getName()}('${paramKey}') param name collides with JavaScript native object property`, 
-      context
-    )
+    panicWithContext(`${decorator.getName()}('${paramKey}') param name collides with JavaScript native object property`, context)
   }
 
   return paramKey
@@ -215,10 +229,10 @@ export function extractArgParamKey(context: MethodContext & {
 
 export function mergeDecoratedArgs(decoratedArgs: DecoratedArg[]): SdkMethodParam {
   let genericParam: SdkMethodParam | null = null
-  let paramMap: SdkMethodParamMap = {}
+  const paramMap: SdkMethodParamMap = {}
 
   for (const decoratedArg of decoratedArgs) {
-    const { argParamKey, decoratorType, arg, context } = decoratedArg
+    const { arg, argParamKey, context, decoratorType } = decoratedArg
     const resolvedType = resolveTypeDependencies(arg.getType(), context.filePath, context.absoluteSrcPath)
 
     if (argParamKey) {
@@ -227,7 +241,7 @@ export function mergeDecoratedArgs(decoratedArgs: DecoratedArg[]): SdkMethodPara
       }
 
       paramMap[argParamKey] = resolvedType
-    } else  {
+    } else {
       if (genericParam) {
         panicWithContext(`${decoratorType}() used twice in controller method`, decoratedArg.context)
       }
@@ -246,7 +260,7 @@ export function mergeDecoratedArgs(decoratedArgs: DecoratedArg[]): SdkMethodPara
 }
 
 const panicWithContext = (message: string, context: MethodContext) => {
-  const { controllerClass, httpMethod, method, filePath } = context
+  const { controllerClass, filePath, httpMethod, method } = context
   const ctx = {
     controller: controllerClass.getName(),
     method: method.getName(),

package/src/analyzer/route.ts

@@ -51,6 +51,7 @@ export function analyzeUri(uriPath: string): Route | Error {
     if (part === '') continue
 
     // Ensure there is no generic character in the path as we don't support them
+    // eslint-disable-next-line no-useless-escape
     const genericErr = _findInvalid(part, /[\*\+\?]/)
 
     if (genericErr) {
@@ -91,7 +92,7 @@ export function analyzeUri(uriPath: string): Route | Error {
  * @param route
  */
 export function routePartIsParam(part: RoutePart): part is { readonly param: string } {
-  return "param" in part
+  return 'param' in part
 }
 
 export function paramsFromRoute(route: Route): string[] {
@@ -119,11 +120,12 @@ export function debugUri(route: Route, color: (str: string) => string): string {
  * @param params
  */
 export function resolveRoute(route: Route, params: { [name: string]: string }): string | Error {
-  let uri: string[] = []
+  const uri: string[] = []
 
   for (const part of route.parts) {
     if ('segment' in part) {
       uri.push(part.segment)
+      // eslint-disable-next-line no-prototype-builtins
     } else if (!params.hasOwnProperty(part.param)) {
       return new Error('Missing route parameter ' + part.param)
     } else {
@@ -140,7 +142,7 @@ export function resolveRoute(route: Route, params: { [name: string]: string }):
  * @param paramsProvider
  */
 export function resolveRouteWith(route: Route, paramsProvider: (param: string) => string | null): string | Error {
-  let uri: string[] = []
+  const uri: string[] = []
 
   for (const part of route.parts) {
     if ('segment' in part) {

package/src/analyzer/typedeps.ts

@@ -3,7 +3,9 @@
  */
 
 import * as path from 'path'
+
 import { ts, Type } from 'ts-morph'
+
 import { unreachable } from '../logging'
 
 /**
@@ -15,15 +17,6 @@ export const IMPORTED_TYPE_REGEX = /\bimport\(['"]([^'"]+)['"]\)\.([a-zA-Z0-9_]+
  * Type with resolved level 1 dependencies (does not look for dependencies' own dependencies!)
  */
 export interface ResolvedTypeDeps {
-  /** The original raw type, with import("...") expressions */
-  readonly rawType: string
-
-  /** The resolved type, without imports */
-  readonly resolvedType: string
-
-  /** File from which the type originates */
-  readonly relativeFilePath: string
-
   /**
    * The type dependencies used by the resolved type
    * A collection of scripts' relative paths mapped with the list of types imported from them
@@ -35,6 +28,15 @@ export interface ResolvedTypeDeps {
    * They may be either local types (declared in the same file than the one analyzed) or globally-defined types
    */
   readonly localTypes: string[]
+
+  /** The original raw type, with import("...") expressions */
+  readonly rawType: string
+
+  /** File from which the type originates */
+  readonly relativeFilePath: string
+
+  /** The resolved type, without imports */
+  readonly resolvedType: string
 }
 
 /**
@@ -55,8 +57,8 @@ export function resolveTypeDependencies(type: Type<ts.Type>, relativeFilePath: s
     )
   }
 
-  let dependencies: ResolvedTypeDeps['dependencies'] = new Map()
-  let localTypes: ResolvedTypeDeps['localTypes'] = []
+  const dependencies: ResolvedTypeDeps['dependencies'] = new Map()
+  const localTypes: ResolvedTypeDeps['localTypes'] = []
 
   /** Resolved type (without import statements) */
   const resolvedType: ResolvedTypeDeps['resolvedType'] = rawType.replace(IMPORTED_TYPE_REGEX, (_, matchedFilePath, type) => {

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,36 @@
-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?: {
+    endpointGroupName?: {
+      addSuffix?: string
+      removeSuffix?: string
+    }
+    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 +38,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 +70,8 @@ export interface Config {
  */
 export interface MagicType {
   readonly nodeModuleFilePath: string
-  readonly typeName: string
   readonly placeholderContent: string
+  readonly typeName: string
 }
 
 /**