@grafana/openapi-to-k6 0.2.6 → 0.3.1

package/src/generator/k6ScriptBuilder.ts

@@ -0,0 +1,328 @@
+import { faker } from '@faker-js/faker'
+import {
+  camel,
+  ClientExtraFilesBuilder,
+  ClientFileBuilder,
+  ContextSpecs,
+  GeneratorVerbOptions,
+  GetterPropType,
+  kebab,
+  NormalizedOutputOptions,
+  pascal,
+  resolveRef,
+  toObjectString,
+} from '@orval/core'
+import Handlebars from 'handlebars'
+import {
+  OperationObject,
+  ParameterObject,
+  ReferenceObject,
+  RequestBodyObject,
+  SchemaObject,
+} from 'openapi3-ts/oas30'
+import path from 'path'
+import {
+  DEFAULT_SCHEMA_TITLE,
+  K6_SCRIPT_TEMPLATE,
+  SAMPLE_K6_SCRIPT_FILE_NAME,
+} from '../constants'
+import { getDirectoryForPath, getGeneratedClientPath } from '../helper'
+import { logger } from '../logger'
+import { generateTitle } from './k6Client'
+
+function getExampleValueForSchema(
+  schema: SchemaObject | ReferenceObject,
+  context: ContextSpecs
+) {
+  // Handle $ref
+  if ('$ref' in schema) {
+    const { schema: resolvedSchema } = resolveRef(schema, context)
+    return getExampleValueForSchema(resolvedSchema as SchemaObject, context)
+  }
+
+  if ('example' in schema) {
+    return `'${schema.example}'`
+  }
+  let schemaType = schema.type
+  if (Array.isArray(schemaType)) {
+    schemaType = schemaType[0]
+  }
+  if (!schemaType) {
+    return undefined
+  }
+  const enumValues = schema.enum
+  switch (schemaType) {
+    case 'string':
+      return enumValues ? `'${enumValues[0]}'` : `'${faker.word.sample()}'`
+    case 'number':
+      return enumValues ? enumValues[0] : faker.number.int()
+    case 'integer':
+      return enumValues ? enumValues[0] : faker.number.int()
+    case 'boolean':
+      return enumValues ? enumValues[0] : faker.datatype.boolean()
+    case 'array':
+      return '[]'
+    case 'object': {
+      let objectString = '{\n'
+      for (const property in schema.properties) {
+        if (schema.properties[property]) {
+          const propertyValue = getExampleValueForSchema(
+            schema.properties[property],
+            context
+          )
+          objectString += `${property}: ${propertyValue},\n`
+        }
+      }
+
+      objectString += '\n}'
+      return objectString
+    }
+    default:
+      return null
+  }
+}
+
+function getExampleValues(
+  requiredProps: GeneratorVerbOptions['props'],
+  originalOperation: OperationObject,
+  context: ContextSpecs
+): string {
+  let exampleValues = ''
+  for (const prop of requiredProps) {
+    const propType = prop.type as GetterPropType
+
+    switch (propType) {
+      case GetterPropType.QUERY_PARAM: {
+        let exampleValue = '{\n'
+        for (const param of originalOperation.parameters || []) {
+          let resolvedParam: ParameterObject | ReferenceObject
+
+          if ('$ref' in param) {
+            const { schema: resolvedSchema } = resolveRef<ParameterObject>(
+              param,
+              context
+            )
+            resolvedParam = resolvedSchema
+          } else {
+            resolvedParam = param
+          }
+
+          // Only add required query parameters to the example values
+          if (resolvedParam.required && resolvedParam.in === 'query') {
+            if ('schema' in resolvedParam && resolvedParam.schema) {
+              exampleValue += `'${resolvedParam.name}': ${getExampleValueForSchema(resolvedParam.schema, context)},\n`
+            }
+          }
+        }
+        exampleValue += '\n}'
+        exampleValues += `params = ${exampleValue};\n`
+        break
+      }
+      case GetterPropType.HEADER: {
+        let exampleValue = '{\n'
+        for (const param of originalOperation.parameters || []) {
+          let resolvedParam: ParameterObject | ReferenceObject
+
+          if ('$ref' in param) {
+            const { schema: resolvedSchema } = resolveRef<ParameterObject>(
+              param,
+              context
+            )
+            resolvedParam = resolvedSchema
+          } else {
+            resolvedParam = param
+          }
+
+          // Only add required query parameters to the example values
+          if (resolvedParam.required && resolvedParam.in === 'header') {
+            if ('schema' in resolvedParam && resolvedParam.schema) {
+              exampleValue += `'${resolvedParam.name}': ${getExampleValueForSchema(resolvedParam.schema, context)},\n`
+            }
+          }
+        }
+        exampleValue += '\n}'
+        exampleValues += `headers = ${exampleValue};\n`
+        break
+        break
+      }
+      case GetterPropType.PARAM: {
+        let example, paramSchema: SchemaObject | ReferenceObject | undefined
+
+        for (const parameter of originalOperation.parameters || []) {
+          if ('name' in parameter) {
+            paramSchema = parameter.schema as SchemaObject
+            break
+          } else if ('$ref' in parameter) {
+            const { schema: resolvedSchema } = resolveRef<ParameterObject>(
+              parameter,
+              context
+            )
+            paramSchema = resolvedSchema.schema
+            break
+          }
+        }
+
+        if (paramSchema) {
+          example = getExampleValueForSchema(paramSchema, context)
+        }
+        if (example) {
+          exampleValues += `${prop.name} = ${example};\n`
+        }
+        break
+      }
+      case GetterPropType.BODY: {
+        // Generate example value from body schema
+        const requestBody = originalOperation.requestBody
+        let requestBodyExample
+        if (!requestBody) {
+          break
+        }
+        let resolvedSchema
+        if ('$ref' in requestBody) {
+          const { schema } = resolveRef<RequestBodyObject>(requestBody, context)
+          resolvedSchema = schema
+        } else if ('content' in requestBody) {
+          resolvedSchema = requestBody
+        }
+
+        if (resolvedSchema && 'content' in resolvedSchema) {
+          // Get the first available content type
+          const contentType = Object.keys(resolvedSchema.content)[0]
+          if (contentType) {
+            const requestBodySchema =
+              resolvedSchema.content[contentType]?.schema
+            if (requestBodySchema) {
+              requestBodyExample = getExampleValueForSchema(
+                requestBodySchema,
+                context
+              )
+            }
+          }
+        }
+        if (requestBodyExample) {
+          exampleValues += `${prop.name} = ${requestBodyExample};\n`
+        }
+        break
+      }
+    }
+  }
+  return exampleValues
+}
+
+function getClientClassName(identifier: string) {
+  return generateTitle(pascal(identifier))
+}
+
+function getClientObjectName(identifier: string) {
+  return camel(generateTitle(pascal(identifier)))
+}
+
+export const k6ScriptBuilder: ClientExtraFilesBuilder = async (
+  verbOptions: Record<string, GeneratorVerbOptions>,
+  output: NormalizedOutputOptions,
+  context: ContextSpecs
+): Promise<ClientFileBuilder[]> => {
+  const schemaTitle =
+    context.specs[context.specKey]?.info.title || DEFAULT_SCHEMA_TITLE
+  const {
+    path: pathOfGeneratedClient,
+    filename,
+    extension,
+  } = await getGeneratedClientPath(output.target!, schemaTitle)
+  const directoryPath = getDirectoryForPath(pathOfGeneratedClient)
+  const generateScriptPath = path.join(
+    directoryPath,
+    SAMPLE_K6_SCRIPT_FILE_NAME
+  )
+
+  logger.debug(
+    `k6ScriptBuilder ~ Generating sample K6 Script\n${JSON.stringify(
+      {
+        pathOfGeneratedClient,
+        filename,
+        extension,
+        schemaTitle,
+        directoryPath,
+        generateScriptPath,
+      },
+      null,
+      2
+    )}`
+  )
+
+  const clientFunctionsList = []
+  const uniqueVariables = new Set<string>() // Track unique variable names
+  const allUniqueTags = new Set<string>()
+
+  for (const verbOption of Object.values(verbOptions)) {
+    if (verbOption.tags && verbOption.tags.length > 0) {
+      verbOption.tags.forEach((tag) => allUniqueTags.add(tag))
+    } else {
+      allUniqueTags.add('default')
+    }
+
+    let clientObjectName
+    if (output.mode === 'tags') {
+      clientObjectName = getClientObjectName(verbOption.tags[0] || 'default')
+    } else {
+      clientObjectName = getClientObjectName(schemaTitle)
+    }
+
+    const { operationName, summary, props, originalOperation } = verbOption
+    const requiredProps = props.filter((prop) => prop.required)
+    // Create example values object
+    const exampleValues = getExampleValues(
+      requiredProps,
+      originalOperation,
+      context
+    )
+
+    for (const prop of requiredProps) {
+      uniqueVariables.add(prop.name)
+    }
+    clientFunctionsList.push({
+      operationName,
+      summary,
+      exampleValues,
+      requiredParametersString: toObjectString(requiredProps, 'name'),
+      clientObjectName,
+    })
+  }
+
+  let importStatements = ''
+  let clientInitializationStatement = ''
+
+  if (output.mode === 'tags') {
+    for (const tag of allUniqueTags) {
+      const { extension } = await getGeneratedClientPath(
+        output.target!,
+        schemaTitle
+      )
+      const clientName = getClientClassName(tag)
+      importStatements += `import { ${clientName} } from './${kebab(tag)}${extension}';\n`
+      clientInitializationStatement += `const ${getClientObjectName(tag)} = new ${clientName}({ baseUrl });\n`
+    }
+  } else {
+    const clientName = getClientClassName(schemaTitle)
+    importStatements = `import { ${clientName} } from './${filename}${extension}';\n`
+    clientInitializationStatement = `const ${getClientObjectName(schemaTitle)} = new ${clientName}({ baseUrl });\n`
+  }
+
+  const scriptContentData = {
+    clientFunctionsList,
+    variableDefinition:
+      uniqueVariables.size > 0
+        ? `let ${Array.from(uniqueVariables).join(', ')};`
+        : '',
+    importStatements,
+    clientInitializationStatement,
+  }
+  const template = Handlebars.compile(K6_SCRIPT_TEMPLATE)
+
+  return [
+    {
+      path: generateScriptPath,
+      content: template(scriptContentData),
+    },
+  ]
+}

package/src/helper.ts

@@ -123,6 +123,23 @@ export class OutputOverrider {
     process.stdout.write = this.originalStdoutWrite
     process.stderr.write = this.originalStderrWrite
   }
+
+  // Method to temporarily write to stdout and stderr
+  public async temporarilyWriteToStdoutAndStderr(
+    callback: () => Promise<void>
+  ) {
+    const currentStdoutWrite = process.stdout.write
+    const currentStderrWrite = process.stderr.write
+
+    process.stdout.write = this.originalStdoutWrite
+    process.stderr.write = this.originalStderrWrite
+    try {
+      await callback()
+    } finally {
+      process.stdout.write = currentStdoutWrite
+      process.stderr.write = currentStderrWrite
+    }
+  }
 }
 
 /**

package/tests/e2e/schema.json

@@ -17,7 +17,8 @@
             "required": true,
             "description": "ID of the item to retrieve",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           },
           {
@@ -27,7 +28,8 @@
             "description": "Whether to return detailed information",
             "schema": {
               "type": "boolean",
-              "default": false
+              "default": false,
+              "example": true
             }
           }
         ],
@@ -47,7 +49,8 @@
             "required": true,
             "description": "ID of the item to create",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -59,10 +62,12 @@
                 "type": "object",
                 "properties": {
                   "name": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Sample Item"
                   },
                   "description": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "This is a sample description for the item."
                   }
                 }
               }
@@ -85,7 +90,8 @@
             "required": true,
             "description": "ID of the item to update",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -97,10 +103,12 @@
                 "type": "object",
                 "properties": {
                   "name": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Updated Item Name"
                   },
                   "description": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Updated description for the item."
                   }
                 }
               }
@@ -123,7 +131,8 @@
             "required": true,
             "description": "ID of the item to partially update",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -135,7 +144,8 @@
                 "type": "object",
                 "properties": {
                   "name": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Partially Updated Item Name"
                   }
                 }
               }
@@ -158,7 +168,8 @@
             "required": true,
             "description": "ID of the item to delete",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -178,7 +189,8 @@
             "required": true,
             "description": "ID of the item to check",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -204,10 +216,12 @@
                 "type": "object",
                 "properties": {
                   "name": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Form Encoded Item"
                   },
                   "description": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Description for form-urlencoded item."
                   }
                 },
                 "required": ["name"]
@@ -234,7 +248,8 @@
                 "type": "object",
                 "properties": {
                   "name": {
-                    "type": "string"
+                    "type": "string",
+                    "example": "Form Data Item"
                   }
                 },
                 "required": ["file", "name"]
@@ -260,7 +275,8 @@
             "required": true,
             "description": "ID of the item to retrieve",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -279,7 +295,8 @@
             "description": "Client ID for the request",
             "required": true,
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "client-123"
             }
           },
           {
@@ -288,11 +305,111 @@
             "description": "Unique request identifier",
             "required": false,
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "req-56789"
             }
           }
         ]
       }
+    },
+    "/users/{userId}/posts/{postId}": {
+      "get": {
+        "operationId": "getUserPost",
+        "parameters": [
+          {
+            "name": "userId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "postId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "title": {
+                      "type": "string"
+                    },
+                    "content": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/items-new-mandatory-headers": {
+      "get": {
+        "tags": ["ItemsHeader"],
+        "summary": "Retrieve a new item with mandatory headers",
+        "parameters": [
+          {
+            "name": "itemId",
+            "in": "query",
+            "required": true,
+            "description": "ID of the item to retrieve",
+            "schema": {
+              "type": "string",
+              "example": "67890"
+            }
+          },
+          {
+            "name": "X-Auth-Token",
+            "in": "header",
+            "description": "Authentication token",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "example": "Bearer abcdef12345"
+            }
+          },
+          {
+            "name": "X-Correlation-ID",
+            "in": "header",
+            "description": "Correlation ID for tracking requests",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "example": "correlation-12345"
+            }
+          },
+          {
+            "name": "X-Optional-Header",
+            "in": "header",
+            "description": "Optional header",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "example": "optional-header-value"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "New item retrieved successfully"
+          },
+          "400": {
+            "description": "Invalid request"
+          }
+        }
+      }
     }
   }
 }

package/tests/e2e/single/k6Script.ts

@@ -3,8 +3,15 @@ import { check } from 'k6'
 import { ComprehensiveAPIClient } from './sdk.ts'
 /* eslint-enable import/no-unresolved */
 
+const commonRequestParameters = {
+  headers: {
+    'Only-Common-Header': 'test',
+    'Only-Common-Header-2': 'test-2',
+    'X-Correlation-ID': 'only-common-header-value',
+  },
+}
 const baseUrl = 'http://localhost:3000'
-const client = new ComprehensiveAPIClient({ baseUrl })
+const client = new ComprehensiveAPIClient({ baseUrl, commonRequestParameters })
 
 export const options = {
   thresholds: {
@@ -79,4 +86,50 @@ export default function () {
     id: 'test',
   })
   checkResponseStatus(getItemsHeaderResponseData.response, 200)
+
+  const requestParameters = {
+    headers: {
+      'Only-Common-Header-2': 'test-common-header-2-parameter',
+      'X-Correlation-ID': 'test-request-parameter',
+    },
+  }
+  const getItemsNewMandatoryHeadersResponseData =
+    client.getItemsNewMandatoryHeaders(
+      {
+        itemId: 'test',
+      },
+      {
+        'X-Auth-Token': 'test',
+        'X-Correlation-ID': 'test-function-argument',
+      },
+      requestParameters
+    )
+  checkResponseStatus(getItemsNewMandatoryHeadersResponseData.response, 200)
+
+  const requestHeaders =
+    getItemsNewMandatoryHeadersResponseData.response.request.headers
+  console.log('requestHeaders')
+  console.log(requestHeaders)
+
+  // Validate that the header present only in common request parameters is present in the request
+  check(requestHeaders, {
+    'has only-common-header': (r) => r['Only-Common-Header'][0] === 'test',
+  })
+
+  // Validate that the header present only in the request parameters is present in the request
+  check(requestHeaders, {
+    'has X-Auth-Token': (r) => r['X-Auth-Token'][0] === 'test',
+  })
+
+  // Validate that the header present in the requestParameters takes precedence over the value in common request parameters
+  check(requestHeaders, {
+    'has correct value of Only-Common-Header-2 from request parameters': (r) =>
+      r['Only-Common-Header-2'][0] === 'test-common-header-2-parameter',
+  })
+
+  // Validate that the value of the header present in function arguments takes precedence over the value in common request parameters and request parameters
+  check(requestHeaders, {
+    'has correct value X-Correlation-ID from function arguments': (r) =>
+      r['X-Correlation-Id'][0] === 'test-function-argument',
+  })
 }

package/tests/functional-tests/helper.ts

@@ -0,0 +1,16 @@
+import fs from 'fs'
+import { promisify } from 'util'
+
+export const writeFile = promisify(fs.writeFile)
+export const readFile = promisify(fs.readFile)
+export const mkdtemp = promisify(fs.mkdtemp)
+export const rmdir = promisify(fs.rmdir)
+
+export const loadFixture = (filePath: string) => {
+  const data = fs.readFileSync(filePath, 'utf-8')
+  return JSON.parse(data)
+}
+
+export const replaceSpacesAndNewLineToSingleSpace = (input: string): string => {
+  return input.replace(/\s+/g, ' ')
+}