@ductape/sdk 0.0.4-v9 → 0.0.4-v91

package/dist/vector/vector-database.service.js

@@ -0,0 +1,850 @@
+"use strict";
+/**
+ * VectorDatabaseService - Product-level Vector Database Management
+ *
+ * This service provides a unified interface for managing vector database configurations
+ * at the product level and executing vector operations.
+ *
+ * Access via: ductape.vector
+ *
+ * @example
+ * ```typescript
+ * // Create a vector database configuration
+ * await ductape.vector.create({
+ *   product: 'my-product',
+ *   tag: 'embeddings',
+ *   name: 'Document Embeddings',
+ *   type: VectorDBType.PINECONE,
+ *   dimensions: 1536,
+ *   metric: DistanceMetric.COSINE,
+ *   envs: [
+ *     {
+ *       slug: 'prd',
+ *       apiKey: 'pk-xxx',
+ *       endpoint: 'https://my-index.svc.pinecone.io',
+ *       index: 'my-index',
+ *     },
+ *   ],
+ * });
+ *
+ * // Query vectors
+ * const results = await ductape.vector.query({
+ *   product: 'my-product',
+ *   env: 'prd',
+ *   tag: 'embeddings',
+ *   vector: [...],
+ *   topK: 10,
+ * });
+ *
+ * // Upsert vectors
+ * await ductape.vector.upsert({
+ *   product: 'my-product',
+ *   env: 'prd',
+ *   tag: 'embeddings',
+ *   vectors: [
+ *     { id: 'doc1', values: [...], metadata: { title: 'Hello' } },
+ *   ],
+ * });
+ * ```
+ */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorDatabaseService = void 0;
+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 index_1 = require("./index");
+const action_manager_1 = require("./actions/action-manager");
+const secrets_1 = require("../secrets");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const crypto_1 = require("crypto");
+/**
+ * VectorDatabaseService
+ *
+ * Provides unified access to vector database management and operations.
+ */
+class VectorDatabaseService {
+    constructor(config) {
+        this.productBuilders = new Map();
+        this.vectorServices = new Map();
+        /** CacheManager for two-tier caching (Redis + remote) */
+        this.cacheManager = null;
+        /** Private keys cache for products (keyed by product tag) */
+        this.privateKeys = new Map();
+        /** LogService instance for logging operations */
+        this.logService = null;
+        /** Current product ID for logging */
+        this.productId = '';
+        this.config = config;
+        // 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,
+            });
+        }
+        // Initialize VectorActionManager
+        this.actions = new action_manager_1.VectorActionManager({
+            getConfig: () => this.config,
+        });
+    }
+    /**
+     * Update auth configuration (called after Ductape auth)
+     */
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+    }
+    // ==================== INTERNAL HELPERS ====================
+    createProductBuilder() {
+        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,
+        });
+    }
+    async getProductBuilder(productTag) {
+        let builder = this.productBuilders.get(productTag);
+        if (!builder) {
+            builder = this.createProductBuilder();
+            await builder.initializeProductByTag(productTag);
+            this.productBuilders.set(productTag, builder);
+            // Cache private key for caching operations
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                this.privateKeys.set(productTag, privateKey);
+            }
+            // Set product ID for logging
+            this.productId = builder.fetchProductId() || '';
+            this.initializeLogService();
+        }
+        return builder;
+    }
+    /**
+     * Initialize logging service
+     * Re-creates the service if productId has changed
+     */
+    initializeLogService() {
+        if (this.config) {
+            // Always recreate if productId changed or logService doesn't exist
+            if (!this.logService || this.logService._currentProductId !== this.productId) {
+                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,
+                });
+                // Track the productId this logService was created with
+                this.logService._currentProductId = this.productId;
+            }
+        }
+    }
+    getVectorServiceKey(product, env, tag) {
+        return `${product}:${env}:${tag}`;
+    }
+    async getVectorService(product, env, tag) {
+        const key = this.getVectorServiceKey(product, env, tag);
+        let service = this.vectorServices.get(key);
+        if (service === null || service === void 0 ? void 0 : service.connected) {
+            return service;
+        }
+        // Get vector config from product
+        const builder = await this.getProductBuilder(product);
+        const vectorConfig = await builder.fetchVector(tag);
+        if (!vectorConfig) {
+            throw new Error(`Vector configuration '${tag}' not found in product '${product}'`);
+        }
+        // Find environment config
+        const envConfig = vectorConfig.envs.find((e) => e.slug === env);
+        if (!envConfig) {
+            throw new Error(`Environment '${env}' not configured for vector '${tag}'`);
+        }
+        // Resolve any secret references in the env config
+        let resolvedEnvConfig = Object.assign({}, envConfig);
+        if ((0, secrets_1.mightContainSecrets)(envConfig)) {
+            const secretsService = (0, secrets_1.getSecretsService)();
+            if (secretsService) {
+                const resolved = await secretsService.resolve(envConfig, { env });
+                resolvedEnvConfig = resolved.value;
+            }
+            else {
+                throw new Error(`Vector configuration contains secret references but secrets service is not initialized. ` +
+                    `Please ensure the Ductape client is properly initialized.`);
+            }
+        }
+        // Create VectorService with decrypted config
+        // Map VectorDistanceMetrics to DistanceMetric
+        const metricMap = {
+            [productsBuilder_types_1.VectorDistanceMetrics.COSINE]: index_1.DistanceMetric.COSINE,
+            [productsBuilder_types_1.VectorDistanceMetrics.EUCLIDEAN]: index_1.DistanceMetric.EUCLIDEAN,
+            [productsBuilder_types_1.VectorDistanceMetrics.DOT_PRODUCT]: index_1.DistanceMetric.DOT_PRODUCT,
+        };
+        const serviceOptions = {
+            type: vectorConfig.type,
+            endpoint: resolvedEnvConfig.endpoint,
+            apiKey: resolvedEnvConfig.apiKey,
+            index: resolvedEnvConfig.index || tag,
+            namespace: resolvedEnvConfig.namespace,
+            dimensions: vectorConfig.dimensions,
+            metric: vectorConfig.metric ? metricMap[vectorConfig.metric] : undefined,
+            region: resolvedEnvConfig.region,
+        };
+        service = new index_1.VectorService(serviceOptions);
+        const connectionResult = await service.connect();
+        if (!connectionResult.connected) {
+            throw new Error(`Failed to connect to vector database '${tag}' in environment '${env}': ${connectionResult.error || 'Unknown error'}`);
+        }
+        // Set logging context on the VectorService so operations are logged
+        this.initializeLogService();
+        if (this.logService && this.config) {
+            service.setLoggingContext({
+                logService: this.logService,
+                productTag: product,
+                workspaceId: this.config.workspace_id,
+                vectorTag: tag,
+                env,
+            });
+        }
+        this.vectorServices.set(key, service);
+        return service;
+    }
+    // ==================== CONNECTION ====================
+    /**
+     * Connect to a vector database
+     *
+     * @example
+     * ```typescript
+     * await ductape.vector.connect({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     * });
+     * ```
+     */
+    async connect(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const { product, env, vector } = options;
+        const start = Date.now();
+        const process_id = (0, crypto_1.randomUUID)();
+        // Ensure logging is initialized
+        await this.getProductBuilder(product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env,
+            app_env: env,
+            process_id,
+            type: logs_types_1.LogEventTypes.VECTOR,
+            parent_tag: vector,
+            child_tag: 'connect',
+            data: { vector, env, operation: 'connect' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Vector connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const service = await this.getVectorService(product, env, vector);
+            const end = Date.now();
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector connect - success', successful_execution: true, data: Object.assign(Object.assign({}, baseLogs.data), { connected: true }), status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            return service;
+        }
+        catch (error) {
+            const end = Date.now();
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector connect - failed', failed_execution: true, data: Object.assign(Object.assign({}, baseLogs.data), { error: String(error) }), status: logs_types_1.LogEventStatus.FAIL }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from a specific vector database
+     */
+    async disconnect(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const { product, env, vector } = options;
+        const start = Date.now();
+        const process_id = (0, crypto_1.randomUUID)();
+        // Ensure logging is initialized
+        await this.getProductBuilder(product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env,
+            app_env: env,
+            process_id,
+            type: logs_types_1.LogEventTypes.VECTOR,
+            parent_tag: vector,
+            child_tag: 'disconnect',
+            data: { vector, env, operation: 'disconnect' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Vector disconnect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const key = this.getVectorServiceKey(product, env, vector);
+            const service = this.vectorServices.get(key);
+            if (service === null || service === void 0 ? void 0 : service.connected) {
+                await service.disconnect();
+            }
+            this.vectorServices.delete(key);
+            const end = Date.now();
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector disconnect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+        }
+        catch (error) {
+            const end = Date.now();
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector disconnect - failed', failed_execution: true, data: Object.assign(Object.assign({}, baseLogs.data), { error: String(error) }), status: logs_types_1.LogEventStatus.FAIL }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            throw error;
+        }
+    }
+    // ==================== CRUD OPERATIONS ====================
+    /**
+     * Create a new vector database configuration
+     *
+     * @example
+     * ```typescript
+     * await ductape.vector.create({
+     *   product: 'my-product',
+     *   tag: 'embeddings',
+     *   name: 'Document Embeddings',
+     *   type: VectorDBType.PINECONE,
+     *   dimensions: 1536,
+     *   metric: DistanceMetric.COSINE,
+     *   envs: [
+     *     {
+     *       slug: 'prd',
+     *       apiKey: 'pk-xxx',
+     *       endpoint: 'https://my-index.svc.pinecone.io',
+     *       index: 'my-index',
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    async create(options) {
+        const builder = await this.getProductBuilder(options.product);
+        // Map DistanceMetric to VectorDistanceMetrics
+        const distanceMetricToVectorMetric = {
+            [index_1.DistanceMetric.COSINE]: productsBuilder_types_1.VectorDistanceMetrics.COSINE,
+            [index_1.DistanceMetric.EUCLIDEAN]: productsBuilder_types_1.VectorDistanceMetrics.EUCLIDEAN,
+            [index_1.DistanceMetric.DOT_PRODUCT]: productsBuilder_types_1.VectorDistanceMetrics.DOT_PRODUCT,
+            [index_1.DistanceMetric.MANHATTAN]: undefined,
+            [index_1.DistanceMetric.HAMMING]: undefined,
+        };
+        const vectorData = {
+            tag: options.tag,
+            name: options.name,
+            description: options.description,
+            type: options.type,
+            dimensions: options.dimensions,
+            metric: options.metric ? distanceMetricToVectorMetric[options.metric] : productsBuilder_types_1.VectorDistanceMetrics.COSINE,
+            envs: options.envs.map((env) => ({
+                slug: env.slug,
+                apiKey: env.apiKey,
+                endpoint: env.endpoint,
+                index: env.index,
+                region: env.region,
+                namespace: env.namespace,
+            })),
+        };
+        await builder.createVector(vectorData);
+    }
+    /**
+     * Update an existing vector database configuration
+     *
+     * @example
+     * ```typescript
+     * await ductape.vector.update({
+     *   product: 'my-product',
+     *   tag: 'embeddings',
+     *   name: 'Updated Embeddings',
+     *   envs: [
+     *     {
+     *       slug: 'prd',
+     *       apiKey: 'new-api-key',
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    async update(options) {
+        const builder = await this.getProductBuilder(options.product);
+        const updateData = {};
+        if (options.name)
+            updateData.name = options.name;
+        if (options.description)
+            updateData.description = options.description;
+        if (options.dimensions)
+            updateData.dimensions = options.dimensions;
+        if (options.metric) {
+            // Map DistanceMetric to VectorDistanceMetrics
+            const distanceMetricToVectorMetric = {
+                [index_1.DistanceMetric.COSINE]: productsBuilder_types_1.VectorDistanceMetrics.COSINE,
+                [index_1.DistanceMetric.EUCLIDEAN]: productsBuilder_types_1.VectorDistanceMetrics.EUCLIDEAN,
+                [index_1.DistanceMetric.DOT_PRODUCT]: productsBuilder_types_1.VectorDistanceMetrics.DOT_PRODUCT,
+                [index_1.DistanceMetric.MANHATTAN]: undefined,
+                [index_1.DistanceMetric.HAMMING]: undefined,
+            };
+            updateData.metric = distanceMetricToVectorMetric[options.metric];
+        }
+        if (options.envs) {
+            updateData.envs = options.envs.map((env) => ({
+                slug: env.slug,
+                apiKey: env.apiKey,
+                endpoint: env.endpoint,
+                index: env.index,
+                region: env.region,
+                namespace: env.namespace,
+            }));
+        }
+        //delete updateData.deleted
+        await builder.updateVector(options.tag, updateData);
+        // Clear cached services for this vector config
+        for (const key of this.vectorServices.keys()) {
+            if (key.startsWith(`${options.product}:`) && key.endsWith(`:${options.tag}`)) {
+                const service = this.vectorServices.get(key);
+                if (service) {
+                    await service.disconnect();
+                }
+                this.vectorServices.delete(key);
+            }
+        }
+    }
+    /**
+     * Fetch a vector database configuration
+     *
+     * @example
+     * ```typescript
+     * const config = await ductape.vector.fetch({
+     *   product: 'my-product',
+     *   tag: 'embeddings',
+     * });
+     * ```
+     */
+    async fetch(options) {
+        const builder = await this.getProductBuilder(options.product);
+        return builder.fetchVector(options.tag);
+    }
+    /**
+     * Fetch all vector database configurations for a product
+     *
+     * @example
+     * ```typescript
+     * const configs = await ductape.vector.fetchAll({
+     *   product: 'my-product',
+     * });
+     * ```
+     */
+    async fetchAll(options) {
+        const builder = await this.getProductBuilder(options.product);
+        return builder.fetchVectors();
+    }
+    /**
+     * Delete a vector database configuration
+     *
+     * @example
+     * ```typescript
+     * await ductape.vector.delete({
+     *   product: 'my-product',
+     *   tag: 'embeddings',
+     * });
+     * ```
+     */
+    async delete(options) {
+        const builder = await this.getProductBuilder(options.product);
+        await builder.deleteVector(options.tag);
+        // Clear cached services for this vector config
+        for (const key of this.vectorServices.keys()) {
+            if (key.startsWith(`${options.product}:`) && key.endsWith(`:${options.tag}`)) {
+                const service = this.vectorServices.get(key);
+                if (service) {
+                    await service.disconnect();
+                }
+                this.vectorServices.delete(key);
+            }
+        }
+    }
+    // ==================== VECTOR OPERATIONS ====================
+    /**
+     * Query vectors by similarity
+     *
+     * @example
+     * ```typescript
+     * const results = await ductape.vector.query({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     *   vector: embeddingVector,
+     *   topK: 10,
+     *   filter: { field: 'category', operator: '$eq', value: 'tech' },
+     * });
+     * ```
+     */
+    async query(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const { product, env, tag, cache } = options, queryOptions = __rest(options, ["product", "env", "tag", "cache"]);
+        const process_id = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        // Ensure product builder is initialized for logging
+        await this.getProductBuilder(product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env,
+            app_env: env,
+            process_id,
+            type: logs_types_1.LogEventTypes.VECTOR,
+            parent_tag: tag,
+            child_tag: 'query',
+            data: { vector: tag, env, operation: 'query', topK: queryOptions.topK, namespace: queryOptions.namespace },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Vector query - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check cache if cache tag is provided
+            const privateKey = this.privateKeys.get(product);
+            if (cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: product,
+                    component_tag: tag,
+                    component_type: 'vector',
+                    input: { vector: queryOptions.vector, topK: queryOptions.topK, filter: queryOptions.filter, namespace: queryOptions.namespace },
+                    privateKey,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    const end = Date.now();
+                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start,
+                        end, message: 'Vector query - success (cached)', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+                    return cached.data;
+                }
+            }
+            const service = await this.getVectorService(product, env, tag);
+            const result = await service.query(queryOptions);
+            // Store in cache if cache tag is provided
+            if (cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: product,
+                    component_tag: tag,
+                    component_type: 'vector',
+                    input: { vector: queryOptions.vector, topK: queryOptions.topK, filter: queryOptions.filter, namespace: queryOptions.namespace },
+                    privateKey,
+                };
+                await this.cacheManager.store(cacheOptions, result);
+            }
+            const end = Date.now();
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector query - success', successful_execution: true, data: { vector: tag, env, operation: 'query', matches: ((_f = result.matches) === null || _f === void 0 ? void 0 : _f.length) || 0 }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            const end = Date.now();
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector query - failed', failed_execution: true, data: { vector: tag, env, operation: 'query', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            (_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish();
+            throw error;
+        }
+    }
+    /**
+     * Upsert vectors (insert or update)
+     *
+     * @example
+     * ```typescript
+     * await ductape.vector.upsert({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     *   vectors: [
+     *     { id: 'doc1', values: [...], metadata: { title: 'Hello' } },
+     *     { id: 'doc2', values: [...], metadata: { title: 'World' } },
+     *   ],
+     * });
+     * ```
+     */
+    async upsert(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const { product, env, tag } = options, upsertOptions = __rest(options, ["product", "env", "tag"]);
+        const process_id = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        // Ensure product builder is initialized for logging
+        await this.getProductBuilder(product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env,
+            app_env: env,
+            process_id,
+            type: logs_types_1.LogEventTypes.VECTOR,
+            parent_tag: tag,
+            child_tag: 'upsert',
+            data: { vector: tag, env, operation: 'upsert', vectorCount: ((_b = upsertOptions.vectors) === null || _b === void 0 ? void 0 : _b.length) || 0, namespace: upsertOptions.namespace },
+        };
+        (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Vector upsert - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const service = await this.getVectorService(product, env, tag);
+            const result = await service.upsert(upsertOptions);
+            const end = Date.now();
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector upsert - success', successful_execution: true, data: { vector: tag, env, operation: 'upsert', upsertedCount: result.upsertedCount }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
+            return result;
+        }
+        catch (error) {
+            const end = Date.now();
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector upsert - failed', failed_execution: true, data: { vector: tag, env, operation: 'upsert', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            throw error;
+        }
+    }
+    /**
+     * Fetch vectors by IDs
+     *
+     * @example
+     * ```typescript
+     * const vectors = await ductape.vector.fetchVectors({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     *   ids: ['doc1', 'doc2'],
+     * });
+     * ```
+     */
+    async fetchVectors(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const { product, env, vector: tag, cache } = options, fetchOptions = __rest(options, ["product", "env", "vector", "cache"]);
+        const process_id = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        // Ensure product builder is initialized for logging
+        await this.getProductBuilder(product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env,
+            app_env: env,
+            process_id,
+            type: logs_types_1.LogEventTypes.VECTOR,
+            parent_tag: tag,
+            child_tag: 'fetch',
+            data: { vector: tag, env, operation: 'fetch', idCount: ((_b = fetchOptions.ids) === null || _b === void 0 ? void 0 : _b.length) || 0, namespace: fetchOptions.namespace },
+        };
+        (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Vector fetch - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Check cache if cache tag is provided
+            const privateKey = this.privateKeys.get(product);
+            if (cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: product,
+                    component_tag: tag,
+                    component_type: 'vector',
+                    input: { ids: fetchOptions.ids, namespace: fetchOptions.namespace },
+                    privateKey,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    const end = Date.now();
+                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
+                        end, message: 'Vector fetch - success (cached)', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+                    (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
+                    return cached.data;
+                }
+            }
+            const service = await this.getVectorService(product, env, tag);
+            const result = await service.fetch(fetchOptions);
+            // Store in cache if cache tag is provided
+            if (cache && this.cacheManager && privateKey) {
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: product,
+                    component_tag: tag,
+                    component_type: 'vector',
+                    input: { ids: fetchOptions.ids, namespace: fetchOptions.namespace },
+                    privateKey,
+                };
+                await this.cacheManager.store(cacheOptions, result);
+            }
+            const end = Date.now();
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector fetch - success', successful_execution: true, data: { vector: tag, env, operation: 'fetch', fetchedCount: Object.keys(result.vectors || {}).length }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            return result;
+        }
+        catch (error) {
+            const end = Date.now();
+            (_h = this.logService) === null || _h === void 0 ? void 0 : _h.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector fetch - failed', failed_execution: true, data: { vector: tag, env, operation: 'fetch', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            (_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish();
+            throw error;
+        }
+    }
+    /**
+     * Delete vectors
+     *
+     * @example
+     * ```typescript
+     * await ductape.vector.deleteVectors({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     *   ids: ['doc1', 'doc2'],
+     * });
+     * ```
+     */
+    async deleteVectors(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const { product, env, tag } = options, deleteOptions = __rest(options, ["product", "env", "tag"]);
+        const process_id = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        // Ensure product builder is initialized for logging
+        await this.getProductBuilder(product);
+        this.initializeLogService();
+        const baseLogs = {
+            product_tag: product,
+            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
+            env,
+            app_env: env,
+            process_id,
+            type: logs_types_1.LogEventTypes.VECTOR,
+            parent_tag: tag,
+            child_tag: 'delete',
+            data: { vector: tag, env, operation: 'delete', idCount: ((_b = deleteOptions.ids) === null || _b === void 0 ? void 0 : _b.length) || 0, deleteAll: deleteOptions.deleteAll, namespace: deleteOptions.namespace },
+        };
+        (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Vector delete - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const service = await this.getVectorService(product, env, tag);
+            const result = await service.delete(deleteOptions);
+            const end = Date.now();
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector delete - success', successful_execution: true, data: { vector: tag, env, operation: 'delete', deletedCount: result.deletedCount }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
+            return result;
+        }
+        catch (error) {
+            const end = Date.now();
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Vector delete - failed', failed_execution: true, data: { vector: tag, env, operation: 'delete', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            throw error;
+        }
+    }
+    // ==================== NAMESPACE & INDEX OPERATIONS ====================
+    /**
+     * List all namespaces/collections in the vector database
+     *
+     * @example
+     * ```typescript
+     * const result = await ductape.vector.listNamespaces({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     * });
+     * console.log(result.namespaces);
+     * ```
+     */
+    async listNamespaces(options) {
+        const { product, env, tag } = options;
+        const service = await this.getVectorService(product, env, tag);
+        return service.listNamespaces();
+    }
+    /**
+     * Get statistics about the vector index
+     *
+     * @example
+     * ```typescript
+     * const stats = await ductape.vector.getStats({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     * });
+     * console.log(stats.vectorCount, stats.dimensions);
+     * ```
+     */
+    async getStats(options) {
+        const { product, env, tag } = options;
+        const service = await this.getVectorService(product, env, tag);
+        return service.getStats();
+    }
+    /**
+     * Describe the vector index configuration
+     *
+     * @example
+     * ```typescript
+     * const info = await ductape.vector.describeIndex({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     * });
+     * console.log(info.name, info.dimensions, info.metric);
+     * ```
+     */
+    async describeIndex(options) {
+        const { product, env, tag } = options;
+        const service = await this.getVectorService(product, env, tag);
+        return service.describeIndex();
+    }
+    /**
+     * Get the raw VectorService for advanced operations
+     *
+     * @example
+     * ```typescript
+     * const service = await ductape.vector.getService({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   tag: 'embeddings',
+     * });
+     *
+     * // Use VectorService directly
+     * const stats = await service.getStats();
+     * const namespaces = await service.listNamespaces();
+     * ```
+     */
+    async getService(options) {
+        return this.getVectorService(options.product, options.env, options.tag);
+    }
+    /**
+     * Disconnect all cached vector services
+     */
+    async disconnectAll() {
+        for (const service of this.vectorServices.values()) {
+            if (service.connected) {
+                await service.disconnect();
+            }
+        }
+        this.vectorServices.clear();
+    }
+}
+exports.VectorDatabaseService = VectorDatabaseService;
+exports.default = VectorDatabaseService;
+//# sourceMappingURL=vector-database.service.js.map