@relevanceai/sdk 1.149.0 → 2.0.1

package/dist-cjs/services/vecdb/Dataset.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dataset = void 0;
+const _1 = require(".");
+class Dataset {
+    constructor(client, name, options) {
+        // TODO validate name
+        this.client = client;
+        this.name = name;
+        this.config = options;
+    }
+    get datasetName() {
+        return this.name;
+    }
+    ;
+    async createIfNotExist() {
+        try {
+            await this.client.apiClient.GetDatasetDetails({}, { dataset_id: this.name });
+            return false;
+        }
+        catch (err) {
+            await this.client.apiClient.CreateDataset({ id: this.name, ...(this.config.schema ? { schema: this.config.schema } : {}) });
+            return true;
+        }
+    }
+    async recreateIfExists() {
+        try {
+            await this.client.apiClient.GetDatasetDetails({}, { dataset_id: this.name });
+            await this.client.apiClient.DeleteDataset({}, { dataset_id: this.name });
+            await this.client.apiClient.CreateDataset({ id: this.name, ...(this.config.schema ? { schema: this.config.schema } : {}) });
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async insertDocument(document, options) {
+        const response = await this.client.apiClient.Insert({
+            document,
+            ...options
+        }, { dataset_id: this.name });
+        return response.body;
+    }
+    async search(...args) {
+        let payload = {};
+        let options = {};
+        for (const arg of args) {
+            if (arg instanceof _1._QueryBuilder) {
+                payload = { ...payload, ...arg.build() };
+            }
+            else {
+                options = arg;
+                if (options.rawPayload)
+                    payload = { ...payload, ...options.rawPayload };
+            }
+        }
+        const reqCallback = async () => await this.client.apiClient.SimpleSearchPost(payload, { dataset_id: this.name });
+        if (options.debounce && this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            return new Promise((resolve) => {
+                this.debounceTimer = setTimeout(async () => { const res = await reqCallback(); resolve(res); }, options.debounce);
+            });
+        }
+        else {
+            const response = await reqCallback();
+            return response.body;
+        }
+    }
+    async insertDocuments(documents, encoders, options) {
+        const results = await this._GenericBulkOperation({
+            data: documents !== null && documents !== void 0 ? documents : [],
+            ...options,
+            fn: async (documentsSlice) => (await this.client.apiClient.BulkInsert({ documents: documentsSlice, ...(encoders ? { encoders } : {}) }, { dataset_id: this.name })).body
+        });
+        const finalResults = results.reduce((prev, cur) => {
+            prev.failed_documents = prev.failed_documents.concat(cur.failed_documents);
+            prev.inserted += cur.inserted;
+            return prev;
+        }, { inserted: 0, failed_documents: [] });
+        return finalResults;
+    }
+    // TODO - ChunkSearch, insert, insertAndVectorize?, vectorize, 
+    async _GenericBulkOperation({ data, batchSize, fn, retryCount }) {
+        batchSize = batchSize !== null && batchSize !== void 0 ? batchSize : 10000;
+        retryCount = retryCount !== null && retryCount !== void 0 ? retryCount : 1;
+        const results = [];
+        for (let i = 0; i < (data === null || data === void 0 ? void 0 : data.length); i += batchSize) {
+            for (let retrysSoFar = 0; retrysSoFar < retryCount; retrysSoFar++) {
+                try {
+                    const res = await fn(data.slice(i, i + batchSize));
+                    results.push(res);
+                    break;
+                }
+                catch (e) {
+                    console.error(`Bulk operation failed with error, retrying - ${e}`);
+                }
+            }
+        }
+        return results;
+    }
+    async updateDocument(documentId, partialUpdates) {
+        const response = await this.client.apiClient.Update({ id: documentId, updates: partialUpdates });
+        return response.body;
+    }
+    async updateDocuments(updates, options) {
+        const results = await this._GenericBulkOperation({
+            data: updates !== null && updates !== void 0 ? updates : [],
+            ...options,
+            fn: async (updatesSlice) => (await this.client.apiClient.BulkUpdate({ updates: updatesSlice }, { dataset_id: this.name })).body
+        });
+        const finalResults = results.reduce((prev, cur) => {
+            prev.failed_documents = prev.failed_documents.concat(cur.failed_documents);
+            prev.inserted += cur.inserted;
+            return prev;
+        }, { inserted: 0, failed_documents: [] });
+        return finalResults;
+    }
+    async updateDocumentsWhere(filters, partialUpdates) {
+        return (await this.client.apiClient.UpdateWhere({ filters: filters.build().filters, updates: partialUpdates })).body;
+    }
+    async getDocument(documentId) {
+        return (await this.client.apiClient.GetDocument({ document_id: documentId })).body;
+    }
+    async deleteDocument(documentId) {
+        return (await this.client.apiClient.DeleteDocument({ id: documentId })).body;
+    }
+    async deleteDocuments(documentIds) {
+        var _a;
+        const filters = (0, _1.QueryBuilder)().match('_id', documentIds);
+        return (await this.client.apiClient.DeleteWhere({ filters: (_a = filters.build().filters) !== null && _a !== void 0 ? _a : [] })).body;
+    }
+    async deleteDocumentsWhere(filters) {
+        var _a;
+        return (await this.client.apiClient.DeleteWhere({ filters: (_a = filters.build().filters) !== null && _a !== void 0 ? _a : [] })).body;
+    }
+}
+exports.Dataset = Dataset;

package/dist-cjs/services/vecdb/index.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VecDBClient = exports._QueryBuilder = exports._FilterBuilder = exports.FilterBuilder = exports.QueryBuilder = void 0;
+const __1 = require("../../");
+const Dataset_1 = require("./Dataset");
+function QueryBuilder() {
+    return new _QueryBuilder();
+}
+exports.QueryBuilder = QueryBuilder;
+function FilterBuilder() {
+    return new _FilterBuilder();
+}
+exports.FilterBuilder = FilterBuilder;
+class _FilterBuilder {
+    constructor() {
+        this.body = { filters: [], fieldsToAggregate: [], fieldsToAggregateStats: [] };
+    }
+    buildFilters() {
+        return this.body.filters;
+    }
+    rawFilter(filter) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push(filter);
+        return this;
+    }
+    filter(type, key, value, ...options) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({
+            [type]: {
+                key,
+                value,
+                ...options
+            }
+        });
+        return this;
+    }
+    match(field, value) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ match: { field: field, value } });
+        return this;
+    }
+    wildcard(field, value) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ wildcard: { field: field, value } });
+        return this;
+    }
+    range(field, options) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ range: { field: field, ...options } });
+        return this;
+    }
+    or(filters) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ or: filters.map(f => { var _a; return (_a = f.body.filters) !== null && _a !== void 0 ? _a : []; }) });
+        return this;
+    }
+}
+exports._FilterBuilder = _FilterBuilder;
+class _QueryBuilder extends _FilterBuilder {
+    constructor() {
+        super();
+        this.shouldPerformTextQuery = false;
+    }
+    build() {
+        if (!this.shouldPerformTextQuery)
+            return this.body;
+        if (!this.defaultQueryValue)
+            throw new Error("Please set the search query by calling .query('my search query') before performing a text search.");
+        this.body.query = this.defaultQueryValue;
+        return this.body;
+    }
+    vector(field, ...args) {
+        if (!Array.isArray(this.body.vectorSearchQuery))
+            this.body.vectorSearchQuery = [];
+        let payload = { field }; // TODO components['schemas']['simpleSearchAndFlatFilterItem']['search']['vectorSearchQuery']
+        const inferredModelMatch = field.match(/_(.*)_.*vector_/); // title_text@1-0_vector_ -> text@1-0
+        if (inferredModelMatch && inferredModelMatch[1])
+            payload.model = inferredModelMatch[1]; // this can be overridden
+        for (const arg of args) {
+            if (typeof arg === 'number')
+                payload.weight = arg; // weight
+            else
+                payload = { ...payload, ...arg }; // options
+        }
+        this.body.vectorSearchQuery.push(payload);
+        return this;
+    }
+    sort(field, direction) {
+        var _a, _b;
+        if (!((_b = (_a = this === null || this === void 0 ? void 0 : this.body) === null || _a === void 0 ? void 0 : _a.sort) === null || _b === void 0 ? void 0 : _b.length))
+            this.body.sort = {};
+        this.body.sort[field] = direction;
+        return this;
+    }
+    rawOption(key, value) {
+        this.body[key] = value;
+        return this;
+    }
+    minimumRelevance(value) {
+        this.body.minimumRelevance = value;
+        return this;
+    }
+    page(value) {
+        this.body.page = value;
+        return this;
+    }
+    pageSize(value) {
+        this.body.pageSize = value;
+        return this;
+    }
+    includeFields(fields) {
+        this.body.includeFields = fields;
+        return this;
+    }
+    ask(query, field, options) {
+        var _a;
+        this.body.instantAnswerQuery = {
+            query,
+            field: field,
+            preset: (_a = options.preset) !== null && _a !== void 0 ? _a : 'support3',
+            ...(options.titleReferenceField ? { titleReferenceField: options.titleReferenceField } : {}),
+            ...(options.urlReferenceField ? { urlReferenceField: options.urlReferenceField } : {}),
+        };
+        return this;
+    }
+}
+exports._QueryBuilder = _QueryBuilder;
+class VecDBClient {
+    constructor(config) {
+        this.apiClient = new __1.VecDBApiClient(config !== null && config !== void 0 ? config : {});
+    }
+    dataset(name, options) {
+        let dataset = new Dataset_1.Dataset(this, name, options);
+        return dataset;
+    }
+}
+exports.VecDBClient = VecDBClient;

package/dist-cjs/shared/serviceConfigs.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serviceConfigs = void 0;
 exports.serviceConfigs = {
-    DiscoveryApi: {
-        schema_url: 'https://api.ap-southeast-2.relevance.ai/latest/openapi_schema.json',
-        endpoint: 'https://api.ap-southeast-2.relevance.ai',
-        name: 'DiscoveryApi',
+    VecDBApi: {
+        schema_url: 'https://api-f1db6c.stack.tryrelevance.com/latest/openapi_schema.json',
+        endpoint: 'https://api-f1db6c.stack.tryrelevance.com',
+        name: 'VecDBApi',
     },
 };