@grafana/openapi-to-k6 0.2.5 → 0.3.0

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

@@ -1,5 +1,7 @@
 import { camel, getFileInfo } from '@orval/core'
 import fs from 'fs'
+import { createSourceFile, ScriptTarget } from 'typescript'
+
 import path from 'path'
 import { format, resolveConfig } from 'prettier'
 import packageJson from '../package.json'
@@ -158,3 +160,41 @@ export function getDirectoryForPath(pathString: string): string {
   // If the path has an extension, it is a file
   return path.dirname(pathString)
 }
+
+/**
+ * Checks if a file contains only comments and whitespace, with no actual code.
+ *
+ * This function uses TypeScript's parser to accurately detect and remove all types
+ * of comments (single-line, multi-line, JSDoc) and whitespace from the input text.
+ * If nothing remains after removing comments and whitespace, then the file is
+ * considered to contain only comments.
+ *
+ * @param fileContent - The string content of the file to check
+ * @returns True if the file contains only comments and whitespace, false if it contains any actual code
+ *
+ * @example
+ * // Returns true
+ * hasOnlyComments('// Just a comment');
+ *
+ * // Returns false
+ * hasOnlyComments('// A comment\nconst x = 1;');
+ */
+export function hasOnlyComments(fileContent: string): boolean {
+  // Create a source file
+  const sourceFile = createSourceFile(
+    'temp.ts',
+    fileContent,
+    ScriptTarget.Latest,
+    true
+  )
+
+  // Remove all comments and whitespace
+  const textWithoutComments = sourceFile
+    .getFullText()
+    .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '') // Remove comments
+    .replace(/\s+/g, '') // Remove whitespace
+
+  // If there's any content left after removing comments and whitespace,
+  // then there's actual code
+  return textWithoutComments.length === 0
+}

package/src/type.d.ts

@@ -31,4 +31,5 @@ export interface GenerateK6SDKOptions {
   shouldGenerateSampleK6Script?: boolean
   analyticsData?: AnalyticsData
   mode: Mode
+  tags?: (string | RegExp)[]
 }

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"]
@@ -251,6 +266,7 @@
     },
     "/items-header": {
       "get": {
+        "tags": ["ItemsHeader"],
         "summary": "Get an item with custom headers",
         "parameters": [
           {
@@ -259,7 +275,8 @@
             "required": true,
             "description": "ID of the item to retrieve",
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "12345"
             }
           }
         ],
@@ -278,7 +295,8 @@
             "description": "Client ID for the request",
             "required": true,
             "schema": {
-              "type": "string"
+              "type": "string",
+              "example": "client-123"
             }
           },
           {
@@ -287,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-tag-filter/k6Script.ts

@@ -0,0 +1,50 @@
+/* eslint-disable import/no-unresolved */
+import { check } from 'k6'
+import { Counter } from 'k6/metrics'
+import { ComprehensiveAPIClient } from './sdk.ts'
+/* eslint-enable import/no-unresolved */
+
+const CounterErrors = new Counter('Errors')
+const CounterSuccess = new Counter('Success')
+const baseUrl = 'http://localhost:3000'
+const client = new ComprehensiveAPIClient({ baseUrl })
+
+export const options = {
+  thresholds: {
+    Errors: ['count>=1'],
+    Success: ['count>=1'],
+    // the rate of successful checks should be higher than 90%
+  },
+}
+
+function checkResponseStatus(response, expectedStatus) {
+  const result = check(response, {
+    [`status is ${expectedStatus}`]: (r) => r.status === expectedStatus,
+  })
+
+  if (!result) {
+    console.error(
+      `Check failed! Expected status ${expectedStatus} but got ${response.status}. Following is the response:`
+    )
+    console.log(JSON.stringify(response, null, 2))
+  } else {
+    CounterSuccess.add(1)
+  }
+}
+
+export default function () {
+  try {
+    const getResponseData = client.getItemsId('1')
+    checkResponseStatus(getResponseData.response, 200)
+  } catch (error) {
+    if (error instanceof TypeError) {
+      // Add a k6 check to verify if the error is thrown
+      CounterErrors.add(1)
+    }
+  }
+
+  const getItemsHeaderResponseData = client.getItemsHeader({
+    id: 'test',
+  })
+  checkResponseStatus(getItemsHeaderResponseData.response, 200)
+}