"use strict";
/**
 * CI/CD Test Data Generator Examples
 *
 * This module demonstrates how to use agentic-synth to generate
 * comprehensive test data for CI/CD pipelines including:
 * - Database fixtures for integration tests
 * - API mock responses
 * - User session data for E2E tests
 * - Load testing datasets
 * - Configuration variations for multi-environment testing
 *
 * @module test-data-generator
 */
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.CICDTestDataGenerator = void 0;
exports.cicdExample = cicdExample;
exports.githubActionsExample = githubActionsExample;
exports.gitlabCIExample = gitlabCIExample;
const index_js_1 = require("../../src/index.js");
const fs = __importStar(require("fs/promises"));
const path = __importStar(require("path"));
/**
 * Test data generator class for CI/CD pipelines
 */
class CICDTestDataGenerator {
    constructor(config = {}) {
        this.config = {
            outputDir: config.outputDir || './test-data',
            format: config.format || 'json',
            provider: config.provider || 'gemini',
            apiKey: config.apiKey || process.env.GEMINI_API_KEY,
            seed: config.seed
        };
        // Initialize agentic-synth
        this.synth = (0, index_js_1.createSynth)({
            provider: this.config.provider,
            apiKey: this.config.apiKey,
            cacheStrategy: 'memory',
            cacheTTL: 3600,
            maxRetries: 3
        });
    }
    /**
     * Generate database fixtures for integration tests
     *
     * Creates realistic database records with proper relationships
     * and constraints for testing database operations.
     *
     * @example
     * ```typescript
     * const generator = new CICDTestDataGenerator();
     * const fixtures = await generator.generateDatabaseFixtures({
     *   users: 50,
     *   posts: 200,
     *   comments: 500
     * });
     * ```
     */
    async generateDatabaseFixtures(options = {}) {
        const { users = 10, posts = 50, comments = 100, orders = 25, products = 30 } = options;
        console.log('Generating database fixtures...');
        try {
            // Generate users with realistic data
            const usersSchema = {
                id: { type: 'uuid', required: true },
                username: { type: 'string', required: true, pattern: '^[a-z0-9_]{3,20}$' },
                email: { type: 'email', required: true },
                firstName: { type: 'string', required: true },
                lastName: { type: 'string', required: true },
                passwordHash: { type: 'string', required: true },
                role: { type: 'enum', values: ['admin', 'user', 'moderator'], required: true },
                isActive: { type: 'boolean', required: true },
                emailVerified: { type: 'boolean', required: true },
                createdAt: { type: 'timestamp', required: true },
                lastLoginAt: { type: 'timestamp', required: false },
                profile: {
                    type: 'object',
                    properties: {
                        bio: { type: 'string' },
                        avatar: { type: 'url' },
                        timezone: { type: 'string' },
                        language: { type: 'string' }
                    }
                }
            };
            // Generate posts with foreign key relationships
            const postsSchema = {
                id: { type: 'uuid', required: true },
                userId: { type: 'uuid', required: true }, // Foreign key to users
                title: { type: 'string', required: true, minLength: 10, maxLength: 200 },
                content: { type: 'text', required: true, minLength: 100 },
                slug: { type: 'string', required: true },
                status: { type: 'enum', values: ['draft', 'published', 'archived'], required: true },
                publishedAt: { type: 'timestamp', required: false },
                viewCount: { type: 'integer', min: 0, max: 1000000, required: true },
                tags: { type: 'array', items: { type: 'string' } },
                createdAt: { type: 'timestamp', required: true },
                updatedAt: { type: 'timestamp', required: true }
            };
            // Generate comments with nested relationships
            const commentsSchema = {
                id: { type: 'uuid', required: true },
                postId: { type: 'uuid', required: true }, // Foreign key to posts
                userId: { type: 'uuid', required: true }, // Foreign key to users
                parentId: { type: 'uuid', required: false }, // Self-referencing for nested comments
                content: { type: 'text', required: true, minLength: 10, maxLength: 1000 },
                isEdited: { type: 'boolean', required: true },
                isDeleted: { type: 'boolean', required: true },
                upvotes: { type: 'integer', min: 0, required: true },
                downvotes: { type: 'integer', min: 0, required: true },
                createdAt: { type: 'timestamp', required: true },
                updatedAt: { type: 'timestamp', required: true }
            };
            // Generate products for e-commerce tests
            const productsSchema = {
                id: { type: 'uuid', required: true },
                sku: { type: 'string', required: true, pattern: '^[A-Z0-9-]{8,15}$' },
                name: { type: 'string', required: true },
                description: { type: 'text', required: true },
                price: { type: 'decimal', min: 0.01, max: 10000, required: true },
                currency: { type: 'string', required: true, default: 'USD' },
                stockQuantity: { type: 'integer', min: 0, max: 10000, required: true },
                category: { type: 'string', required: true },
                brand: { type: 'string', required: false },
                weight: { type: 'decimal', min: 0, required: false },
                dimensions: {
                    type: 'object',
                    properties: {
                        length: { type: 'decimal' },
                        width: { type: 'decimal' },
                        height: { type: 'decimal' },
                        unit: { type: 'string', default: 'cm' }
                    }
                },
                images: { type: 'array', items: { type: 'url' } },
                isActive: { type: 'boolean', required: true },
                createdAt: { type: 'timestamp', required: true }
            };
            // Generate orders with complex relationships
            const ordersSchema = {
                id: { type: 'uuid', required: true },
                userId: { type: 'uuid', required: true },
                orderNumber: { type: 'string', required: true, pattern: '^ORD-[0-9]{10}$' },
                status: { type: 'enum', values: ['pending', 'processing', 'shipped', 'delivered', 'cancelled'], required: true },
                subtotal: { type: 'decimal', min: 0, required: true },
                tax: { type: 'decimal', min: 0, required: true },
                shipping: { type: 'decimal', min: 0, required: true },
                total: { type: 'decimal', min: 0, required: true },
                currency: { type: 'string', required: true, default: 'USD' },
                paymentMethod: { type: 'enum', values: ['credit_card', 'paypal', 'bank_transfer'], required: true },
                paymentStatus: { type: 'enum', values: ['pending', 'completed', 'failed', 'refunded'], required: true },
                shippingAddress: {
                    type: 'object',
                    properties: {
                        street: { type: 'string' },
                        city: { type: 'string' },
                        state: { type: 'string' },
                        postalCode: { type: 'string' },
                        country: { type: 'string' }
                    }
                },
                items: {
                    type: 'array',
                    items: {
                        type: 'object',
                        properties: {
                            productId: { type: 'uuid' },
                            quantity: { type: 'integer', min: 1 },
                            price: { type: 'decimal' }
                        }
                    }
                },
                createdAt: { type: 'timestamp', required: true },
                updatedAt: { type: 'timestamp', required: true }
            };
            // Generate all fixtures in parallel
            const [usersResult, postsResult, commentsResult, productsResult, ordersResult] = await Promise.all([
                this.synth.generateStructured({ count: users, schema: usersSchema, seed: this.config.seed }),
                this.synth.generateStructured({ count: posts, schema: postsSchema, seed: this.config.seed }),
                this.synth.generateStructured({ count: comments, schema: commentsSchema, seed: this.config.seed }),
                this.synth.generateStructured({ count: products, schema: productsSchema, seed: this.config.seed }),
                this.synth.generateStructured({ count: orders, schema: ordersSchema, seed: this.config.seed })
            ]);
            // Save to files
            await this.saveToFile('users', usersResult);
            await this.saveToFile('posts', postsResult);
            await this.saveToFile('comments', commentsResult);
            await this.saveToFile('products', productsResult);
            await this.saveToFile('orders', ordersResult);
            console.log('✅ Database fixtures generated successfully');
            console.log(`   Users: ${usersResult.metadata.count}`);
            console.log(`   Posts: ${postsResult.metadata.count}`);
            console.log(`   Comments: ${commentsResult.metadata.count}`);
            console.log(`   Products: ${productsResult.metadata.count}`);
            console.log(`   Orders: ${ordersResult.metadata.count}`);
            return {
                users: usersResult,
                posts: postsResult,
                comments: commentsResult,
                products: productsResult,
                orders: ordersResult
            };
        }
        catch (error) {
            console.error('❌ Failed to generate database fixtures:', error);
            throw new index_js_1.SynthError('Database fixture generation failed', 'FIXTURE_ERROR', error);
        }
    }
    /**
     * Generate API mock responses for testing
     *
     * Creates realistic API responses with various status codes,
     * headers, and payloads for comprehensive API testing.
     */
    async generateAPIMockResponses(options = {}) {
        const { endpoints = ['/api/users', '/api/posts', '/api/products', '/api/orders'], responsesPerEndpoint = 5, includeErrors = true } = options;
        console.log('Generating API mock responses...');
        try {
            const mockResponseSchema = {
                endpoint: { type: 'string', required: true },
                method: { type: 'enum', values: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'], required: true },
                statusCode: { type: 'integer', required: true },
                statusText: { type: 'string', required: true },
                headers: {
                    type: 'object',
                    properties: {
                        'Content-Type': { type: 'string' },
                        'X-Request-Id': { type: 'uuid' },
                        'X-RateLimit-Limit': { type: 'integer' },
                        'X-RateLimit-Remaining': { type: 'integer' },
                        'Cache-Control': { type: 'string' }
                    }
                },
                body: { type: 'object', required: true },
                latency: { type: 'integer', min: 10, max: 5000, required: true },
                timestamp: { type: 'timestamp', required: true }
            };
            const totalResponses = endpoints.length * responsesPerEndpoint;
            const result = await this.synth.generateStructured({
                count: totalResponses,
                schema: mockResponseSchema,
                seed: this.config.seed
            });
            await this.saveToFile('api-mocks', result);
            console.log('✅ API mock responses generated successfully');
            console.log(`   Total responses: ${result.metadata.count}`);
            console.log(`   Endpoints: ${endpoints.length}`);
            return result;
        }
        catch (error) {
            console.error('❌ Failed to generate API mocks:', error);
            throw new index_js_1.SynthError('API mock generation failed', 'MOCK_ERROR', error);
        }
    }
    /**
     * Generate user session data for E2E tests
     *
     * Creates realistic user sessions with cookies, tokens,
     * and session state for end-to-end testing.
     */
    async generateUserSessions(options = {}) {
        const { sessionCount = 20, includeAnonymous = true } = options;
        console.log('Generating user session data...');
        try {
            const sessionSchema = {
                sessionId: { type: 'uuid', required: true },
                userId: { type: 'uuid', required: false }, // Null for anonymous sessions
                isAuthenticated: { type: 'boolean', required: true },
                username: { type: 'string', required: false },
                email: { type: 'email', required: false },
                token: { type: 'string', required: false }, // JWT token
                refreshToken: { type: 'string', required: false },
                tokenExpiry: { type: 'timestamp', required: false },
                cookies: {
                    type: 'object',
                    properties: {
                        sessionId: { type: 'string' },
                        csrfToken: { type: 'string' },
                        preferences: { type: 'string' }
                    }
                },
                userAgent: { type: 'string', required: true },
                ipAddress: { type: 'string', required: true },
                location: {
                    type: 'object',
                    properties: {
                        country: { type: 'string' },
                        city: { type: 'string' },
                        timezone: { type: 'string' }
                    }
                },
                permissions: { type: 'array', items: { type: 'string' } },
                createdAt: { type: 'timestamp', required: true },
                lastActivityAt: { type: 'timestamp', required: true },
                expiresAt: { type: 'timestamp', required: true }
            };
            const result = await this.synth.generateStructured({
                count: sessionCount,
                schema: sessionSchema,
                seed: this.config.seed
            });
            await this.saveToFile('user-sessions', result);
            console.log('✅ User session data generated successfully');
            console.log(`   Sessions: ${result.metadata.count}`);
            return result;
        }
        catch (error) {
            console.error('❌ Failed to generate user sessions:', error);
            throw new index_js_1.SynthError('Session generation failed', 'SESSION_ERROR', error);
        }
    }
    /**
     * Generate load testing datasets
     *
     * Creates large-scale datasets for load and performance testing
     * with configurable data patterns and distributions.
     */
    async generateLoadTestData(options = {}) {
        const { requestCount = 10000, concurrent = 100, duration = 10 } = options;
        console.log('Generating load test data...');
        try {
            const loadTestSchema = {
                requestId: { type: 'uuid', required: true },
                endpoint: { type: 'string', required: true },
                method: { type: 'enum', values: ['GET', 'POST', 'PUT', 'DELETE'], required: true },
                payload: { type: 'object', required: false },
                headers: {
                    type: 'object',
                    properties: {
                        'Authorization': { type: 'string' },
                        'Content-Type': { type: 'string' },
                        'User-Agent': { type: 'string' }
                    }
                },
                timestamp: { type: 'timestamp', required: true },
                priority: { type: 'enum', values: ['low', 'medium', 'high', 'critical'], required: true },
                expectedStatusCode: { type: 'integer', required: true },
                timeout: { type: 'integer', min: 1000, max: 30000, required: true }
            };
            // Generate in batches for better performance
            const batchSize = 1000;
            const batches = Math.ceil(requestCount / batchSize);
            const batchOptions = Array.from({ length: batches }, () => ({
                count: batchSize,
                schema: loadTestSchema,
                seed: this.config.seed
            }));
            const results = await this.synth.generateBatch('structured', batchOptions, concurrent);
            // Combine all results
            const combinedData = results.flatMap(r => r.data);
            const combinedResult = {
                data: combinedData,
                metadata: {
                    count: combinedData.length,
                    generatedAt: new Date(),
                    provider: results[0].metadata.provider,
                    model: results[0].metadata.model,
                    cached: false,
                    duration: results.reduce((sum, r) => sum + r.metadata.duration, 0)
                }
            };
            await this.saveToFile('load-test-data', combinedResult);
            console.log('✅ Load test data generated successfully');
            console.log(`   Requests: ${combinedResult.metadata.count}`);
            console.log(`   Duration: ${combinedResult.metadata.duration}ms`);
            return combinedResult;
        }
        catch (error) {
            console.error('❌ Failed to generate load test data:', error);
            throw new index_js_1.SynthError('Load test data generation failed', 'LOAD_TEST_ERROR', error);
        }
    }
    /**
     * Generate configuration variations for multi-environment testing
     *
     * Creates configuration files for different environments
     * (dev, staging, production) with realistic values.
     */
    async generateEnvironmentConfigs(options = {}) {
        const { environments = ['development', 'staging', 'production'], includeSecrets = false } = options;
        console.log('Generating environment configurations...');
        try {
            const configSchema = {
                environment: { type: 'string', required: true },
                app: {
                    type: 'object',
                    properties: {
                        name: { type: 'string' },
                        version: { type: 'string', pattern: '^\\d+\\.\\d+\\.\\d+$' },
                        port: { type: 'integer', min: 3000, max: 9999 },
                        host: { type: 'string' },
                        logLevel: { type: 'enum', values: ['debug', 'info', 'warn', 'error'] }
                    }
                },
                database: {
                    type: 'object',
                    properties: {
                        host: { type: 'string' },
                        port: { type: 'integer' },
                        name: { type: 'string' },
                        username: { type: 'string' },
                        password: { type: 'string', required: includeSecrets },
                        ssl: { type: 'boolean' },
                        poolSize: { type: 'integer', min: 5, max: 100 },
                        timeout: { type: 'integer' }
                    }
                },
                redis: {
                    type: 'object',
                    properties: {
                        host: { type: 'string' },
                        port: { type: 'integer' },
                        password: { type: 'string', required: includeSecrets },
                        db: { type: 'integer', min: 0, max: 15 }
                    }
                },
                api: {
                    type: 'object',
                    properties: {
                        baseUrl: { type: 'url' },
                        timeout: { type: 'integer' },
                        retries: { type: 'integer', min: 0, max: 5 },
                        rateLimit: {
                            type: 'object',
                            properties: {
                                maxRequests: { type: 'integer' },
                                windowMs: { type: 'integer' }
                            }
                        }
                    }
                },
                features: {
                    type: 'object',
                    properties: {
                        authentication: { type: 'boolean' },
                        caching: { type: 'boolean' },
                        monitoring: { type: 'boolean' },
                        analytics: { type: 'boolean' }
                    }
                }
            };
            const results = {};
            for (const env of environments) {
                const result = await this.synth.generateStructured({
                    count: 1,
                    schema: { ...configSchema, environment: { type: 'string', default: env } },
                    seed: `${this.config.seed}-${env}`
                });
                results[env] = result;
                await this.saveToFile(`config-${env}`, result);
            }
            console.log('✅ Environment configurations generated successfully');
            console.log(`   Environments: ${environments.join(', ')}`);
            return results;
        }
        catch (error) {
            console.error('❌ Failed to generate environment configs:', error);
            throw new index_js_1.SynthError('Config generation failed', 'CONFIG_ERROR', error);
        }
    }
    /**
     * Generate all test data at once
     *
     * Convenience method to generate all types of test data
     * in a single operation.
     */
    async generateAll(options = {}) {
        console.log('🚀 Generating all test data...\n');
        const startTime = Date.now();
        try {
            await Promise.all([
                this.generateDatabaseFixtures({
                    users: options.users,
                    posts: options.posts,
                    comments: options.comments,
                    orders: options.orders,
                    products: options.products
                }),
                this.generateAPIMockResponses({
                    responsesPerEndpoint: options.apiMocks || 5
                }),
                this.generateUserSessions({
                    sessionCount: options.sessions || 20
                }),
                this.generateEnvironmentConfigs()
            ]);
            // Load test data generation is CPU-intensive, run separately
            if (options.loadTestRequests && options.loadTestRequests > 0) {
                await this.generateLoadTestData({
                    requestCount: options.loadTestRequests
                });
            }
            const duration = Date.now() - startTime;
            console.log(`\n✅ All test data generated successfully in ${duration}ms`);
            console.log(`📁 Output directory: ${path.resolve(this.config.outputDir)}`);
        }
        catch (error) {
            console.error('\n❌ Failed to generate test data:', error);
            throw error;
        }
    }
    /**
     * Save generation result to file
     */
    async saveToFile(name, result) {
        try {
            // Ensure output directory exists
            await fs.mkdir(this.config.outputDir, { recursive: true });
            const filename = `${name}.${this.config.format}`;
            const filepath = path.join(this.config.outputDir, filename);
            let content;
            if (this.config.format === 'json') {
                content = JSON.stringify(result.data, null, 2);
            }
            else if (this.config.format === 'csv') {
                // Simple CSV conversion (you might want to use a library for production)
                if (result.data.length === 0) {
                    content = '';
                }
                else {
                    const headers = Object.keys(result.data[0]);
                    const rows = result.data.map((item) => headers.map(header => JSON.stringify(item[header] ?? '')).join(','));
                    content = [headers.join(','), ...rows].join('\n');
                }
            }
            else {
                content = JSON.stringify(result.data, null, 2);
            }
            await fs.writeFile(filepath, content, 'utf-8');
            // Also save metadata
            const metadataPath = path.join(this.config.outputDir, `${name}.metadata.json`);
            await fs.writeFile(metadataPath, JSON.stringify(result.metadata, null, 2), 'utf-8');
        }
        catch (error) {
            console.error(`Failed to save ${name}:`, error);
            throw error;
        }
    }
}
exports.CICDTestDataGenerator = CICDTestDataGenerator;
/**
 * Example usage in CI/CD pipeline
 */
async function cicdExample() {
    // Initialize generator
    const generator = new CICDTestDataGenerator({
        outputDir: './test-fixtures',
        format: 'json',
        provider: 'gemini',
        seed: process.env.CI_COMMIT_SHA || 'default-seed' // Use commit SHA for reproducibility
    });
    // Generate all test data
    await generator.generateAll({
        users: 50,
        posts: 200,
        comments: 500,
        orders: 100,
        products: 75,
        apiMocks: 10,
        sessions: 30,
        loadTestRequests: 5000
    });
    console.log('Test data ready for CI/CD pipeline');
}
/**
 * GitHub Actions example
 */
async function githubActionsExample() {
    const generator = new CICDTestDataGenerator({
        outputDir: process.env.GITHUB_WORKSPACE + '/test-data',
        seed: process.env.GITHUB_SHA
    });
    await generator.generateDatabaseFixtures();
    await generator.generateAPIMockResponses();
}
/**
 * GitLab CI example
 */
async function gitlabCIExample() {
    const generator = new CICDTestDataGenerator({
        outputDir: process.env.CI_PROJECT_DIR + '/test-data',
        seed: process.env.CI_COMMIT_SHORT_SHA
    });
    await generator.generateAll();
}
// Run if called directly
if (import.meta.url === `file://${process.argv[1]}`) {
    cicdExample().catch(console.error);
}
//# sourceMappingURL=test-data-generator.js.map