@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,208 +0,0 @@
-/**
- * Unified Where Clause Interface
- *
- * A consistent filtering interface that works across databases,
- * graphs, and vector stores using MongoDB-style operators.
- */
-/**
- * Standard comparison operators (work on all data types)
- */
-export interface IComparisonCondition {
-    /** Equals */
-    $eq?: any;
-    /** Not equals */
-    $ne?: any;
-    /** Greater than */
-    $gt?: any;
-    /** Greater than or equal */
-    $gte?: any;
-    /** Less than */
-    $lt?: any;
-    /** Less than or equal */
-    $lte?: any;
-    /** In array */
-    $in?: any[];
-    /** Not in array */
-    $nin?: any[];
-    /** Between two values (inclusive) */
-    $between?: [any, any];
-    /** Is null */
-    $isNull?: boolean;
-    /** Exists (field is present) */
-    $exists?: boolean;
-}
-/**
- * String-specific operators
- */
-export interface IStringCondition extends IComparisonCondition {
-    /** SQL LIKE pattern (case-sensitive) */
-    $like?: string;
-    /** SQL ILIKE pattern (case-insensitive) */
-    $ilike?: string;
-    /** Starts with prefix */
-    $startsWith?: string;
-    /** Ends with suffix */
-    $endsWith?: string;
-    /** Contains substring */
-    $contains?: string;
-    /** Regular expression match */
-    $regex?: string | {
-        pattern: string;
-        flags?: string;
-    };
-}
-/**
- * Array-specific operators
- */
-export interface IArrayCondition extends IComparisonCondition {
-    /** Array contains value */
-    $contains?: any;
-    /** Array is contained by */
-    $containedBy?: any[];
-    /** Arrays overlap */
-    $overlaps?: any[];
-    /** Array has length */
-    $size?: number;
-    /** All elements match condition */
-    $all?: any[];
-    /** At least one element matches */
-    $elemMatch?: IUnifiedWhereClause;
-}
-/**
- * JSON/Object-specific operators
- */
-export interface IJsonCondition extends IComparisonCondition {
-    /** JSON path exists */
-    $hasKey?: string;
-    /** JSON contains */
-    $jsonContains?: Record<string, any>;
-    /** Contained by JSON */
-    $jsonContainedBy?: Record<string, any>;
-}
-/**
- * Vector similarity operator (for semantic search)
- */
-export interface IVectorSimilarityCondition {
-    $similar?: {
-        /** Vector to compare against */
-        vector: number[];
-        /** Minimum similarity threshold (0-1 for cosine) */
-        threshold?: number;
-        /** Maximum number of similar items */
-        topK?: number;
-        /** Distance metric */
-        metric?: 'cosine' | 'euclidean' | 'dot_product';
-    };
-}
-/**
- * Graph connectivity operator
- */
-export interface IGraphConnectivityCondition {
-    $connected?: {
-        /**
-         * Target node specification
-         * Can be node ID or "Label:property=value"
-         */
-        to: string;
-        /** Relationship type to traverse */
-        via?: string;
-        /** Maximum traversal depth */
-        maxDepth?: number;
-        /** Direction of traversal */
-        direction?: 'outgoing' | 'incoming' | 'both';
-    };
-    /** Node has specific label */
-    $hasLabel?: string | string[];
-    /** Relationship exists */
-    $hasRelationship?: {
-        type: string;
-        direction?: 'outgoing' | 'incoming' | 'both';
-        properties?: IUnifiedWhereClause;
-    };
-}
-/**
- * Full-text search operator
- */
-export interface IFullTextCondition {
-    $text?: {
-        /** Search query */
-        search: string;
-        /** Language for stemming */
-        language?: string;
-        /** Case sensitive */
-        caseSensitive?: boolean;
-        /** Diacritic sensitive */
-        diacriticSensitive?: boolean;
-    };
-    $match?: {
-        /** Match query */
-        query: string;
-        /** Fields to search */
-        fields?: string[];
-        /** Fuzziness level */
-        fuzziness?: number | 'auto';
-    };
-}
-/**
- * All possible field conditions
- */
-export type IFieldCondition = IComparisonCondition & IStringCondition & IArrayCondition & IJsonCondition & IVectorSimilarityCondition & IGraphConnectivityCondition & IFullTextCondition;
-/**
- * Logical operators for combining conditions
- */
-export interface ILogicalOperators {
-    /** All conditions must match */
-    $and?: IUnifiedWhereClause[];
-    /** At least one condition must match */
-    $or?: IUnifiedWhereClause[];
-    /** Condition must not match */
-    $not?: IUnifiedWhereClause;
-    /** None of the conditions must match */
-    $nor?: IUnifiedWhereClause[];
-}
-/**
- * Unified where clause that works across all data source types
- *
- * @example
- * // Simple equality
- * { "u.status": { $eq: "active" } }
- *
- * @example
- * // Complex with logical operators
- * {
- *   $and: [
- *     { "u.age": { $gte: 18 } },
- *     { $or: [
- *       { "u.status": { $eq: "active" } },
- *       { "u.role": { $eq: "admin" } }
- *     ]}
- *   ]
- * }
- *
- * @example
- * // Vector similarity
- * { "embedding": { $similar: { vector: [...], threshold: 0.8 } } }
- *
- * @example
- * // Graph connectivity
- * { "node": { $connected: { to: "Category:AI", via: "BELONGS_TO" } } }
- */
-export type IUnifiedWhereClause = ILogicalOperators & {
-    [fieldPath: string]: IFieldCondition | any;
-};
-/**
- * Check if a where clause is empty
- */
-export declare function isEmptyWhereClause(where?: IUnifiedWhereClause): boolean;
-/**
- * Check if a condition uses vector operators
- */
-export declare function hasVectorOperators(where?: IUnifiedWhereClause): boolean;
-/**
- * Check if a condition uses graph operators
- */
-export declare function hasGraphOperators(where?: IUnifiedWhereClause): boolean;
-/**
- * Extract field paths from a where clause
- */
-export declare function extractFieldPaths(where?: IUnifiedWhereClause): string[];

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

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * Unified Where Clause Interface
- *
- * A consistent filtering interface that works across databases,
- * graphs, and vector stores using MongoDB-style operators.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyWhereClause = isEmptyWhereClause;
-exports.hasVectorOperators = hasVectorOperators;
-exports.hasGraphOperators = hasGraphOperators;
-exports.extractFieldPaths = extractFieldPaths;
-// ==================== WHERE CLAUSE UTILITIES ====================
-/**
- * Check if a where clause is empty
- */
-function isEmptyWhereClause(where) {
-    if (!where)
-        return true;
-    return Object.keys(where).length === 0;
-}
-/**
- * Check if a condition uses vector operators
- */
-function hasVectorOperators(where) {
-    if (!where)
-        return false;
-    for (const [, value] of Object.entries(where)) {
-        if (value && typeof value === 'object') {
-            if ('$similar' in value)
-                return true;
-        }
-    }
-    // Check nested logical operators
-    if (where.$and) {
-        return where.$and.some(hasVectorOperators);
-    }
-    if (where.$or) {
-        return where.$or.some(hasVectorOperators);
-    }
-    return false;
-}
-/**
- * Check if a condition uses graph operators
- */
-function hasGraphOperators(where) {
-    if (!where)
-        return false;
-    for (const [, value] of Object.entries(where)) {
-        if (value && typeof value === 'object') {
-            if ('$connected' in value || '$hasLabel' in value || '$hasRelationship' in value) {
-                return true;
-            }
-        }
-    }
-    // Check nested logical operators
-    if (where.$and) {
-        return where.$and.some(hasGraphOperators);
-    }
-    if (where.$or) {
-        return where.$or.some(hasGraphOperators);
-    }
-    return false;
-}
-/**
- * Extract field paths from a where clause
- */
-function extractFieldPaths(where) {
-    if (!where)
-        return [];
-    const paths = [];
-    for (const [key, value] of Object.entries(where)) {
-        // Skip logical operators
-        if (key.startsWith('$')) {
-            if (key === '$and' || key === '$or' || key === '$nor') {
-                const nested = value;
-                nested.forEach(w => paths.push(...extractFieldPaths(w)));
-            }
-            else if (key === '$not') {
-                paths.push(...extractFieldPaths(value));
-            }
-        }
-        else {
-            paths.push(key);
-        }
-    }
-    return [...new Set(paths)];
-}
-//# sourceMappingURL=where.interface.js.map

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

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

package/dist/warehouse/warehouse.service.d.ts

@@ -1,200 +0,0 @@
-/**
- * Warehouse Service
- *
- * Unified data warehouse interface for querying and writing data across
- * databases, graphs, and vector stores using a single JSON interface.
- *
- * Features:
- * - Cross-database joins (hash, nested loop, sort-merge)
- * - Semantic joins (vector similarity)
- * - Graph traversal joins
- * - Unified where clauses
- * - Distributed transactions (Saga pattern)
- * - Query parsing and validation
- */
-import { DatabaseService } from '../database/databases.service';
-import { GraphService } from '../graph/graphs.service';
-import { VectorDatabaseService } from '../vector/vector-database.service';
-import { IWarehouseQuery, IWarehouseResult, IDataSource, ISagaTransaction, ISagaResult, DataSourceType } from './types';
-import { IRegistryConfig } from './registry';
-/**
- * Warehouse service configuration
- */
-export interface IWarehouseConfig {
-    /** Registry configuration */
-    registry?: IRegistryConfig;
-    /** Default query timeout (ms) */
-    defaultTimeout?: number;
-    /** Enable query caching */
-    enableCache?: boolean;
-    /** Cache TTL (seconds) */
-    cacheTtl?: number;
-    /** Maximum join memory (bytes) */
-    maxJoinMemory?: number;
-    /** Enable parallel execution */
-    parallel?: boolean;
-    /** Embedding function for semantic joins */
-    embedFn?: (text: string) => Promise<number[]>;
-}
-/**
- * Context for warehouse operations
- */
-export interface IWarehouseContext {
-    /** Default environment */
-    env: string;
-    /** Default product */
-    product: string;
-}
-/**
- * Warehouse Service
- *
- * Main entry point for the unified data warehouse interface.
- * Orchestrates queries across databases, graphs, and vector stores.
- */
-export declare class WarehouseService {
-    private readonly databaseService;
-    private readonly graphService;
-    private readonly vectorService;
-    private readonly context;
-    private readonly config;
-    private readonly registry;
-    private readonly parser;
-    private readonly singleSourceExecutor;
-    private readonly joinExecutor;
-    private readonly semanticJoinExecutor;
-    private readonly sagaOrchestrator;
-    constructor(databaseService: DatabaseService, graphService: GraphService, vectorService: VectorDatabaseService, context: IWarehouseContext, config?: IWarehouseConfig);
-    /**
-     * Register a database data source
-     */
-    registerDatabase(tag: string, env?: string, product?: string): Promise<void>;
-    /**
-     * Register a graph data source
-     */
-    registerGraph(tag: string, env?: string, product?: string): Promise<void>;
-    /**
-     * Register a vector data source
-     */
-    registerVector(tag: string, env?: string, product?: string): Promise<void>;
-    /**
-     * Get registered data sources
-     */
-    getDataSources(type?: DataSourceType): import("./registry").IRegisteredDataSource[];
-    /**
-     * Execute a warehouse query
-     *
-     * @example
-     * // Simple database query
-     * const result = await warehouse.query({
-     *   operation: 'select',
-     *   from: { type: 'database', tag: 'users-pg', entity: 'users', alias: 'u' },
-     *   fields: ['u.id', 'u.name', 'u.email'],
-     *   where: { 'u.status': { $eq: 'active' } },
-     *   limit: 100
-     * });
-     *
-     * @example
-     * // Cross-database join
-     * const result = await warehouse.query({
-     *   operation: 'select',
-     *   from: { type: 'database', tag: 'users-pg', entity: 'users', alias: 'u' },
-     *   fields: ['u.name', 'o.total'],
-     *   join: [{
-     *     type: 'left',
-     *     source: { type: 'database', tag: 'orders-mongo', entity: 'orders', alias: 'o' },
-     *     on: { left: 'u.id', right: 'o.userId' }
-     *   }],
-     *   where: { 'u.status': { $eq: 'active' } }
-     * });
-     *
-     * @example
-     * // Semantic join (vector similarity)
-     * const result = await warehouse.query({
-     *   operation: 'select',
-     *   from: { type: 'database', tag: 'products-pg', entity: 'products', alias: 'p' },
-     *   join: [{
-     *     type: 'semantic',
-     *     source: { type: 'vector', tag: 'embeddings-pinecone', entity: 'products', alias: 's' },
-     *     semantic: { embedField: 'p.description', similarityThreshold: 0.8, topK: 5 }
-     *   }]
-     * });
-     */
-    query<T = Record<string, any>>(query: IWarehouseQuery): Promise<IWarehouseResult<T>>;
-    /**
-     * Execute a single query (for saga orchestrator)
-     */
-    private executeSingleQuery;
-    /**
-     * Select from a single source
-     */
-    select<T = Record<string, any>>(source: IDataSource, options?: {
-        fields?: string[];
-        where?: Record<string, any>;
-        orderBy?: {
-            field: string;
-            order: 'ASC' | 'DESC';
-        }[];
-        limit?: number;
-        offset?: number;
-    }): Promise<T[]>;
-    /**
-     * Insert into a source
-     */
-    insert<T = Record<string, any>>(source: IDataSource, data: Record<string, any> | Record<string, any>[], options?: {
-        returning?: boolean;
-    }): Promise<IWarehouseResult<T>>;
-    /**
-     * Update in a source
-     */
-    update<T = Record<string, any>>(source: IDataSource, data: Record<string, any>, where: Record<string, any>, options?: {
-        returning?: boolean;
-    }): Promise<IWarehouseResult<T>>;
-    /**
-     * Delete from a source
-     */
-    delete<T = Record<string, any>>(source: IDataSource, where: Record<string, any>, options?: {
-        returning?: boolean;
-    }): Promise<IWarehouseResult<T>>;
-    /**
-     * Upsert into a source
-     */
-    upsert<T = Record<string, any>>(source: IDataSource, data: Record<string, any>, options?: {
-        returning?: boolean;
-    }): Promise<IWarehouseResult<T>>;
-    /**
-     * Execute multiple operations in a saga transaction
-     */
-    transaction(operations: Omit<IWarehouseQuery, 'transaction'>[], options?: Partial<ISagaTransaction>): Promise<ISagaResult>;
-    /**
-     * Execute a single-source query
-     */
-    private executeSingleSource;
-    /**
-     * Execute a query with cross-database joins
-     */
-    private executeWithJoins;
-    /**
-     * Execute a single join operation
-     */
-    private executeJoin;
-    /**
-     * Execute a graph traversal join
-     */
-    private executeGraphJoin;
-    /**
-     * Execute query with transaction
-     */
-    private executeWithTransaction;
-    /**
-     * Merge two rows
-     */
-    private mergeRows;
-    /**
-     * Project result to requested fields
-     */
-    private projectFields;
-    /**
-     * Clean up resources
-     */
-    destroy(): void;
-}