@gftdcojp/ksqldb-orm/dist/types.d.ts

ksqldb-orm - Server-Side TypeScript ORM for ksqlDB with enterprise security extensions

/**
 * 基本型定義
 */
import { PullQueryOptions } from './ksqldb-client';
import { ColumnNameTransformConfig } from './utils/column-name-transform';
export interface ExecutionContext {
    userId: string;
    tenantId: string;
    roles: string[];
    [key: string]: any;
}
export interface KsqlDbConfig {
    url: string;
    apiKey?: string;
    apiSecret?: string;
    headers?: Record<string, string>;
    resilience?: ResilienceConfig;
    /** 列名変換設定 - KsqlDBの強制大文字化に対応 */
    columnNameTransform?: ColumnNameTransformConfig;
}
export interface SchemaRegistryConfig {
    url: string;
    auth?: {
        user: string;
        pass: string;
    };
    apiKey?: string;
}
export interface OrmConfig {
    ksql: KsqlDbConfig;
    schemaRegistry: SchemaRegistryConfig;
}
/**
 * ksqlDB のストリーム/テーブルの種類
 */
export declare enum StreamType {
    STREAM = "STREAM",
    TABLE = "TABLE",
    MATERIALIZED_VIEW = "MATERIALIZED_VIEW"
}
export interface AvroSchema {
    type: 'record';
    name: string;
    fields: AvroField[];
}
export interface AvroField {
    name: string;
    type: string | string[] | AvroComplexType;
    default?: any;
}
export interface AvroComplexType {
    type: string;
    logicalType?: string;
    [key: string]: any;
}
/**
 * Materialized View 設定
 */
export interface MaterializedViewConfig {
    sourceTable?: string;
    sourceStream?: string;
    query?: string;
    groupBy?: string[];
    aggregations?: Record<string, string>;
    windowConfig?: {
        type: 'TUMBLING' | 'HOPPING' | 'SESSION';
        size: string;
        advanceBy?: string;
    };
    refreshInterval?: number;
}
/**
 * SQL オプション（拡張）
 */
export interface SqlOptions {
    as?: string;
    with?: Record<string, any>;
    materializedView?: MaterializedViewConfig;
    partitions?: number;
    replicas?: number;
    [key: string]: any;
}
export interface WhereCondition {
    [field: string]: any | {
        like?: string;
        in?: any[];
        gt?: any;
        gte?: any;
        lt?: any;
        lte?: any;
        eq?: any;
        ne?: any;
    };
}
export interface OrderByCondition {
    [field: string]: 'asc' | 'desc';
}
export interface FindManyOptions {
    where?: WhereCondition;
    orderBy?: OrderByCondition;
    limit?: number;
    offset?: number;
}
export type PolicyFunction = (ctx: ExecutionContext) => string;
/**
 * Resilience Configuration for partition rebalancing and error handling
 */
export interface ResilienceConfig {
    /** Retry configuration */
    retries?: RetryConfig;
    /** Circuit breaker configuration */
    circuitBreaker?: CircuitBreakerConfig;
    /** Partition awareness configuration */
    partitionAwareness?: PartitionAwarenessConfig;
    /** Fallback strategies configuration */
    fallback?: FallbackConfig;
    /** Metrics collection configuration */
    metrics?: MetricsConfig;
}
export interface RetryConfig {
    /** Maximum number of retries (default: 5) */
    maxRetries?: number;
    /** Base delay between retries in milliseconds (default: 1500) */
    baseDelay?: number;
    /** Maximum delay between retries in milliseconds (default: 30000) */
    maxDelay?: number;
    /** Backoff strategy (default: 'exponential') */
    backoffStrategy?: 'exponential' | 'linear' | 'fixed';
    /** Jitter to add randomness to retry delays (default: 0.1) */
    jitter?: number;
    /** Retry only specific error types */
    retryableErrors?: string[];
}
export interface CircuitBreakerConfig {
    /** Whether circuit breaker is enabled (default: true) */
    enabled?: boolean;
    /** Failure threshold to open circuit (default: 5) */
    failureThreshold?: number;
    /** Time window for failure tracking in milliseconds (default: 60000) */
    timeWindow?: number;
    /** Time to wait before attempting to close circuit in milliseconds (default: 30000) */
    openTimeout?: number;
    /** Number of successful calls needed to close circuit (default: 2) */
    successThreshold?: number;
}
export interface PartitionAwarenessConfig {
    /** Whether partition awareness is enabled (default: true) */
    enabled?: boolean;
    /** Partition-specific error patterns to detect */
    errorPatterns?: string[];
    /** Timeout for partition rebalancing detection in milliseconds (default: 10000) */
    rebalanceTimeout?: number;
}
export interface FallbackConfig {
    /** Whether to fallback to HTTP when WebSocket fails (default: true) */
    fallbackToHttp?: boolean;
    /** Alternative endpoints to try */
    alternativeEndpoints?: string[];
    /** Timeout for fallback attempts in milliseconds (default: 5000) */
    fallbackTimeout?: number;
}
export interface MetricsConfig {
    /** Whether metrics collection is enabled (default: true) */
    enabled?: boolean;
    /** Metrics collection interval in milliseconds (default: 60000) */
    interval?: number;
    /** Custom metrics collector function */
    collector?: (metrics: ResilienceMetrics) => void;
}
/**
 * Resilience metrics data structure
 */
export interface ResilienceMetrics {
    /** Total number of requests */
    totalRequests: number;
    /** Number of successful requests */
    successfulRequests: number;
    /** Number of failed requests */
    failedRequests: number;
    /** Number of retried requests */
    retriedRequests: number;
    /** Number of circuit breaker trips */
    circuitBreakerTrips: number;
    /** Number of fallback activations */
    fallbackActivations: number;
    /** Average response time in milliseconds */
    averageResponseTime: number;
    /** Partition rebalancing events detected */
    partitionRebalanceEvents: number;
    /** Timestamp of last update */
    lastUpdated: Date;
}
/**
 * Error types for resilience handling
 */
export declare enum ResilienceErrorType {
    PARTITION_REBALANCING = "partition_rebalancing",
    CONNECTION_TIMEOUT = "connection_timeout",
    NETWORK_ERROR = "network_error",
    SERVER_ERROR = "server_error",
    UNKNOWN_ERROR = "unknown_error"
}
/**
 * Circuit breaker states
 */
export declare enum CircuitBreakerState {
    CLOSED = "closed",
    OPEN = "open",
    HALF_OPEN = "half_open"
}
/**
 * Enhanced pull query options with resilience features
 */
export interface EnhancedPullQueryOptions extends PullQueryOptions {
    /** Retry configuration for this specific query */
    retries?: number;
    /** Backoff strategy for this specific query */
    backoffStrategy?: 'exponential' | 'linear' | 'fixed';
    /** Whether to use HTTP fallback for this query */
    fallbackToHttp?: boolean;
    /** Custom timeout for this query in milliseconds */
    timeout?: number;
}
/**
 * Result wrapper with resilience information
 */
export interface ResilientQueryResult<T = any> {
    /** Query result data */
    data: T;
    /** Error information if any */
    error?: any;
    /** Resilience metadata */
    resilience: {
        /** Number of retries attempted */
        retryCount: number;
        /** Whether fallback was used */
        fallbackUsed: boolean;
        /** Total execution time in milliseconds */
        executionTime: number;
        /** Circuit breaker state when query was executed */
        circuitBreakerState: CircuitBreakerState;
    };
}
//# sourceMappingURL=types.d.ts.map