@ductape/sdk 0.0.4 → 0.0.5

package/dist/vector/adapters/weaviate.adapter.js

@@ -0,0 +1,661 @@
+"use strict";
+/**
+ * Weaviate Adapter
+ *
+ * Vector database adapter for Weaviate.
+ * https://weaviate.io/
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeaviateAdapter = void 0;
+const crypto_1 = require("crypto");
+const types_1 = require("../types");
+const base_adapter_1 = require("./base.adapter");
+const utils_1 = require("../utils");
+// UUID regex pattern
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Convert a string to a valid Weaviate class name.
+ * Weaviate class names must:
+ * - Start with an uppercase letter
+ * - Contain only alphanumeric characters (no hyphens, underscores, etc.)
+ * - Follow PascalCase convention
+ */
+function toWeaviateClassName(name) {
+    // Split by non-alphanumeric characters
+    const parts = name.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+    // Convert to PascalCase
+    const pascalCase = parts
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join('');
+    // Ensure it starts with a letter (prepend 'Class' if it starts with number)
+    if (/^\d/.test(pascalCase)) {
+        return 'Class' + pascalCase;
+    }
+    return pascalCase || 'DefaultClass';
+}
+/**
+ * Convert a string ID to a deterministic UUID v5-like format.
+ * If the ID is already a valid UUID, return it as-is.
+ */
+function toWeaviateId(id) {
+    // If already a valid UUID, return as-is
+    if (UUID_REGEX.test(id)) {
+        return id.toLowerCase();
+    }
+    // Create a deterministic UUID from the string using SHA-256
+    // We take the first 32 hex chars and format as UUID
+    const hash = (0, crypto_1.createHash)('sha256').update(id).digest('hex');
+    return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+}
+/**
+ * Weaviate adapter implementation
+ */
+class WeaviateAdapter extends base_adapter_1.BaseVectorAdapter {
+    constructor() {
+        super(...arguments);
+        this.type = types_1.VectorDBType.WEAVIATE;
+        this.apiKey = '';
+        this.baseUrl = '';
+        this.className = '';
+        this.timeout = 30000;
+    }
+    // ==================== CONNECTION ====================
+    async connect(options) {
+        var _a;
+        this.connectionOptions = options;
+        this.apiKey = options.apiKey || '';
+        this.baseUrl = options.endpoint.replace(/\/$/, '');
+        // Convert index name to valid Weaviate class name (PascalCase, no special chars)
+        this.className = toWeaviateClassName(options.index);
+        this.timeout = ((_a = options.options) === null || _a === void 0 ? void 0 : _a.timeout) || 30000;
+        try {
+            // First, test basic connectivity by checking server readiness
+            const canConnect = await this.testConnection();
+            if (!canConnect) {
+                this._connected = false;
+                return {
+                    connected: false,
+                    error: 'Failed to connect to Weaviate server',
+                };
+            }
+            // Try to get class info if it exists
+            try {
+                const info = await this.describeIndex();
+                this._connected = true;
+                return {
+                    connected: true,
+                    index: this.className,
+                    dimensions: info.dimensions,
+                    vectorCount: info.vectorCount,
+                };
+            }
+            catch (_b) {
+                // Class might not exist yet, but we're connected to the server
+                this._connected = true;
+                return {
+                    connected: true,
+                    index: this.className,
+                    dimensions: options.dimensions,
+                    vectorCount: 0,
+                };
+            }
+        }
+        catch (error) {
+            this._connected = false;
+            return {
+                connected: false,
+                error: error.message || 'Failed to connect to Weaviate',
+            };
+        }
+    }
+    async disconnect() {
+        this._connected = false;
+        this.connectionOptions = null;
+    }
+    async testConnection() {
+        try {
+            await this.request('GET', '/v1/.well-known/ready');
+            return true;
+        }
+        catch (error) {
+            console.error('[WeaviateAdapter] Connection test failed:', error instanceof Error ? error.message : error);
+            return false;
+        }
+    }
+    // ==================== VECTOR OPERATIONS ====================
+    async upsert(options) {
+        this.validateDimensions(options.vectors);
+        // Ensure the class (schema) exists before inserting
+        await this.ensureClassExists();
+        // Weaviate batch insert - convert IDs to UUIDs
+        const objects = options.vectors.map((v) => ({
+            class: this.className,
+            id: toWeaviateId(v.id),
+            vector: v.values,
+            properties: Object.assign(Object.assign({}, v.metadata), { 
+                // Store the original ID in properties for retrieval
+                _originalId: v.id }),
+        }));
+        await this.request('POST', '/v1/batch/objects', { objects });
+        return {
+            upsertedCount: objects.length,
+            upsertedIds: options.vectors.map((v) => v.id),
+        };
+    }
+    async query(options) {
+        var _a, _b;
+        const startTime = Date.now();
+        // Build GraphQL query
+        const nearVector = {
+            vector: options.vector,
+            certainty: options.minScore,
+        };
+        let whereFilter = '';
+        if (options.filter) {
+            whereFilter = `where: ${JSON.stringify(this.convertFilter(options.filter))}`;
+        }
+        const additionalFields = [];
+        if (options.includeValues) {
+            additionalFields.push('vector');
+        }
+        additionalFields.push('certainty', 'id');
+        const query = `
+      {
+        Get {
+          ${this.className}(
+            nearVector: ${JSON.stringify(nearVector)}
+            limit: ${options.topK}
+            ${whereFilter}
+          ) {
+            _additional {
+              ${additionalFields.join(' ')}
+            }
+            ${options.includeMetadata !== false ? '... on ' + this.className + ' { }' : ''}
+          }
+        }
+      }
+    `;
+        const response = await this.graphql(query);
+        const results = ((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.Get) === null || _b === void 0 ? void 0 : _b[this.className]) || [];
+        const matches = results.map((r) => {
+            var _a, _b, _c;
+            return ({
+                id: (_a = r._additional) === null || _a === void 0 ? void 0 : _a.id,
+                score: ((_b = r._additional) === null || _b === void 0 ? void 0 : _b.certainty) || 0,
+                values: (_c = r._additional) === null || _c === void 0 ? void 0 : _c.vector,
+                metadata: this.extractProperties(r),
+            });
+        });
+        return {
+            matches,
+            queryTime: Date.now() - startTime,
+        };
+    }
+    async fetch(options) {
+        var _a;
+        const vectors = {};
+        for (const id of options.ids) {
+            try {
+                const weaviateId = toWeaviateId(id);
+                const response = await this.request('GET', `/v1/objects/${this.className}/${weaviateId}?include=vector`);
+                // Extract original ID from properties if available, otherwise use the input ID
+                const originalId = ((_a = response.properties) === null || _a === void 0 ? void 0 : _a._originalId) || id;
+                const _b = response.properties || {}, { _originalId } = _b, metadata = __rest(_b, ["_originalId"]);
+                vectors[id] = {
+                    id: originalId,
+                    values: response.vector,
+                    metadata,
+                };
+            }
+            catch (_c) {
+                vectors[id] = null;
+            }
+        }
+        return { vectors };
+    }
+    async update(options) {
+        var _a;
+        const weaviateId = toWeaviateId(options.id);
+        const body = {
+            class: this.className,
+        };
+        if (options.values) {
+            body.vector = options.values;
+        }
+        if (options.setMetadata) {
+            body.properties = Object.assign(Object.assign({}, options.setMetadata), { _originalId: options.id });
+        }
+        else if (options.mergeMetadata) {
+            // Fetch existing, merge, then update
+            const existing = await this.fetch({ ids: [options.id], includeValues: false });
+            const currentMetadata = ((_a = existing.vectors[options.id]) === null || _a === void 0 ? void 0 : _a.metadata) || {};
+            body.properties = Object.assign(Object.assign(Object.assign({}, currentMetadata), options.mergeMetadata), { _originalId: options.id });
+        }
+        await this.request('PATCH', `/v1/objects/${this.className}/${weaviateId}`, body);
+        return {
+            success: true,
+            id: options.id,
+        };
+    }
+    async delete(options) {
+        var _a;
+        let deletedCount = 0;
+        if (options.ids) {
+            for (const id of options.ids) {
+                try {
+                    const weaviateId = toWeaviateId(id);
+                    await this.request('DELETE', `/v1/objects/${this.className}/${weaviateId}`);
+                    deletedCount++;
+                }
+                catch (_b) {
+                    // Ignore errors for individual deletes
+                }
+            }
+        }
+        else if (options.filter) {
+            const body = {
+                match: {
+                    class: this.className,
+                    where: this.convertFilter(options.filter),
+                },
+            };
+            const response = await this.request('DELETE', '/v1/batch/objects', body);
+            deletedCount = ((_a = response.results) === null || _a === void 0 ? void 0 : _a.successful) || 0;
+        }
+        else if (options.deleteAll) {
+            // Delete class and recreate
+            const info = await this.describeIndex();
+            await this.deleteIndex({ name: this.className });
+            await this.createIndex({
+                name: this.className,
+                dimensions: info.dimensions,
+                metric: info.metric,
+            });
+            deletedCount = info.vectorCount;
+        }
+        return {
+            deletedCount,
+            deletedIds: options.ids,
+        };
+    }
+    async list(options) {
+        var _a, _b;
+        const limit = options.limit || 100;
+        const offset = options.cursor ? parseInt(options.cursor, 10) : 0;
+        const query = `
+      {
+        Get {
+          ${this.className}(
+            limit: ${limit}
+            offset: ${offset}
+          ) {
+            _additional {
+              id
+            }
+            _originalId
+          }
+        }
+      }
+    `;
+        const response = await this.graphql(query);
+        const results = ((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.Get) === null || _b === void 0 ? void 0 : _b[this.className]) || [];
+        return {
+            // Return original ID if available, otherwise return Weaviate UUID
+            ids: results.map((r) => { var _a; return r._originalId || ((_a = r._additional) === null || _a === void 0 ? void 0 : _a.id); }).filter(Boolean),
+            nextCursor: results.length === limit ? String(offset + limit) : undefined,
+        };
+    }
+    // ==================== NAMESPACE OPERATIONS ====================
+    async listNamespaces() {
+        // In Weaviate, classes are like namespaces
+        const response = await this.request('GET', '/v1/schema');
+        const namespaces = await Promise.all((response.classes || []).map(async (c) => {
+            var _a, _b, _c, _d, _e;
+            let vectorCount = 0;
+            try {
+                const countQuery = `
+            {
+              Aggregate {
+                ${c.class} {
+                  meta {
+                    count
+                  }
+                }
+              }
+            }
+          `;
+                const countResponse = await this.graphql(countQuery);
+                vectorCount = ((_e = (_d = (_c = (_b = (_a = countResponse.data) === null || _a === void 0 ? void 0 : _a.Aggregate) === null || _b === void 0 ? void 0 : _b[c.class]) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.meta) === null || _e === void 0 ? void 0 : _e.count) || 0;
+            }
+            catch (_f) {
+                // Ignore count errors for individual classes
+            }
+            return {
+                name: c.class,
+                vectorCount,
+            };
+        }));
+        return { namespaces };
+    }
+    async deleteNamespace(namespace) {
+        await this.deleteIndex({ name: namespace });
+    }
+    // ==================== INDEX OPERATIONS ====================
+    async describeIndex() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let response;
+        try {
+            response = await this.request('GET', `/v1/schema/${this.className}`);
+        }
+        catch (error) {
+            // Handle 404 when class doesn't exist yet
+            if ((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('404')) {
+                return {
+                    name: this.className,
+                    dimensions: this.dimensions,
+                    metric: types_1.DistanceMetric.COSINE,
+                    vectorCount: 0,
+                    status: 'initializing',
+                };
+            }
+            throw error;
+        }
+        // Get count via aggregate
+        let vectorCount = 0;
+        try {
+            const countQuery = `
+        {
+          Aggregate {
+            ${this.className} {
+              meta {
+                count
+              }
+            }
+          }
+        }
+      `;
+            const countResponse = await this.graphql(countQuery);
+            vectorCount = ((_f = (_e = (_d = (_c = (_b = countResponse.data) === null || _b === void 0 ? void 0 : _b.Aggregate) === null || _c === void 0 ? void 0 : _c[this.className]) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.meta) === null || _f === void 0 ? void 0 : _f.count) || 0;
+        }
+        catch (_j) {
+            // Ignore count errors
+        }
+        return {
+            name: this.className,
+            dimensions: ((_g = response.vectorIndexConfig) === null || _g === void 0 ? void 0 : _g.dimensions) || this.dimensions,
+            metric: this.mapWeaviateMetric((_h = response.vectorIndexConfig) === null || _h === void 0 ? void 0 : _h.distance),
+            vectorCount,
+            status: 'ready',
+        };
+    }
+    async getIndexStats() {
+        const info = await this.describeIndex();
+        return {
+            vectorCount: info.vectorCount,
+            dimensions: info.dimensions,
+        };
+    }
+    async createIndex(options) {
+        const body = {
+            class: options.name,
+            vectorIndexConfig: {
+                distance: this.mapToWeaviateMetric(options.metric || types_1.DistanceMetric.COSINE),
+            },
+            properties: [],
+        };
+        await this.request('POST', '/v1/schema', body);
+        return {
+            success: true,
+            name: options.name,
+        };
+    }
+    async deleteIndex(options) {
+        await this.request('DELETE', `/v1/schema/${options.name}`);
+        return { success: true };
+    }
+    async listIndexes() {
+        const response = await this.request('GET', '/v1/schema');
+        return Promise.all((response.classes || []).map(async (c) => {
+            var _a, _b, _c, _d, _e, _f, _g;
+            let vectorCount = 0;
+            try {
+                const countQuery = `
+            {
+              Aggregate {
+                ${c.class} {
+                  meta {
+                    count
+                  }
+                }
+              }
+            }
+          `;
+                const countResponse = await this.graphql(countQuery);
+                vectorCount = ((_e = (_d = (_c = (_b = (_a = countResponse.data) === null || _a === void 0 ? void 0 : _a.Aggregate) === null || _b === void 0 ? void 0 : _b[c.class]) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.meta) === null || _e === void 0 ? void 0 : _e.count) || 0;
+            }
+            catch (_h) {
+                // Ignore count errors
+            }
+            return {
+                name: c.class,
+                dimensions: ((_f = c.vectorIndexConfig) === null || _f === void 0 ? void 0 : _f.dimensions) || -1,
+                metric: this.mapWeaviateMetric((_g = c.vectorIndexConfig) === null || _g === void 0 ? void 0 : _g.distance),
+                vectorCount,
+                status: 'ready',
+            };
+        }));
+    }
+    // ==================== FEATURE DETECTION ====================
+    supportsFeature(feature) {
+        switch (feature) {
+            case types_1.VectorFeature.METADATA_FILTERING:
+            case types_1.VectorFeature.BATCH_OPERATIONS:
+            case types_1.VectorFeature.VECTOR_UPDATES:
+            case types_1.VectorFeature.INDEX_MANAGEMENT:
+            case types_1.VectorFeature.HYBRID_SEARCH:
+                return true;
+            case types_1.VectorFeature.NAMESPACES:
+            case types_1.VectorFeature.SPARSE_VECTORS:
+            case types_1.VectorFeature.AGGREGATIONS:
+                return false;
+            default:
+                return false;
+        }
+    }
+    // ==================== PRIVATE METHODS ====================
+    /**
+     * Ensure the Weaviate class (schema) exists, creating it if necessary
+     */
+    async ensureClassExists() {
+        var _a;
+        try {
+            // Check if class already exists
+            await this.request('GET', `/v1/schema/${this.className}`);
+        }
+        catch (_b) {
+            // Class doesn't exist, create it
+            const body = {
+                class: this.className,
+                vectorIndexConfig: {
+                    distance: this.mapToWeaviateMetric(((_a = this.connectionOptions) === null || _a === void 0 ? void 0 : _a.metric) || types_1.DistanceMetric.COSINE),
+                },
+                properties: [
+                    {
+                        name: '_originalId',
+                        dataType: ['text'],
+                        description: 'Original ID before UUID conversion',
+                    },
+                ],
+            };
+            await this.request('POST', '/v1/schema', body);
+        }
+    }
+    /**
+     * Make REST request
+     */
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const options = {
+            method,
+            headers,
+            signal: AbortSignal.timeout(this.timeout),
+        };
+        if (body && method !== 'GET') {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw utils_1.VectorError.fromUnknown(new Error(`Weaviate API error: ${response.status} - ${errorText}`), types_1.VectorDBType.WEAVIATE);
+        }
+        // Handle responses with no content (204 or empty body like health checks)
+        if (response.status === 204) {
+            return {};
+        }
+        // Check if response has content before parsing JSON
+        const contentLength = response.headers.get('content-length');
+        if (contentLength === '0') {
+            return {};
+        }
+        const text = await response.text();
+        if (!text || text.trim() === '') {
+            return {};
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch (_a) {
+            // If JSON parsing fails, return empty object for health check endpoints
+            return {};
+        }
+    }
+    /**
+     * Make GraphQL request
+     */
+    async graphql(query) {
+        const url = `${this.baseUrl}/v1/graphql`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ query }),
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw utils_1.VectorError.fromUnknown(new Error(`Weaviate GraphQL error: ${response.status} - ${errorText}`), types_1.VectorDBType.WEAVIATE);
+        }
+        return response.json();
+    }
+    /**
+     * Convert filter to Weaviate format
+     */
+    convertFilter(filter) {
+        if ('$and' in filter) {
+            return {
+                operator: 'And',
+                operands: filter.$and.map((f) => this.convertFilter(f)),
+            };
+        }
+        if ('$or' in filter) {
+            return {
+                operator: 'Or',
+                operands: filter.$or.map((f) => this.convertFilter(f)),
+            };
+        }
+        const f = filter;
+        return this.convertSingleFilter(f);
+    }
+    /**
+     * Convert single filter
+     */
+    convertSingleFilter(filter) {
+        const { field, operator, value } = filter;
+        const path = [field];
+        switch (operator) {
+            case '$eq':
+                return { path, operator: 'Equal', valueString: String(value) };
+            case '$ne':
+                return { path, operator: 'NotEqual', valueString: String(value) };
+            case '$gt':
+                return { path, operator: 'GreaterThan', valueNumber: Number(value) };
+            case '$gte':
+                return { path, operator: 'GreaterThanEqual', valueNumber: Number(value) };
+            case '$lt':
+                return { path, operator: 'LessThan', valueNumber: Number(value) };
+            case '$lte':
+                return { path, operator: 'LessThanEqual', valueNumber: Number(value) };
+            case '$contains':
+                return { path, operator: 'ContainsAny', valueStringArray: [String(value)] };
+            default:
+                return { path, operator: 'Equal', valueString: String(value) };
+        }
+    }
+    /**
+     * Extract properties from Weaviate result (excluding _additional)
+     */
+    extractProperties(result) {
+        const props = {};
+        for (const [key, value] of Object.entries(result)) {
+            if (key !== '_additional') {
+                props[key] = value;
+            }
+        }
+        return props;
+    }
+    /**
+     * Map Weaviate distance to our enum
+     */
+    mapWeaviateMetric(distance) {
+        switch (distance === null || distance === void 0 ? void 0 : distance.toLowerCase()) {
+            case 'cosine':
+                return types_1.DistanceMetric.COSINE;
+            case 'l2-squared':
+                return types_1.DistanceMetric.EUCLIDEAN;
+            case 'dot':
+                return types_1.DistanceMetric.DOT_PRODUCT;
+            default:
+                return types_1.DistanceMetric.COSINE;
+        }
+    }
+    /**
+     * Map our enum to Weaviate distance
+     */
+    mapToWeaviateMetric(metric) {
+        switch (metric) {
+            case types_1.DistanceMetric.COSINE:
+                return 'cosine';
+            case types_1.DistanceMetric.EUCLIDEAN:
+                return 'l2-squared';
+            case types_1.DistanceMetric.DOT_PRODUCT:
+                return 'dot';
+            default:
+                return 'cosine';
+        }
+    }
+}
+exports.WeaviateAdapter = WeaviateAdapter;
+exports.default = WeaviateAdapter;
+//# sourceMappingURL=weaviate.adapter.js.map