@gati-framework/runtime/dist/timescape/transformer.d.ts

Gati runtime execution engine for running handler-based applications

import type { TSV } from './types.js';
/**
 * Transformer function type
 */
export type TransformFunction = (data: unknown) => unknown | Promise<unknown>;
/**
 * Transformer pair for bidirectional conversion between adjacent versions
 * Transformers are IMMUTABLE once created
 */
export interface TransformerPair {
    readonly fromVersion: TSV;
    readonly toVersion: TSV;
    readonly immutable: true;
    readonly createdAt: number;
    readonly createdBy: string;
    /**
     * Forward transformation: fromVersion → toVersion
     */
    readonly forward: {
        readonly transformRequest?: TransformFunction;
        readonly transformResponse?: TransformFunction;
    };
    /**
     * Backward transformation: toVersion → fromVersion
     */
    readonly backward: {
        readonly transformRequest?: TransformFunction;
        readonly transformResponse?: TransformFunction;
    };
}
/**
 * Transformation result
 */
export interface TransformResult<T = unknown> {
    success: boolean;
    data?: T;
    error?: Error;
    transformedVersions: TSV[];
    chainLength?: number;
}
/**
 * Transformer chain execution options
 */
export interface ChainOptions {
    maxHops?: number;
    timeout?: number;
    fallbackOnError?: boolean;
}
/**
 * Transformer registry and execution engine
 */
export declare class TransformerEngine {
    private transformers;
    private readonly maxChainLength;
    constructor(maxChainLength?: number);
    /**
     * Register a transformer pair (adjacent versions only)
     */
    register(transformer: TransformerPair): void;
    /**
     * Get transformer between two adjacent versions
     */
    getTransformer(from: TSV, to: TSV): TransformerPair | undefined;
    /**
     * Check if transformer exists
     */
    hasTransformer(from: TSV, to: TSV): boolean;
    /**
     * Build transformation chain from source to target version
     * Returns linear chain (no circular dependencies possible)
     */
    buildChain(from: TSV, to: TSV, versions: TSV[]): TSV[] | null;
    /**
     * Execute transformation chain for request data
     */
    transformRequest(data: unknown, from: TSV, to: TSV, versions: TSV[], options?: ChainOptions): Promise<TransformResult>;
    /**
     * Execute transformation chain for response data
     */
    transformResponse(data: unknown, from: TSV, to: TSV, versions: TSV[], options?: ChainOptions): Promise<TransformResult>;
    /**
     * Execute transformation chain
     */
    private executeChain;
    /**
     * Get all registered transformers
     */
    getAllTransformers(): TransformerPair[];
    /**
     * Get transformer count
     */
    getTransformerCount(): number;
    /**
     * Clear all transformers (for testing)
     */
    clear(): void;
    /**
     * Create key for transformer lookup
     */
    private makeKey;
    /**
     * Extract timestamp from TSV
     */
    private extractTimestamp;
    /**
     * Execute promise with timeout
     */
    private withTimeout;
}
/**
 * Create a transformer pair
 */
export declare function createTransformerPair(fromVersion: TSV, toVersion: TSV, forward: TransformerPair['forward'], backward: TransformerPair['backward'], createdBy?: string): TransformerPair;
//# sourceMappingURL=transformer.d.ts.map