@ductape/sdk 0.0.4-v6 → 0.0.4-v60

package/dist/graph/graphs.service.js

@@ -0,0 +1,1893 @@
+"use strict";
+/**
+ * Graph Service
+ *
+ * Main service class for graph database operations.
+ * Provides a unified API for working with different graph databases
+ * (Neo4j, Neptune, ArangoDB, Memgraph).
+ *
+ * Based on Ductape Graph API documentation.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphService = void 0;
+const adapter_factory_1 = require("./adapters/adapter.factory");
+const transaction_manager_1 = require("./transactions/transaction-manager");
+const graph_error_1 = require("./utils/graph-error");
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const productsBuilder_types_1 = require("../types/productsBuilder.types");
+const cache_manager_1 = require("../cache/cache.manager");
+const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
+const crypto_1 = require("crypto");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const processor_utils_1 = require("../processor/utils/processor.utils");
+const secrets_1 = require("../secrets");
+/**
+ * Main graph database service
+ */
+class GraphService {
+    constructor(config) {
+        /** Cache of adapters by connection key */
+        this.adapters = new Map();
+        /** Connection contexts */
+        this.connectionContexts = new Map();
+        /** Currently active connection context */
+        this.currentContext = null;
+        /** Transaction manager */
+        this.transactionManager = null;
+        /** Service configuration */
+        this.config = null;
+        /** Product builders cache */
+        this.productBuilders = new Map();
+        /** Local graph configurations */
+        this.localConfigs = new Map();
+        /** LogService instance for logging operations */
+        this.logService = null;
+        /** Current product ID for logging */
+        this.productId = '';
+        /** CacheManager for two-tier caching (Redis + remote) */
+        this.cacheManager = null;
+        /** Private keys cache for products (keyed by product tag) */
+        this.privateKeys = new Map();
+        // ==================== GRAPH ACTIONS ====================
+        /** Local cache of graph actions */
+        this.actions = new Map();
+        this.adapterFactory = new adapter_factory_1.GraphAdapterFactory();
+        if (config) {
+            this.config = config;
+            this._privateKey = config.private_key || '';
+            // Initialize CacheManager if Redis client is provided
+            if (config.redis_client) {
+                this.cacheManager = new cache_manager_1.CacheManager({
+                    workspace_id: config.workspace_id,
+                    public_key: config.public_key,
+                    user_id: config.user_id,
+                    token: config.token,
+                    env_type: config.env_type,
+                    redis_client: config.redis_client,
+                });
+            }
+        }
+    }
+    // ==================== CONFIGURATION ====================
+    /**
+     * Update service configuration
+     */
+    updateConfig(config) {
+        this.config = config;
+    }
+    /**
+     * Get service configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    // ==================== PRODUCT BUILDER MANAGEMENT ====================
+    /**
+     * Create a new ProductBuilder instance
+     */
+    createNewProductBuilder() {
+        if (!this.config) {
+            throw graph_error_1.GraphError.configurationError('GraphService not configured. Please provide config when initializing.');
+        }
+        return new products_service_1.default({
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            user_id: this.config.user_id,
+            token: this.config.token,
+            env_type: this.config.env_type,
+            access_key: this.config.access_key,
+        });
+    }
+    /**
+     * Get or create a ProductBuilder instance for the given product tag
+     */
+    async getProductBuilder(productTag) {
+        let builder = this.productBuilders.get(productTag);
+        if (!builder) {
+            builder = this.createNewProductBuilder();
+            await builder.initializeProductByTag(productTag);
+            this.productBuilders.set(productTag, builder);
+            // Update productId for logging
+            this.productId = builder.fetchProductId() || '';
+            // Cache private key for caching operations
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                this.privateKeys.set(productTag, privateKey);
+            }
+        }
+        return builder;
+    }
+    /**
+     * Initialize logging service
+     */
+    initializeLogService() {
+        if (!this.logService && this.config) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+            });
+        }
+    }
+    /**
+     * Create a new ProcessorService instance for job scheduling
+     */
+    createNewProcessor() {
+        if (!this.config) {
+            throw graph_error_1.GraphError.configurationError('GraphService not configured. Please provide config when initializing.');
+        }
+        return new processor_service_1.default({
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            user_id: this.config.user_id,
+            token: this.config.token,
+            env_type: this.config.env_type,
+            private_key: this._privateKey,
+        });
+    }
+    // ==================== GRAPH REGISTRATION ====================
+    /**
+     * Register a new graph database
+     * As documented in getting-started.md
+     *
+     * @example
+     * ```ts
+     * await ductape.graph.create({
+     *   name: 'Social Graph',
+     *   tag: 'social-graph',
+     *   type: 'neo4j',
+     *   description: 'Stores user relationships',
+     *   envs: [
+     *     { slug: 'dev', connection_url: 'bolt://localhost:7687' },
+     *     { slug: 'prd', connection_url: 'bolt://neo4j-prod:7687' },
+     *   ],
+     * });
+     * ```
+     */
+    async create(graphConfig, productTag) {
+        var _a, _b, _c;
+        console.log('[GraphService.create] Starting with config:', JSON.stringify({
+            name: graphConfig.name,
+            tag: graphConfig.tag,
+            type: graphConfig.type,
+            envs: (_a = graphConfig.envs) === null || _a === void 0 ? void 0 : _a.map(e => {
+                var _a;
+                return ({
+                    slug: e.slug,
+                    connection_url: ((_a = e.connection_url) === null || _a === void 0 ? void 0 : _a.substring(0, 30)) + '...',
+                    hasUsername: !!e.username,
+                    hasPassword: !!e.password,
+                    database: e.database,
+                    graphName: e.graphName,
+                });
+            }),
+        }, null, 2));
+        // Validate required fields
+        if (!graphConfig.name || !graphConfig.tag || !graphConfig.type || !((_b = graphConfig.envs) === null || _b === void 0 ? void 0 : _b.length)) {
+            throw graph_error_1.GraphError.validationError('Graph configuration requires name, tag, type, and at least one environment');
+        }
+        const exists = await this.fetchGraphFromProduct(productTag, graphConfig.tag);
+        if (exists) {
+            return;
+        }
+        // Validate graph type
+        if (!this.adapterFactory.isSupported(graphConfig.type)) {
+            throw graph_error_1.GraphError.validationError(`Unsupported graph type: ${graphConfig.type}. ` +
+                `Supported types: ${this.adapterFactory.getSupportedTypes().join(', ')}`);
+        }
+        // Process sensitive fields - store as secrets if not already secret references
+        const processedEnvs = [];
+        console.log('[GraphService.create] Secrets service available:', !!(0, secrets_1.getSecretsService)());
+        console.log('[GraphService.create] ProductTag:', productTag);
+        for (const env of graphConfig.envs) {
+            console.log(`[GraphService.create] Processing env '${env.slug}':`, {
+                hasConnectionUrl: !!env.connection_url,
+                hasGraphName: !!env.graphName,
+                hasRegion: !!env.region,
+                hasUsername: !!env.username,
+                hasPassword: !!env.password,
+            });
+            // Store all sensitive fields as secrets
+            const connectionUrl = productTag
+                ? await this.storeAsSecretIfNeeded(env.connection_url, productTag, graphConfig.tag, env.slug, 'url', `Graph connection URL for ${graphConfig.tag} in ${env.slug}`)
+                : env.connection_url;
+            const graphName = productTag
+                ? await this.storeAsSecretIfNeeded(env.graphName, productTag, graphConfig.tag, env.slug, 'graphName', `Graph name for ${graphConfig.tag} in ${env.slug}`)
+                : env.graphName;
+            const region = productTag
+                ? await this.storeAsSecretIfNeeded(env.region, productTag, graphConfig.tag, env.slug, 'region', `AWS region for ${graphConfig.tag} in ${env.slug}`)
+                : env.region;
+            const username = productTag
+                ? await this.storeAsSecretIfNeeded(env.username, productTag, graphConfig.tag, env.slug, 'username', `Username for ${graphConfig.tag} in ${env.slug}`)
+                : env.username;
+            const password = productTag
+                ? await this.storeAsSecretIfNeeded(env.password, productTag, graphConfig.tag, env.slug, 'password', `Password for ${graphConfig.tag} in ${env.slug}`)
+                : env.password;
+            processedEnvs.push(Object.assign(Object.assign({}, env), { connection_url: connectionUrl || env.connection_url, graphName,
+                region,
+                username,
+                password }));
+            console.log(`[GraphService.create] Processed env '${env.slug}' - secrets stored`);
+        }
+        // If productTag is provided, use ProductBuilder to persist to backend
+        if (productTag) {
+            console.log('[GraphService.create] Persisting to backend with productTag:', productTag);
+            const builder = await this.getProductBuilder(productTag);
+            const productGraph = {
+                name: graphConfig.name,
+                tag: graphConfig.tag,
+                description: graphConfig.description,
+                type: graphConfig.type,
+                envs: processedEnvs.map((env) => ({
+                    slug: env.slug,
+                    connection_url: env.connection_url,
+                    description: env.description,
+                    database: env.database,
+                    graphName: env.graphName,
+                    region: env.region,
+                    username: env.username,
+                    password: env.password,
+                })),
+            };
+            await builder.createGraph(productGraph);
+        }
+        // Store locally with processed envs
+        const processedConfig = Object.assign(Object.assign({}, graphConfig), { envs: processedEnvs });
+        this.localConfigs.set(graphConfig.tag, processedConfig);
+        console.log('[GraphService.create] Stored in localConfigs');
+        // Create adapters for each environment
+        for (const envConfig of processedEnvs) {
+            const contextKey = `${graphConfig.tag}:${envConfig.slug}`;
+            const adapter = this.adapterFactory.create(graphConfig.type);
+            this.adapters.set(contextKey, adapter);
+            console.log(`[GraphService.create] Creating context for ${contextKey}:`, {
+                hasUsername: !!envConfig.username,
+                hasPassword: !!envConfig.password,
+                connectionUrl: ((_c = envConfig.connection_url) === null || _c === void 0 ? void 0 : _c.substring(0, 30)) + '...',
+            });
+            // Store connection context (not connected yet)
+            this.connectionContexts.set(contextKey, {
+                graph: graphConfig.tag,
+                env: envConfig.slug,
+                type: graphConfig.type,
+                connectionUrl: envConfig.connection_url,
+                connected: false,
+                name: graphConfig.name,
+                description: graphConfig.description,
+                database: envConfig.database,
+                graphName: envConfig.graphName,
+                username: envConfig.username,
+                password: envConfig.password,
+            });
+        }
+        console.log('[GraphService.create] Completed successfully');
+    }
+    /**
+     * Generate a secret key for graph configuration field
+     * Format: GRAPH_{PRODUCT}_{ASSET_TAG}_{ENV}_{KEY}
+     *
+     * Where:
+     * - PRODUCT = productTag.split('.')[1] (second part after workspace)
+     * - ASSET_TAG = if graphTag starts with same workspace prefix, use second part; otherwise sanitize full tag
+     * - All parts are automatically capitalized
+     */
+    generateGraphSecretKey(productTag, graphTag, envSlug, field) {
+        const sanitize = (str) => str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        // Support both ':' and '.' delimiters for product tags (e.g., 'ductape:rematch' or 'ductape.rematch')
+        const productParts = productTag.includes(':') ? productTag.split(':') : productTag.split('.');
+        const product = productParts[1] || productParts[0]; // Use product name (index 1), fallback to index 0
+        const workspace = productParts[0];
+        // Support both ':' and '.' delimiters for graph tags
+        const graphParts = graphTag.includes(':') ? graphTag.split(':') : graphTag.split('.');
+        let assetTag;
+        if (graphParts.length > 1 && graphParts[0] === workspace) {
+            // Same workspace prefix, use second part
+            assetTag = graphParts[1];
+        }
+        else {
+            // Different or no prefix, use full tag
+            assetTag = graphTag;
+        }
+        return `GRAPH_${sanitize(product)}_${sanitize(assetTag)}_${sanitize(envSlug)}_${sanitize(field)}`;
+    }
+    /**
+     * Store a value as a secret if it exists and is not already a secret reference
+     * @returns The secret reference if stored, or the original value
+     */
+    async storeAsSecretIfNeeded(value, productTag, graphTag, envSlug, fieldName, description) {
+        if (!value) {
+            return undefined;
+        }
+        const secretsService = (0, secrets_1.getSecretsService)();
+        const secretCheck = (0, secrets_1.isSecretReference)(value);
+        console.log(`[GraphService.storeAsSecretIfNeeded] Processing '${fieldName}' for env '${envSlug}':`, {
+            isSecretReference: secretCheck.isSecret,
+            hasValue: !!value,
+        });
+        // If not already a secret reference and we have a secrets service, store it as a secret
+        if (!secretCheck.isSecret && secretsService && productTag) {
+            const secretKey = this.generateGraphSecretKey(productTag, graphTag, envSlug, fieldName);
+            try {
+                const exists = await secretsService.exists(secretKey);
+                console.log(`[GraphService.storeAsSecretIfNeeded] Secret '${secretKey}' exists:`, exists);
+                if (exists) {
+                    await secretsService.update(secretKey, { value });
+                    console.log(`[GraphService.storeAsSecretIfNeeded] Updated existing secret '${secretKey}'`);
+                }
+                else {
+                    await secretsService.create({
+                        key: secretKey,
+                        value,
+                        description,
+                        scope: [productTag, graphTag],
+                        envs: [envSlug],
+                    });
+                    console.log(`[GraphService.storeAsSecretIfNeeded] Created new secret '${secretKey}'`);
+                }
+                return `$Secret{${secretKey}}`;
+            }
+            catch (error) {
+                console.warn(`[GraphService.storeAsSecretIfNeeded] Failed to store '${fieldName}' as secret: ${secretKey}`, error);
+                // Continue with the original value
+                return value;
+            }
+        }
+        return value;
+    }
+    /**
+     * Fetch all registered graphs for a product
+     */
+    async fetchAll(productTag) {
+        // Return local configs if no product tag
+        if (!productTag) {
+            return Array.from(this.localConfigs.values());
+        }
+        // Fetch from API using ProductBuilder
+        try {
+            const builder = await this.getProductBuilder(productTag);
+            const graphs = await builder.fetchGraphs();
+            // Convert IProductGraph[] to IGraphConfig[]
+            return graphs.map((graph) => this.productGraphToConfig(graph));
+        }
+        catch (error) {
+            // Fall back to local configs if API fails
+            return Array.from(this.localConfigs.values());
+        }
+    }
+    /**
+     * Fetch a specific graph configuration
+     */
+    async fetch(graphTag, productTag) {
+        // If productTag is provided, fetch from API
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                const graph = await builder.fetchGraph(graphTag);
+                if (graph) {
+                    const config = this.productGraphToConfig(graph);
+                    // Also update local cache
+                    this.localConfigs.set(graphTag, config);
+                    return config;
+                }
+                return null;
+            }
+            catch (error) {
+                // Fall back to local config
+                return this.localConfigs.get(graphTag) || null;
+            }
+        }
+        return this.localConfigs.get(graphTag) || null;
+    }
+    /**
+     * Update graph configuration
+     */
+    async update(graphTag, updates, productTag) {
+        var _a;
+        // If productTag is provided, use ProductBuilder to update in backend
+        if (productTag) {
+            const builder = await this.getProductBuilder(productTag);
+            const productGraphUpdates = {
+                name: updates.name,
+                description: updates.description,
+                type: updates.type,
+                envs: (_a = updates.envs) === null || _a === void 0 ? void 0 : _a.map((env) => ({
+                    slug: env.slug,
+                    connection_url: env.connection_url,
+                    description: env.description,
+                    database: env.database,
+                    graphName: env.graphName,
+                    region: env.region,
+                    username: env.username,
+                    password: env.password,
+                })),
+            };
+            await builder.updateGraph(graphTag, productGraphUpdates);
+        }
+        const existing = this.localConfigs.get(graphTag);
+        if (!existing && !productTag) {
+            throw graph_error_1.GraphError.notFoundError(`Graph '${graphTag}' not found`);
+        }
+        const updated = Object.assign(Object.assign(Object.assign({}, (existing || {})), updates), { tag: graphTag });
+        this.localConfigs.set(graphTag, updated);
+        // Update connection contexts
+        if (updates.envs) {
+            for (const envConfig of updates.envs) {
+                const contextKey = `${graphTag}:${envConfig.slug}`;
+                const existingContext = this.connectionContexts.get(contextKey);
+                if (existingContext) {
+                    this.connectionContexts.set(contextKey, Object.assign(Object.assign({}, existingContext), { connectionUrl: envConfig.connection_url, database: envConfig.database, graphName: envConfig.graphName, username: envConfig.username, password: envConfig.password }));
+                }
+            }
+        }
+    }
+    /**
+     * Delete a graph configuration
+     */
+    async delete(graphTag, productTag) {
+        var _a;
+        // If productTag is provided, use ProductBuilder to delete from backend
+        if (productTag) {
+            const builder = await this.getProductBuilder(productTag);
+            await builder.deleteGraph(graphTag);
+        }
+        // Get local config to clean up adapters and contexts
+        const config = this.localConfigs.get(graphTag);
+        if (config) {
+            // Clean up adapters and contexts for each environment
+            for (const envConfig of config.envs) {
+                const contextKey = `${graphTag}:${envConfig.slug}`;
+                // Disconnect adapter if connected
+                const adapter = this.adapters.get(contextKey);
+                if (adapter) {
+                    try {
+                        await adapter.disconnect();
+                    }
+                    catch (error) {
+                        // Ignore disconnect errors during cleanup
+                    }
+                    this.adapters.delete(contextKey);
+                }
+                // Remove connection context
+                this.connectionContexts.delete(contextKey);
+            }
+            // Remove from local configs
+            this.localConfigs.delete(graphTag);
+            // Clear current context if it was the deleted graph
+            if (((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.graph) === graphTag) {
+                this.currentContext = null;
+                this.transactionManager = null;
+            }
+        }
+        else if (!productTag) {
+            throw graph_error_1.GraphError.notFoundError(`Graph '${graphTag}' not found`);
+        }
+    }
+    /**
+     * Convert IProductGraph to IGraphConfig
+     */
+    productGraphToConfig(graph) {
+        return {
+            name: graph.name,
+            tag: graph.tag,
+            type: graph.type,
+            description: graph.description,
+            envs: graph.envs.map((env) => ({
+                slug: env.slug,
+                connection_url: env.connection_url,
+                description: env.description,
+                database: env.database,
+                graphName: env.graphName,
+                region: env.region,
+                username: env.username,
+                password: env.password,
+            })),
+        };
+    }
+    // ==================== CONNECTION MANAGEMENT ====================
+    /**
+     * Connect to a graph database
+     * As documented in getting-started.md
+     *
+     * @example
+     * ```ts
+     * await ductape.graph.connect({
+     *   env: 'dev',
+     *   product: 'my-app',
+     *   graph: 'social-graph',
+     * });
+     * ```
+     */
+    async connect(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const contextKey = `${config.graph}:${config.env}`;
+        console.log('[GraphService.connect] Starting connection:', {
+            graph: config.graph,
+            env: config.env,
+            product: config.product,
+            contextKey,
+        });
+        // Get adapter
+        let adapter = this.adapters.get(contextKey);
+        let context = this.connectionContexts.get(contextKey);
+        console.log('[GraphService.connect] Initial lookup:', {
+            hasAdapter: !!adapter,
+            hasContext: !!context,
+        });
+        // If not locally registered, try to fetch from API
+        if (!adapter || !context) {
+            console.log('[GraphService.connect] Not locally registered, fetching from API...');
+            // Initialize product builder to get productId for logging
+            if (config.product) {
+                await this.getProductBuilder(config.product);
+            }
+            const graphConfig = await this.fetchGraphFromProduct(config.product, config.graph);
+            console.log('[GraphService.connect] Fetched graph config:', graphConfig ? {
+                tag: graphConfig.tag,
+                type: graphConfig.type,
+                envsCount: (_a = graphConfig.envs) === null || _a === void 0 ? void 0 : _a.length,
+                envs: (_b = graphConfig.envs) === null || _b === void 0 ? void 0 : _b.map(e => ({
+                    slug: e.slug,
+                    hasUsername: !!e.username,
+                    hasPassword: !!e.password,
+                })),
+            } : null);
+            if (!graphConfig) {
+                throw graph_error_1.GraphError.notFoundError(`Graph '${config.graph}' not found in product '${config.product}'`);
+            }
+            // Register the graph locally
+            await this.create(graphConfig);
+            adapter = this.adapters.get(contextKey);
+            context = this.connectionContexts.get(contextKey);
+        }
+        if (!adapter || !context) {
+            throw graph_error_1.GraphError.configurationError(`Failed to initialize adapter for ${contextKey}`);
+        }
+        console.log('[GraphService.connect] Context loaded:', {
+            graph: context.graph,
+            env: context.env,
+            type: context.type,
+            hasUsername: !!context.username,
+            hasPassword: !!context.password,
+            connectionUrl: ((_c = context.connectionUrl) === null || _c === void 0 ? void 0 : _c.substring(0, 30)) + '...',
+        });
+        // Initialize logging
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: config.product || '',
+            workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '',
+            env: config.env,
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: config.graph,
+            data: { graph: config.graph, env: config.env },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Resolve all secret references in the context
+            const secretsService = (0, secrets_1.getSecretsService)();
+            console.log('[GraphService.connect] Secrets service available:', !!secretsService);
+            // Helper function to resolve a value if it's a secret reference
+            const resolveSecret = async (value, fieldName) => {
+                if (!value)
+                    return undefined;
+                const secretCheck = (0, secrets_1.isSecretReference)(value);
+                console.log(`[GraphService.connect] Secret check for ${fieldName}:`, {
+                    isSecret: secretCheck.isSecret,
+                    secretKey: secretCheck.isSecret ? secretCheck.key : null,
+                });
+                if (secretCheck.isSecret) {
+                    if (secretsService) {
+                        console.log(`[GraphService.connect] Resolving secret for ${fieldName}:`, secretCheck.key);
+                        const resolved = await secretsService.resolve(value, { env: config.env });
+                        console.log(`[GraphService.connect] Secret resolved successfully for ${fieldName}`);
+                        return resolved.value;
+                    }
+                    else {
+                        throw graph_error_1.GraphError.configurationError(`${fieldName} contains secret reference '${value}' but secrets service is not initialized. ` +
+                            `Please ensure the Ductape client is properly initialized.`);
+                    }
+                }
+                return value;
+            };
+            // Resolve all sensitive fields
+            const connectionUrl = await resolveSecret(context.connectionUrl, 'connectionUrl');
+            const graphName = await resolveSecret(context.graphName, 'graphName');
+            const username = await resolveSecret(context.username, 'username');
+            const password = await resolveSecret(context.password, 'password');
+            if (!connectionUrl) {
+                throw graph_error_1.GraphError.configurationError('Connection URL is required');
+            }
+            // Connect with auth credentials if provided
+            const authConfig = username && password
+                ? { username, password }
+                : undefined;
+            console.log('[GraphService.connect] Calling adapter.connect with:', {
+                hasConnectionUrl: !!connectionUrl,
+                database: context.database,
+                graphName: graphName || context.graphName,
+                hasAuth: !!authConfig,
+                authUsername: (authConfig === null || authConfig === void 0 ? void 0 : authConfig.username) ? '***' : undefined,
+            });
+            const result = await adapter.connect({
+                connectionUrl,
+                database: context.database,
+                graphName: graphName || context.graphName,
+                options: config.options,
+                auth: authConfig,
+            });
+            console.log('[GraphService.connect] Connection result:', result);
+            // Update context
+            context.connected = result.connected;
+            context.product = config.product;
+            this.connectionContexts.set(contextKey, context);
+            // Set as current context
+            this.currentContext = context;
+            // Initialize transaction manager
+            this.transactionManager = new transaction_manager_1.GraphTransactionManager(adapter);
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph connect - failed', failed_execution: true, data: { graph: config.graph, env: config.env, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            throw error;
+        }
+    }
+    /**
+     * Test connection to a graph database
+     */
+    async testConnection(config) {
+        const contextKey = `${config.graph}:${config.env}`;
+        const context = this.connectionContexts.get(contextKey);
+        if (!context) {
+            throw graph_error_1.GraphError.notFoundError(`Graph configuration not found for ${config.graph}:${config.env}`);
+        }
+        const adapter = this.adapterFactory.create(context.type);
+        return adapter.testConnection({
+            connectionUrl: context.connectionUrl,
+            database: context.database,
+            graphName: context.graphName,
+            options: config.options,
+            auth: context.username && context.password
+                ? { username: context.username, password: context.password }
+                : undefined,
+        });
+    }
+    /**
+     * Disconnect from current graph
+     */
+    async disconnect() {
+        if (this.currentContext) {
+            const contextKey = `${this.currentContext.graph}:${this.currentContext.env}`;
+            const adapter = this.adapters.get(contextKey);
+            if (adapter) {
+                // Rollback any pending transactions
+                if (this.transactionManager) {
+                    await this.transactionManager.rollbackAll();
+                }
+                await adapter.disconnect();
+                this.currentContext.connected = false;
+            }
+            this.currentContext = null;
+        }
+    }
+    /**
+     * Disconnect from all graphs
+     */
+    async closeAll() {
+        for (const [key, adapter] of this.adapters.entries()) {
+            try {
+                await adapter.disconnect();
+                const context = this.connectionContexts.get(key);
+                if (context) {
+                    context.connected = false;
+                }
+            }
+            catch (error) {
+                console.error(`Failed to disconnect ${key}:`, error);
+            }
+        }
+        if (this.transactionManager) {
+            await this.transactionManager.rollbackAll();
+        }
+        this.currentContext = null;
+    }
+    // ==================== NODE OPERATIONS ====================
+    /**
+     * Create a node
+     * As documented in nodes.md
+     */
+    async createNode(options, transaction) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) || '',
+            workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '',
+            env: ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.env) || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.graph) || '',
+            data: { labels: options.labels, operation: 'createNode' },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph createNode - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter();
+            const result = await adapter.createNode(options, transaction);
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph createNode - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph createNode - failed', failed_execution: true, data: { labels: options.labels, operation: 'createNode', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            throw error;
+        }
+    }
+    /**
+     * Find nodes by criteria
+     * As documented in nodes.md
+     */
+    async findNodes(options, transaction) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) || '',
+            workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '',
+            env: ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.env) || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.graph) || '',
+            data: { labels: options.labels, operation: 'findNodes' },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph findNodes - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check cache if cache tag is provided
+            const productTag = (_f = this.currentContext) === null || _f === void 0 ? void 0 : _f.product;
+            const privateKey = productTag ? this.privateKeys.get(productTag) : undefined;
+            if (options.cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: options.cache,
+                    product_tag: productTag || '',
+                    component_tag: ((_g = this.currentContext) === null || _g === void 0 ? void 0 : _g.graph) || '',
+                    component_type: 'graph',
+                    input: { labels: options.labels, where: options.where, select: options.select, orderBy: options.orderBy, limit: options.limit, offset: options.offset },
+                    privateKey,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: `Graph findNodes - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+                    (_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish();
+                    return cached.data;
+                }
+            }
+            const adapter = this.getAdapter();
+            const result = await adapter.findNodes(options, transaction);
+            // Store in cache if cache tag is provided
+            if (options.cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: options.cache,
+                    product_tag: productTag || '',
+                    component_tag: ((_k = this.currentContext) === null || _k === void 0 ? void 0 : _k.graph) || '',
+                    component_type: 'graph',
+                    input: { labels: options.labels, where: options.where, select: options.select, orderBy: options.orderBy, limit: options.limit, offset: options.offset },
+                    privateKey,
+                };
+                await this.cacheManager.store(cacheOptions, result);
+            }
+            (_l = this.logService) === null || _l === void 0 ? void 0 : _l.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph findNodes - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_m = this.logService) === null || _m === void 0 ? void 0 : _m.publish();
+            return result;
+        }
+        catch (error) {
+            (_o = this.logService) === null || _o === void 0 ? void 0 : _o.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph findNodes - failed', failed_execution: true, data: { labels: options.labels, operation: 'findNodes', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_p = this.logService) === null || _p === void 0 ? void 0 : _p.publish());
+            throw error;
+        }
+    }
+    /**
+     * Find a node by ID
+     * As documented in nodes.md
+     */
+    async findNodeById(id, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.findNodeById(id, transaction);
+    }
+    /**
+     * Update a node
+     * As documented in nodes.md
+     */
+    async updateNode(options, transaction) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) || '',
+            workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '',
+            env: ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.env) || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.graph) || '',
+            data: { id: options.id, operation: 'updateNode' },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph updateNode - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter();
+            const result = await adapter.updateNode(options, transaction);
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph updateNode - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph updateNode - failed', failed_execution: true, data: { id: options.id, operation: 'updateNode', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            throw error;
+        }
+    }
+    /**
+     * Delete a node
+     * As documented in nodes.md
+     */
+    async deleteNode(options, transaction) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) || '',
+            workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '',
+            env: ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.env) || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.graph) || '',
+            data: { id: options.id, operation: 'deleteNode' },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph deleteNode - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter();
+            const result = await adapter.deleteNode(options, transaction);
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph deleteNode - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph deleteNode - failed', failed_execution: true, data: { id: options.id, operation: 'deleteNode', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            throw error;
+        }
+    }
+    /**
+     * Merge (upsert) a node
+     * As documented in nodes.md
+     */
+    async mergeNode(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.mergeNode(options, transaction);
+    }
+    // ==================== LABEL MANAGEMENT ====================
+    /**
+     * Add labels to an existing node
+     *
+     * @example
+     * ```ts
+     * const result = await graphService.addLabels({
+     *   id: 'node-123',
+     *   labels: ['Admin', 'Verified'],
+     * });
+     * console.log(result.node.labels); // ['Person', 'Admin', 'Verified']
+     * ```
+     */
+    async addLabels(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.addLabels(options, transaction);
+    }
+    /**
+     * Remove labels from an existing node
+     *
+     * @example
+     * ```ts
+     * const result = await graphService.removeLabels({
+     *   id: 'node-123',
+     *   labels: ['Temporary'],
+     * });
+     * console.log(result.removedLabels); // ['Temporary']
+     * ```
+     */
+    async removeLabels(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.removeLabels(options, transaction);
+    }
+    /**
+     * Set labels on a node (replaces all existing labels)
+     *
+     * @example
+     * ```ts
+     * const result = await graphService.setLabels({
+     *   id: 'node-123',
+     *   labels: ['Person', 'Employee'],
+     * });
+     * console.log(result.previousLabels); // ['Person', 'Contractor']
+     * console.log(result.newLabels); // ['Person', 'Employee']
+     * ```
+     */
+    async setLabels(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.setLabels(options, transaction);
+    }
+    // ==================== RELATIONSHIP OPERATIONS ====================
+    /**
+     * Create a relationship
+     * As documented in relationships.md
+     */
+    async createRelationship(options, transaction) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) || '',
+            workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '',
+            env: ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.env) || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.graph) || '',
+            data: { type: options.type, operation: 'createRelationship' },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph createRelationship - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter();
+            const result = await adapter.createRelationship(options, transaction);
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph createRelationship - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph createRelationship - failed', failed_execution: true, data: { type: options.type, operation: 'createRelationship', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            throw error;
+        }
+    }
+    /**
+     * Find relationships by criteria
+     * As documented in relationships.md
+     */
+    async findRelationships(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.findRelationships(options, transaction);
+    }
+    /**
+     * Find a relationship by ID
+     */
+    async findRelationshipById(id, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.findRelationshipById(id, transaction);
+    }
+    /**
+     * Update a relationship
+     * As documented in relationships.md
+     */
+    async updateRelationship(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.updateRelationship(options, transaction);
+    }
+    /**
+     * Delete a relationship
+     * As documented in relationships.md
+     */
+    async deleteRelationship(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.deleteRelationship(options, transaction);
+    }
+    /**
+     * Merge (upsert) a relationship
+     * As documented in relationships.md
+     */
+    async mergeRelationship(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.mergeRelationship(options, transaction);
+    }
+    // ==================== TRAVERSAL OPERATIONS ====================
+    /**
+     * Traverse the graph from a starting node
+     * As documented in traversals.md
+     */
+    async traverse(options, transaction) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) || '',
+            workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '',
+            env: ((_c = this.currentContext) === null || _c === void 0 ? void 0 : _c.env) || '',
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: ((_d = this.currentContext) === null || _d === void 0 ? void 0 : _d.graph) || '',
+            data: { startNodeId: options.startNodeId, operation: 'traverse' },
+        };
+        (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph traverse - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const adapter = this.getAdapter();
+            const result = await adapter.traverse(options, transaction);
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph traverse - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph traverse - failed', failed_execution: true, data: { startNodeId: options.startNodeId, operation: 'traverse', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            throw error;
+        }
+    }
+    /**
+     * Find the shortest path between two nodes
+     * As documented in traversals.md
+     */
+    async shortestPath(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.shortestPath(options, transaction);
+    }
+    /**
+     * Find all paths between two nodes
+     * As documented in traversals.md
+     */
+    async allPaths(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.allPaths(options, transaction);
+    }
+    /**
+     * Get the neighborhood of a node
+     * As documented in traversals.md
+     */
+    async getNeighborhood(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.getNeighborhood(options, transaction);
+    }
+    /**
+     * Find connected components in the graph
+     * As documented in traversals.md
+     */
+    async findConnectedComponents(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.findConnectedComponents(options, transaction);
+    }
+    // ==================== AGGREGATION OPERATIONS ====================
+    /**
+     * Count nodes matching criteria
+     * As documented in overview.md
+     */
+    async countNodes(labels, where, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.countNodes(labels, where, transaction);
+    }
+    /**
+     * Count relationships matching criteria
+     * As documented in overview.md
+     */
+    async countRelationships(types, where, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.countRelationships(types, where, transaction);
+    }
+    /**
+     * Get graph statistics
+     * As documented in overview.md
+     */
+    async getStatistics(transaction) {
+        const adapter = this.getAdapter();
+        return adapter.getStatistics(transaction);
+    }
+    // ==================== SEARCH OPERATIONS ====================
+    /**
+     * Full-text search
+     * As documented in overview.md
+     */
+    async fullTextSearch(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.fullTextSearch(options, transaction);
+    }
+    /**
+     * Vector similarity search
+     * As documented in overview.md
+     */
+    async vectorSearch(options, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.vectorSearch(options, transaction);
+    }
+    // ==================== RAW QUERY ====================
+    /**
+     * Execute a raw query
+     * As documented in overview.md
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.graph.query(
+     *   'MATCH (p:Person)-[:FRIENDS_WITH]->(f) WHERE p.name = $name RETURN f',
+     *   { name: 'Alice' }
+     * );
+     * ```
+     */
+    async query(query, params, transaction) {
+        const adapter = this.getAdapter();
+        return adapter.query({ query, params }, transaction);
+    }
+    // ==================== SCHEMA OPERATIONS ====================
+    /**
+     * Create a node index
+     * As documented in overview.md
+     */
+    async createNodeIndex(options) {
+        const adapter = this.getAdapter();
+        return adapter.createNodeIndex(options);
+    }
+    /**
+     * Create a node constraint
+     * As documented in overview.md
+     */
+    async createNodeConstraint(options) {
+        const adapter = this.getAdapter();
+        return adapter.createNodeConstraint(options);
+    }
+    /**
+     * Create a relationship index
+     */
+    async createRelationshipIndex(options) {
+        const adapter = this.getAdapter();
+        return adapter.createRelationshipIndex(options);
+    }
+    /**
+     * List all indexes
+     * As documented in overview.md
+     */
+    async listIndexes() {
+        const adapter = this.getAdapter();
+        return adapter.listIndexes();
+    }
+    /**
+     * List all constraints
+     */
+    async listConstraints() {
+        const adapter = this.getAdapter();
+        return adapter.listConstraints();
+    }
+    /**
+     * Drop an index
+     */
+    async dropIndex(name) {
+        const adapter = this.getAdapter();
+        return adapter.dropIndex(name);
+    }
+    /**
+     * Drop a constraint
+     */
+    async dropConstraint(name) {
+        const adapter = this.getAdapter();
+        return adapter.dropConstraint(name);
+    }
+    // ==================== SCHEMA INTROSPECTION ====================
+    /**
+     * List all node labels with counts and property information
+     * Used for GraphExplorer sidebar
+     */
+    async listLabels() {
+        const adapter = this.getAdapter();
+        return adapter.listLabels();
+    }
+    /**
+     * List all relationship types with counts
+     * Used for GraphExplorer sidebar
+     */
+    async listRelationshipTypes() {
+        const adapter = this.getAdapter();
+        return adapter.listRelationshipTypes();
+    }
+    /**
+     * Generate a URL-safe tag from a name
+     */
+    generateActionTag(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    /**
+     * Create a new graph action (saved parameterized query)
+     *
+     * @example
+     * ```ts
+     * const action = await graphService.createAction({
+     *   name: 'Find Persons',
+     *   description: 'Find persons with configurable limit',
+     *   operation: 'findNodes',
+     *   query: {
+     *     operation: 'findNodes',
+     *     options: { labels: ['Person'], limit: '{{limit}}' }
+     *   },
+     *   parameters: [
+     *     { name: 'limit', path: 'options.limit', defaultValue: 25, type: 'number' }
+     *   ]
+     * }, 'my-product');
+     * ```
+     */
+    async createAction(options, productTag) {
+        var _a;
+        const graphTag = options.graphTag || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.graph);
+        if (!graphTag) {
+            throw graph_error_1.GraphError.configurationError('No graph specified. Please connect first or provide graphTag.');
+        }
+        const actionTag = this.generateActionTag(options.name);
+        const now = new Date().toISOString();
+        const action = {
+            id: `action_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+            tag: actionTag,
+            name: options.name,
+            description: options.description,
+            operation: options.operation,
+            query: options.query,
+            parameters: options.parameters,
+            createdAt: now,
+            graphTag,
+        };
+        // If productTag is provided, persist to backend using ProductBuilder
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                await builder.createGraphAction(graphTag, action);
+            }
+            catch (error) {
+                // Fall back to local storage if API fails
+                console.warn('Failed to persist action to backend, storing locally:', error);
+            }
+        }
+        // Store locally
+        const graphActions = this.actions.get(graphTag) || [];
+        graphActions.push(action);
+        this.actions.set(graphTag, graphActions);
+        return action;
+    }
+    /**
+     * List all actions for a graph
+     */
+    async listActions(graphTag, productTag) {
+        var _a;
+        const tag = graphTag || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.graph);
+        if (!tag) {
+            throw graph_error_1.GraphError.configurationError('No graph specified. Please connect first or provide graphTag.');
+        }
+        // If productTag is provided, fetch from backend using ProductBuilder
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                const actions = await builder.fetchGraphActions(tag);
+                // Update local cache
+                this.actions.set(tag, actions);
+                return { actions };
+            }
+            catch (error) {
+                // Fall back to local cache
+                console.warn('Failed to fetch actions from backend, using local cache:', error);
+            }
+        }
+        const actions = this.actions.get(tag) || [];
+        return { actions };
+    }
+    /**
+     * Get a specific action by tag
+     */
+    async getAction(actionTag, graphTag, productTag) {
+        var _a;
+        const tag = graphTag || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.graph);
+        if (!tag) {
+            throw graph_error_1.GraphError.configurationError('No graph specified. Please connect first or provide graphTag.');
+        }
+        // If productTag is provided, fetch from backend using ProductBuilder
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                const action = await builder.fetchGraphAction(tag, actionTag);
+                if (action) {
+                    // Update local cache
+                    const actions = this.actions.get(tag) || [];
+                    const existingIndex = actions.findIndex(a => a.tag === actionTag);
+                    if (existingIndex >= 0) {
+                        actions[existingIndex] = action;
+                    }
+                    else {
+                        actions.push(action);
+                    }
+                    this.actions.set(tag, actions);
+                    return action;
+                }
+            }
+            catch (error) {
+                // Fall back to local cache
+                console.warn('Failed to fetch action from backend, using local cache:', error);
+            }
+        }
+        const actions = this.actions.get(tag) || [];
+        return actions.find(a => a.tag === actionTag) || null;
+    }
+    /**
+     * Update an existing action
+     */
+    async updateAction(actionTag, updates, graphTag, productTag) {
+        var _a, _b, _c, _d, _e;
+        const tag = graphTag || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.graph);
+        if (!tag) {
+            throw graph_error_1.GraphError.configurationError('No graph specified. Please connect first or provide graphTag.');
+        }
+        const actions = this.actions.get(tag) || [];
+        const index = actions.findIndex(a => a.tag === actionTag);
+        if (index === -1) {
+            throw graph_error_1.GraphError.notFoundError(`Action '${actionTag}' not found`);
+        }
+        const existing = actions[index];
+        const updated = Object.assign(Object.assign({}, existing), { name: (_b = updates.name) !== null && _b !== void 0 ? _b : existing.name, description: (_c = updates.description) !== null && _c !== void 0 ? _c : existing.description, query: (_d = updates.query) !== null && _d !== void 0 ? _d : existing.query, parameters: (_e = updates.parameters) !== null && _e !== void 0 ? _e : existing.parameters, updatedAt: new Date().toISOString() });
+        // If productTag is provided, persist to backend using ProductBuilder
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                await builder.updateGraphAction(tag, actionTag, updated);
+            }
+            catch (error) {
+                console.warn('Failed to update action in backend:', error);
+            }
+        }
+        actions[index] = updated;
+        this.actions.set(tag, actions);
+        return updated;
+    }
+    /**
+     * Delete an action
+     */
+    async deleteAction(actionTag, graphTag, productTag) {
+        var _a;
+        const tag = graphTag || ((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.graph);
+        if (!tag) {
+            throw graph_error_1.GraphError.configurationError('No graph specified. Please connect first or provide graphTag.');
+        }
+        // If productTag is provided, delete from backend using ProductBuilder
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                await builder.deleteGraphAction(tag, actionTag);
+            }
+            catch (error) {
+                console.warn('Failed to delete action from backend:', error);
+            }
+        }
+        const actions = this.actions.get(tag) || [];
+        const filtered = actions.filter(a => a.tag !== actionTag);
+        if (filtered.length === actions.length) {
+            throw graph_error_1.GraphError.notFoundError(`Action '${actionTag}' not found`);
+        }
+        this.actions.set(tag, filtered);
+    }
+    /**
+     * Execute a graph action with parameter substitution
+     *
+     * @example
+     * ```ts
+     * const result = await graphService.execute({
+     *   product: 'my-app',
+     *   env: 'dev',
+     *   graph: 'social-graph',
+     *   action: 'find-persons',
+     *   input: { limit: 50 }
+     * });
+     * ```
+     */
+    async execute(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const startTime = Date.now();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Initialize product builder and logging
+        if (options.product) {
+            const builder = await this.getProductBuilder(options.product);
+            // Process session if provided
+            if (options.session) {
+                const privateKey = builder.fetchPrivateKey();
+                if (privateKey) {
+                    const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                    const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env);
+                    if (sessionResult.error) {
+                        throw new Error(`Session validation failed: ${sessionResult.error}`);
+                    }
+                    resolvedOptions = sessionResult.input;
+                    sessionLogFields = sessionResult.logFields;
+                }
+            }
+        }
+        this.initializeLogService();
+        const baseLogs = Object.assign({ product_tag: options.product || '', workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: options.env, process_id, type: logs_types_1.LogEventTypes.GRAPH, parent_tag: options.graph, child_tag: options.action, data: { graph: options.graph, action: options.action } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph action execute - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        // Get the action
+        const action = await this.getAction(resolvedOptions.action, resolvedOptions.graph);
+        if (!action) {
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph action execute - failed', failed_execution: true, data: { graph: options.graph, action: options.action, error: `Action '${options.action}' not found` }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish());
+            return {
+                success: false,
+                executionTime: Date.now() - startTime,
+                data: [],
+                count: 0,
+                error: `Action '${options.action}' not found`,
+            };
+        }
+        try {
+            // Build the query with parameter substitution
+            const query = this.substituteParameters(action.query, action.parameters, resolvedOptions.input || {});
+            // Execute based on operation type
+            const result = await this.executeOperation(query);
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph action execute - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            return {
+                success: true,
+                executionTime: Date.now() - startTime,
+                data: result.data,
+                count: result.data.length,
+            };
+        }
+        catch (error) {
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph action execute - failed', failed_execution: true, data: { graph: options.graph, action: options.action, error: error.message || 'Execution failed' }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_h = this.logService) === null || _h === void 0 ? void 0 : _h.publish());
+            return {
+                success: false,
+                executionTime: Date.now() - startTime,
+                data: [],
+                count: 0,
+                error: error.message || 'Execution failed',
+            };
+        }
+    }
+    // ==================== DISPATCH OPERATIONS ====================
+    /**
+     * Action dispatch operations - for predefined graph actions.
+     */
+    get action() {
+        return {
+            /**
+             * Dispatches a graph action to run as a scheduled job.
+             * @param {IGraphActionDispatchInput} data - The graph action dispatch input.
+             * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+             * @example
+             * // Schedule a graph action to run in 1 hour
+             * await ductape.graph.action.dispatch({
+             *   product: 'my-product',
+             *   env: 'production',
+             *   graph: 'social-graph',
+             *   event: 'compute-recommendations',
+             *   input: { userId: '123', limit: 10 },
+             *   schedule: { start_at: Date.now() + 3600000 }
+             * });
+             *
+             * // Run on a cron schedule
+             * await ductape.graph.action.dispatch({
+             *   product: 'my-product',
+             *   env: 'production',
+             *   graph: 'analytics-graph',
+             *   event: 'aggregate-metrics',
+             *   input: {},
+             *   schedule: { cron: '0 0 * * *' } // Daily at midnight
+             * });
+             */
+            dispatch: async (data) => {
+                const processorService = this.createNewProcessor();
+                const productBuilder = await this.getProductBuilder(data.product);
+                const schedule = data.schedule || {};
+                const startAt = typeof schedule.start_at === 'string'
+                    ? new Date(schedule.start_at).getTime()
+                    : schedule.start_at || Date.now();
+                // Generate job tag based on type, graph, and event
+                const jobTag = `graph-action:${data.graph}:${data.event}`;
+                // Check if job exists, if not create it
+                const existingJob = await productBuilder.fetchJob(jobTag);
+                if (!existingJob) {
+                    await productBuilder.createJob({
+                        tag: jobTag,
+                        name: `Graph Action: ${data.graph}/${data.event}`,
+                        description: `Auto-created job for graph action ${data.event} on graph ${data.graph}`,
+                        type: productsBuilder_types_1.JobEventTypes.GRAPH_ACTION,
+                        app: data.graph,
+                        event: data.event,
+                        executions: 0,
+                        intervals: schedule.every || 0,
+                        start_at: startAt,
+                    });
+                }
+                const jobInput = {
+                    product: data.product,
+                    env: data.env,
+                    event: jobTag,
+                    input: data.input,
+                    retries: data.retries || 0,
+                    start_at: startAt,
+                    session: data.session,
+                    cache: data.cache,
+                    repeat: schedule.cron || schedule.every ? {
+                        cron: schedule.cron,
+                        every: schedule.every,
+                        limit: schedule.limit,
+                        endDate: schedule.endDate,
+                        tz: schedule.tz,
+                    } : undefined,
+                };
+                await processorService.processJob(jobInput);
+                const isRecurring = !!(schedule.cron || schedule.every);
+                let nextRunAt;
+                if (isRecurring && schedule.every) {
+                    nextRunAt = startAt + schedule.every;
+                }
+                return {
+                    job_id: (0, crypto_1.randomUUID)(),
+                    status: startAt > Date.now() ? 'scheduled' : 'queued',
+                    scheduled_at: startAt,
+                    recurring: isRecurring,
+                    next_run_at: nextRunAt,
+                };
+            },
+        };
+    }
+    /**
+     * Dispatches a graph operation to run as a scheduled job.
+     * Use this for direct graph operations (traverse, query, createNode, deleteNodes, etc.).
+     * @param {IGraphOperationDispatchInput} data - The graph operation dispatch input.
+     * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+     * @example
+     * // Schedule a graph traversal operation
+     * await ductape.graph.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   graph: 'social-graph',
+     *   operation: 'traverse',
+     *   input: { startNode: 'user:123', direction: 'outgoing', depth: 3 },
+     *   schedule: { start_at: Date.now() + 3600000 }
+     * });
+     *
+     * // Run periodic graph cleanup
+     * await ductape.graph.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   graph: 'session-graph',
+     *   operation: 'deleteNodes',
+     *   input: { filter: { expired: true } },
+     *   schedule: { cron: '0 4 * * *' } // Daily at 4 AM
+     * });
+     */
+    async dispatch(data) {
+        var _a, _b, _c, _d, _e, _f;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const processorService = this.createNewProcessor();
+        const productBuilder = await this.getProductBuilder(data.product);
+        const schedule = data.schedule || {};
+        const startAt = typeof schedule.start_at === 'string'
+            ? new Date(schedule.start_at).getTime()
+            : schedule.start_at || Date.now();
+        // Generate job tag based on type, graph, and operation
+        const jobTag = `graph-operation:${data.graph}:${data.operation}`;
+        // Initialize logging
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: data.product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env: data.env,
+            process_id,
+            type: logs_types_1.LogEventTypes.GRAPH,
+            parent_tag: data.graph,
+            child_tag: data.operation,
+            data: { graph: data.graph, operation: data.operation },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph dispatch - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check if job exists, if not create it
+            const existingJob = await productBuilder.fetchJob(jobTag);
+            if (!existingJob) {
+                await productBuilder.createJob({
+                    tag: jobTag,
+                    name: `Graph Operation: ${data.graph}/${data.operation}`,
+                    description: `Auto-created job for graph operation ${data.operation} on graph ${data.graph}`,
+                    type: productsBuilder_types_1.JobEventTypes.GRAPH_OPERATION,
+                    app: data.graph,
+                    event: data.operation,
+                    executions: 0,
+                    intervals: schedule.every || 0,
+                    start_at: startAt,
+                });
+            }
+            const jobInput = {
+                product: data.product,
+                env: data.env,
+                event: jobTag,
+                input: data.input,
+                retries: data.retries || 0,
+                start_at: startAt,
+                session: data.session,
+                cache: data.cache,
+                repeat: schedule.cron || schedule.every ? {
+                    cron: schedule.cron,
+                    every: schedule.every,
+                    limit: schedule.limit,
+                    endDate: schedule.endDate,
+                    tz: schedule.tz,
+                } : undefined,
+            };
+            await processorService.processJob(jobInput);
+            const isRecurring = !!(schedule.cron || schedule.every);
+            let nextRunAt;
+            if (isRecurring && schedule.every) {
+                nextRunAt = startAt + schedule.every;
+            }
+            const job_id = (0, crypto_1.randomUUID)();
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph dispatch - success', successful_execution: true, data: { graph: data.graph, operation: data.operation, job_id }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return {
+                job_id,
+                status: startAt > Date.now() ? 'scheduled' : 'queued',
+                scheduled_at: startAt,
+                recurring: isRecurring,
+                next_run_at: nextRunAt,
+            };
+        }
+        catch (error) {
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Graph dispatch - failed', failed_execution: true, data: { graph: data.graph, operation: data.operation, error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
+            throw error;
+        }
+    }
+    /**
+     * Substitute parameter placeholders in a query object
+     */
+    substituteParameters(query, parameters, input) {
+        var _a;
+        // Deep clone the query
+        const result = JSON.parse(JSON.stringify(query));
+        // Substitute each parameter
+        for (const param of parameters) {
+            const value = (_a = input[param.name]) !== null && _a !== void 0 ? _a : param.defaultValue;
+            this.setNestedValue(result, param.path, value);
+        }
+        return result;
+    }
+    /**
+     * Set a nested value in an object using a dot-notation path
+     */
+    setNestedValue(obj, path, value) {
+        const keys = path.replace(/\[(\d+)\]/g, '.$1').split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            if (current[key] === undefined) {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        current[keys[keys.length - 1]] = value;
+    }
+    /**
+     * Execute an operation based on the query object
+     */
+    async executeOperation(query) {
+        const { operation, options } = query;
+        switch (operation) {
+            case 'findNodes': {
+                const result = await this.findNodes(options);
+                return { data: result.nodes };
+            }
+            case 'findRelationships': {
+                const result = await this.findRelationships(options);
+                return { data: result.relationships };
+            }
+            case 'traverse': {
+                const result = await this.traverse(options);
+                return { data: result.paths };
+            }
+            case 'shortestPath': {
+                const result = await this.shortestPath(options);
+                return { data: result.path ? [result.path] : [] };
+            }
+            case 'allPaths': {
+                const result = await this.allPaths(options);
+                return { data: result.paths };
+            }
+            case 'getNeighborhood': {
+                const result = await this.getNeighborhood(options);
+                return { data: result.nodes };
+            }
+            case 'countNodes': {
+                const result = await this.countNodes(options === null || options === void 0 ? void 0 : options.labels, options === null || options === void 0 ? void 0 : options.where);
+                return { data: [{ count: result.count }] };
+            }
+            case 'countRelationships': {
+                const result = await this.countRelationships(options === null || options === void 0 ? void 0 : options.types, options === null || options === void 0 ? void 0 : options.where);
+                return { data: [{ count: result.count }] };
+            }
+            case 'getStatistics': {
+                const result = await this.getStatistics();
+                return { data: [result] };
+            }
+            case 'executeRaw':
+            case 'query': {
+                const result = await this.query(options.query, options.params);
+                return { data: result.records };
+            }
+            default:
+                throw new Error(`Unsupported operation: ${operation}`);
+        }
+    }
+    // ==================== TRANSACTION OPERATIONS ====================
+    /**
+     * Execute operations within a transaction
+     * As documented in transactions.md
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.graph.executeTransaction(async (transaction) => {
+     *   const alice = await ductape.graph.createNode({
+     *     labels: ['Person'],
+     *     properties: { name: 'Alice' },
+     *   }, transaction);
+     *
+     *   const bob = await ductape.graph.createNode({
+     *     labels: ['Person'],
+     *     properties: { name: 'Bob' },
+     *   }, transaction);
+     *
+     *   await ductape.graph.createRelationship({
+     *     type: 'FRIENDS_WITH',
+     *     startNodeId: alice.node.id,
+     *     endNodeId: bob.node.id,
+     *   }, transaction);
+     *
+     *   return { alice, bob };
+     * });
+     * ```
+     */
+    async executeTransaction(callback, options) {
+        if (!this.transactionManager) {
+            throw graph_error_1.GraphError.configurationError('No connection established. Please connect first.');
+        }
+        return this.transactionManager.executeTransaction(callback, options);
+    }
+    /**
+     * Begin a manual transaction
+     * As documented in transactions.md
+     */
+    async beginTransaction(options) {
+        if (!this.transactionManager) {
+            throw graph_error_1.GraphError.configurationError('No connection established. Please connect first.');
+        }
+        return this.transactionManager.beginTransaction(options);
+    }
+    /**
+     * Commit a transaction
+     */
+    async commitTransaction(transaction) {
+        if (!this.transactionManager) {
+            throw graph_error_1.GraphError.configurationError('No connection established.');
+        }
+        return this.transactionManager.commitTransaction(transaction);
+    }
+    /**
+     * Rollback a transaction
+     */
+    async rollbackTransaction(transaction) {
+        if (!this.transactionManager) {
+            throw graph_error_1.GraphError.configurationError('No connection established.');
+        }
+        return this.transactionManager.rollbackTransaction(transaction);
+    }
+    // ==================== UTILITY METHODS ====================
+    /**
+     * Get the current adapter
+     */
+    getAdapter() {
+        if (!this.currentContext) {
+            throw graph_error_1.GraphError.configurationError('No connection established. Please call connect() first.');
+        }
+        const contextKey = `${this.currentContext.graph}:${this.currentContext.env}`;
+        const adapter = this.adapters.get(contextKey);
+        if (!adapter) {
+            throw graph_error_1.GraphError.configurationError(`Adapter not found for ${contextKey}`);
+        }
+        if (!this.currentContext.connected) {
+            throw graph_error_1.GraphError.connectionError('Not connected to graph database');
+        }
+        return adapter;
+    }
+    /**
+     * Fetch graph configuration from product API
+     */
+    async fetchGraphFromProduct(productTag, graphTag) {
+        try {
+            const builder = await this.getProductBuilder(productTag);
+            // Note: This would need corresponding API endpoints for graphs
+            // For now, return null to fall back to local configs
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Get current connection context
+     */
+    getCurrentContext() {
+        return this.currentContext;
+    }
+    /**
+     * Check if a feature is supported by the current adapter
+     */
+    supportsFeature(feature) {
+        try {
+            const adapter = this.getAdapter();
+            return adapter.supportsFeature(feature);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.GraphService = GraphService;
+//# sourceMappingURL=graphs.service.js.map