supa-seed/dist/features/generation/assets/asset-data-mapper.d.ts

A constraint-aware, framework-agnostic database seeding framework with deep PostgreSQL business logic discovery and MakerKit integration support

/**
 * Asset-to-Data Mapping System
 * Phase 2, Checkpoint B3 - Bridge between asset selection and database seeding
 */
import { LoadedAsset } from './asset-loader';
export interface FieldMapping {
    sourceField: string;
    targetField: string;
    dataType: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array';
    required: boolean;
    defaultValue?: any;
    transformer?: (value: any, asset: LoadedAsset) => any;
    validator?: (value: any) => boolean;
    fallbackGenerator?: () => any;
}
export interface MappingConfig {
    tableName: string;
    mappings: FieldMapping[];
    globalDefaults?: Record<string, any>;
    requireAll?: boolean;
    allowPartial?: boolean;
    batchSize?: number;
    onMappingError?: 'skip' | 'throw' | 'use_fallback';
}
export interface MappedRecord {
    originalAsset: LoadedAsset;
    mappedData: Record<string, any>;
    errors: string[];
    warnings: string[];
    isValid: boolean;
    usedFallbacks: string[];
}
export interface MappingResult {
    records: MappedRecord[];
    successful: number;
    failed: number;
    totalAssets: number;
    executionTime: number;
    errors: Array<{
        asset: LoadedAsset;
        error: string;
    }>;
    statistics: {
        fieldUsageStats: Record<string, number>;
        dataTypeStats: Record<string, number>;
        fallbackUsageStats: Record<string, number>;
        validationFailureStats: Record<string, number>;
    };
}
export declare class AssetDataMapper {
    private static readonly SPECIAL_FIELDS;
    /**
     * Map assets to database records using the provided configuration
     */
    static mapAssetsToRecords(assets: LoadedAsset[], config: MappingConfig): MappingResult;
    /**
     * Map a single asset to a database record
     */
    private static mapSingleAsset;
    /**
     * Map a single field from asset to target format
     */
    private static mapField;
    /**
     * Extract field value from asset
     */
    private static extractFieldValue;
    /**
     * Convert value to target data type
     */
    private static convertDataType;
    /**
     * Create common field mapping configurations
     */
    static createMappings: {
        /**
         * Create mapping for blog posts
         */
        blogPost: () => FieldMapping[];
        /**
         * Create mapping for users from CSV
         */
        users: () => FieldMapping[];
        /**
         * Create mapping for products
         */
        products: () => FieldMapping[];
        /**
         * Create mapping for generic content
         */
        content: () => FieldMapping[];
    };
    /**
     * Create common transformers for field values
     */
    static createTransformers: {
        /**
         * Slugify a string for URL-safe identifiers
         */
        slugify: (value: any) => string;
        /**
         * Truncate text to specified length
         */
        truncate: (maxLength: number) => (value: any) => string;
        /**
         * Extract first N words
         */
        firstWords: (count: number) => (value: any) => string;
        /**
         * Format date to ISO string
         */
        toISOString: (value: any) => string | null;
        /**
         * Clean HTML tags from text
         */
        stripHtml: (value: any) => string;
        /**
         * Convert markdown to plain text (simple)
         */
        markdownToText: (value: any) => string;
    };
    /**
     * Validate mapping configuration
     */
    static validateMappingConfig(config: MappingConfig): {
        isValid: boolean;
        errors: string[];
        warnings: string[];
    };
}
//# sourceMappingURL=asset-data-mapper.d.ts.map