agentic-qe/dist/agents/TestDataArchitectAgent.d.ts

Agentic Quality Engineering Fleet System - AI-driven quality management platform

/**
 * TestDataArchitectAgent - Realistic test data generation specialist
 *
 * Implements schema-aware data generation with referential integrity preservation,
 * PII anonymization (GDPR compliance), edge case coverage, realistic data synthesis
 * using Faker.js patterns, and high-speed generation (10,000+ records/second).
 *
 * Based on SPARC methodology and AQE Fleet specification
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { QETask } from '../types';
export interface TestDataArchitectAgentConfig extends BaseAgentConfig {
    databases?: Array<'postgresql' | 'mysql' | 'mongodb' | 'sqlite'>;
    generationRate?: number;
    referentialIntegrity?: boolean;
    piiAnonymization?: boolean;
    gdprCompliant?: boolean;
    edgeCaseGeneration?: boolean;
    fakerLocale?: string;
    seedValue?: number;
    batchSize?: number;
    parallelGeneration?: boolean;
}
export interface DatabaseSchema {
    name: string;
    tables: TableSchema[];
    relationships: Relationship[];
    indexes: Index[];
    constraints: Constraint[];
}
export interface TableSchema {
    name: string;
    fields: FieldSchema[];
    primaryKey: string[];
    uniqueConstraints: string[][];
    checkConstraints: CheckConstraint[];
    foreignKeys: ForeignKey[];
}
export interface FieldSchema {
    name: string;
    type: FieldType;
    nullable: boolean;
    defaultValue?: any;
    maxLength?: number;
    precision?: number;
    scale?: number;
    constraints: FieldConstraint[];
    format?: SemanticFormat;
    sensitive?: boolean;
    generator?: DataGenerator;
}
export declare enum FieldType {
    STRING = "string",
    INTEGER = "integer",
    FLOAT = "float",
    DECIMAL = "decimal",
    BOOLEAN = "boolean",
    DATE = "date",
    DATETIME = "datetime",
    TIMESTAMP = "timestamp",
    UUID = "uuid",
    JSON = "json",
    ARRAY = "array",
    BINARY = "binary",
    TEXT = "text",
    ENUM = "enum"
}
export declare enum SemanticFormat {
    UUID = "uuid",
    EMAIL = "email",
    PHONE = "phone",
    URL = "url",
    NAME = "name",
    ADDRESS = "address",
    CITY = "city",
    COUNTRY = "country",
    ZIPCODE = "zipcode",
    CREDIT_CARD = "credit_card",
    SSN = "ssn",
    IP_ADDRESS = "ip_address",
    MAC_ADDRESS = "mac_address",
    USER_AGENT = "user_agent",
    PRICE = "price",
    CURRENCY = "currency",
    COMPANY = "company",
    JOB_TITLE = "job_title",
    PRODUCT_NAME = "product_name",
    DESCRIPTION = "description",
    LATITUDE = "latitude",
    LONGITUDE = "longitude",
    COLOR = "color"
}
export interface FieldConstraint {
    type: 'min' | 'max' | 'length' | 'pattern' | 'enum' | 'unique' | 'not_null';
    value: any;
}
export interface CheckConstraint {
    name: string;
    expression: string;
}
export interface ForeignKey {
    column: string;
    referencedTable: string;
    referencedColumn: string;
    onDelete?: 'CASCADE' | 'SET_NULL' | 'RESTRICT';
    onUpdate?: 'CASCADE' | 'SET_NULL' | 'RESTRICT';
}
export interface Relationship {
    from: string;
    to: string;
    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
    foreignKey: string;
}
export interface Index {
    name: string;
    table: string;
    columns: string[];
    unique: boolean;
}
export interface Constraint {
    name: string;
    table: string;
    type: 'PRIMARY_KEY' | 'FOREIGN_KEY' | 'UNIQUE' | 'CHECK';
    definition: string;
}
export interface DataGenerationRequest {
    schema: DatabaseSchema | TableSchema;
    count: number;
    includeEdgeCases?: boolean;
    preserveIntegrity?: boolean;
    anonymizePII?: boolean;
    seedValue?: number;
    format?: 'json' | 'sql' | 'csv';
}
export interface DataGenerationResult {
    id: string;
    schema: string;
    recordsGenerated: number;
    duration: number;
    generationRate: number;
    data: GeneratedDataset;
    edgeCases?: GeneratedDataset;
    validationResult: ValidationResult;
    metadata: GenerationMetadata;
}
export interface GeneratedDataset {
    tables?: Record<string, any[]>;
    records?: any[];
    format: 'json' | 'sql' | 'csv';
    size: number;
}
export interface ValidationResult {
    valid: boolean;
    violations: ConstraintViolation[];
    warnings: string[];
    integrityChecks: IntegrityCheck[];
}
export interface ConstraintViolation {
    type: 'NOT_NULL' | 'UNIQUE' | 'CHECK' | 'FOREIGN_KEY' | 'DATA_TYPE';
    field: string;
    table?: string;
    value?: any;
    message: string;
    severity: 'ERROR' | 'WARNING';
}
export interface IntegrityCheck {
    type: 'FOREIGN_KEY' | 'UNIQUE' | 'PRIMARY_KEY';
    table: string;
    status: 'PASS' | 'FAIL';
    details?: string;
}
export interface GenerationMetadata {
    timestamp: Date;
    generator: string;
    version: string;
    config: any;
    statistics: DataStatistics;
}
export interface DataStatistics {
    nullCount: Record<string, number>;
    uniqueValues: Record<string, number>;
    dataDistribution: Record<string, Distribution>;
    edgeCasePercentage?: number;
}
export interface Distribution {
    min?: number;
    max?: number;
    mean?: number;
    median?: number;
    stdDev?: number;
    percentiles?: Record<string, number>;
}
export interface AnonymizationConfig {
    strategy: AnonymizationStrategy;
    preserveFormat?: boolean;
    preserveStatistics?: boolean;
    salt?: string;
    kAnonymity?: number;
}
export declare enum AnonymizationStrategy {
    MASK = "mask",
    HASH = "hash",
    TOKENIZE = "tokenize",
    GENERALIZE = "generalize",
    SUBSTITUTE = "substitute",
    SYNTHETIC = "synthetic"
}
export interface AnonymizationResult {
    originalRecords: number;
    anonymizedRecords: number;
    fieldsAnonymized: string[];
    strategy: AnonymizationStrategy;
    statisticalValidation: StatisticalValidation;
    gdprCompliant: boolean;
}
export interface StatisticalValidation {
    correlationPreserved: boolean;
    distributionSimilarity: number;
    deviationFromOriginal: number;
}
export type DataGenerator = () => any;
export declare class TestDataArchitectAgent extends BaseAgent {
    private readonly config;
    private schemaCache;
    private generatedDatasets;
    private tokenMap;
    private faker;
    constructor(config: TestDataArchitectAgentConfig);
    protected initializeComponents(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    /**
     * Introspect database schema from various sources
     */
    introspectSchema(config: {
        source: 'postgresql' | 'mysql' | 'mongodb' | 'sqlite' | 'openapi' | 'graphql' | 'typescript';
        connectionString?: string;
        schemaFile?: string;
        tables?: string[];
    }): Promise<DatabaseSchema>;
    /**
     * Introspect SQL database schema (PostgreSQL, MySQL, SQLite)
     */
    private introspectSQLDatabase;
    /**
     * Introspect MongoDB schema
     */
    private introspectMongoDatabase;
    /**
     * Introspect OpenAPI schema
     */
    private introspectOpenAPISchema;
    /**
     * Introspect GraphQL schema
     */
    private introspectGraphQLSchema;
    /**
     * Introspect TypeScript schema
     */
    private introspectTypeScriptSchema;
    /**
     * Generate test data based on schema
     */
    generateData(request: DataGenerationRequest): Promise<DataGenerationResult>;
    /**
     * Generate data with referential integrity preserved
     */
    private generateWithIntegrity;
    /**
     * Generate data for a single table
     */
    private generateTableData;
    /**
     * Generate a batch of records
     */
    private generateBatch;
    /**
     * Topological sort for dependency resolution
     */
    private topologicalSort;
    /**
     * Generate edge case data
     */
    generateEdgeCases(config: {
        schema: TableSchema | DatabaseSchema;
        comprehensive?: boolean;
    }): Promise<any[]>;
    /**
     * Generate edge cases for entire schema
     */
    private generateEdgeCasesForSchema;
    /**
     * Generate edge cases for a table
     */
    private generateEdgeCasesForTable;
    /**
     * Generate edge cases for a field
     */
    private generateFieldEdgeCases;
    /**
     * Anonymize PII data
     */
    anonymizeData(config: {
        data: any[];
        schema: TableSchema;
        strategy?: AnonymizationStrategy;
        preserveStatistics?: boolean;
    }): Promise<AnonymizationResult>;
    /**
     * Anonymize dataset
     */
    private anonymizeDataset;
    /**
     * Anonymize a single field value
     */
    private anonymizeField;
    /**
     * Mask a value (show first and last char)
     */
    private maskValue;
    /**
     * Hash a value (deterministic)
     */
    private hashValue;
    /**
     * Tokenize a value (consistent replacement)
     */
    private tokenizeValue;
    /**
     * Generalize a value (reduce precision)
     */
    private generalizeValue;
    /**
     * Substitute with random value
     */
    private substituteValue;
    /**
     * Validate generated data
     */
    validateData(config: {
        data: any[];
        schema: TableSchema | DatabaseSchema;
    }): Promise<ValidationResult>;
    /**
     * Validate generated dataset
     */
    private validateGeneratedData;
    /**
     * Evaluate a check constraint
     */
    private evaluateCheckConstraint;
    /**
     * Analyze production data patterns
     */
    analyzeProductionPatterns(config: {
        data: any[];
        schema: TableSchema;
    }): Promise<any>;
    /**
     * Calculate distribution statistics
     */
    private calculateDistribution;
    /**
     * Create a data version
     */
    createDataVersion(config: {
        datasetId: string;
        version: string;
        description?: string;
        tags?: string[];
    }): Promise<any>;
    /**
     * Calculate checksum for dataset
     */
    private calculateChecksum;
    /**
     * Seed database with generated data
     */
    seedDatabase(config: {
        datasetId: string;
        database: 'postgresql' | 'mysql' | 'mongodb' | 'sqlite';
        connectionString: string;
        truncate?: boolean;
    }): Promise<any>;
    /**
     * Initialize Faker.js
     */
    private initializeFaker;
    /**
     * Load schema templates
     */
    private loadSchemaTemplates;
    /**
     * Create data generator function
     */
    private createGenerator;
    /**
     * Generate field value
     */
    private generateFieldValue;
    /**
     * Calculate statistics for dataset
     */
    private calculateStatistics;
    /**
     * Generate UUID
     */
    private generateUUID;
    /**
     * Generate email
     */
    private generateEmail;
    /**
     * Generate name
     */
    private generateName;
    /**
     * Generate age
     */
    private generateAge;
    /**
     * Generate integer
     */
    private generateInteger;
    /**
     * Generate float
     */
    private generateFloat;
    /**
     * Generate price
     */
    private generatePrice;
    /**
     * Generate string
     */
    private generateString;
    /**
     * Select random element from array
     */
    private selectRandom;
    /**
     * Generate dataset ID
     */
    private generateDatasetId;
    /**
     * Generate version ID
     */
    private generateVersionId;
}
export default TestDataArchitectAgent;
//# sourceMappingURL=TestDataArchitectAgent.d.ts.map