@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,661 +0,0 @@
-"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