@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/graph/graph.service.js

@@ -1,687 +0,0 @@
-"use strict";
-/**
- * Graph Service
- * Main entry point for graph database operations in Ductape SDK
- *
- * Provides a unified interface for interacting with graph databases
- * including Neo4j, AWS Neptune, ArangoDB, and Memgraph
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphService = void 0;
-exports.createGraphService = createGraphService;
-const adapters_1 = require("./adapters");
-const graph_types_1 = require("./types/graph.types");
-const connection_types_1 = require("./types/connection.types");
-const products_service_1 = __importDefault(require("../products/services/products.service"));
-const productsBuilder_types_1 = require("../types/productsBuilder.types");
-const index_types_1 = require("../types/index.types");
-const logs_service_1 = __importDefault(require("../logs/logs.service"));
-const logs_types_1 = require("../logs/logs.types");
-const uuid_1 = require("uuid");
-/**
- * Graph Service Class
- * Provides a high-level API for graph database operations
- */
-class GraphService {
-    constructor(config) {
-        this.adapters = new Map();
-        this.connectionPool = new Map();
-        this.currentConnection = null;
-        this.currentAdapter = null;
-        this.config = config;
-        this.initializeAdapters();
-    }
-    /**
-     * Initialize all supported adapters
-     */
-    initializeAdapters() {
-        this.adapters.set(graph_types_1.GraphDatabaseType.NEO4J, new adapters_1.Neo4jAdapter());
-        this.adapters.set(graph_types_1.GraphDatabaseType.NEPTUNE, new adapters_1.NeptuneAdapter());
-        this.adapters.set(graph_types_1.GraphDatabaseType.ARANGODB, new adapters_1.ArangoDBAdapter());
-        this.adapters.set(graph_types_1.GraphDatabaseType.MEMGRAPH, new adapters_1.MemgraphAdapter());
-    }
-    /**
-     * Get adapter for a specific database type
-     */
-    getAdapter(type) {
-        const adapter = this.adapters.get(type);
-        if (!adapter) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `No adapter available for database type: ${type}`);
-        }
-        return adapter;
-    }
-    /**
-     * Generate a unique connection key
-     */
-    getConnectionKey(config) {
-        const baseKey = `${config.type}-${config.env}`;
-        if (config.connectionTag) {
-            return `${baseKey}-${config.connectionTag}`;
-        }
-        return baseKey;
-    }
-    // ==================== CONNECTION MANAGEMENT ====================
-    /**
-     * Connect to a graph database
-     */
-    async connect(config) {
-        let resolvedConfig;
-        if ((0, connection_types_1.isProductGraphConfig)(config)) {
-            // Resolve product-based configuration
-            resolvedConfig = await this.resolveProductConfig(config);
-        }
-        else {
-            resolvedConfig = config;
-        }
-        const connectionKey = this.getConnectionKey(resolvedConfig);
-        // Check if connection already exists in pool
-        const pooled = this.connectionPool.get(connectionKey);
-        if (pooled && pooled.connection.isConnected()) {
-            pooled.inUse = true;
-            pooled.lastUsed = new Date();
-            this.currentConnection = pooled.connection;
-            this.currentAdapter = pooled.adapter;
-            return pooled.connection;
-        }
-        // Create new connection
-        const adapter = this.getAdapter(resolvedConfig.type);
-        const connection = await adapter.connect(resolvedConfig);
-        // Add to pool
-        this.connectionPool.set(connectionKey, {
-            connection,
-            adapter,
-            lastUsed: new Date(),
-            inUse: true,
-        });
-        this.currentConnection = connection;
-        this.currentAdapter = adapter;
-        return connection;
-    }
-    /**
-     * Disconnect from a graph database
-     */
-    async disconnect(connection) {
-        const conn = connection || this.currentConnection;
-        if (!conn) {
-            return;
-        }
-        // Find in pool and mark as not in use
-        for (const [key, pooled] of this.connectionPool.entries()) {
-            if (pooled.connection === conn) {
-                pooled.inUse = false;
-                await pooled.adapter.disconnect(conn);
-                this.connectionPool.delete(key);
-                break;
-            }
-        }
-        if (conn === this.currentConnection) {
-            this.currentConnection = null;
-            this.currentAdapter = null;
-        }
-    }
-    /**
-     * Disconnect all connections
-     */
-    async disconnectAll() {
-        for (const [key, pooled] of this.connectionPool.entries()) {
-            await pooled.adapter.disconnect(pooled.connection);
-        }
-        this.connectionPool.clear();
-        this.currentConnection = null;
-        this.currentAdapter = null;
-    }
-    /**
-     * Test a connection
-     */
-    async testConnection(config) {
-        if (config) {
-            const connection = await this.connect(config);
-            const adapter = this.currentAdapter;
-            const result = await adapter.testConnection(connection);
-            return result;
-        }
-        if (!this.currentConnection || !this.currentAdapter) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'No active connection. Call connect() first or provide a config.');
-        }
-        return this.currentAdapter.testConnection(this.currentConnection);
-    }
-    /**
-     * Get database info
-     */
-    async getDatabaseInfo() {
-        this.ensureConnection();
-        return this.currentAdapter.getDatabaseInfo(this.currentConnection);
-    }
-    /**
-     * Resolve product-based configuration
-     * In a real implementation, this would fetch config from Ductape API
-     */
-    async resolveProductConfig(config) {
-        // This would typically call the Ductape API to get the actual connection config
-        // For now, throw an error indicating this needs to be implemented
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Product-based graph configuration requires Ductape API integration. Use direct connection config instead.');
-    }
-    // ==================== TRANSACTION MANAGEMENT ====================
-    /**
-     * Begin a transaction
-     */
-    async beginTransaction(options) {
-        this.ensureConnection();
-        return this.currentAdapter.beginTransaction(this.currentConnection, options);
-    }
-    /**
-     * Commit a transaction
-     */
-    async commitTransaction(transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.commitTransaction(this.currentConnection, transaction);
-    }
-    /**
-     * Rollback a transaction
-     */
-    async rollbackTransaction(transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.rollbackTransaction(this.currentConnection, transaction);
-    }
-    /**
-     * Execute operations within a transaction
-     */
-    async executeTransaction(callback, options) {
-        this.ensureConnection();
-        return this.currentAdapter.executeTransaction(this.currentConnection, callback, options);
-    }
-    // ==================== RAW QUERY ====================
-    /**
-     * Execute a raw query
-     */
-    async query(query, params, options) {
-        this.ensureConnection();
-        return this.currentAdapter.executeRaw(this.currentConnection, Object.assign({ query, params }, options));
-    }
-    /**
-     * Execute a raw query with full options
-     */
-    async executeRaw(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.executeRaw(this.currentConnection, options, transaction);
-    }
-    // ==================== NODE OPERATIONS ====================
-    /**
-     * Create a node
-     */
-    async createNode(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.createNode(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find nodes
-     */
-    async findNodes(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.findNodes(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find a single node by ID
-     */
-    async findNodeById(id, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.findNodeById(this.currentConnection, id, transaction);
-    }
-    /**
-     * Update a node
-     */
-    async updateNode(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.updateNode(this.currentConnection, options, transaction);
-    }
-    /**
-     * Delete node(s)
-     */
-    async deleteNode(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.deleteNode(this.currentConnection, options, transaction);
-    }
-    /**
-     * Merge a node (create if not exists, update if exists)
-     */
-    async mergeNode(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.mergeNode(this.currentConnection, options, transaction);
-    }
-    // ==================== RELATIONSHIP OPERATIONS ====================
-    /**
-     * Create a relationship
-     */
-    async createRelationship(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.createRelationship(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find relationships
-     */
-    async findRelationships(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.findRelationships(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find a single relationship by ID
-     */
-    async findRelationshipById(id, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.findRelationshipById(this.currentConnection, id, transaction);
-    }
-    /**
-     * Update a relationship
-     */
-    async updateRelationship(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.updateRelationship(this.currentConnection, options, transaction);
-    }
-    /**
-     * Delete relationship(s)
-     */
-    async deleteRelationship(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.deleteRelationship(this.currentConnection, options, transaction);
-    }
-    /**
-     * Merge a relationship
-     */
-    async mergeRelationship(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.mergeRelationship(this.currentConnection, options, transaction);
-    }
-    // ==================== PATH & TRAVERSAL OPERATIONS ====================
-    /**
-     * Traverse the graph
-     */
-    async traverse(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.traverse(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find shortest path
-     */
-    async shortestPath(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.shortestPath(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find all paths between nodes
-     */
-    async allPaths(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.allPaths(this.currentConnection, options, transaction);
-    }
-    /**
-     * Match a graph pattern
-     */
-    async matchPattern(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.matchPattern(this.currentConnection, options, transaction);
-    }
-    /**
-     * Extract a subgraph
-     */
-    async extractSubgraph(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.extractSubgraph(this.currentConnection, options, transaction);
-    }
-    /**
-     * Get node neighborhood
-     */
-    async getNeighborhood(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.getNeighborhood(this.currentConnection, options, transaction);
-    }
-    /**
-     * Find connected components
-     */
-    async findConnectedComponents(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.findConnectedComponents(this.currentConnection, options, transaction);
-    }
-    // ==================== AGGREGATION OPERATIONS ====================
-    /**
-     * Count nodes
-     */
-    async countNodes(labels, where, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.countNodes(this.currentConnection, labels, where, transaction);
-    }
-    /**
-     * Count relationships
-     */
-    async countRelationships(type, where, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.countRelationships(this.currentConnection, type, where, transaction);
-    }
-    /**
-     * Get graph statistics
-     */
-    async getStatistics(transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.getStatistics(this.currentConnection, transaction);
-    }
-    // ==================== SEARCH OPERATIONS ====================
-    /**
-     * Full-text search
-     */
-    async fullTextSearch(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.fullTextSearch(this.currentConnection, options, transaction);
-    }
-    /**
-     * Vector similarity search
-     */
-    async vectorSearch(options, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.vectorSearch(this.currentConnection, options, transaction);
-    }
-    // ==================== SCHEMA OPERATIONS ====================
-    /**
-     * Create a constraint on nodes
-     */
-    async createNodeConstraint(constraint, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.createNodeConstraint(this.currentConnection, constraint, transaction);
-    }
-    /**
-     * Create a constraint on relationships
-     */
-    async createRelationshipConstraint(constraint, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.createRelationshipConstraint(this.currentConnection, constraint, transaction);
-    }
-    /**
-     * Drop a constraint
-     */
-    async dropConstraint(name, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.dropConstraint(this.currentConnection, name, transaction);
-    }
-    /**
-     * List all constraints
-     */
-    async listConstraints(transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.listConstraints(this.currentConnection, transaction);
-    }
-    /**
-     * Create an index on nodes
-     */
-    async createNodeIndex(index, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.createNodeIndex(this.currentConnection, index, transaction);
-    }
-    /**
-     * Create an index on relationships
-     */
-    async createRelationshipIndex(index, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.createRelationshipIndex(this.currentConnection, index, transaction);
-    }
-    /**
-     * Drop an index
-     */
-    async dropIndex(name, transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.dropIndex(this.currentConnection, name, transaction);
-    }
-    /**
-     * List all indexes
-     */
-    async listIndexes(transaction) {
-        this.ensureConnection();
-        return this.currentAdapter.listIndexes(this.currentConnection, transaction);
-    }
-    // ==================== EXECUTE ACTION METHODS ====================
-    /**
-     * Execute a graph action by tag
-     *
-     * @example
-     * ```typescript
-     * await ductape.graph.execute({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   graph: 'my-graph',
-     *   action: 'find-users',
-     *   input: { name: 'John' }
-     * });
-     * ```
-     */
-    async execute(options) {
-        const { product, env, graph, action: actionTag, input = {} } = options;
-        const startTime = Date.now();
-        const processId = (0, uuid_1.v4)();
-        let logService = null;
-        const productTag = product;
-        try {
-            // Create ProductBuilder instance to fetch action
-            const productBuilder = new products_service_1.default({
-                workspace_id: this.config.workspace_id,
-                user_id: this.config.user_id,
-                public_key: this.config.public_key,
-                token: this.config.token,
-                env_type: this.config.env_type || index_types_1.EnvType.PRODUCTION,
-                redis_client: this.config.redis_client,
-            });
-            // Initialize the product
-            await productBuilder.initializeProductByTag(product);
-            // Initialize LogsService for fire-and-forget logging
-            logService = new logs_service_1.default({
-                workspace_id: this.config.workspace_id,
-                user_id: this.config.user_id,
-                public_key: this.config.public_key,
-                token: this.config.token,
-                product_id: productBuilder.fetchProductId(),
-                env_type: this.config.env_type || index_types_1.EnvType.PRODUCTION,
-                app_id: null,
-            });
-            // Fetch the graph action
-            const fullActionTag = `${graph}:${actionTag}`;
-            const graphAction = await productBuilder.fetchGraphAction(fullActionTag);
-            if (!graphAction) {
-                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.QUERY_ERROR, `Graph action '${fullActionTag}' not found in product '${product}'`);
-            }
-            // Connect to the graph database using product config
-            await this.connect({
-                env,
-                product,
-                graph,
-            });
-            // Process the action template with input parameters
-            const processedQuery = this.processActionTemplate(graphAction, input);
-            // Execute based on action type
-            let result;
-            switch (graphAction.type) {
-                case productsBuilder_types_1.GraphActionTypes.FIND_NODES:
-                    result = await this.findNodes(processedQuery).then(res => res.nodes);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.FIND_NODE_BY_ID:
-                    result = await this.findNodeById(processedQuery.id).then(res => res);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.CREATE_NODE:
-                    result = await this.createNode(processedQuery).then(res => res.node);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.UPDATE_NODE:
-                    result = await this.updateNode(processedQuery).then(res => res.node);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.DELETE_NODE:
-                    result = await this.deleteNode(processedQuery).then(res => res);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.MERGE_NODE:
-                    result = await this.mergeNode(processedQuery).then(res => res.node);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.FIND_RELATIONSHIPS:
-                    result = await this.findRelationships(processedQuery).then(res => res.relationships);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.CREATE_RELATIONSHIP:
-                    result = await this.createRelationship(processedQuery).then(res => res.relationship);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.UPDATE_RELATIONSHIP:
-                    result = await this.updateRelationship(processedQuery).then(res => res.relationship);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.DELETE_RELATIONSHIP:
-                    result = await this.deleteRelationship(processedQuery).then(res => res);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.MERGE_RELATIONSHIP:
-                    result = await this.mergeRelationship(processedQuery).then(res => res.relationship);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.TRAVERSE:
-                    result = await this.traverse(processedQuery).then(res => res);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.SHORTEST_PATH:
-                    result = await this.shortestPath(processedQuery).then(res => res);
-                    break;
-                case productsBuilder_types_1.GraphActionTypes.RAW_QUERY:
-                    result = await this.query(processedQuery.query, processedQuery.params).then(res => res.data);
-                    break;
-                default:
-                    throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.QUERY_ERROR, `Unsupported action type: ${graphAction.type}`);
-            }
-            // Fire-and-forget success logging
-            if (logService) {
-                logService.add({
-                    process_id: processId,
-                    product_tag: productTag,
-                    env,
-                    type: logs_types_1.LogEventTypes.GRAPH_ACTION,
-                    action: fullActionTag,
-                    status: logs_types_1.LogEventStatus.SUCCESS,
-                    start: startTime,
-                    end: Date.now(),
-                    data: { action: actionTag, graph, actionType: graphAction.type },
-                });
-                logService.publish().catch(() => { }); // Silent fail - don't affect main request
-            }
-            return result;
-        }
-        catch (error) {
-            // Fire-and-forget failure logging
-            if (logService) {
-                logService.add({
-                    process_id: processId,
-                    product_tag: productTag,
-                    env,
-                    type: logs_types_1.LogEventTypes.GRAPH_ACTION,
-                    action: `${graph}:${actionTag}`,
-                    status: logs_types_1.LogEventStatus.FAIL,
-                    start: startTime,
-                    end: Date.now(),
-                    data: { action: actionTag, graph, error: error.message },
-                });
-                logService.publish().catch(() => { }); // Silent fail - don't affect main request
-            }
-            if (error instanceof graph_types_1.GraphError) {
-                throw error;
-            }
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.QUERY_ERROR, `Failed to execute graph action: ${error.message}`);
-        }
-    }
-    /**
-     * Process action template with input parameters
-     */
-    processActionTemplate(action, input) {
-        let template = action.template;
-        // If template is a string, parse it as JSON
-        if (typeof template === 'string') {
-            try {
-                template = JSON.parse(template);
-            }
-            catch (_a) {
-                // If it's not valid JSON, return it as a raw query
-                return { query: this.replaceTemplateParams(template, input), params: input };
-            }
-        }
-        // Deep clone to avoid mutation
-        const processed = JSON.parse(JSON.stringify(template));
-        // Replace parameters in the template
-        return this.replaceParamsInObject(processed, input);
-    }
-    /**
-     * Replace template parameters with actual values
-     */
-    replaceTemplateParams(template, params) {
-        let result = template;
-        for (const [key, value] of Object.entries(params)) {
-            const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-            result = result.replace(placeholder, typeof value === 'string' ? value : JSON.stringify(value));
-        }
-        return result;
-    }
-    /**
-     * Recursively replace parameters in an object
-     */
-    replaceParamsInObject(obj, params) {
-        if (typeof obj === 'string') {
-            // Check if it's a parameter placeholder
-            const match = obj.match(/^\{\{(\w+)\}\}$/);
-            if (match) {
-                const paramName = match[1];
-                return params[paramName] !== undefined ? params[paramName] : obj;
-            }
-            // Replace inline parameters
-            return this.replaceTemplateParams(obj, params);
-        }
-        if (Array.isArray(obj)) {
-            return obj.map(item => this.replaceParamsInObject(item, params));
-        }
-        if (obj && typeof obj === 'object') {
-            const result = {};
-            for (const [key, value] of Object.entries(obj)) {
-                result[key] = this.replaceParamsInObject(value, params);
-            }
-            return result;
-        }
-        return obj;
-    }
-    // ==================== UTILITY METHODS ====================
-    /**
-     * Get the current connection
-     */
-    getConnection() {
-        return this.currentConnection;
-    }
-    /**
-     * Get the current adapter
-     */
-    getCurrentAdapter() {
-        return this.currentAdapter;
-    }
-    /**
-     * Get supported database types
-     */
-    getSupportedDatabaseTypes() {
-        return Array.from(this.adapters.keys());
-    }
-    /**
-     * Check if a database type is supported
-     */
-    isDatabaseTypeSupported(type) {
-        return this.adapters.has(type);
-    }
-    /**
-     * Ensure there's an active connection
-     */
-    ensureConnection() {
-        if (!this.currentConnection || !this.currentAdapter) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'No active connection. Call connect() first.');
-        }
-        if (!this.currentConnection.isConnected()) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Connection is not active. Reconnect required.');
-        }
-    }
-}
-exports.GraphService = GraphService;
-/**
- * Create a new GraphService instance
- */
-function createGraphService(config) {
-    return new GraphService(config);
-}
-exports.default = GraphService;
-//# sourceMappingURL=graph.service.js.map