@ductape/sdk 0.1.8 → 0.1.10

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

@@ -0,0 +1,1073 @@
+"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 __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 __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 cloud_runtime_util_1 = require("../cloud/cloud-runtime.util");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const crypto_1 = require("crypto");
+const utils_1 = require("./utils");
+/** Shared vector services: one per workspace+product+vector+env. Not exported. */
+const sharedVectorRegistry = new Map();
+const sharedVectorInFlight = new Map();
+function getSharedVectorKey(workspaceId, product, vector, env) {
+    return `${workspaceId}:${product}:${vector}:${env}`;
+}
+/** Log debounce for vector connect/disconnect */
+const lastVectorConnectLogAt = new Map();
+const lastVectorDisconnectLogAt = new Map();
+const VECTOR_LOG_DEBOUNCE_MS = 15000;
+/**
+ * VectorDatabaseService
+ *
+ * Provides unified access to vector database management and operations.
+ */
+class VectorDatabaseService {
+    constructor(config) {
+        this.runtimeDefaults = {};
+        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;
+        this._workspacePrivateKey = config.private_key;
+        if (config.default_product || config.default_env) {
+            this.runtimeDefaults = {
+                default_product: config.default_product,
+                default_env: config.default_env,
+            };
+        }
+        // Initialize CacheManager (Redis is optional - Tier 1 internal cache and Tier 3 remote cache always work)
+        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, // Optional - Tier 2 cache
+        });
+        // 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);
+    }
+    mergeVectorConnectOptions(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const product = ((_a = options.product) === null || _a === void 0 ? void 0 : _a.trim()) ||
+            ((_b = this.runtimeDefaults.default_product) === null || _b === void 0 ? void 0 : _b.trim()) ||
+            ((_c = this.config.default_product) === null || _c === void 0 ? void 0 : _c.trim());
+        const env = ((_d = options.env) === null || _d === void 0 ? void 0 : _d.trim()) ||
+            ((_e = this.runtimeDefaults.default_env) === null || _e === void 0 ? void 0 : _e.trim()) ||
+            ((_f = this.config.default_env) === null || _f === void 0 ? void 0 : _f.trim());
+        if (!product || !env) {
+            throw new Error('product and env are required. Pass them in vector.connect() or set both on the Ductape constructor.');
+        }
+        return Object.assign(Object.assign({}, options), { product, env });
+    }
+    // ==================== 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() {
+        var _a;
+        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,
+                    workspace_private_key: (_a = this._workspacePrivateKey) !== null && _a !== void 0 ? _a : undefined,
+                });
+                // 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) {
+        var _a, _b;
+        const key = this.getVectorServiceKey(product, env, tag);
+        const workspaceId = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) !== null && _b !== void 0 ? _b : '';
+        const useShared = workspaceId !== '' && product !== '';
+        if (useShared) {
+            const sharedKey = getSharedVectorKey(workspaceId, product, tag, env);
+            const existing = sharedVectorRegistry.get(sharedKey);
+            if (existing === null || existing === void 0 ? void 0 : existing.connected) {
+                this.vectorServices.set(key, existing);
+                return existing;
+            }
+            const inFlight = sharedVectorInFlight.get(sharedKey);
+            if (inFlight) {
+                const service = await inFlight;
+                this.vectorServices.set(key, service);
+                return service;
+            }
+            const createPromise = this.createAndRegisterVectorShared(sharedKey, product, env, tag, key);
+            sharedVectorInFlight.set(sharedKey, createPromise);
+            try {
+                const service = await createPromise;
+                this.vectorServices.set(key, service);
+                return service;
+            }
+            finally {
+                sharedVectorInFlight.delete(sharedKey);
+            }
+        }
+        let service = this.vectorServices.get(key);
+        if (service === null || service === void 0 ? void 0 : service.connected)
+            return service;
+        return this.createVectorServiceAndCache(product, env, tag, key);
+    }
+    /**
+     * Disconnect any existing connection to this vector from the SDK (shared registry and this instance) before creating a fresh one.
+     */
+    async disconnectExistingForResource(sharedKey, localKey) {
+        const existingInRegistry = sharedVectorRegistry.get(sharedKey);
+        if (existingInRegistry === null || existingInRegistry === void 0 ? void 0 : existingInRegistry.connected) {
+            try {
+                await existingInRegistry.disconnect();
+            }
+            catch (_a) {
+                // Non-fatal
+            }
+            sharedVectorRegistry.delete(sharedKey);
+        }
+        const instanceService = this.vectorServices.get(localKey);
+        if (instanceService === null || instanceService === void 0 ? void 0 : instanceService.connected) {
+            try {
+                await instanceService.disconnect();
+            }
+            catch (_b) {
+                // Non-fatal
+            }
+            this.vectorServices.delete(localKey);
+            sharedVectorRegistry.delete(sharedKey);
+        }
+    }
+    async createAndRegisterVectorShared(sharedKey, product, env, tag, localKey) {
+        await this.disconnectExistingForResource(sharedKey, localKey);
+        const service = await this.createVectorServiceAndCache(product, env, tag, localKey);
+        const raceExisting = sharedVectorRegistry.get(sharedKey);
+        if (raceExisting === null || raceExisting === void 0 ? void 0 : raceExisting.connected) {
+            try {
+                await raceExisting.disconnect();
+            }
+            catch (_a) {
+                // Non-fatal
+            }
+            sharedVectorRegistry.delete(sharedKey);
+        }
+        sharedVectorRegistry.set(sharedKey, service);
+        return service;
+    }
+    async createVectorServiceAndCache(product, env, tag, key) {
+        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}'`);
+        }
+        const envConfig = vectorConfig.envs.find((e) => e.slug === env);
+        if (!envConfig) {
+            throw new Error(`Environment '${env}' not configured for vector '${tag}'`);
+        }
+        let resolvedEnvConfig = Object.assign({}, envConfig);
+        if (this.config && (envConfig.authMode === 'cloud_connection' || (0, secrets_1.mightContainSecrets)(envConfig))) {
+            resolvedEnvConfig = await (0, cloud_runtime_util_1.resolveCloudLinkedEnvConfig)(Object.assign({}, envConfig), {
+                environment: this.config.env_type,
+                auth: {
+                    token: this.config.token,
+                    public_key: this.config.public_key,
+                    user_id: this.config.user_id,
+                    workspace_id: this.config.workspace_id,
+                    access_key: this.config.access_key,
+                },
+                productTag: product,
+                componentTag: tag,
+                envSlug: env,
+            });
+        }
+        else 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.`);
+            }
+        }
+        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,
+        };
+        const 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'}`);
+        }
+        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;
+        const { product, env, vector } = this.mergeVectorConnectOptions(options);
+        const start = Date.now();
+        const process_id = (0, crypto_1.randomUUID)();
+        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' },
+        };
+        const logKey = `${product}:${vector}:${env}`;
+        const now = Date.now();
+        const last = (_b = lastVectorConnectLogAt.get(logKey)) !== null && _b !== void 0 ? _b : {};
+        if (this.logService && (!last.initiated || now - last.initiated >= VECTOR_LOG_DEBOUNCE_MS)) {
+            lastVectorConnectLogAt.set(logKey, Object.assign(Object.assign({}, last), { initiated: now }));
+            this.logService.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();
+            const lastSuccess = (_c = lastVectorConnectLogAt.get(logKey)) !== null && _c !== void 0 ? _c : {};
+            if (this.logService && (!lastSuccess.success || end - lastSuccess.success >= VECTOR_LOG_DEBOUNCE_MS)) {
+                lastVectorConnectLogAt.set(logKey, Object.assign(Object.assign({}, lastSuccess), { success: end }));
+                this.logService.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 }));
+                this.logService.publish();
+            }
+            return service;
+        }
+        catch (error) {
+            const end = Date.now();
+            const lastFail = (_d = lastVectorConnectLogAt.get(logKey)) !== null && _d !== void 0 ? _d : {};
+            if (this.logService && (!lastFail.failed || end - lastFail.failed >= VECTOR_LOG_DEBOUNCE_MS)) {
+                lastVectorConnectLogAt.set(logKey, Object.assign(Object.assign({}, lastFail), { failed: end }));
+                this.logService.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 }));
+                this.logService.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)();
+        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' },
+        };
+        const logKey = `${product}:${vector}:${env}`;
+        const now = Date.now();
+        const last = (_b = lastVectorDisconnectLogAt.get(logKey)) !== null && _b !== void 0 ? _b : {};
+        if (this.logService && (!last.initiated || now - last.initiated >= VECTOR_LOG_DEBOUNCE_MS)) {
+            lastVectorDisconnectLogAt.set(logKey, Object.assign(Object.assign({}, last), { initiated: now }));
+            this.logService.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 workspaceId = (_d = (_c = this.config) === null || _c === void 0 ? void 0 : _c.workspace_id) !== null && _d !== void 0 ? _d : '';
+            if (workspaceId && product) {
+                sharedVectorRegistry.delete(getSharedVectorKey(workspaceId, product, vector, env));
+            }
+            const end = Date.now();
+            const lastSuccess = (_e = lastVectorDisconnectLogAt.get(logKey)) !== null && _e !== void 0 ? _e : {};
+            if (this.logService && (!lastSuccess.success || end - lastSuccess.success >= VECTOR_LOG_DEBOUNCE_MS)) {
+                lastVectorDisconnectLogAt.set(logKey, Object.assign(Object.assign({}, lastSuccess), { success: end }));
+                this.logService.add(Object.assign(Object.assign({}, baseLogs), { start, end, message: 'Vector disconnect - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+                this.logService.publish();
+            }
+        }
+        catch (error) {
+            const end = Date.now();
+            const lastFail = (_f = lastVectorDisconnectLogAt.get(logKey)) !== null && _f !== void 0 ? _f : {};
+            if (this.logService && (!lastFail.failed || end - lastFail.failed >= VECTOR_LOG_DEBOUNCE_MS)) {
+                lastVectorDisconnectLogAt.set(logKey, Object.assign(Object.assign({}, lastFail), { failed: end }));
+                this.logService.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 }));
+                this.logService.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 - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: cached.key, cache_status: true }));
+                    (_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,
+                };
+                this.cacheManager.store(cacheOptions, result); // Fire-and-forget
+            }
+            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, session } = options, upsertOptions = __rest(options, ["product", "env", "tag", "session"]);
+        const process_id = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        // Ensure product builder is initialized for logging
+        const builder = await this.getProductBuilder(product);
+        this.initializeLogService();
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedUpsertOptions = upsertOptions;
+        // Process session if provided
+        if (session) {
+            const privateKey = builder.fetchPrivateKey();
+            if (privateKey) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                const sessionResult = await processSessionForExecution(session, privateKey, upsertOptions, env, {
+                    fetchSessionSelector: async (sessionTag) => {
+                        const sessionConfig = await builder.fetchSession(sessionTag);
+                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
+                    },
+                });
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedUpsertOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
+        }
+        const baseLogs = Object.assign({ 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 = resolvedUpsertOptions.vectors) === null || _b === void 0 ? void 0 : _b.length) || 0, namespace: resolvedUpsertOptions.namespace } }, sessionLogFields);
+        (_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(resolvedUpsertOptions);
+            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 - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, cache_tag: cache, cache_key: cached.key, cache_status: true }));
+                    (_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,
+                };
+                this.cacheManager.store(cacheOptions, result); // Fire-and-forget
+            }
+            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();
+    }
+    /**
+     * Return a normalized schema snapshot for a vector config, including inferred metadata schema.
+     * This allows payload/metadata generators to build accurate filters and payload fields.
+     */
+    async getSchemaSnapshot(options) {
+        const { product, env, tag, namespace, sampleSize = 100, includeNamespaces = true } = options;
+        const service = await this.getVectorService(product, env, tag);
+        const [index, stats, namespacesResult] = await Promise.all([
+            service.describeIndex(),
+            service.getStats(),
+            includeNamespaces ? service.listNamespaces() : Promise.resolve(null),
+        ]);
+        // Sample vector metadata to infer field schema.
+        const listed = await service.list({
+            namespace,
+            limit: Math.max(1, Math.min(sampleSize, 1000)),
+        });
+        const ids = listed.ids || [];
+        const fetched = ids.length
+            ? await service.fetch({ ids, namespace, includeValues: false })
+            : { vectors: {} };
+        const metadataSamples = Object.values(fetched.vectors || {})
+            .map(v => v === null || v === void 0 ? void 0 : v.metadata)
+            .filter((m) => !!m && typeof m === 'object');
+        return {
+            vectorTag: tag,
+            env,
+            index,
+            stats,
+            namespaces: namespacesResult === null || namespacesResult === void 0 ? void 0 : namespacesResult.namespaces,
+            metadataSchema: (0, utils_1.inferVectorMetadataSchema)(metadataSamples),
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * 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() {
+        var _a, _b;
+        const workspaceId = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) !== null && _b !== void 0 ? _b : '';
+        for (const [key, service] of this.vectorServices.entries()) {
+            if (service.connected)
+                await service.disconnect();
+            const [product, env, tag] = key.split(':');
+            if (workspaceId && product && tag) {
+                sharedVectorRegistry.delete(getSharedVectorKey(workspaceId, product, tag, env));
+            }
+        }
+        this.vectorServices.clear();
+    }
+}
+exports.VectorDatabaseService = VectorDatabaseService;
+exports.default = VectorDatabaseService;
+//# sourceMappingURL=vector-database.service.js.map