@ductape/sdk 0.1.7 → 0.1.8

package/dist/warehouse/index.js

@@ -1,111 +0,0 @@
-"use strict";
-/**
- * Ductape Warehouse
- *
- * Unified data warehouse interface for cross-database operations
- * across traditional databases, graphs, and vector stores.
- *
- * @example
- * // Initialize warehouse
- * const warehouse = new WarehouseService(
- *   databaseService,
- *   graphService,
- *   vectorService,
- *   { env: 'production', product: 'myapp' }
- * );
- *
- * // Register data sources
- * await warehouse.registerDatabase('users-postgres');
- * await warehouse.registerGraph('social-neo4j');
- * await warehouse.registerVector('embeddings-pinecone');
- *
- * // Cross-database query
- * const result = await warehouse.query({
- *   operation: 'select',
- *   from: { type: 'database', tag: 'users-postgres', entity: 'users', alias: 'u' },
- *   fields: ['u.name', 'u.email', 'friends.name as friend_name'],
- *   join: [
- *     {
- *       type: 'left',
- *       source: { type: 'graph', tag: 'social-neo4j', entity: 'Person', alias: 'friends' },
- *       graph: { relationship: 'FRIENDS_WITH', direction: 'both' },
- *       on: { left: 'u.id', right: 'friends.userId' }
- *     }
- *   ],
- *   where: { 'u.status': { $eq: 'active' } },
- *   limit: 100
- * });
- *
- * // Semantic search with database enrichment
- * const similar = await warehouse.query({
- *   operation: 'select',
- *   from: { type: 'vector', tag: 'embeddings-pinecone', entity: 'documents', alias: 'v' },
- *   fields: ['v.id', 'v.score', 'doc.title', 'doc.content'],
- *   join: [
- *     {
- *       type: 'inner',
- *       source: { type: 'database', tag: 'docs-postgres', entity: 'documents', alias: 'doc' },
- *       on: { left: 'v.id', right: 'doc.id' }
- *     }
- *   ],
- *   where: {
- *     'v': { $similar: { vector: queryEmbedding, threshold: 0.8, topK: 10 } }
- *   }
- * });
- *
- * // Cross-database transaction
- * const txResult = await warehouse.transaction([
- *   {
- *     operation: 'insert',
- *     from: { type: 'database', tag: 'orders-postgres', entity: 'orders' },
- *     data: { userId: 'u1', total: 99.99 }
- *   },
- *   {
- *     operation: 'insert',
- *     from: { type: 'graph', tag: 'activity-neo4j', entity: 'Event' },
- *     data: { type: 'ORDER_PLACED', userId: 'u1' }
- *   },
- *   {
- *     operation: 'upsert',
- *     from: { type: 'vector', tag: 'user-behavior-pinecone', entity: 'behaviors' },
- *     data: { id: 'u1_order', vector: [...], metadata: { action: 'order' } }
- *   }
- * ]);
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SagaOrchestrator = exports.SemanticJoinExecutor = exports.JoinExecutor = exports.SingleSourceExecutor = exports.QueryValidationError = exports.QueryParser = exports.DataSourceRegistry = exports.WarehouseService = void 0;
-// Main service
-var warehouse_service_1 = require("./warehouse.service");
-Object.defineProperty(exports, "WarehouseService", { enumerable: true, get: function () { return warehouse_service_1.WarehouseService; } });
-// Types
-__exportStar(require("./types"), exports);
-// Registry
-var registry_1 = require("./registry");
-Object.defineProperty(exports, "DataSourceRegistry", { enumerable: true, get: function () { return registry_1.DataSourceRegistry; } });
-// Parser
-var parser_1 = require("./parser");
-Object.defineProperty(exports, "QueryParser", { enumerable: true, get: function () { return parser_1.QueryParser; } });
-Object.defineProperty(exports, "QueryValidationError", { enumerable: true, get: function () { return parser_1.QueryValidationError; } });
-// Executors
-var executor_1 = require("./executor");
-Object.defineProperty(exports, "SingleSourceExecutor", { enumerable: true, get: function () { return executor_1.SingleSourceExecutor; } });
-Object.defineProperty(exports, "JoinExecutor", { enumerable: true, get: function () { return executor_1.JoinExecutor; } });
-Object.defineProperty(exports, "SemanticJoinExecutor", { enumerable: true, get: function () { return executor_1.SemanticJoinExecutor; } });
-// Transactions
-var transactions_1 = require("./transactions");
-Object.defineProperty(exports, "SagaOrchestrator", { enumerable: true, get: function () { return transactions_1.SagaOrchestrator; } });
-//# sourceMappingURL=index.js.map

package/dist/warehouse/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/warehouse/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;;;;;;;;;;;;;;;;;AAEH,eAAe;AACf,yDAA4F;AAAnF,qHAAA,gBAAgB,OAAA;AAEzB,QAAQ;AACR,0CAAwB;AAExB,WAAW;AACX,uCAQoB;AAPlB,8GAAA,kBAAkB,OAAA;AASpB,SAAS;AACT,mCASkB;AARhB,qGAAA,WAAW,OAAA;AACX,8GAAA,oBAAoB,OAAA;AAStB,YAAY;AACZ,uCAUoB;AATlB,gHAAA,oBAAoB,OAAA;AAGpB,wGAAA,YAAY,OAAA;AAGZ,gHAAA,oBAAoB,OAAA;AAKtB,eAAe;AACf,+CAA0F;AAAjF,gHAAA,gBAAgB,OAAA"}

package/dist/warehouse/parser/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Parser exports
- */
-export { QueryParser, QueryValidationError, IQueryAST, IParsedDataSource, IParsedField, IParsedJoin, IParsedWhere, IParsedAggregation, } from './query-parser';

package/dist/warehouse/parser/index.js

@@ -1,10 +0,0 @@
-"use strict";
-/**
- * Parser exports
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryValidationError = exports.QueryParser = void 0;
-var query_parser_1 = require("./query-parser");
-Object.defineProperty(exports, "QueryParser", { enumerable: true, get: function () { return query_parser_1.QueryParser; } });
-Object.defineProperty(exports, "QueryValidationError", { enumerable: true, get: function () { return query_parser_1.QueryValidationError; } });
-//# sourceMappingURL=index.js.map

package/dist/warehouse/parser/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/warehouse/parser/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,+CAUwB;AATtB,2GAAA,WAAW,OAAA;AACX,oHAAA,oBAAoB,OAAA"}

package/dist/warehouse/parser/query-parser.d.ts

@@ -1,181 +0,0 @@
-/**
- * Query Parser
- *
- * Parses and validates warehouse queries, building an abstract syntax tree (AST)
- * for execution planning.
- */
-import { IWarehouseQuery, IDataSource, IJoinClause, IUnifiedWhereClause, IOrderBy } from '../types';
-import { DataSourceRegistry } from '../registry';
-/**
- * Parsed query AST
- */
-export interface IQueryAST {
-    /** Operation type */
-    operation: 'select' | 'insert' | 'update' | 'delete' | 'upsert';
-    /** Primary data source */
-    primarySource: IParsedDataSource;
-    /** Parsed field selections */
-    fields?: IParsedField[];
-    /** Parsed joins */
-    joins?: IParsedJoin[];
-    /** Parsed where clause */
-    where?: IParsedWhere;
-    /** Parsed aggregations */
-    aggregations?: IParsedAggregation[];
-    /** Group by fields */
-    groupBy?: string[];
-    /** Having clause */
-    having?: IParsedWhere;
-    /** Order by */
-    orderBy?: IOrderBy[];
-    /** Limit */
-    limit?: number;
-    /** Offset */
-    offset?: number;
-    /** Data for writes */
-    data?: Record<string, any> | Record<string, any>[];
-    /** Return results */
-    returning?: boolean | string[];
-    /** Transaction info */
-    hasTransaction: boolean;
-    /** All source aliases used in the query */
-    aliases: Map<string, IParsedDataSource>;
-    /** All field references */
-    fieldReferences: Set<string>;
-}
-/**
- * Parsed data source
- */
-export interface IParsedDataSource {
-    /** Original data source */
-    original: IDataSource;
-    /** Resolved alias (generated if not provided) */
-    alias: string;
-    /** Environment (from registry) */
-    env?: string;
-    /** Product (from registry) */
-    product?: string;
-}
-/**
- * Parsed field selection
- */
-export interface IParsedField {
-    /** Full field path (e.g., "u.name") */
-    path: string;
-    /** Source alias */
-    sourceAlias?: string;
-    /** Field name within source */
-    fieldName: string;
-    /** Output alias */
-    outputAlias?: string;
-    /** Is wildcard (*) */
-    isWildcard: boolean;
-}
-/**
- * Parsed join
- */
-export interface IParsedJoin {
-    /** Original join clause */
-    original: IJoinClause;
-    /** Parsed source */
-    source: IParsedDataSource;
-    /** Join type */
-    type: 'inner' | 'left' | 'right' | 'full' | 'cross' | 'semantic' | 'graph';
-    /** Parsed join condition fields */
-    leftFields?: string[];
-    rightFields?: string[];
-    /** Dependencies on other sources */
-    dependsOn: string[];
-}
-/**
- * Parsed where clause
- */
-export interface IParsedWhere {
-    /** Original where clause */
-    original: IUnifiedWhereClause;
-    /** Fields referenced */
-    referencedFields: string[];
-    /** Sources referenced */
-    referencedSources: string[];
-    /** Has vector operators */
-    hasVectorOps: boolean;
-    /** Has graph operators */
-    hasGraphOps: boolean;
-    /** Can be pushed down to source */
-    canPushDown: boolean;
-}
-/**
- * Parsed aggregation
- */
-export interface IParsedAggregation {
-    /** Aggregate function */
-    function: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'count_distinct';
-    /** Field to aggregate */
-    field: string;
-    /** Source alias (if field is qualified) */
-    sourceAlias?: string;
-    /** Output alias */
-    outputAlias: string;
-}
-/**
- * Query validation error
- */
-export declare class QueryValidationError extends Error {
-    readonly errors: string[];
-    readonly query?: IWarehouseQuery;
-    constructor(message: string, errors: string[], query?: IWarehouseQuery);
-}
-/**
- * Query Parser
- *
- * Validates and parses warehouse queries into an AST for execution.
- */
-export declare class QueryParser {
-    private readonly registry?;
-    private aliasCounter;
-    constructor(registry?: DataSourceRegistry);
-    /**
-     * Parse a warehouse query into an AST
-     */
-    parse(query: IWarehouseQuery): IQueryAST;
-    /**
-     * Validate a warehouse query
-     */
-    validate(query: IWarehouseQuery): string[];
-    /**
-     * Validate a data source
-     */
-    private validateDataSource;
-    /**
-     * Parse a data source
-     */
-    private parseDataSource;
-    /**
-     * Parse a join clause
-     */
-    private parseJoin;
-    /**
-     * Parse field selections
-     */
-    private parseFields;
-    /**
-     * Parse a field string
-     */
-    private parseFieldString;
-    /**
-     * Parse a field mapping
-     */
-    private parseFieldMapping;
-    /**
-     * Parse where clause
-     */
-    private parseWhere;
-    /**
-     * Parse aggregation
-     */
-    private parseAggregation;
-    /**
-     * Generate an alias for a data source
-     */
-    private generateAlias;
-}