@grafana/openapi-to-k6 0.1.2 → 0.2.0

package/src/{k6SdkClient.ts → generator/k6Client.ts}

@@ -8,18 +8,14 @@ import {
   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'
@@ -27,16 +23,144 @@ import {
   DEFAULT_SCHEMA_TITLE,
   K6_SCRIPT_TEMPLATE,
   SAMPLE_K6_SCRIPT_FILE_NAME,
-} from './constants'
-import { getDirectoryForPath, getGeneratedClientPath } from './helper'
-import { logger } from './logger'
-import { AnalyticsData, SchemaDetails } from './type'
+} from '../constants'
+import { getDirectoryForPath, getGeneratedClientPath } from '../helper'
+import { logger } from '../logger'
+import { AnalyticsData } from '../type'
+
+/**
+ * In case the supplied schema does not have a title set, it will set the default title to ensure
+ * proper client generation
+ *
+ * @param context - The context object containing the schema details
+ */
+function _setDefaultSchemaTitle(context: ContextSpecs) {
+  const schemaDetails = context.specs[context.specKey]
+  if (schemaDetails && !schemaDetails.info.title) {
+    schemaDetails.info.title = DEFAULT_SCHEMA_TITLE
+  }
+}
+
+function _generateResponseTypeDefinition(response: GetterResponse): string {
+  let responseDataType = ''
+
+  if (
+    response.definition.success &&
+    !['any', 'unknown'].includes(response.definition.success)
+  ) {
+    responseDataType += response.definition.success
+  } else {
+    responseDataType += 'ResponseBody'
+  }
+
+  return `{
+    response: Response
+    data: ${responseDataType}
+}`
+}
+
+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
+ */
+  private _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 || {},
+        },
+    };
+};`
+}
+
+const _getRequestParamsValue = ({
+  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'
+  }
 
-// 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()
+  let value = '\n    ...mergedRequestParameters,'
 
-export const getK6Dependencies: ClientDependenciesBuilder = () => [
+  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// In the schema, headers can be of any type like number but k6 accepts only strings as headers, hence converting all headers to string`
+      headersValue += `\n...Object.fromEntries(Object.entries(headers || {}).map(([key, value]) => [key, String(value)])),`
+    }
+
+    headersValue += `\n...mergedRequestParameters?.headers},`
+    value += headersValue
+  }
+
+  return `{${value}}`
+}
+
+const _getK6RequestOptions = (verbOptions: GeneratorVerbOptions) => {
+  const { body, headers, queryParams, response, verb } = verbOptions
+  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 requestParametersValue = _getRequestParamsValue({
+    response,
+    body,
+    headers: headers?.schema,
+    queryParams: queryParams?.schema,
+  })
+
+  // Sample output
+  // 'GET', 'http://test.com/route', <body>, <options>
+
+  return `"${verb.toUpperCase()}",
+        url.toString(),
+        ${fetchBodyOption},
+        ${requestParametersValue}`
+}
+
+const getK6Dependencies: ClientDependenciesBuilder = () => [
   {
     exports: [
       {
@@ -81,59 +205,21 @@ export const getK6Dependencies: ClientDependenciesBuilder = () => [
   },
 ]
 
-function getSchemaTitleFromContext(context: ContextSpecs) {
-  const specData = Object.values(context.specs)
-
-  let schemaTitle
-
-  if (specData[0]) {
-    schemaTitle = specData[0].info.title
-  }
-
-  schemaTitle ??= DEFAULT_SCHEMA_TITLE
-
-  return schemaTitle
-}
-
-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,
+  verbOptions: GeneratorVerbOptions,
+  { route }: GeneratorOptions,
+  analyticsData?: AnalyticsData
+) => {
+  const {
     queryParams,
     operationName,
     response,
     body,
     props,
     verb,
-    override,
     formData,
     formUrlEncoded,
-    paramsSerializer,
-  }: GeneratorVerbOptions,
-  { route }: GeneratorOptions,
-  analyticsData?: AnalyticsData
-) => {
+  } = verbOptions
   if (analyticsData) {
     analyticsData.generatedRequestsCount[verb] += 1
   }
@@ -146,40 +232,24 @@ const generateK6Implementation = (
     isFormUrlEncoded: false,
   })
 
-  // Generate response return types
-  returnTypesToWrite.set(
-    operationName,
-    _generateResponseTypeDefinition(operationName, response)
-  )
-
-  let url = `cleanBaseUrl + \`${route}\``
+  let url = `this.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,
-  })
+  const options = _getK6RequestOptions(verbOptions)
 
-  return `const ${operationName} = (\n    ${toObjectString(props, 'implementation')} requestParameters?: Params): ${_generateResponseTypeName(operationName)} => {${bodyForm}
+  return `${operationName}(\n    ${toObjectString(props, 'implementation')} requestParameters?: Params): ${_generateResponseTypeDefinition(response)} {\n${bodyForm}
         ${urlGeneration}
-        const mergedRequestParameters = _mergeRequestParameters(requestParameters || {}, clientOptions.commonRequestParameters);
+        const mergedRequestParameters = this._mergeRequestParameters(requestParameters || {}, this.commonRequestParameters);
         const response = http.request(${options});
         let data;
 
         try {
             data = response.json();
-        } catch (error) {
+        } catch {
             data = response.body;
         }
       return {
@@ -190,154 +260,38 @@ const generateK6Implementation = (
   `
 }
 
-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 generateTitle: ClientTitleBuilder = (title) => {
   const sanTitle = sanitize(title || DEFAULT_SCHEMA_TITLE)
-  return `create${pascal(sanTitle)}`
+  return `${pascal(sanTitle)}Client`
 }
 
-export const generateK6Header: ClientHeaderBuilder = ({ title }) => {
-  const clientOptionsTypeName = `${pascal(title)}Options`
+const generateK6Header: ClientHeaderBuilder = ({ title }) => {
   return `
-  export type ${clientOptionsTypeName} = {
+  /**
+   * This is the base client to use for interacting with the API.
+   */
+  export class ${title} {
+      private cleanBaseUrl: string;
+      private commonRequestParameters: Params;
+
+      constructor (clientOptions: {
     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`
+}) {
+       this.cleanBaseUrl = clientOptions.baseUrl.replace(/\\/+$/, '');\n
+      }\n
+`
 }
 
-export const generateFooter: ClientFooterBuilder = ({ operationNames }) => {
-  let footer = ''
+const generateFooter: ClientFooterBuilder = () => {
+  // Add function definition for merging request parameters
+  const footer = `
 
-  footer += `return {${operationNames.join(',')}}};\n\n`
+  ${_getRequestParametersMergerFunctionImplementation()}
 
-  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
 }
 
@@ -346,7 +300,8 @@ const k6ScriptBuilder: ClientExtraFilesBuilder = async (
   output,
   context
 ) => {
-  const schemaTitle = getSchemaTitleFromContext(context)
+  const schemaTitle =
+    context.specs[context.specKey]?.info.title || DEFAULT_SCHEMA_TITLE
   const {
     path: pathOfGeneratedClient,
     filename,
@@ -400,21 +355,19 @@ const k6ScriptBuilder: ClientExtraFilesBuilder = async (
   ]
 }
 
-function getK6Client(
-  schemaDetails: SchemaDetails,
-  analyticsData?: AnalyticsData
-) {
+function getK6Client(analyticsData?: AnalyticsData) {
   return function (
     verbOptions: GeneratorVerbOptions,
     options: GeneratorOptions
   ) {
+    _setDefaultSchemaTitle(options.context)
+
     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) {
@@ -427,12 +380,11 @@ function getK6Client(
 }
 
 export function getK6ClientBuilder(
-  schemaDetails: SchemaDetails,
   shouldGenerateSampleK6Script?: boolean,
   analyticsData?: AnalyticsData
 ): ClientGeneratorsBuilder {
   return {
-    client: getK6Client(schemaDetails, analyticsData),
+    client: getK6Client(analyticsData),
     header: generateK6Header,
     dependencies: getK6Dependencies,
     footer: generateFooter,

package/src/type.d.ts

@@ -1,3 +1,5 @@
+import { Mode } from './constants'
+
 export interface PackageDetails {
   name: string
   commandName: string
@@ -5,10 +7,6 @@ export interface PackageDetails {
   version: string
 }
 
-export interface SchemaDetails {
-  title: string
-}
-
 export interface AnalyticsData {
   generatedRequestsCount: {
     post: number
@@ -31,4 +29,5 @@ export interface GenerateK6SDKOptions {
   outputDir: string
   shouldGenerateSampleK6Script?: boolean
   analyticsData?: AnalyticsData
+  mode: Mode
 }

package/tests/e2e/schema.json

@@ -8,6 +8,7 @@
   "paths": {
     "/items/{id}": {
       "get": {
+        "tags": ["Items"],
         "summary": "Get an item by ID",
         "parameters": [
           {
@@ -37,6 +38,7 @@
         }
       },
       "post": {
+        "tags": ["Items"],
         "summary": "Create an item by ID",
         "parameters": [
           {
@@ -74,6 +76,7 @@
         }
       },
       "put": {
+        "tags": ["Items"],
         "summary": "Update an item by ID",
         "parameters": [
           {
@@ -111,6 +114,7 @@
         }
       },
       "patch": {
+        "tags": ["Items"],
         "summary": "Partially update an item by ID",
         "parameters": [
           {
@@ -145,6 +149,7 @@
         }
       },
       "delete": {
+        "tags": ["Items"],
         "summary": "Delete an item by ID",
         "parameters": [
           {
@@ -164,6 +169,7 @@
         }
       },
       "head": {
+        "tags": ["Items"],
         "summary": "Check if item exists",
         "parameters": [
           {
@@ -188,6 +194,7 @@
     },
     "/items-form-url-encoded": {
       "post": {
+        "tags": ["ItemsForm", "Items"],
         "summary": "Create an item using form-urlencoded data",
         "requestBody": {
           "required": true,
@@ -217,6 +224,7 @@
     },
     "/items-form-data": {
       "post": {
+        "tags": ["ItemsForm", "Items"],
         "summary": "Create an item using form-data",
         "requestBody": {
           "required": true,

package/tests/e2e/{k6Script.ts → single/k6Script.ts}

@@ -1,10 +1,10 @@
 /* eslint-disable import/no-unresolved */
 import { check } from 'k6'
-import { createComprehensiveAPI } from './sdk.ts'
+import { ComprehensiveAPIClient } from './sdk.ts'
 /* eslint-enable import/no-unresolved */
 
 const baseUrl = 'http://localhost:3000'
-const client = createComprehensiveAPI({ baseUrl })
+const client = new ComprehensiveAPIClient({ baseUrl })
 
 export const options = {
   thresholds: {
@@ -74,4 +74,9 @@ export default function () {
         'multipart/form-data; boundary=---'
       ),
   })
+
+  const getItemsHeaderResponseData = client.getItemsHeader({
+    id: 'test',
+  })
+  checkResponseStatus(getItemsHeaderResponseData.response, 200)
 }

package/tests/e2e/split/k6Script.ts

@@ -0,0 +1,82 @@
+/* eslint-disable import/no-unresolved */
+import { check } from 'k6'
+import { ComprehensiveAPIClient } from './sdk.ts'
+/* eslint-enable import/no-unresolved */
+
+const baseUrl = 'http://localhost:3000'
+const client = new ComprehensiveAPIClient({ baseUrl })
+
+export const options = {
+  thresholds: {
+    // the rate of successful checks should be higher than 90%
+    checks: ['rate>=1'],
+  },
+}
+
+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))
+  }
+}
+
+export default function () {
+  const getResponseData = client.getItemsId('1')
+  checkResponseStatus(getResponseData.response, 200)
+
+  const postResponseData = client.postItemsId('1', {
+    name: 'string',
+  })
+  checkResponseStatus(postResponseData.response, 201)
+
+  const putResponseData = client.putItemsId('1', {
+    description: 'string',
+  })
+  checkResponseStatus(putResponseData.response, 200)
+
+  const deleteResponseData = client.deleteItemsId('1')
+  checkResponseStatus(deleteResponseData.response, 204)
+
+  const patchResponseData = client.patchItemsId('1', {
+    name: 'string',
+  })
+  checkResponseStatus(patchResponseData.response, 200)
+
+  const headResponseData = client.headItemsId('1')
+  checkResponseStatus(headResponseData.response, 200)
+
+  const postFormUrlEncodedResponseData = client.postItemsFormUrlEncoded({
+    name: 'string',
+  })
+  checkResponseStatus(postFormUrlEncodedResponseData.response, 201)
+  // Should add x-www-form-urlencoded content type header in request
+  check(postFormUrlEncodedResponseData.response, {
+    'has x-www-form-urlencoded content type header': (r) =>
+      r.request.headers['Content-Type'][0] ===
+      'application/x-www-form-urlencoded',
+  })
+
+  const postFormDataResponseData = client.postItemsFormData({
+    name: 'string',
+  })
+  checkResponseStatus(postFormDataResponseData.response, 201)
+
+  // Should add multipart/form-data content type header in request with boundary
+  check(postFormDataResponseData.response, {
+    'has multipart/form-data content type header with bounday': (r) =>
+      r.request.headers['Content-Type'][0].includes(
+        'multipart/form-data; boundary=---'
+      ),
+  })
+
+  const getItemsHeaderResponseData = client.getItemsHeader({
+    id: 'test',
+  })
+  checkResponseStatus(getItemsHeaderResponseData.response, 200)
+}