@grafana/openapi-to-k6 0.2.5 → 0.3.0

package/.github/workflows/tests.yaml

@@ -33,6 +33,7 @@ jobs:
           npm run dev -- ./tests/e2e/schema.json ./tests/e2e/single/sdk.ts --disable-analytics --mode single
           npm run dev -- ./tests/e2e/schema.json ./tests/e2e/split/sdk.ts --disable-analytics --mode split
           npm run dev -- ./tests/e2e/schema.json ./tests/e2e/tags/sdk.ts --disable-analytics --mode tags
+          npm run dev -- ./tests/e2e/schema.json ./tests/e2e/single-tag-filter/sdk.ts --disable-analytics --mode single --only-tags ItemsHeader
       - name: Start Mockoon CLI
         uses: mockoon/cli-action@v2
         with:

package/README.md

@@ -60,10 +60,12 @@ Following are some of the configuration options supported by the tool.
    3. `tags`: This modes splits your OpenAPI schema based on the tags and generates a separate client for each tag. If a route has no tag set, it will be available in `default.ts` file.
 
    To check how the output looks for each mode, check out the [examples](./examples) directory.
-2. `--disable-analytics`: Disable anonymous usage analytics reporting which helping making the tool better. You can also set an environment variable `DISABLE_ANALYTICS=true` to disable the analytics.
-3. `--include-sample-script`: Generate a sample k6 script.
-4. `--verbose` or `-v` : Enable verbose logging to see more detailed logging output.
-5. `--help` or `-h` : Show help message.
+2. `--only-tags`: Filter the generated client to only include routes with specific tags from your OpenAPI schema. Multiple tags can be specified to include routes matching any of those tags. Routes without tags will be excluded. This is useful for generating focused clients that only contain the endpoints you need.
+e.g. `openapi-to-k6 <path-to-openapi-schema> <output path> --only-tags ItemsHeader` will generate a client with only the routes that have the `ItemsHeader` tag. Multiple tags can be specified by using multiple `--only-tags` flags or by separating them with spaces.
+3. `--disable-analytics`: Disable anonymous usage analytics reporting which helping making the tool better. You can also set an environment variable `DISABLE_ANALYTICS=true` to disable the analytics.
+4. `--include-sample-script`: Generate a sample k6 script. The generated sample script uses the examples defined in the OpenAPI schema requests to make the script usable out of the box. If the examples are not defined, it will use Faker to generate random data.
+5. `--verbose` or `-v` : Enable verbose logging to see more detailed logging output.
+6. `--help` or `-h` : Show help message.
 
 ## Developing locally
 
@@ -130,4 +132,8 @@ k6 run --compatibility-mode=experimental_enhanced ./K6Script.ts
 2. Install the compiled package locally by using `npm install .` or `npm install -g .`.
 3. Use the CLI `k6-sdkgen <path-to-openapi-schema> <output path>`
 
+## Releasing
+
+To release a new version of the tool, create a new release on GitHub with the new version number as tag (e.g. `0.1.0` ) and the release notes. After the release is created, the GitHub actions will automatically package the tool and publish it to npm.
+
 Special mention for the the open-source library [Orval](https://orval.dev/) which is used for the generation of the TypeScript client.

package/dist/cli.js

@@ -17,6 +17,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const analytics_1 = require("./analytics");
 const constants_1 = require("./constants");
+const errors_1 = require("./errors");
 const generator_1 = __importDefault(require("./generator"));
 const helper_1 = require("./helper");
 const logger_1 = require("./logger");
@@ -35,23 +36,30 @@ function validateMode(value) {
     return value;
 }
 function generateSDK(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ openApiPath, outputDir, shouldGenerateSampleK6Script, analyticsData, mode, }) {
-        logger_1.logger.logMessage('Generating TypeScript client for k6...\n');
-        logger_1.logger.logMessage(`OpenAPI schema: ${openApiPath}`);
-        logger_1.logger.logMessage(`Output: ${outputDir}\n`);
+    return __awaiter(this, arguments, void 0, function* ({ openApiPath, outputDir, shouldGenerateSampleK6Script, analyticsData, mode, tags, }) {
+        logger_1.logger.logMessage('Generating TypeScript client for k6...\n' +
+            'OpenAPI schema: ' +
+            chalk_1.default.cyan(openApiPath) +
+            '\n' +
+            'Output: ' +
+            chalk_1.default.cyan(outputDir) +
+            '\n' +
+            ((tags === null || tags === void 0 ? void 0 : tags.length)
+                ? 'Filtering by tag(s): ' + chalk_1.default.cyan(tags.join(', '))
+                : '') +
+            '\n');
         yield (0, generator_1.default)({
             openApiPath,
             outputDir,
             shouldGenerateSampleK6Script,
             analyticsData,
             mode,
+            tags,
         });
-        if (shouldGenerateSampleK6Script) {
-            logger_1.logger.logMessage(`TypeScript client and sample k6 script generated successfully.`, chalk_1.default.green);
-        }
-        else {
-            logger_1.logger.logMessage(`TypeScript client generated successfully.`, chalk_1.default.green);
-        }
+        const message = shouldGenerateSampleK6Script
+            ? 'TypeScript client and sample k6 script generated successfully.'
+            : 'TypeScript client generated successfully.';
+        logger_1.logger.logMessage(message, chalk_1.default.green);
     });
 }
 program
@@ -61,6 +69,7 @@ program
     .argument('<openApiPath>', 'Path or URL for the OpenAPI schema file')
     .argument('<outputDir>', 'Directory where the SDK should be generated')
     .option('-m, --mode <string>', `mode to use for generating the client. Valid values - ${Object.values(constants_1.Mode).join(', ')}`, validateMode, constants_1.Mode.SINGLE)
+    .option('--only-tags <filters...>', 'list of tags to filter on. Generated client will only include operations with these tags')
     .option('-v, --verbose', 'enable verbose mode to show debug logs')
     .option('--include-sample-script', 'generate a sample k6 script')
     .option('--disable-analytics', 'disable anonymous usage data collection')
@@ -89,11 +98,17 @@ program
             shouldGenerateSampleK6Script: !!options.includeSampleScript,
             analyticsData,
             mode: options.mode,
+            tags: options.onlyTags,
         });
     }
     catch (error) {
-        logger_1.logger.error('Failed to generate SDK:');
-        console.error(error);
+        if (error instanceof errors_1.NoFilesGeneratedError) {
+            logger_1.logger.logMessage(error.message, chalk_1.default.yellow);
+        }
+        else {
+            logger_1.logger.error('Failed to generate SDK:');
+            console.error(error);
+        }
     }
     if (!shouldDisableAnalytics && analyticsData) {
         logger_1.logger.debug('Reporting following usage analytics data:');

package/dist/constants.js

@@ -4,17 +4,21 @@ exports.Mode = exports.K6_SCRIPT_TEMPLATE = exports.SAMPLE_K6_SCRIPT_FILE_NAME =
 exports.DEFAULT_SCHEMA_TITLE = 'K6Client';
 exports.SAMPLE_K6_SCRIPT_FILE_NAME = 'k6-script.sample.ts';
 exports.K6_SCRIPT_TEMPLATE = `
-import { {{clientFunctionName}} } from '{{clientPath}}'
+{{{importStatements}}}
 
 const baseUrl = '<BASE_URL>';
-const client = new {{clientFunctionName}}({ baseUrl })
+{{{clientInitializationStatement}}}
+
 
 export default function () {
+    {{{this.variableDefinition}}}
+
     {{#each clientFunctionsList}}
     /**
      * {{this.summary}}
      */
-    const {{this.operationName}}ResponseData = client.{{this.operationName}}({{this.requiredParametersString}});
+    {{{this.exampleValues}}}
+    const {{this.operationName}}ResponseData = {{clientObjectName}}.{{this.operationName}}({{this.requiredParametersString}});
 
     {{/each}}
 }

package/dist/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoFilesGeneratedError = void 0;
+class NoFilesGeneratedError extends Error {
+    constructor(message = 'No files were generated') {
+        super(message);
+        this.name = 'NoFilesGeneratedError';
+    }
+}
+exports.NoFilesGeneratedError = NoFilesGeneratedError;

package/dist/generator/index.js

@@ -16,6 +16,7 @@ const fs_1 = __importDefault(require("fs"));
 const orval_1 = __importDefault(require("orval"));
 const path_1 = __importDefault(require("path"));
 const constants_1 = require("../constants");
+const errors_1 = require("../errors");
 const helper_1 = require("../helper");
 const logger_1 = require("../logger");
 const k6Client_1 = require("./k6Client");
@@ -31,7 +32,28 @@ const generatedFileHeaderGenerator = (info) => {
     ];
 };
 const afterAllFilesWriteHandler = (filePaths) => __awaiter(void 0, void 0, void 0, function* () {
+    const removeSingleFile = (filePath) => {
+        try {
+            fs_1.default.unlinkSync(filePath);
+        }
+        catch (error) {
+            // This is non-critical, so we just log it
+            logger_1.logger.debug(`afterAllFilesWriteHandler ~ Error deleting file ${filePath}: ${error}`);
+        }
+    };
+    const emptyFileList = [];
     for (const filePath of filePaths) {
+        // There is a bug in the orval library which generates empty files when tags filter is applied
+        // and no matching endpoints are found and used mode is split or single.
+        // It generates the file with only the header comment.
+        // Hence, we manually remove those empty files.
+        // Issue link - https://github.com/orval-labs/orval/issues/1691
+        if ((0, helper_1.hasOnlyComments)(fs_1.default.readFileSync(filePath, 'utf-8'))) {
+            emptyFileList.push(filePath);
+            // Delete the file
+            removeSingleFile(filePath);
+            continue;
+        }
         yield (0, helper_1.formatFileWithPrettier)(filePath);
         const fileName = path_1.default.basename(filePath);
         if (fileName === '.ts') {
@@ -43,16 +65,32 @@ const afterAllFilesWriteHandler = (filePaths) => __awaiter(void 0, void 0, void
             fs_1.default.renameSync(filePath, newPath);
         }
     }
+    if (emptyFileList.length > 0) {
+        logger_1.logger.debug(`afterAllFilesWriteHandler ~ The following files were empty and removed: ${emptyFileList.join(', ')}`);
+    }
+    // Return the list of generated file paths excluding the empty files
+    const filteredFilePaths = filePaths.filter((filePath) => !emptyFileList.includes(filePath));
+    // Check if all the filtered file path end with `.schemas.ts`
+    if (filteredFilePaths.every((filePath) => filePath.endsWith('.schemas.ts'))) {
+        // If yes we should remove them as only schemas files is not needed
+        filteredFilePaths.map(removeSingleFile);
+        return [];
+    }
+    return filteredFilePaths;
 });
-exports.default = (_a) => __awaiter(void 0, [_a], void 0, function* ({ openApiPath, outputDir, shouldGenerateSampleK6Script, analyticsData, mode, }) {
+exports.default = (_a) => __awaiter(void 0, [_a], void 0, function* ({ openApiPath, outputDir, shouldGenerateSampleK6Script, analyticsData, mode, tags, }) {
     /**
      * Note!
      * 1. override.requestOptions is not supported for the custom K6 client
      * 2. override.mutator is not supported for the custom K6 client
      */
+    const generatedFilePaths = [];
     yield outputOverrider.redirectOutputToNullStream(() => __awaiter(void 0, void 0, void 0, function* () {
         yield (0, orval_1.default)({
-            input: openApiPath,
+            input: {
+                target: openApiPath,
+                filters: { tags: tags && tags.length > 0 ? tags : undefined },
+            },
             output: {
                 target: outputDir,
                 mode: mode,
@@ -63,8 +101,17 @@ exports.default = (_a) => __awaiter(void 0, [_a], void 0, function* ({ openApiPa
                 headers: true,
             },
             hooks: {
-                afterAllFilesWrite: afterAllFilesWriteHandler,
+                afterAllFilesWrite: (filePaths) => __awaiter(void 0, void 0, void 0, function* () {
+                    const filteredFilePaths = yield afterAllFilesWriteHandler(filePaths);
+                    generatedFilePaths.push(...filteredFilePaths);
+                }),
             },
         });
     }));
+    if (generatedFilePaths.length === 0) {
+        const tagsMessage = (tags === null || tags === void 0 ? void 0 : tags.length) && tags.length > 0
+            ? ` Applied tag filter(s): ${tags.join(', ')}`
+            : '';
+        throw new errors_1.NoFilesGeneratedError(`No files were generated.${tagsMessage}`);
+    }
 });

package/dist/generator/k6Client.js

@@ -1,24 +1,10 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTitle = void 0;
 exports.getK6ClientBuilder = getK6ClientBuilder;
 const core_1 = require("@orval/core");
-const handlebars_1 = __importDefault(require("handlebars"));
-const path_1 = __importDefault(require("path"));
 const constants_1 = require("../constants");
-const helper_1 = require("../helper");
-const logger_1 = require("../logger");
+const k6ScriptBuilder_1 = require("./k6ScriptBuilder");
 /**
  * In case the supplied schema does not have a title set, it will set the default title to ensure
  * proper client generation
@@ -209,6 +195,7 @@ const generateTitle = (title) => {
     const sanTitle = (0, core_1.sanitize)(title || constants_1.DEFAULT_SCHEMA_TITLE);
     return `${(0, core_1.pascal)(sanTitle)}Client`;
 };
+exports.generateTitle = generateTitle;
 const generateK6Header = ({ title }) => {
     return `
   /**
@@ -237,43 +224,6 @@ const generateFooter = () => {
   `;
     return footer;
 };
-const k6ScriptBuilder = (verbOptions, output, context) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const schemaTitle = ((_a = context.specs[context.specKey]) === null || _a === void 0 ? void 0 : _a.info.title) || constants_1.DEFAULT_SCHEMA_TITLE;
-    const { path: pathOfGeneratedClient, filename, extension, } = yield (0, helper_1.getGeneratedClientPath)(output.target, schemaTitle);
-    const directoryPath = (0, helper_1.getDirectoryForPath)(pathOfGeneratedClient);
-    const generateScriptPath = path_1.default.join(directoryPath, constants_1.SAMPLE_K6_SCRIPT_FILE_NAME);
-    logger_1.logger.debug(`k6ScriptBuilder ~ Generating sample K6 Script\n${JSON.stringify({
-        pathOfGeneratedClient,
-        filename,
-        extension,
-        schemaTitle,
-        directoryPath,
-        generateScriptPath,
-    }, null, 2)}`);
-    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: (0, core_1.toObjectString)(requiredProps, 'name'),
-        });
-    }
-    const scriptContentData = {
-        clientFunctionName: generateTitle(schemaTitle),
-        clientPath: `./${filename}${extension}`,
-        clientFunctionsList,
-    };
-    const template = handlebars_1.default.compile(constants_1.K6_SCRIPT_TEMPLATE);
-    return [
-        {
-            path: generateScriptPath,
-            content: template(scriptContentData),
-        },
-    ];
-});
 function getK6Client(analyticsData) {
     return function (verbOptions, options) {
         _setDefaultSchemaTitle(options.context);
@@ -294,7 +244,7 @@ function getK6ClientBuilder(shouldGenerateSampleK6Script, analyticsData) {
         header: generateK6Header,
         dependencies: getK6Dependencies,
         footer: generateFooter,
-        title: generateTitle,
-        extraFiles: shouldGenerateSampleK6Script ? k6ScriptBuilder : undefined,
+        title: exports.generateTitle,
+        extraFiles: shouldGenerateSampleK6Script ? k6ScriptBuilder_1.k6ScriptBuilder : undefined,
     };
 }

package/dist/generator/k6ScriptBuilder.js

@@ -0,0 +1,256 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.k6ScriptBuilder = void 0;
+const faker_1 = require("@faker-js/faker");
+const core_1 = require("@orval/core");
+const handlebars_1 = __importDefault(require("handlebars"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../constants");
+const helper_1 = require("../helper");
+const logger_1 = require("../logger");
+const k6Client_1 = require("./k6Client");
+function getExampleValueForSchema(schema, context) {
+    // Handle $ref
+    if ('$ref' in schema) {
+        const { schema: resolvedSchema } = (0, core_1.resolveRef)(schema, context);
+        return getExampleValueForSchema(resolvedSchema, 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_1.faker.word.sample()}'`;
+        case 'number':
+            return enumValues ? enumValues[0] : faker_1.faker.number.int();
+        case 'integer':
+            return enumValues ? enumValues[0] : faker_1.faker.number.int();
+        case 'boolean':
+            return enumValues ? enumValues[0] : faker_1.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, originalOperation, context) {
+    var _a;
+    let exampleValues = '';
+    for (const prop of requiredProps) {
+        const propType = prop.type;
+        switch (propType) {
+            case core_1.GetterPropType.QUERY_PARAM: {
+                let exampleValue = '{\n';
+                for (const param of originalOperation.parameters || []) {
+                    let resolvedParam;
+                    if ('$ref' in param) {
+                        const { schema: resolvedSchema } = (0, core_1.resolveRef)(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 core_1.GetterPropType.HEADER: {
+                let exampleValue = '{\n';
+                for (const param of originalOperation.parameters || []) {
+                    let resolvedParam;
+                    if ('$ref' in param) {
+                        const { schema: resolvedSchema } = (0, core_1.resolveRef)(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 core_1.GetterPropType.PARAM: {
+                let example, paramSchema;
+                for (const parameter of originalOperation.parameters || []) {
+                    if ('name' in parameter) {
+                        paramSchema = parameter.schema;
+                        break;
+                    }
+                    else if ('$ref' in parameter) {
+                        const { schema: resolvedSchema } = (0, core_1.resolveRef)(parameter, context);
+                        paramSchema = resolvedSchema.schema;
+                        break;
+                    }
+                }
+                if (paramSchema) {
+                    example = getExampleValueForSchema(paramSchema, context);
+                }
+                if (example) {
+                    exampleValues += `${prop.name} = ${example};\n`;
+                }
+                break;
+            }
+            case core_1.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 } = (0, core_1.resolveRef)(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 = (_a = resolvedSchema.content[contentType]) === null || _a === void 0 ? void 0 : _a.schema;
+                        if (requestBodySchema) {
+                            requestBodyExample = getExampleValueForSchema(requestBodySchema, context);
+                        }
+                    }
+                }
+                if (requestBodyExample) {
+                    exampleValues += `${prop.name} = ${requestBodyExample};\n`;
+                }
+                break;
+            }
+        }
+    }
+    return exampleValues;
+}
+function getClientClassName(identifier) {
+    return (0, k6Client_1.generateTitle)((0, core_1.pascal)(identifier));
+}
+function getClientObjectName(identifier) {
+    return (0, core_1.camel)((0, k6Client_1.generateTitle)((0, core_1.pascal)(identifier)));
+}
+const k6ScriptBuilder = (verbOptions, output, context) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const schemaTitle = ((_a = context.specs[context.specKey]) === null || _a === void 0 ? void 0 : _a.info.title) || constants_1.DEFAULT_SCHEMA_TITLE;
+    const { path: pathOfGeneratedClient, filename, extension, } = yield (0, helper_1.getGeneratedClientPath)(output.target, schemaTitle);
+    const directoryPath = (0, helper_1.getDirectoryForPath)(pathOfGeneratedClient);
+    const generateScriptPath = path_1.default.join(directoryPath, constants_1.SAMPLE_K6_SCRIPT_FILE_NAME);
+    logger_1.logger.debug(`k6ScriptBuilder ~ Generating sample K6 Script\n${JSON.stringify({
+        pathOfGeneratedClient,
+        filename,
+        extension,
+        schemaTitle,
+        directoryPath,
+        generateScriptPath,
+    }, null, 2)}`);
+    const clientFunctionsList = [];
+    const uniqueVariables = new Set(); // Track unique variable names
+    const allUniqueTags = new Set();
+    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: (0, core_1.toObjectString)(requiredProps, 'name'),
+            clientObjectName,
+        });
+    }
+    let importStatements = '';
+    let clientInitializationStatement = '';
+    if (output.mode === 'tags') {
+        for (const tag of allUniqueTags) {
+            const { extension } = yield (0, helper_1.getGeneratedClientPath)(output.target, schemaTitle);
+            const clientName = getClientClassName(tag);
+            importStatements += `import { ${clientName} } from './${(0, core_1.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_1.default.compile(constants_1.K6_SCRIPT_TEMPLATE);
+    return [
+        {
+            path: generateScriptPath,
+            content: template(scriptContentData),
+        },
+    ];
+});
+exports.k6ScriptBuilder = k6ScriptBuilder;

package/dist/helper.js

@@ -17,8 +17,10 @@ exports.formatFileWithPrettier = formatFileWithPrettier;
 exports.getGeneratedClientPath = getGeneratedClientPath;
 exports.djb2Hash = djb2Hash;
 exports.getDirectoryForPath = getDirectoryForPath;
+exports.hasOnlyComments = hasOnlyComments;
 const core_1 = require("@orval/core");
 const fs_1 = __importDefault(require("fs"));
+const typescript_1 = require("typescript");
 const path_1 = __importDefault(require("path"));
 const prettier_1 = require("prettier");
 const package_json_1 = __importDefault(require("../package.json"));
@@ -156,3 +158,33 @@ function getDirectoryForPath(pathString) {
     // If the path has an extension, it is a file
     return path_1.default.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;');
+ */
+function hasOnlyComments(fileContent) {
+    // Create a source file
+    const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', fileContent, typescript_1.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/examples/basic_schema/single/k6-script.sample.ts

@@ -1,11 +1,12 @@
 import { SimpleAPIClient } from './simpleAPI.ts'
 
 const baseUrl = '<BASE_URL>'
-const client = new SimpleAPIClient({ baseUrl })
+const simpleAPIClient = new SimpleAPIClient({ baseUrl })
 
 export default function () {
   /**
    * Retrieve example data
    */
-  const getExampleResponseData = client.getExample()
+
+  const getExampleResponseData = simpleAPIClient.getExample()
 }

package/examples/basic_schema/single/simpleAPI.ts

@@ -1,5 +1,5 @@
 /**
- * Automatically generated by @grafana/openapi-to-k6: 0.2.5
+ * Automatically generated by @grafana/openapi-to-k6: 0.3.0
  * Do not edit manually.
  * Simple API
  * Service version: 1.0.0