@testsmith/perfornium 0.1.0

package/dist/utils/faker-manager.d.ts

@@ -0,0 +1,55 @@
+type FakerType = typeof import('@faker-js/faker').faker;
+/**
+ * Lazy-loading Faker manager
+ * Only initializes faker when actually used, reducing startup time
+ */
+export declare class FakerManager {
+    private static _instance;
+    private _faker;
+    private _locales;
+    private _currentLocale;
+    private _seed;
+    private _initialized;
+    private constructor();
+    static getInstance(): FakerManager;
+    /**
+     * Check if faker has been initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Get the current locale
+     */
+    get currentLocale(): string;
+    /**
+     * Set locale (will be applied on next getFaker call)
+     */
+    setLocale(locale: string): void;
+    /**
+     * Set seed for reproducible data
+     */
+    setSeed(seed: number | undefined): void;
+    /**
+     * Get available locales
+     */
+    getAvailableLocales(): string[];
+    /**
+     * Lazily get faker instance - only loads when first called
+     */
+    getFaker(): FakerType;
+    /**
+     * Synchronous initialization using require
+     * This is called lazily on first use
+     */
+    private initializeSync;
+    /**
+     * Switch to a different locale (loads lazily if not cached)
+     */
+    switchLocale(locale: string): FakerType;
+    /**
+     * Reset the manager (useful for testing)
+     */
+    reset(): void;
+}
+export declare const fakerManager: FakerManager;
+export declare function getFaker(): FakerType;
+export {};

package/dist/utils/faker-manager.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakerManager = exports.FakerManager = void 0;
+exports.getFaker = getFaker;
+const logger_1 = require("./logger");
+/**
+ * Lazy-loading Faker manager
+ * Only initializes faker when actually used, reducing startup time
+ */
+class FakerManager {
+    constructor() {
+        this._faker = null;
+        this._locales = new Map();
+        this._currentLocale = 'en';
+        this._initialized = false;
+    }
+    static getInstance() {
+        if (!FakerManager._instance) {
+            FakerManager._instance = new FakerManager();
+        }
+        return FakerManager._instance;
+    }
+    /**
+     * Check if faker has been initialized
+     */
+    get isInitialized() {
+        return this._initialized;
+    }
+    /**
+     * Get the current locale
+     */
+    get currentLocale() {
+        return this._currentLocale;
+    }
+    /**
+     * Set locale (will be applied on next getFaker call)
+     */
+    setLocale(locale) {
+        if (locale !== this._currentLocale) {
+            this._currentLocale = locale;
+            // Clear cached faker to force reload with new locale
+            if (this._initialized && !this._locales.has(locale)) {
+                logger_1.logger.debug(`Locale changed to ${locale}, will load on next use`);
+            }
+        }
+    }
+    /**
+     * Set seed for reproducible data
+     */
+    setSeed(seed) {
+        this._seed = seed;
+        if (this._faker) {
+            this._faker.seed(seed);
+        }
+    }
+    /**
+     * Get available locales
+     */
+    getAvailableLocales() {
+        return ['en', 'de', 'fr', 'es', 'nl'];
+    }
+    /**
+     * Lazily get faker instance - only loads when first called
+     */
+    getFaker() {
+        if (!this._initialized) {
+            this.initializeSync();
+        }
+        return this._faker;
+    }
+    /**
+     * Synchronous initialization using require
+     * This is called lazily on first use
+     */
+    initializeSync() {
+        if (this._initialized)
+            return;
+        logger_1.logger.debug(`Lazily initializing faker with locale: ${this._currentLocale}`);
+        try {
+            // Use require for synchronous loading
+            const fakerModule = require('@faker-js/faker');
+            // Load the appropriate locale
+            switch (this._currentLocale) {
+                case 'de':
+                    this._faker = fakerModule.fakerDE;
+                    break;
+                case 'fr':
+                    this._faker = fakerModule.fakerFR;
+                    break;
+                case 'es':
+                    this._faker = fakerModule.fakerES;
+                    break;
+                case 'nl':
+                    this._faker = fakerModule.fakerNL;
+                    break;
+                default:
+                    this._faker = fakerModule.faker;
+            }
+            this._locales.set(this._currentLocale, this._faker);
+            if (this._seed !== undefined) {
+                this._faker.seed(this._seed);
+            }
+            this._initialized = true;
+            logger_1.logger.debug(`Faker initialized with locale: ${this._currentLocale}`);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to initialize faker:', error);
+            throw error;
+        }
+    }
+    /**
+     * Switch to a different locale (loads lazily if not cached)
+     */
+    switchLocale(locale) {
+        if (this._locales.has(locale)) {
+            this._faker = this._locales.get(locale);
+            this._currentLocale = locale;
+            return this._faker;
+        }
+        // Load the new locale
+        const fakerModule = require('@faker-js/faker');
+        let localeFaker;
+        switch (locale) {
+            case 'de':
+                localeFaker = fakerModule.fakerDE;
+                break;
+            case 'fr':
+                localeFaker = fakerModule.fakerFR;
+                break;
+            case 'es':
+                localeFaker = fakerModule.fakerES;
+                break;
+            case 'nl':
+                localeFaker = fakerModule.fakerNL;
+                break;
+            default:
+                localeFaker = fakerModule.faker;
+        }
+        this._locales.set(locale, localeFaker);
+        this._faker = localeFaker;
+        this._currentLocale = locale;
+        if (this._seed !== undefined) {
+            this._faker.seed(this._seed);
+        }
+        logger_1.logger.debug(`Switched to faker locale: ${locale}`);
+        return this._faker;
+    }
+    /**
+     * Reset the manager (useful for testing)
+     */
+    reset() {
+        this._faker = null;
+        this._locales.clear();
+        this._currentLocale = 'en';
+        this._seed = undefined;
+        this._initialized = false;
+    }
+}
+exports.FakerManager = FakerManager;
+FakerManager._instance = null;
+// Export singleton accessor
+exports.fakerManager = FakerManager.getInstance();
+// Export a proxy getter for backward compatibility
+function getFaker() {
+    return exports.fakerManager.getFaker();
+}

package/dist/utils/file-manager.d.ts

@@ -0,0 +1,33 @@
+/**
+ * File management utility for handling timestamped files and ensuring directories exist
+ */
+export declare class FileManager {
+    /**
+     * Process template path and ensure directory exists
+     */
+    static processFilePath(templatePath: string, context?: any): string;
+    /**
+     * Process timestamp templates in file paths using TimestampHelper
+     */
+    private static processTimestampTemplate;
+    /**
+     * Ensure directory exists for a file path
+     */
+    static ensureDirectoryExists(filePath: string): void;
+    /**
+     * Create file with timestamped name and ensure directory exists
+     */
+    static createTimestampedFile(templatePath: string, content: string, context?: any): string;
+    /**
+     * Generate unique filename if file already exists
+     */
+    static generateUniqueFileName(originalPath: string): string;
+    /**
+     * Safe write - creates unique filename if needed
+     */
+    static safeWriteFile(templatePath: string, content: string, context?: any, overwrite?: boolean): string;
+    /**
+     * Create timestamped backup of existing file
+     */
+    static createBackup(filePath: string): string | null;
+}

package/dist/utils/file-manager.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const timestamp_helper_1 = require("./timestamp-helper");
+/**
+ * File management utility for handling timestamped files and ensuring directories exist
+ */
+class FileManager {
+    /**
+     * Process template path and ensure directory exists
+     */
+    static processFilePath(templatePath, context) {
+        let processedPath = templatePath;
+        // Always process timestamp templates, even without full context
+        if (templatePath.includes('{{timestamp')) {
+            processedPath = this.processTimestampTemplate(templatePath);
+        }
+        // If context is provided, use full template processing
+        if (context) {
+            const { TemplateProcessor } = require('./template');
+            const processor = new TemplateProcessor();
+            processedPath = processor.process(processedPath, context);
+        }
+        // Ensure directory exists
+        this.ensureDirectoryExists(processedPath);
+        return processedPath;
+    }
+    /**
+     * Process timestamp templates in file paths using TimestampHelper
+     */
+    static processTimestampTemplate(templatePath) {
+        return templatePath.replace(/\{\{timestamp(?::([^}]+))?\}\}/g, (_match, format) => {
+            const fmt = (format || 'file');
+            return timestamp_helper_1.TimestampHelper.getTimestamp(fmt);
+        });
+    }
+    /**
+     * Ensure directory exists for a file path
+     */
+    static ensureDirectoryExists(filePath) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+            console.log(`📁 Created directory: ${dir}`);
+        }
+    }
+    /**
+     * Create file with timestamped name and ensure directory exists
+     */
+    static createTimestampedFile(templatePath, content, context) {
+        const processedPath = this.processFilePath(templatePath, context);
+        try {
+            fs.writeFileSync(processedPath, content);
+            console.log(`📄 Created file: ${processedPath}`);
+            return processedPath;
+        }
+        catch (error) {
+            console.error(`❌ Failed to create file ${processedPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Generate unique filename if file already exists
+     */
+    static generateUniqueFileName(originalPath) {
+        if (!fs.existsSync(originalPath)) {
+            return originalPath;
+        }
+        const dir = path.dirname(originalPath);
+        const ext = path.extname(originalPath);
+        const name = path.basename(originalPath, ext);
+        let counter = 1;
+        let newPath;
+        do {
+            newPath = path.join(dir, `${name}-${counter}${ext}`);
+            counter++;
+        } while (fs.existsSync(newPath));
+        return newPath;
+    }
+    /**
+     * Safe write - creates unique filename if needed
+     */
+    static safeWriteFile(templatePath, content, context, overwrite = false) {
+        const processedPath = this.processFilePath(templatePath, context);
+        const finalPath = overwrite ? processedPath : this.generateUniqueFileName(processedPath);
+        try {
+            fs.writeFileSync(finalPath, content);
+            console.log(`📄 Safely created file: ${finalPath}`);
+            return finalPath;
+        }
+        catch (error) {
+            console.error(`❌ Failed to safely create file ${finalPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Create timestamped backup of existing file
+     */
+    static createBackup(filePath) {
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const dir = path.dirname(filePath);
+        const ext = path.extname(filePath);
+        const name = path.basename(filePath, ext);
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = path.join(dir, `${name}.${timestamp}.backup${ext}`);
+        try {
+            fs.copyFileSync(filePath, backupPath);
+            console.log(`💾 Created backup: ${backupPath}`);
+            return backupPath;
+        }
+        catch (error) {
+            console.error(`❌ Failed to create backup of ${filePath}:`, error);
+            return null;
+        }
+    }
+}
+exports.FileManager = FileManager;

package/dist/utils/handlebars-manager.d.ts

@@ -0,0 +1,42 @@
+import * as Handlebars from 'handlebars';
+export interface TemplateConfig {
+    file: string;
+    data?: Record<string, any>;
+    helpers?: Record<string, any>;
+}
+export declare class HandlebarsTemplateManager {
+    private static instance;
+    private templateCache;
+    private baseDir;
+    private constructor();
+    static getInstance(): HandlebarsTemplateManager;
+    /**
+     * Set the base directory for template files
+     */
+    setBaseDir(dir: string): void;
+    /**
+     * Register default Handlebars helpers for faker and utilities
+     */
+    private registerDefaultHelpers;
+    /**
+     * Register custom helpers
+     */
+    registerHelper(name: string, helper: Handlebars.HelperDelegate): void;
+    /**
+     * Load and compile a template file
+     */
+    private loadTemplate;
+    /**
+     * Process a template with data
+     */
+    processTemplate(templateConfig: TemplateConfig, context: Record<string, any>): any;
+    /**
+     * Clear template cache (useful for development)
+     */
+    clearCache(): void;
+    /**
+     * Get nested property from object
+     */
+    private getNestedProperty;
+}
+export declare const handlebarsManager: HandlebarsTemplateManager;

package/dist/utils/handlebars-manager.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlebarsManager = exports.HandlebarsTemplateManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const Handlebars = __importStar(require("handlebars"));
+const faker_manager_1 = require("./faker-manager");
+const logger_1 = require("./logger");
+class HandlebarsTemplateManager {
+    constructor() {
+        this.templateCache = new Map();
+        this.baseDir = process.cwd();
+        this.registerDefaultHelpers();
+    }
+    static getInstance() {
+        if (!HandlebarsTemplateManager.instance) {
+            HandlebarsTemplateManager.instance = new HandlebarsTemplateManager();
+        }
+        return HandlebarsTemplateManager.instance;
+    }
+    /**
+     * Set the base directory for template files
+     */
+    setBaseDir(dir) {
+        this.baseDir = dir;
+    }
+    /**
+     * Register default Handlebars helpers for faker and utilities
+     */
+    registerDefaultHelpers() {
+        // Faker helpers - lazily load faker only when helper is called
+        Handlebars.registerHelper('faker', (path) => {
+            return this.getNestedProperty((0, faker_manager_1.getFaker)(), path)();
+        });
+        // Random helpers
+        Handlebars.registerHelper('randomInt', (min, max) => {
+            return (0, faker_manager_1.getFaker)().number.int({ min, max });
+        });
+        Handlebars.registerHelper('randomChoice', (...args) => {
+            // Remove the last argument (Handlebars options)
+            const choices = args.slice(0, -1);
+            return (0, faker_manager_1.getFaker)().helpers.arrayElement(choices);
+        });
+        Handlebars.registerHelper('uuid', () => {
+            return (0, faker_manager_1.getFaker)().string.uuid();
+        });
+        Handlebars.registerHelper('timestamp', () => {
+            return Date.now();
+        });
+        Handlebars.registerHelper('isoDate', (days = 0) => {
+            const date = new Date();
+            date.setDate(date.getDate() + days);
+            return date.toISOString();
+        });
+        // Conditional helpers
+        Handlebars.registerHelper('eq', (a, b) => a === b);
+        Handlebars.registerHelper('ne', (a, b) => a !== b);
+        Handlebars.registerHelper('gt', (a, b) => a > b);
+        Handlebars.registerHelper('lt', (a, b) => a < b);
+        // Array helpers
+        Handlebars.registerHelper('length', (array) => array ? array.length : 0);
+        Handlebars.registerHelper('first', (array) => array && array.length > 0 ? array[0] : null);
+        Handlebars.registerHelper('last', (array) => array && array.length > 0 ? array[array.length - 1] : null);
+    }
+    /**
+     * Register custom helpers
+     */
+    registerHelper(name, helper) {
+        Handlebars.registerHelper(name, helper);
+    }
+    /**
+     * Load and compile a template file
+     */
+    loadTemplate(templatePath) {
+        const fullPath = path.resolve(this.baseDir, templatePath);
+        if (this.templateCache.has(fullPath)) {
+            return this.templateCache.get(fullPath);
+        }
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Template file not found: ${fullPath}`);
+        }
+        const templateContent = fs.readFileSync(fullPath, 'utf8');
+        const compiledTemplate = Handlebars.compile(templateContent);
+        this.templateCache.set(fullPath, compiledTemplate);
+        return compiledTemplate;
+    }
+    /**
+     * Process a template with data
+     */
+    processTemplate(templateConfig, context) {
+        const template = this.loadTemplate(templateConfig.file);
+        // Merge data sources: template data + context + extracted data
+        const templateData = {
+            ...context.variables,
+            ...context.extracted_data,
+            ...templateConfig.data,
+            // Add context info
+            vu_id: context.vu_id,
+            iteration: context.iteration,
+            timestamp: Date.now(),
+        };
+        logger_1.logger.debug(`Processing Handlebars template: ${templateConfig.file}`);
+        logger_1.logger.debug(`Template data: ${JSON.stringify(templateData, null, 2)}`);
+        const result = template(templateData);
+        try {
+            // Try to parse as JSON if it looks like JSON
+            const trimmed = result.trim();
+            if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+                (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+                return JSON.parse(result);
+            }
+            return result;
+        }
+        catch {
+            // If JSON parsing fails, return as string
+            return result;
+        }
+    }
+    /**
+     * Clear template cache (useful for development)
+     */
+    clearCache() {
+        this.templateCache.clear();
+    }
+    /**
+     * Get nested property from object
+     */
+    getNestedProperty(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            if (current && typeof current === 'object' && key in current) {
+                return current[key];
+            }
+            throw new Error(`Property "${key}" not found in path "${path}"`);
+        }, obj);
+    }
+}
+exports.HandlebarsTemplateManager = HandlebarsTemplateManager;
+// Export singleton instance
+exports.handlebarsManager = HandlebarsTemplateManager.getInstance();

package/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export declare class Logger {
+    private level;
+    setLevel(level: LogLevel): void;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    success(message: string, ...args: any[]): void;
+}
+export declare const logger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    constructor() {
+        // Default to WARN - minimal output unless verbose mode is enabled
+        this.level = LogLevel.WARN;
+    }
+    setLevel(level) { this.level = level; }
+    debug(message, ...args) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log(chalk_1.default.gray(`[DEBUG] ${message}`), ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.level <= LogLevel.INFO) {
+            console.log(chalk_1.default.blue(`[INFO] ${message}`), ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.level <= LogLevel.WARN) {
+            console.warn(chalk_1.default.yellow(`[WARN] ${message}`), ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.level <= LogLevel.ERROR) {
+            console.error(chalk_1.default.red(`[ERROR] ${message}`), ...args);
+        }
+    }
+    success(message, ...args) {
+        console.log(chalk_1.default.green(`[SUCCESS] ${message}`), ...args);
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();