@relevanceai/sdk 1.149.0 → 2.0.1

package/dist-es/generated/index.js

@@ -1 +1 @@
-export * from "./DiscoveryApi";
+export * from "./VecDBApi";

package/dist-es/index.js

@@ -1,2 +1,2 @@
 export * from './generated';
-// export * from './services';
+export * from './services';

package/dist-es/services/index.js

@@ -1,3 +1,2 @@
-"use strict";
-// Not interested in this right now
 // export * from './discovery';
+export * from './vecdb';

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

@@ -0,0 +1,356 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { QueryBuilder, _QueryBuilder } from ".";
+var Dataset = /** @class */ (function () {
+    function Dataset(client, name, options) {
+        // TODO validate name
+        this.client = client;
+        this.name = name;
+        this.config = options;
+    }
+    Object.defineProperty(Dataset.prototype, "datasetName", {
+        get: function () {
+            return this.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ;
+    Dataset.prototype.createIfNotExist = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 4]);
+                        return [4 /*yield*/, this.client.apiClient.GetDatasetDetails({}, { dataset_id: this.name })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, false];
+                    case 2:
+                        err_1 = _a.sent();
+                        return [4 /*yield*/, this.client.apiClient.CreateDataset(__assign({ id: this.name }, (this.config.schema ? { schema: this.config.schema } : {})))];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Dataset.prototype.recreateIfExists = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, this.client.apiClient.GetDatasetDetails({}, { dataset_id: this.name })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.client.apiClient.DeleteDataset({}, { dataset_id: this.name })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.client.apiClient.CreateDataset(__assign({ id: this.name }, (this.config.schema ? { schema: this.config.schema } : {})))];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                    case 4:
+                        err_2 = _a.sent();
+                        return [2 /*return*/, false];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Dataset.prototype.insertDocument = function (document, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.apiClient.Insert(__assign({ document: document }, options), { dataset_id: this.name })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.search = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, options, args_1, args_1_1, arg, reqCallback, response;
+            var e_1, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        payload = {};
+                        options = {};
+                        try {
+                            for (args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
+                                arg = args_1_1.value;
+                                if (arg instanceof _QueryBuilder) {
+                                    payload = __assign(__assign({}, payload), arg.build());
+                                }
+                                else {
+                                    options = arg;
+                                    if (options.rawPayload)
+                                        payload = __assign(__assign({}, payload), options.rawPayload);
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        reqCallback = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.client.apiClient.SimpleSearchPost(payload, { dataset_id: this.name })];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); };
+                        if (!(options.debounce && this.debounceTimer)) return [3 /*break*/, 1];
+                        clearTimeout(this.debounceTimer);
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                _this.debounceTimer = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () { var res; return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, reqCallback()];
+                                        case 1:
+                                            res = _a.sent();
+                                            resolve(res);
+                                            return [2 /*return*/];
+                                    }
+                                }); }); }, options.debounce);
+                            })];
+                    case 1: return [4 /*yield*/, reqCallback()];
+                    case 2:
+                        response = _b.sent();
+                        return [2 /*return*/, response.body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.insertDocuments = function (documents, encoders, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, finalResults;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._GenericBulkOperation(__assign(__assign({ data: documents !== null && documents !== void 0 ? documents : [] }, options), { fn: function (documentsSlice) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.client.apiClient.BulkInsert(__assign({ documents: documentsSlice }, (encoders ? { encoders: encoders } : {})), { dataset_id: this.name })];
+                                    case 1: return [2 /*return*/, (_a.sent()).body];
+                                }
+                            }); }); } }))];
+                    case 1:
+                        results = _a.sent();
+                        finalResults = results.reduce(function (prev, cur) {
+                            prev.failed_documents = prev.failed_documents.concat(cur.failed_documents);
+                            prev.inserted += cur.inserted;
+                            return prev;
+                        }, { inserted: 0, failed_documents: [] });
+                        return [2 /*return*/, finalResults];
+                }
+            });
+        });
+    };
+    // TODO - ChunkSearch, insert, insertAndVectorize?, vectorize, 
+    Dataset.prototype._GenericBulkOperation = function (_a) {
+        var data = _a.data, batchSize = _a.batchSize, fn = _a.fn, retryCount = _a.retryCount;
+        return __awaiter(this, void 0, void 0, function () {
+            var results, i, retrysSoFar, res, e_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        batchSize = batchSize !== null && batchSize !== void 0 ? batchSize : 10000;
+                        retryCount = retryCount !== null && retryCount !== void 0 ? retryCount : 1;
+                        results = [];
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < (data === null || data === void 0 ? void 0 : data.length))) return [3 /*break*/, 8];
+                        retrysSoFar = 0;
+                        _b.label = 2;
+                    case 2:
+                        if (!(retrysSoFar < retryCount)) return [3 /*break*/, 7];
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, fn(data.slice(i, i + batchSize))];
+                    case 4:
+                        res = _b.sent();
+                        results.push(res);
+                        return [3 /*break*/, 7];
+                    case 5:
+                        e_2 = _b.sent();
+                        console.error("Bulk operation failed with error, retrying - ".concat(e_2));
+                        return [3 /*break*/, 6];
+                    case 6:
+                        retrysSoFar++;
+                        return [3 /*break*/, 2];
+                    case 7:
+                        i += batchSize;
+                        return [3 /*break*/, 1];
+                    case 8: return [2 /*return*/, results];
+                }
+            });
+        });
+    };
+    Dataset.prototype.updateDocument = function (documentId, partialUpdates) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.apiClient.Update({ id: documentId, updates: partialUpdates })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.updateDocuments = function (updates, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, finalResults;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._GenericBulkOperation(__assign(__assign({ data: updates !== null && updates !== void 0 ? updates : [] }, options), { fn: function (updatesSlice) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.client.apiClient.BulkUpdate({ updates: updatesSlice }, { dataset_id: this.name })];
+                                    case 1: return [2 /*return*/, (_a.sent()).body];
+                                }
+                            }); }); } }))];
+                    case 1:
+                        results = _a.sent();
+                        finalResults = results.reduce(function (prev, cur) {
+                            prev.failed_documents = prev.failed_documents.concat(cur.failed_documents);
+                            prev.inserted += cur.inserted;
+                            return prev;
+                        }, { inserted: 0, failed_documents: [] });
+                        return [2 /*return*/, finalResults];
+                }
+            });
+        });
+    };
+    Dataset.prototype.updateDocumentsWhere = function (filters, partialUpdates) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.apiClient.UpdateWhere({ filters: filters.build().filters, updates: partialUpdates })];
+                    case 1: return [2 /*return*/, (_a.sent()).body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.getDocument = function (documentId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.apiClient.GetDocument({ document_id: documentId })];
+                    case 1: return [2 /*return*/, (_a.sent()).body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.deleteDocument = function (documentId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.apiClient.DeleteDocument({ id: documentId })];
+                    case 1: return [2 /*return*/, (_a.sent()).body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.deleteDocuments = function (documentIds) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var filters;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        filters = QueryBuilder().match('_id', documentIds);
+                        return [4 /*yield*/, this.client.apiClient.DeleteWhere({ filters: (_a = filters.build().filters) !== null && _a !== void 0 ? _a : [] })];
+                    case 1: return [2 /*return*/, (_b.sent()).body];
+                }
+            });
+        });
+    };
+    Dataset.prototype.deleteDocumentsWhere = function (filters) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.client.apiClient.DeleteWhere({ filters: (_a = filters.build().filters) !== null && _a !== void 0 ? _a : [] })];
+                    case 1: return [2 /*return*/, (_b.sent()).body];
+                }
+            });
+        });
+    };
+    return Dataset;
+}());
+export { Dataset };

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

@@ -0,0 +1,184 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { VecDBApiClient } from '../../';
+import { Dataset } from './Dataset';
+export function QueryBuilder() {
+    return new _QueryBuilder();
+}
+export function FilterBuilder() {
+    return new _FilterBuilder();
+}
+var _FilterBuilder = /** @class */ (function () {
+    function _FilterBuilder() {
+        this.body = { filters: [], fieldsToAggregate: [], fieldsToAggregateStats: [] };
+    }
+    _FilterBuilder.prototype.buildFilters = function () {
+        return this.body.filters;
+    };
+    _FilterBuilder.prototype.rawFilter = function (filter) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push(filter);
+        return this;
+    };
+    _FilterBuilder.prototype.filter = function (type, key, value) {
+        var _a;
+        var _b;
+        var options = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            options[_i - 3] = arguments[_i];
+        }
+        (_b = this.body.filters) === null || _b === void 0 ? void 0 : _b.push((_a = {},
+            _a[type] = __assign({ key: key, value: value }, options),
+            _a));
+        return this;
+    };
+    _FilterBuilder.prototype.match = function (field, value) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ match: { field: field, value: value } });
+        return this;
+    };
+    _FilterBuilder.prototype.wildcard = function (field, value) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ wildcard: { field: field, value: value } });
+        return this;
+    };
+    _FilterBuilder.prototype.range = function (field, options) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ range: __assign({ field: field }, options) });
+        return this;
+    };
+    _FilterBuilder.prototype.or = function (filters) {
+        var _a;
+        (_a = this.body.filters) === null || _a === void 0 ? void 0 : _a.push({ or: filters.map(function (f) { var _a; return (_a = f.body.filters) !== null && _a !== void 0 ? _a : []; }) });
+        return this;
+    };
+    return _FilterBuilder;
+}());
+export { _FilterBuilder };
+var _QueryBuilder = /** @class */ (function (_super) {
+    __extends(_QueryBuilder, _super);
+    function _QueryBuilder() {
+        var _this = _super.call(this) || this;
+        _this.shouldPerformTextQuery = false;
+        return _this;
+    }
+    _QueryBuilder.prototype.build = function () {
+        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;
+    };
+    _QueryBuilder.prototype.vector = function (field) {
+        var e_1, _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (!Array.isArray(this.body.vectorSearchQuery))
+            this.body.vectorSearchQuery = [];
+        var payload = { field: field }; // TODO components['schemas']['simpleSearchAndFlatFilterItem']['search']['vectorSearchQuery']
+        var inferredModelMatch = field.match(/_(.*)_.*vector_/); // title_text@1-0_vector_ -> text@1-0
+        if (inferredModelMatch && inferredModelMatch[1])
+            payload.model = inferredModelMatch[1]; // this can be overridden
+        try {
+            for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
+                var arg = args_1_1.value;
+                if (typeof arg === 'number')
+                    payload.weight = arg; // weight
+                else
+                    payload = __assign(__assign({}, payload), arg); // options
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this.body.vectorSearchQuery.push(payload);
+        return this;
+    };
+    _QueryBuilder.prototype.sort = function (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;
+    };
+    _QueryBuilder.prototype.rawOption = function (key, value) {
+        this.body[key] = value;
+        return this;
+    };
+    _QueryBuilder.prototype.minimumRelevance = function (value) {
+        this.body.minimumRelevance = value;
+        return this;
+    };
+    _QueryBuilder.prototype.page = function (value) {
+        this.body.page = value;
+        return this;
+    };
+    _QueryBuilder.prototype.pageSize = function (value) {
+        this.body.pageSize = value;
+        return this;
+    };
+    _QueryBuilder.prototype.includeFields = function (fields) {
+        this.body.includeFields = fields;
+        return this;
+    };
+    _QueryBuilder.prototype.ask = function (query, field, options) {
+        var _a;
+        this.body.instantAnswerQuery = __assign(__assign({ query: 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;
+    };
+    return _QueryBuilder;
+}(_FilterBuilder));
+export { _QueryBuilder };
+var VecDBClient = /** @class */ (function () {
+    function VecDBClient(config) {
+        this.apiClient = new VecDBApiClient(config !== null && config !== void 0 ? config : {});
+    }
+    VecDBClient.prototype.dataset = function (name, options) {
+        var dataset = new Dataset(this, name, options);
+        return dataset;
+    };
+    return VecDBClient;
+}());
+export { VecDBClient };

package/dist-es/shared/serviceConfigs.js

@@ -1,7 +1,7 @@
 export var 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',
     },
 };