@grafana/openapi-to-k6 0.1.0

package/src/helper.ts

@@ -0,0 +1,210 @@
+import { camel, getFileInfo } from '@orval/core'
+import fs from 'fs'
+import path from 'path'
+import { format, resolveConfig } from 'prettier'
+import packageJson from '../package.json'
+import { SAMPLE_K6_SCRIPT_FILE_NAME } from './constants'
+import { logger } from './logger'
+import { PackageDetails } from './type'
+
+export const getPackageDetails = (): PackageDetails => {
+  const commandName = Object.keys(packageJson.bin)[0] || 'openapi-to-k6'
+  return {
+    name: packageJson.name,
+    commandName,
+    description: packageJson.description,
+    version: packageJson.version,
+  }
+}
+
+/**
+ * Format the given file using Prettier.
+ *
+ * @param filePath - Path to the file to format.
+ */
+export async function formatFileWithPrettier(filePath: string) {
+  // Read file contents
+  const content = fs.readFileSync(filePath, 'utf-8')
+  // Format using Prettier
+  const options = await resolveConfig(filePath)
+  const formatted = await format(content, {
+    ...options,
+    filepath: filePath,
+  })
+
+  // Write formatted content back to the file
+  fs.writeFileSync(filePath, formatted)
+  logger.debug(`Formatted: ${filePath}`)
+}
+
+/**
+ * Format the generated files using Prettier.
+ *
+ * @param outputTarget - Path to the generated files.
+ * @param schemaTitle - Title of the schema.
+ */
+export async function formatGeneratedFiles(
+  outputTarget: string,
+  schemaTitle: string,
+  isSampleK6ScriptGenerated: boolean
+) {
+  // Here we call the original function from @orval/core used by the library to generate the
+  // file name with same defaults.
+  const { path: clientPath } = await getGeneratedClientPath(
+    outputTarget,
+    schemaTitle
+  )
+
+  logger.debug('Following are the details for formatting generated files:')
+  logger.debug(`Path: ${path}`)
+  logger.debug(`Schema Title: ${schemaTitle}`)
+  logger.debug(`Output Target: ${outputTarget}`)
+
+  await exports.formatFileWithPrettier(clientPath)
+
+  if (isSampleK6ScriptGenerated) {
+    const k6ScriptPath = path.join(
+      getDirectoryForPath(clientPath),
+      SAMPLE_K6_SCRIPT_FILE_NAME
+    )
+    logger.debug(`Generated sample K6 Script Path: ${k6ScriptPath}`)
+
+    if (fs.existsSync(k6ScriptPath)) {
+      logger.debug('Formatting sample k6 script file')
+      await exports.formatFileWithPrettier(k6ScriptPath)
+    } else {
+      logger.error(
+        'Unable to format sample K6 script file as it does not exist!'
+      )
+    }
+  }
+}
+
+/**
+ * Get the path for the generated client file.
+ *
+ * @param outputTarget - Path to the generated files.
+ * @param schemaTitle - Title of the schema.
+ *
+ * @returns Path to the generated client file.
+ */
+
+export async function getGeneratedClientPath(
+  outputTarget: string,
+  schemaTitle: string
+): Promise<{
+  path: string
+  filename: string
+  extension: string
+}> {
+  const { path, filename, extension } = getFileInfo(outputTarget, {
+    backupFilename: camel(schemaTitle),
+    extension: '.ts',
+  })
+
+  return { path, filename, extension }
+}
+
+/**
+ * A singleton Class to allow redirecting stdout and stderr to a null stream.
+ * This is used to supress the output from third-party libraries.
+ *
+ * Note: Make sure to call restoreOutput() after the third-party library call to restore the output.
+ *
+ * @example
+ * ```typescript
+ * const outputOverrider = OutputOverrider.getInstance();
+ * outputOverrider.redirectOutputToNullStream();
+ * // Call the third-party library
+ * outputOverrider.restoreOutput();
+ * ```
+ *
+ * @export
+ * @class OutputOverrider
+ */
+export class OutputOverrider {
+  private static instance: OutputOverrider | null = null
+  private originalStdoutWrite: any // eslint-disable-line @typescript-eslint/no-explicit-any
+  private originalStderrWrite: any // eslint-disable-line @typescript-eslint/no-explicit-any
+
+  // Making the constructor private to prevent direct instantiation
+  private constructor() {
+    this.originalStdoutWrite = process.stdout.write
+    this.originalStderrWrite = process.stderr.write
+  }
+  // Static method to get the single instance of the class
+  public static getInstance() {
+    if (OutputOverrider.instance === null) {
+      OutputOverrider.instance = new OutputOverrider()
+    }
+    return OutputOverrider.instance
+  }
+
+  public async redirectOutputToNullStream(callback?: () => Promise<void>) {
+    process.stdout.write = process.stderr.write = () => true
+
+    try {
+      if (callback) {
+        await callback()
+      }
+    } finally {
+      this._restoreOutput()
+    }
+  }
+
+  private _restoreOutput() {
+    process.stdout.write = this.originalStdoutWrite
+    process.stderr.write = this.originalStderrWrite
+  }
+}
+
+/**
+ * Check if the current script is running with ts-node. i.e. directly from source.
+ *
+ * @export
+ * @returns {boolean}
+ */
+export function isTsNode(): boolean {
+  const scriptPath = process.argv[1]
+  if (scriptPath) {
+    return scriptPath.endsWith('.ts') || scriptPath.includes('ts-node')
+  } else {
+    return false
+  }
+}
+
+/**
+ * Create a hash from the given string using the djb2 algorithm.
+ *
+ * @param str
+ * @returns generated hash
+ */
+export function djb2Hash(str: string): number {
+  let hash = 5381
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash * 33) ^ str.charCodeAt(i)
+  }
+  return hash >>> 0 // Ensure the hash is a positive integer
+}
+
+/**
+ * Returns the directory for the given path.
+ *
+ * If the path is a file, the directory of the file is returned.
+ * If the path is a directory, the path itself is returned.
+ *
+ * @param path - The path to get the directory for.
+ *
+ * @returns The directory for the given path.
+ */
+export function getDirectoryForPath(pathString: string): string {
+  const extensionName = path.extname(pathString)
+
+  if (!extensionName) {
+    // If the path does not have an extension, it is a directory
+    return pathString
+  }
+
+  // If the path has an extension, it is a file
+  return path.dirname(pathString)
+}

package/src/k6SdkClient.ts

@@ -0,0 +1,434 @@
+import {
+  ClientDependenciesBuilder,
+  ClientExtraFilesBuilder,
+  ClientFooterBuilder,
+  ClientGeneratorsBuilder,
+  ClientHeaderBuilder,
+  ClientTitleBuilder,
+  ContextSpecs,
+  generateFormDataAndUrlEncodedFunction,
+  generateVerbImports,
+  GeneratorMutator,
+  GeneratorOptions,
+  GeneratorSchema,
+  GeneratorVerbOptions,
+  GetterBody,
+  GetterQueryParam,
+  GetterResponse,
+  ParamsSerializerOptions,
+  pascal,
+  sanitize,
+  toObjectString,
+  Verbs,
+} from '@orval/core'
+import Handlebars from 'handlebars'
+import path from 'path'
+import {
+  DEFAULT_SCHEMA_TITLE,
+  K6_SCRIPT_TEMPLATE,
+  SAMPLE_K6_SCRIPT_FILE_NAME,
+} from './constants'
+import { getDirectoryForPath, getGeneratedClientPath } from './helper'
+import { AnalyticsData, SchemaDetails } from './type'
+
+// A map to store the operationNames for which a return type is to be written at the end to export
+// and the return type definition
+const returnTypesToWrite: Map<string, string> = new Map()
+
+export const getK6Dependencies: ClientDependenciesBuilder = () => [
+  {
+    exports: [
+      {
+        name: 'http',
+        default: true,
+        values: true,
+        syntheticDefaultImport: true,
+      },
+      { name: 'Response' },
+      { name: 'ResponseBody' },
+      { name: 'Params' },
+    ],
+    dependency: 'k6/http',
+  },
+  {
+    exports: [
+      {
+        name: 'URLSearchParams',
+        default: false,
+        values: true,
+        // syntheticDefaultImport: true,
+      },
+      {
+        name: 'URL',
+        default: false,
+        values: true,
+        // syntheticDefaultImport: true,
+      },
+    ],
+    dependency: 'https://jslib.k6.io/url/1.0.0/index.js',
+  },
+  {
+    exports: [
+      {
+        name: 'FormData',
+        default: false,
+        values: true,
+        // syntheticDefaultImport: true,
+      },
+    ],
+    dependency: 'https://jslib.k6.io/formdata/0.0.2/index.js',
+  },
+]
+
+function getSchemaTitleFromContext(context: ContextSpecs) {
+  const specData = Object.values(context.specs)
+
+  if (specData[0]) {
+    return specData[0].info.title
+  }
+
+  return DEFAULT_SCHEMA_TITLE
+}
+
+function _generateResponseTypeName(operationName: string): string {
+  return `${pascal(operationName)}Response`
+}
+
+function _generateResponseTypeDefinition(
+  operationName: string,
+  response: GetterResponse
+): string {
+  const typeName = _generateResponseTypeName(operationName)
+  let responseDataType = ''
+
+  if (response.definition.success) {
+    responseDataType += response.definition.success + ' | '
+  }
+  responseDataType += 'ResponseBody'
+
+  return `export type ${typeName} = {
+    response: Response
+    data: ${responseDataType}
+};`
+}
+
+const generateK6Implementation = (
+  {
+    headers,
+    queryParams,
+    operationName,
+    response,
+    body,
+    props,
+    verb,
+    override,
+    formData,
+    formUrlEncoded,
+    paramsSerializer,
+  }: GeneratorVerbOptions,
+  { route }: GeneratorOptions,
+  analyticsData?: AnalyticsData
+) => {
+  if (analyticsData) {
+    analyticsData.generatedRequestsCount[verb] += 1
+  }
+
+  const bodyForm = generateFormDataAndUrlEncodedFunction({
+    formData,
+    formUrlEncoded,
+    body,
+    isFormData: true,
+    isFormUrlEncoded: false,
+  })
+
+  // Generate response return types
+  returnTypesToWrite.set(
+    operationName,
+    _generateResponseTypeDefinition(operationName, response)
+  )
+
+  let url = `cleanBaseUrl + \`${route}\``
+
+  if (queryParams) {
+    url += '+`?${new URLSearchParams(params).toString()}`'
+  }
+  const urlGeneration = `const url = new URL(${url});`
+
+  const options = getK6RequestOptions({
+    route,
+    body,
+    headers,
+    queryParams,
+    response,
+    verb,
+    requestOptions: override?.requestOptions,
+    paramsSerializer,
+    paramsSerializerOptions: override?.paramsSerializerOptions,
+  })
+
+  return `const ${operationName} = (\n    ${toObjectString(props, 'implementation')} requestParameters?: Params): ${_generateResponseTypeName(operationName)} => {${bodyForm}
+        ${urlGeneration}
+        const mergedRequestParameters = _mergeRequestParameters(requestParameters || {}, clientOptions.commonRequestParameters);
+        const response = http.request(${options});
+        let data;
+
+        try {
+            data = response.json();
+        } catch (error) {
+            data = response.body;
+        }
+      return {
+        response,
+        data
+      }
+    }
+  `
+}
+
+type OptionsInput = {
+  route: string
+  body: GetterBody
+  headers?: GetterQueryParam
+  queryParams?: GetterQueryParam
+  response: GetterResponse
+  verb: Verbs
+  requestOptions?: object | boolean
+  isVue?: boolean
+  paramsSerializer?: GeneratorMutator
+  paramsSerializerOptions?: ParamsSerializerOptions
+}
+
+const getParamsInputValue = ({
+  response,
+  queryParams,
+  headers,
+  body,
+}: {
+  response: GetterResponse
+  body: GetterBody
+  queryParams?: GeneratorSchema
+  headers?: GeneratorSchema
+}) => {
+  if (!queryParams && !headers && !response.isBlob && !body.contentType) {
+    // No parameters to merge, return the request parameters directly
+    return 'mergedRequestParameters'
+  }
+
+  let value = '\n    ...mergedRequestParameters,'
+
+  if (response.isBlob) {
+    value += `\n        responseType: 'binary',`
+  }
+  // Expand the headers
+  if (body.contentType || headers) {
+    let headersValue = `\n       headers: {`
+    if (body.contentType) {
+      if (body.formData) {
+        headersValue += `\n'Content-Type': '${body.contentType}; boundary=' + formData.boundary,`
+      } else {
+        headersValue += `\n'Content-Type': '${body.contentType}',`
+      }
+    }
+
+    if (headers) {
+      headersValue += `\n...headers,`
+    }
+
+    headersValue += `\n...mergedRequestParameters?.headers},`
+    value += headersValue
+  }
+
+  return `{${value}}`
+}
+
+const getK6RequestOptions = (options: OptionsInput) => {
+  const { body, headers, queryParams, response, verb } = options
+
+  let fetchBodyOption = 'undefined'
+
+  if (body.formData) {
+    // Use the FormData.body() method to get the body of the request
+    fetchBodyOption = 'formData.body()'
+  } else if (body.formUrlEncoded || body.implementation) {
+    fetchBodyOption = `JSON.stringify(${body.implementation})`
+  }
+
+  // Generate the params input for the call
+
+  const paramsValue = getParamsInputValue({
+    response,
+    body,
+    headers: headers?.schema,
+    queryParams: queryParams?.schema,
+  })
+
+  // Sample output
+  // 'GET', 'http://test.com/route', <body>, <options>
+
+  return `"${verb.toUpperCase()}",
+        url.toString(),
+        ${fetchBodyOption},
+        ${paramsValue}`
+}
+
+function _getRequestParametersMergerFunctionImplementation() {
+  return `/**
+ * Merges the provided request parameters with default parameters for the client.
+ *
+ * @param {Params} requestParameters - The parameters provided specifically for the request
+ * @param {Params} commonRequestParameters - Common parameters for all requests
+ * @returns {Params} - The merged parameters
+ */
+  const _mergeRequestParameters = (requestParameters?: Params, commonRequestParameters?: Params): Params => {
+    return {
+        ...commonRequestParameters,  // Default to common parameters
+        ...requestParameters,        // Override with request-specific parameters
+        headers: {
+            ...commonRequestParameters?.headers || {},  // Ensure headers are defined
+            ...requestParameters?.headers || {},
+        },
+        cookies: {
+            ...commonRequestParameters?.cookies || {},  // Ensure cookies are defined
+            ...requestParameters?.cookies || {},
+        },
+        tags: {
+            ...commonRequestParameters?.tags || {},     // Ensure tags are defined
+            ...requestParameters?.tags || {},
+        },
+    };
+};`
+}
+
+export const generateTitle: ClientTitleBuilder = (title) => {
+  const sanTitle = sanitize(title || DEFAULT_SCHEMA_TITLE)
+  return `create${pascal(sanTitle)}`
+}
+
+export const generateK6Header: ClientHeaderBuilder = ({ title }) => {
+  const clientOptionsTypeName = `${pascal(title)}Options`
+  return `
+  export type ${clientOptionsTypeName} = {
+    baseUrl: string,
+    commonRequestParameters?: Params
+  }
+
+  /**
+ * This is the base client to use for interacting with the API.
+ */
+  export const ${title} = (clientOptions: ${clientOptionsTypeName}) => {\n
+        const cleanBaseUrl = clientOptions.baseUrl.replace(/\\/+$/, '');\n`
+}
+
+export const generateFooter: ClientFooterBuilder = ({ operationNames }) => {
+  let footer = ''
+
+  footer += `return {${operationNames.join(',')}}};\n\n`
+
+  operationNames.forEach((operationName) => {
+    if (returnTypesToWrite.has(operationName)) {
+      footer += returnTypesToWrite.get(operationName) + '\n'
+    }
+  })
+
+  // Add function definition for merging request parameters
+  footer += `\n\n${_getRequestParametersMergerFunctionImplementation()}\n`
+
+  return footer
+}
+
+const k6ScriptBuilder: ClientExtraFilesBuilder = async (
+  verbOptions,
+  output,
+  context
+) => {
+  console.log(
+    JSON.stringify(
+      {
+        verbOptions,
+        output,
+        context,
+      },
+      null,
+      2
+    )
+  )
+
+  const schemaTitle = getSchemaTitleFromContext(context)
+  const {
+    path: pathOfGeneratedClient,
+    filename,
+    extension,
+  } = await getGeneratedClientPath(output.target!, schemaTitle)
+  const directoryPath = getDirectoryForPath(pathOfGeneratedClient)
+  const generateScriptPath = path.join(
+    directoryPath,
+    SAMPLE_K6_SCRIPT_FILE_NAME
+  )
+
+  const clientFunctionsList = []
+
+  for (const verbOption of Object.values(verbOptions)) {
+    const { operationName, summary, props } = verbOption
+    const requiredProps = props.filter((prop) => prop.required)
+    clientFunctionsList.push({
+      operationName,
+      summary,
+      requiredParametersString: toObjectString(requiredProps, 'name'),
+    })
+  }
+
+  const scriptContentData = {
+    clientFunctionName: generateTitle(schemaTitle),
+    clientPath: `./${filename}${extension}`,
+    clientFunctionsList,
+  }
+  const template = Handlebars.compile(K6_SCRIPT_TEMPLATE)
+
+  return [
+    {
+      path: generateScriptPath,
+      content: template(scriptContentData),
+    },
+  ]
+}
+
+function getK6Client(
+  schemaDetails: SchemaDetails,
+  analyticsData?: AnalyticsData
+) {
+  return function (
+    verbOptions: GeneratorVerbOptions,
+    options: GeneratorOptions
+  ) {
+    const imports = generateVerbImports(verbOptions)
+    const implementation = generateK6Implementation(
+      verbOptions,
+      options,
+      analyticsData
+    )
+    schemaDetails.title = getSchemaTitleFromContext(options.context)
+    const specData = Object.values(options.context.specs)
+    if (specData[0]) {
+      if (analyticsData) {
+        analyticsData.openApiSpecVersion = specData[0].openapi
+      }
+    }
+
+    return { implementation, imports }
+  }
+}
+
+export function getK6ClientBuilder(
+  schemaDetails: SchemaDetails,
+  shouldGenerateSampleK6Script?: boolean,
+  analyticsData?: AnalyticsData
+): ClientGeneratorsBuilder {
+  return {
+    client: getK6Client(schemaDetails, analyticsData),
+    header: generateK6Header,
+    dependencies: getK6Dependencies,
+    footer: generateFooter,
+    title: generateTitle,
+    extraFiles: shouldGenerateSampleK6Script ? k6ScriptBuilder : undefined,
+  }
+}

package/src/logger.ts

@@ -0,0 +1,61 @@
+import chalk from 'chalk'
+
+enum LogLevel {
+  INFO = 'INFO',
+  WARNING = 'WARNING',
+  ERROR = 'ERROR',
+  DEBUG = 'DEBUG',
+}
+
+class Logger {
+  private static instance: Logger
+  private isVerbose: boolean = false
+
+  private constructor() {}
+
+  public static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger()
+    }
+    return Logger.instance
+  }
+
+  public setVerbose(verbose: boolean): void {
+    this.isVerbose = verbose
+  }
+
+  private logWithColor(
+    message: string,
+    level: LogLevel,
+    color: chalk.Chalk
+  ): void {
+    const timestamp = new Date().toISOString()
+    console.log(
+      `${color(`[${level}]`)} ${chalk.gray(`[${timestamp}]`)} ${message}`
+    )
+  }
+
+  public info(message: string): void {
+    this.logWithColor(message, LogLevel.INFO, chalk.blue)
+  }
+
+  public logMessage(message: string): void {
+    console.log(message)
+  }
+
+  public warning(message: string): void {
+    this.logWithColor(message, LogLevel.WARNING, chalk.yellow)
+  }
+
+  public error(message: string): void {
+    this.logWithColor(message, LogLevel.ERROR, chalk.red)
+  }
+
+  public debug(message: string): void {
+    if (this.isVerbose) {
+      this.logWithColor(message, LogLevel.DEBUG, chalk.green)
+    }
+  }
+}
+
+export const logger = Logger.getInstance()