@ductape/sdk 0.0.4-v9 → 0.0.4-v91

package/dist/warehouse/types/join.interface.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Join Interface
+ *
+ * Defines cross-database join operations including standard SQL-style joins,
+ * semantic joins (vector similarity), and graph traversal joins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompoundCondition = isCompoundCondition;
+exports.isStandardJoin = isStandardJoin;
+exports.parseFieldPath = parseFieldPath;
+exports.buildFieldPath = buildFieldPath;
+exports.extractJoinAliases = extractJoinAliases;
+exports.validateJoinClause = validateJoinClause;
+// ==================== UTILITIES ====================
+/**
+ * Check if a join condition is compound
+ */
+function isCompoundCondition(condition) {
+    return 'logic' in condition && 'conditions' in condition;
+}
+/**
+ * Check if a join is a standard SQL-style join
+ */
+function isStandardJoin(type) {
+    return ['inner', 'left', 'right', 'full', 'cross'].includes(type);
+}
+/**
+ * Parse a field path into alias and field name
+ *
+ * @example
+ * parseFieldPath('u.name') // { alias: 'u', field: 'name' }
+ * parseFieldPath('name')    // { alias: undefined, field: 'name' }
+ */
+function parseFieldPath(path) {
+    const parts = path.split('.');
+    if (parts.length === 1) {
+        return { field: parts[0] };
+    }
+    return { alias: parts[0], field: parts.slice(1).join('.') };
+}
+/**
+ * Build a field path from alias and field name
+ */
+function buildFieldPath(alias, field) {
+    return alias ? `${alias}.${field}` : field;
+}
+/**
+ * Extract all source aliases from a list of join clauses
+ */
+function extractJoinAliases(joins) {
+    return joins
+        .map(j => j.source.alias)
+        .filter((alias) => alias !== undefined);
+}
+/**
+ * Validate join clause configuration
+ */
+function validateJoinClause(join) {
+    const errors = [];
+    // Check source has alias for joins
+    if (!join.source.alias) {
+        errors.push(`Join source must have an alias: ${join.source.tag}/${join.source.entity}`);
+    }
+    // Standard joins require 'on' condition (except cross join)
+    if (isStandardJoin(join.type) && join.type !== 'cross' && !join.on) {
+        errors.push(`${join.type} join requires an 'on' condition`);
+    }
+    // Semantic joins require semantic config
+    if (join.type === 'semantic' && !join.semantic) {
+        errors.push(`Semantic join requires 'semantic' configuration`);
+    }
+    // Graph joins require graph config
+    if (join.type === 'graph' && !join.graph) {
+        errors.push(`Graph join requires 'graph' configuration`);
+    }
+    // Semantic join must target a vector source
+    if (join.type === 'semantic' && join.source.type !== 'vector') {
+        errors.push(`Semantic join must target a vector data source`);
+    }
+    // Graph join must target a graph source
+    if (join.type === 'graph' && join.source.type !== 'graph') {
+        errors.push(`Graph join must target a graph data source`);
+    }
+    return errors;
+}
+//# sourceMappingURL=join.interface.js.map

package/dist/warehouse/types/join.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.interface.js","sourceRoot":"","sources":["../../../src/warehouse/types/join.interface.ts"],"names":[],"mappings":"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"}

package/dist/warehouse/types/query.interface.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Warehouse Query Interface
+ *
+ * Unified query schema for cross-database operations across
+ * traditional databases, graphs, and vector stores.
+ */
+import { IUnifiedWhereClause } from './where.interface';
+import { IJoinClause } from './join.interface';
+import { ISagaTransaction } from './transaction.interface';
+/**
+ * Types of data sources supported by the warehouse
+ */
+export type DataSourceType = 'database' | 'graph' | 'vector';
+/**
+ * Reference to a configured data source
+ */
+export interface IDataSource {
+    /** Source type */
+    type: DataSourceType;
+    /**
+     * Tag reference to configured data source
+     * e.g., "users-postgres", "knowledge-neo4j", "embeddings-pinecone"
+     */
+    tag: string;
+    /**
+     * Entity within the source
+     * - database: table name
+     * - graph: node label
+     * - vector: index/collection name
+     */
+    entity: string;
+    /** Alias for use in joins and field references */
+    alias?: string;
+}
+/**
+ * Supported warehouse operations
+ */
+export type WarehouseOperation = 'select' | 'insert' | 'update' | 'delete' | 'upsert';
+/**
+ * Field mapping for projections
+ */
+export interface IFieldMapping {
+    /** Source field path (e.g., "u.name") */
+    source: string;
+    /** Output alias */
+    as?: string;
+    /** Aggregate function */
+    aggregate?: 'count' | 'sum' | 'avg' | 'min' | 'max';
+}
+/**
+ * Aggregation specification
+ */
+export interface IAggregation {
+    /** Aggregate function */
+    function: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'count_distinct';
+    /** Field to aggregate (use '*' for count) */
+    field: string;
+    /** Output alias */
+    as: string;
+}
+/**
+ * Order by specification
+ */
+export interface IOrderBy {
+    /** Field path */
+    field: string;
+    /** Sort order */
+    order: 'ASC' | 'DESC';
+    /** Nulls position */
+    nulls?: 'FIRST' | 'LAST';
+}
+/**
+ * Unified warehouse query interface
+ *
+ * Supports querying across databases, graphs, and vector stores
+ * with cross-database joins, aggregations, and transactions.
+ */
+export interface IWarehouseQuery {
+    /** Operation type */
+    operation: WarehouseOperation;
+    /** Primary data source */
+    from: IDataSource;
+    /**
+     * Fields to return (select)
+     * Can be string paths or field mappings with aliases
+     */
+    fields?: (string | IFieldMapping)[];
+    /**
+     * Data for write operations (insert/update/upsert)
+     * Single object or array for bulk operations
+     */
+    data?: Record<string, any> | Record<string, any>[];
+    /** Cross-database joins */
+    join?: IJoinClause[];
+    /** Unified where clause (works across all data types) */
+    where?: IUnifiedWhereClause;
+    /** Aggregations */
+    aggregate?: IAggregation[];
+    /** Group by fields */
+    groupBy?: string[];
+    /** Having clause (for aggregations) */
+    having?: IUnifiedWhereClause;
+    /** Order by */
+    orderBy?: IOrderBy[];
+    /** Limit results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /**
+     * Return inserted/updated data
+     * Only applicable for write operations
+     */
+    returning?: boolean | string[];
+    /**
+     * Conflict keys for upsert operations
+     * Columns to detect conflict on (unique keys)
+     */
+    conflictKeys?: string[];
+    /**
+     * Transaction context for cross-database transactions
+     * Uses Saga pattern for distributed consistency
+     */
+    transaction?: ISagaTransaction;
+    /** Execution hints for optimization */
+    hints?: IExecutionHints;
+}
+/**
+ * Hints for query optimization
+ */
+export interface IExecutionHints {
+    /**
+     * Preferred join strategy
+     * - hash: Build hash table from smaller dataset
+     * - nested_loop: Iterate outer, query inner per row
+     * - sort_merge: Sort both sides and merge
+     */
+    joinStrategy?: 'hash' | 'nested_loop' | 'sort_merge' | 'auto';
+    /** Maximum memory for join operations (bytes) */
+    maxJoinMemory?: number;
+    /** Enable parallel execution of independent sub-queries */
+    parallel?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Enable result streaming for large datasets */
+    streaming?: boolean;
+    /** Cache results for this duration (seconds) */
+    cacheTtl?: number;
+    /** Force read from primary (not replicas) */
+    readFromPrimary?: boolean;
+}
+/**
+ * Unified query result
+ */
+export interface IWarehouseResult<T = Record<string, any>> {
+    /** Result data */
+    data: T[];
+    /** Total count (if available) */
+    count?: number;
+    /** Affected rows (for write operations) */
+    affectedRows?: number;
+    /** Execution metadata */
+    metadata: IQueryMetadata;
+}
+/**
+ * Query execution metadata
+ */
+export interface IQueryMetadata {
+    /** Total execution time in milliseconds */
+    executionTime: number;
+    /** Number of data sources queried */
+    sourcesQueried: number;
+    /** Breakdown by source */
+    sourceStats: ISourceStats[];
+    /** Join statistics (if applicable) */
+    joinStats?: IJoinStats;
+    /** Whether results were cached */
+    cached: boolean;
+    /** Query plan used */
+    plan?: IExecutionPlan;
+}
+/**
+ * Per-source execution statistics
+ */
+export interface ISourceStats {
+    /** Data source tag */
+    tag: string;
+    /** Source type */
+    type: DataSourceType;
+    /** Execution time for this source */
+    executionTime: number;
+    /** Rows/nodes/vectors returned */
+    rowsReturned: number;
+}
+/**
+ * Join execution statistics
+ */
+export interface IJoinStats {
+    /** Join strategy used */
+    strategy: 'hash' | 'nested_loop' | 'sort_merge' | 'semantic';
+    /** Left side row count */
+    leftRows: number;
+    /** Right side row count */
+    rightRows: number;
+    /** Result row count */
+    resultRows: number;
+    /** Join execution time */
+    executionTime: number;
+}
+/**
+ * Execution plan (for debugging/optimization)
+ */
+export interface IExecutionPlan {
+    /** Plan steps */
+    steps: IExecutionStep[];
+    /** Estimated total cost */
+    estimatedCost: number;
+}
+/**
+ * Single execution step
+ */
+export interface IExecutionStep {
+    /** Step type */
+    type: 'scan' | 'filter' | 'join' | 'aggregate' | 'sort' | 'limit';
+    /** Target source (if applicable) */
+    source?: string;
+    /** Estimated rows */
+    estimatedRows: number;
+    /** Estimated cost */
+    estimatedCost: number;
+    /** Step details */
+    details?: Record<string, any>;
+}

package/dist/warehouse/types/query.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Warehouse Query Interface
+ *
+ * Unified query schema for cross-database operations across
+ * traditional databases, graphs, and vector stores.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=query.interface.js.map

package/dist/warehouse/types/query.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.interface.js","sourceRoot":"","sources":["../../../src/warehouse/types/query.interface.ts"],"names":[],"mappings":";AAAA;;;;;GAKG"}

package/dist/warehouse/types/transaction.interface.d.ts

@@ -0,0 +1,236 @@
+/**
+ * Transaction Interface
+ *
+ * Defines cross-database transaction support using the Saga pattern
+ * for distributed consistency across databases, graphs, and vector stores.
+ */
+import { IWarehouseQuery, IWarehouseResult } from './query.interface';
+/**
+ * Saga transaction for cross-database operations
+ *
+ * Uses compensating transactions to maintain consistency across
+ * multiple data sources. If any step fails, previous steps are
+ * rolled back using their compensation actions.
+ */
+export interface ISagaTransaction {
+    /**
+     * Unique transaction identifier
+     * Generated automatically if not provided
+     */
+    id?: string;
+    /**
+     * Additional operations to execute atomically
+     * These run in sequence with the main query
+     */
+    operations?: ISagaStep[];
+    /**
+     * Transaction isolation behavior
+     * @default 'best_effort'
+     */
+    isolation?: SagaIsolation;
+    /**
+     * Timeout for the entire saga in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Retry configuration for failed steps
+     */
+    retry?: IRetryConfig;
+    /**
+     * What to do on failure
+     * @default 'compensate'
+     */
+    onFailure?: 'compensate' | 'continue' | 'abort';
+}
+/**
+ * Saga isolation levels
+ */
+export type SagaIsolation = 
+/** Best effort - no guarantees across sources */
+'best_effort'
+/** Read committed equivalent - see committed data */
+ | 'read_committed'
+/** Serializable - full isolation (may use locks) */
+ | 'serializable';
+/**
+ * Single step in a saga transaction
+ */
+export interface ISagaStep {
+    /**
+     * Step identifier for tracking
+     */
+    id?: string;
+    /**
+     * Step name for logging/debugging
+     */
+    name?: string;
+    /**
+     * The operation to execute
+     */
+    operation: Omit<IWarehouseQuery, 'transaction'>;
+    /**
+     * Compensation operation to undo this step
+     * If not provided, will attempt to auto-generate
+     * (e.g., delete for insert, update with old values for update)
+     */
+    compensation?: Omit<IWarehouseQuery, 'transaction'>;
+    /**
+     * Whether this step is required
+     * If false, failure won't trigger saga rollback
+     * @default true
+     */
+    required?: boolean;
+    /**
+     * Order of execution (lower = earlier)
+     * @default 0
+     */
+    order?: number;
+    /**
+     * Dependencies on other steps (by id)
+     * This step waits for dependencies to complete
+     */
+    dependsOn?: string[];
+}
+/**
+ * Retry configuration for saga steps
+ */
+export interface IRetryConfig {
+    /**
+     * Maximum retry attempts
+     * @default 3
+     */
+    maxAttempts?: number;
+    /**
+     * Initial delay between retries in milliseconds
+     * @default 1000
+     */
+    initialDelay?: number;
+    /**
+     * Maximum delay between retries
+     * @default 10000
+     */
+    maxDelay?: number;
+    /**
+     * Backoff multiplier
+     * @default 2
+     */
+    backoffMultiplier?: number;
+    /**
+     * Retry on these error types only
+     */
+    retryOn?: ('timeout' | 'connection' | 'conflict' | 'transient')[];
+}
+/**
+ * Transaction execution state
+ */
+export interface ISagaState {
+    /** Transaction ID */
+    id: string;
+    /** Current status */
+    status: SagaStatus;
+    /** All steps with their status */
+    steps: ISagaStepState[];
+    /** When the saga started */
+    startedAt: Date;
+    /** When the saga completed (if finished) */
+    completedAt?: Date;
+    /** Error if saga failed */
+    error?: ISagaError;
+    /** Results from each step */
+    results: Map<string, IWarehouseResult>;
+}
+/**
+ * Saga status
+ */
+export type SagaStatus = 'pending' | 'executing' | 'compensating' | 'committed' | 'rolled_back' | 'failed' | 'partially_committed';
+/**
+ * Individual step state
+ */
+export interface ISagaStepState {
+    /** Step ID */
+    id: string;
+    /** Step name */
+    name?: string;
+    /** Step status */
+    status: StepStatus;
+    /** Step result (if successful) */
+    result?: IWarehouseResult;
+    /** Compensation status (if compensated) */
+    compensationStatus?: StepStatus;
+    /** Error if step failed */
+    error?: Error;
+    /** Execution time */
+    executionTime?: number;
+    /** Retry attempts made */
+    attempts: number;
+}
+/**
+ * Step execution status
+ */
+export type StepStatus = 'pending' | 'executing' | 'completed' | 'failed' | 'skipped' | 'compensated' | 'compensation_failed';
+/**
+ * Saga error with details
+ */
+export interface ISagaError {
+    /** Error message */
+    message: string;
+    /** Step that failed */
+    failedStep?: string;
+    /** Whether compensation was successful */
+    compensationSuccessful: boolean;
+    /** Steps that were rolled back */
+    rolledBackSteps: string[];
+    /** Steps that failed to roll back */
+    failedRollbackSteps: string[];
+    /** Original error */
+    cause?: Error;
+}
+/**
+ * Result of a saga transaction
+ */
+export interface ISagaResult {
+    /** Transaction ID */
+    transactionId: string;
+    /** Final status */
+    status: SagaStatus;
+    /** Results from all steps (keyed by step ID) */
+    stepResults: Record<string, IWarehouseResult>;
+    /** Total execution time */
+    executionTime: number;
+    /** Error details if failed */
+    error?: ISagaError;
+}
+/**
+ * Transaction context for passing between operations
+ */
+export interface ITransactionContext {
+    /** Transaction ID */
+    id: string;
+    /** Current saga state */
+    state: ISagaState;
+    /** Active database transactions (by source tag) */
+    activeTransactions: Map<string, any>;
+    /** Compensation queue */
+    compensationQueue: ISagaStep[];
+}
+/**
+ * Generate a unique saga ID
+ */
+export declare function generateSagaId(): string;
+/**
+ * Generate a unique step ID
+ */
+export declare function generateStepId(stepName?: string): string;
+/**
+ * Check if a saga is still in progress
+ */
+export declare function isSagaInProgress(status: SagaStatus): boolean;
+/**
+ * Check if a saga completed successfully
+ */
+export declare function isSagaSuccessful(status: SagaStatus): boolean;
+/**
+ * Auto-generate compensation for a write operation
+ */
+export declare function generateCompensation(operation: Omit<IWarehouseQuery, 'transaction'>, result?: IWarehouseResult): Omit<IWarehouseQuery, 'transaction'> | undefined;

package/dist/warehouse/types/transaction.interface.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Transaction Interface
+ *
+ * Defines cross-database transaction support using the Saga pattern
+ * for distributed consistency across databases, graphs, and vector stores.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSagaId = generateSagaId;
+exports.generateStepId = generateStepId;
+exports.isSagaInProgress = isSagaInProgress;
+exports.isSagaSuccessful = isSagaSuccessful;
+exports.generateCompensation = generateCompensation;
+// ==================== UTILITIES ====================
+/**
+ * Generate a unique saga ID
+ */
+function generateSagaId() {
+    return `saga_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Generate a unique step ID
+ */
+function generateStepId(stepName) {
+    const base = stepName ? stepName.toLowerCase().replace(/\s+/g, '_') : 'step';
+    return `${base}_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`;
+}
+/**
+ * Check if a saga is still in progress
+ */
+function isSagaInProgress(status) {
+    return status === 'pending' || status === 'executing' || status === 'compensating';
+}
+/**
+ * Check if a saga completed successfully
+ */
+function isSagaSuccessful(status) {
+    return status === 'committed';
+}
+/**
+ * Auto-generate compensation for a write operation
+ */
+function generateCompensation(operation, result) {
+    switch (operation.operation) {
+        case 'insert':
+            // Compensation for insert is delete
+            if ((result === null || result === void 0 ? void 0 : result.data) && result.data.length > 0) {
+                // Assuming inserted data has 'id' field
+                const ids = result.data.map((r) => r.id).filter(Boolean);
+                if (ids.length > 0) {
+                    return {
+                        operation: 'delete',
+                        from: operation.from,
+                        where: { id: { $in: ids } },
+                    };
+                }
+            }
+            return undefined;
+        case 'update':
+            // Compensation for update requires old values (should be captured during execution)
+            // This is a placeholder - actual implementation needs to store old values
+            return undefined;
+        case 'delete':
+            // Compensation for delete requires old values (should be captured during execution)
+            // This is a placeholder - actual implementation needs to store old values
+            return undefined;
+        case 'upsert':
+            // Complex - depends on whether it was insert or update
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=transaction.interface.js.map

package/dist/warehouse/types/transaction.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.interface.js","sourceRoot":"","sources":["../../../src/warehouse/types/transaction.interface.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAmSH,wCAEC;AAKD,wCAGC;AAKD,4CAEC;AAKD,4CAEC;AAKD,oDAqCC;AAvED,sDAAsD;AAEtD;;GAEG;AACH,SAAgB,cAAc;IAC5B,OAAO,QAAQ,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;AAC5E,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,QAAiB;IAC9C,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC7E,OAAO,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;AAC/E,CAAC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,MAAkB;IACjD,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,WAAW,IAAI,MAAM,KAAK,cAAc,CAAC;AACrF,CAAC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,MAAkB;IACjD,OAAO,MAAM,KAAK,WAAW,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CAClC,SAA+C,EAC/C,MAAyB;IAEzB,QAAQ,SAAS,CAAC,SAAS,EAAE,CAAC;QAC5B,KAAK,QAAQ;YACX,oCAAoC;YACpC,IAAI,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,KAAI,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC3C,wCAAwC;gBACxC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAC9D,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACnB,OAAO;wBACL,SAAS,EAAE,QAAQ;wBACnB,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE;qBAC5B,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,OAAO,SAAS,CAAC;QAEnB,KAAK,QAAQ;YACX,oFAAoF;YACpF,0EAA0E;YAC1E,OAAO,SAAS,CAAC;QAEnB,KAAK,QAAQ;YACX,oFAAoF;YACpF,0EAA0E;YAC1E,OAAO,SAAS,CAAC;QAEnB,KAAK,QAAQ;YACX,uDAAuD;YACvD,OAAO,SAAS,CAAC;QAEnB;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC"}