tsense 0.0.17 → 0.2.0-next.0

package/dist/tsense.js

@@ -1,13 +1,3 @@
-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 _a;
 import redaxios from "redaxios";
 import { TSenseMigrator } from "./migrator.js";
 import { defaultTransformers } from "./transformers/defaults.js";
@@ -18,7 +8,24 @@ function chunkArray(arr, size) {
     }
     return chunks;
 }
-const redaxiosInstance = (_a = redaxios.default) !== null && _a !== void 0 ? _a : redaxios;
+const redaxiosInstance = redaxios.default ?? redaxios;
+function escapeFilterValue(value) {
+    if (typeof value === "string") {
+        return `\`${value.replaceAll("`", "")}\``;
+    }
+    if (Array.isArray(value)) {
+        return value.map(escapeFilterValue);
+    }
+    return value;
+}
+const filterOperators = {
+    not: (k, v) => `${k}:!=${v}`,
+    gt: (k, v) => `${k}:>${v}`,
+    gte: (k, v) => `${k}:>=${v}`,
+    lt: (k, v) => `${k}:<${v}`,
+    lte: (k, v) => `${k}:<=${v}`,
+    notIn: (k, v) => `${k}:!=[${v.join(",")}]`,
+};
 const arkToTsense = {
     string: "string",
     number: "float",
@@ -30,21 +37,20 @@ const arkToTsense = {
     "boolean[]": "bool[]",
 };
 export class TSense {
-    getFields() {
-        return this.fields;
-    }
+    options;
+    fields = [];
+    axios;
+    synced = false;
+    fieldTransformers = new Map();
+    dataSyncConfig;
+    infer = undefined;
     constructor(options) {
-        var _a;
         this.options = options;
-        this.fields = [];
-        this.synced = false;
-        this.fieldTransformers = new Map();
-        this.infer = undefined;
         this.axios = redaxiosInstance.create({
             baseURL: `${options.connection.protocol}://${options.connection.host}:${options.connection.port}`,
             headers: { "X-TYPESENSE-API-KEY": options.connection.apiKey },
         });
-        this.extractFields((_a = options.transformers) !== null && _a !== void 0 ? _a : defaultTransformers);
+        this.fields = this.extractFields(options.transformers ?? defaultTransformers);
         this.dataSyncConfig = options.dataSync;
     }
     getBaseType(expression, domain) {
@@ -65,7 +71,7 @@ export class TSense {
         return "string";
     }
     serializeDoc(doc) {
-        const result = Object.assign({}, doc);
+        const result = { ...doc };
         for (const [field, transformer] of this.fieldTransformers) {
             if (result[field] != null) {
                 result[field] = transformer.serialize(result[field]);
@@ -88,124 +94,147 @@ export class TSense {
         if (Array.isArray(value)) {
             return value.map((v) => transformer.serialize(v));
         }
-        if (typeof value === "object" && value !== null) {
-            const v = value;
-            const isFilterObject = "min" in v || "max" in v || "not" in v;
-            if (!isFilterObject) {
-                return transformer.serialize(value);
+        if (typeof value === "object" &&
+            value !== null &&
+            Object.getPrototypeOf(value) === Object.prototype) {
+            const result = {};
+            for (const [opKey, opValue] of Object.entries(value)) {
+                if (opValue == null) {
+                    result[opKey] = opValue;
+                    continue;
+                }
+                if (Array.isArray(opValue)) {
+                    result[opKey] = opValue.map((item) => transformer.serialize(item));
+                }
+                else {
+                    result[opKey] = transformer.serialize(opValue);
+                }
             }
-            const result = Object.assign({}, v);
-            if ("min" in v && v.min != null)
-                result.min = transformer.serialize(v.min);
-            if ("max" in v && v.max != null)
-                result.max = transformer.serialize(v.max);
-            if ("not" in v && v.not != null)
-                result.not = transformer.serialize(v.not);
             return result;
         }
         return transformer.serialize(value);
     }
     extractFields(transformers) {
-        var _a, _b, _c, _d;
         const internal = this.options.schema;
+        const fields = [];
         for (const prop of internal.structure.props) {
-            const innerType = (_b = (_a = prop.value.branches) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : prop.value;
-            const meta = ((_c = innerType.meta) !== null && _c !== void 0 ? _c : prop.value.meta);
+            const branches = prop.value.branches ?? [];
+            const enumValues = [];
+            for (const branch of branches) {
+                if (typeof branch.unit === "string") {
+                    enumValues.push(branch.unit);
+                }
+            }
+            const innerType = branches[0] ?? prop.value;
+            const meta = (innerType.meta ?? prop.value.meta);
             const expression = String(prop.value.expression);
             const domain = prop.value.domain;
             const baseType = this.getBaseType(expression, domain);
             const transformer = transformers.find((t) => t.match(expression, domain) || t.match(baseType, domain));
             if (transformer) {
                 this.fieldTransformers.set(prop.key, transformer);
-                this.fields.push({
+                fields.push({
                     name: prop.key,
                     type: transformer.storageType,
+                    sourceExpression: expression,
                     optional: prop.kind === "optional",
-                    facet: meta === null || meta === void 0 ? void 0 : meta.facet,
-                    sort: meta === null || meta === void 0 ? void 0 : meta.sort,
-                    index: meta === null || meta === void 0 ? void 0 : meta.index,
+                    facet: meta?.facet,
+                    sort: meta?.sort,
+                    index: meta?.index,
+                    enumValues,
                 });
                 continue;
             }
-            const type = (_d = meta === null || meta === void 0 ? void 0 : meta.type) !== null && _d !== void 0 ? _d : this.inferType(baseType);
-            this.fields.push({
+            const type = meta?.type ?? this.inferType(baseType);
+            fields.push({
                 name: prop.key,
                 type,
+                sourceExpression: expression,
                 optional: prop.kind === "optional",
-                facet: meta === null || meta === void 0 ? void 0 : meta.facet,
-                sort: meta === null || meta === void 0 ? void 0 : meta.sort,
-                index: meta === null || meta === void 0 ? void 0 : meta.index,
+                facet: meta?.facet,
+                sort: meta?.sort,
+                index: meta?.index,
+                enumValues,
             });
         }
+        return fields;
     }
-    ensureSynced(force) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!force && (this.synced || !this.options.autoSyncSchema))
-                return;
-            yield new TSenseMigrator(this.options.name, this.fields, this.options.defaultSortingField, this.axios).sync();
-            this.synced = true;
-        });
+    async ensureSynced(force) {
+        if (!force && (this.synced || !this.options.autoSyncSchema))
+            return;
+        await new TSenseMigrator(this.options.name, this.fields, this.options.defaultSortingField, this.axios).sync();
+        this.synced = true;
     }
-    syncSchema() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced(true);
-        });
+    async syncSchema() {
+        await this.ensureSynced(true);
     }
     buildObjectFilter(key, value) {
-        var _a, _b;
-        if (Array.isArray(value)) {
-            return `(${key}:[${value.join(",")}])`;
-        }
-        const v = value;
-        if ("not" in v) {
-            return `${key}:!=${v.not}`;
-        }
-        const min = (_a = v.min) !== null && _a !== void 0 ? _a : undefined;
-        const max = (_b = v.max) !== null && _b !== void 0 ? _b : undefined;
-        if (min != null && max != null) {
-            return `${key}:[${min}..${max}]`;
-        }
-        if (max != null) {
-            return `${key}:<=${max}`;
+        if (value.gte != null && value.lte != null) {
+            const escaped = escapeFilterValue(value.gte);
+            const escapedLte = escapeFilterValue(value.lte);
+            const parts = [`${key}:[${escaped}..${escapedLte}]`];
+            for (const [op, opValue] of Object.entries(value)) {
+                if (op === "gte" || op === "lte" || opValue == null)
+                    continue;
+                const builder = filterOperators[op];
+                if (builder) {
+                    parts.push(builder(key, escapeFilterValue(opValue)));
+                }
+            }
+            return parts;
         }
-        if (min != null) {
-            return `${key}:>=${min}`;
+        const parts = [];
+        for (const [op, opValue] of Object.entries(value)) {
+            if (opValue == null)
+                continue;
+            const builder = filterOperators[op];
+            if (builder) {
+                parts.push(builder(key, escapeFilterValue(opValue)));
+            }
         }
+        return parts;
     }
     buildFilter(filter) {
         const result = [];
-        for (const entry of Object.entries(filter !== null && filter !== void 0 ? filter : {})) {
+        for (const entry of Object.entries(filter ?? {})) {
             const [key, rawValue] = entry;
             if (rawValue == null)
                 continue;
             if (key === "OR") {
-                const orFilter = [];
+                const orParts = [];
                 for (const condition of rawValue) {
                     const inner = this.buildFilter(condition);
-                    orFilter.push(`(${inner.join("||")})`);
+                    orParts.push(`(${inner.join("&&")})`);
                 }
-                result.push(`(${orFilter.join("||")})`);
+                result.push(`(${orParts.join("||")})`);
                 continue;
             }
             const value = this.serializeFilterValue(key, rawValue);
-            switch (typeof value) {
-                case "string":
-                case "number":
-                case "boolean":
-                    result.push(`${key}:=${value}`);
-                    break;
-                case "object": {
-                    const built = this.buildObjectFilter(key, value);
-                    if (built)
-                        result.push(built);
-                    break;
-                }
-                default:
-                    break;
+            const escaped = escapeFilterValue(value);
+            if (typeof escaped === "string" ||
+                typeof escaped === "number" ||
+                typeof escaped === "boolean") {
+                result.push(`${key}:=${escaped}`);
+                continue;
+            }
+            if (Array.isArray(escaped)) {
+                result.push(`${key}:[${escaped.join(",")}]`);
+                continue;
+            }
+            if (typeof value === "object" && value !== null) {
+                result.push(...this.buildObjectFilter(key, value));
             }
         }
         return result;
     }
+    validateFields(fields) {
+        const valid = new Set(this.fields.map((f) => f.name));
+        for (const field of fields) {
+            if (field !== "score" && !valid.has(field)) {
+                throw new Error(`INVALID_FIELD: ${field}`);
+            }
+        }
+    }
     buildSort(options) {
         if (!options.sortBy)
             return;
@@ -219,322 +248,307 @@ export class TSense {
         }
         return result.join(",");
     }
-    create() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const enableNested = this.fields.some((f) => f.type === "object" || f.type === "object[]");
-            yield this.axios({
-                method: "POST",
-                url: "/collections",
-                data: {
-                    name: this.options.name,
-                    fields: this.fields,
-                    default_sorting_field: this.options.defaultSortingField,
-                    enable_nested_fields: enableNested,
-                },
-            });
-            return this;
+    async create() {
+        const enableNested = this.fields.some((f) => f.type === "object" || f.type === "object[]");
+        await this.axios({
+            method: "POST",
+            url: "/collections",
+            data: {
+                name: this.options.name,
+                fields: this.fields,
+                default_sorting_field: this.options.defaultSortingField,
+                enable_nested_fields: enableNested,
+            },
         });
+        return this;
     }
-    drop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.axios({
-                method: "DELETE",
-                url: `/collections/${this.options.name}`,
-            });
+    async drop() {
+        await this.axios({
+            method: "DELETE",
+            url: `/collections/${this.options.name}`,
         });
     }
-    get(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const { data } = yield this.axios({
-                method: "GET",
-                url: `/collections/${this.options.name}/documents/${id}`,
-            }).catch((e) => {
-                if (e.status === 404)
-                    return { data: null };
-                throw e;
-            });
-            return data ? this.deserializeDoc(data) : null;
+    async get(id) {
+        await this.ensureSynced();
+        const { data } = await this.axios({
+            method: "GET",
+            url: `/collections/${this.options.name}/documents/${id}`,
+        }).catch((e) => {
+            if (e.status === 404)
+                return { data: null };
+            throw e;
         });
+        return data ? this.deserializeDoc(data) : null;
     }
-    delete(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const { data } = yield this.axios({
-                method: "DELETE",
-                url: `/collections/${this.options.name}/documents/${id}`,
-            }).catch((e) => {
-                if (e.status === 404)
-                    return { data: null };
-                throw e;
-            });
-            return data != null;
+    async delete(id) {
+        await this.ensureSynced();
+        const { data } = await this.axios({
+            method: "DELETE",
+            url: `/collections/${this.options.name}/documents/${id}`,
+        }).catch((e) => {
+            if (e.status === 404)
+                return { data: null };
+            throw e;
         });
+        return data != null;
     }
-    deleteMany(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const filterBy = this.buildFilter(filter).join("&&");
-            if (!filterBy) {
-                throw new Error("FILTER_REQUIRED");
-            }
-            const { data } = yield this.axios({
-                method: "DELETE",
-                url: `/collections/${this.options.name}/documents`,
-                params: { filter_by: filterBy },
-            });
-            return { deleted: data.num_deleted };
+    async deleteMany(filter) {
+        await this.ensureSynced();
+        const filterBy = this.buildFilter(filter).join("&&");
+        if (!filterBy) {
+            throw new Error("FILTER_REQUIRED");
+        }
+        const { data } = await this.axios({
+            method: "DELETE",
+            url: `/collections/${this.options.name}/documents`,
+            params: { filter_by: filterBy },
         });
+        return { deleted: data.num_deleted };
     }
-    update(id, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const serialized = this.serializeDoc(data);
-            const { data: updated } = yield this.axios({
-                method: "PATCH",
-                url: `/collections/${this.options.name}/documents/${id}`,
-                data: serialized,
-            });
-            return this.deserializeDoc(updated);
+    async update(id, data) {
+        await this.ensureSynced();
+        const serialized = this.serializeDoc(data);
+        const { data: updated } = await this.axios({
+            method: "PATCH",
+            url: `/collections/${this.options.name}/documents/${id}`,
+            data: serialized,
         });
+        return this.deserializeDoc(updated);
     }
-    updateMany(filter, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const filterBy = this.buildFilter(filter).join("&&");
-            if (!filterBy) {
-                throw new Error("FILTER_REQUIRED");
-            }
-            const serialized = this.serializeDoc(data);
-            const { data: result } = yield this.axios({
-                method: "PATCH",
-                url: `/collections/${this.options.name}/documents`,
-                params: { filter_by: filterBy },
-                data: serialized,
-            });
-            return { updated: result.num_updated };
+    async updateMany(filter, data) {
+        await this.ensureSynced();
+        const filterBy = this.buildFilter(filter).join("&&");
+        if (!filterBy) {
+            throw new Error("FILTER_REQUIRED");
+        }
+        const serialized = this.serializeDoc(data);
+        const { data: result } = await this.axios({
+            method: "PATCH",
+            url: `/collections/${this.options.name}/documents`,
+            params: { filter_by: filterBy },
+            data: serialized,
         });
+        return { updated: result.num_updated };
     }
-    search(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g;
-            yield this.ensureSynced();
-            const params = {
-                q: (_a = options.query) !== null && _a !== void 0 ? _a : "",
-                query_by: ((_b = options.queryBy) !== null && _b !== void 0 ? _b : [this.options.defaultSearchField]).join(","),
-            };
-            const sortBy = this.buildSort(options);
-            if (sortBy)
-                params.sort_by = sortBy;
-            const filterBy = this.buildFilter(options.filter).join("&&");
-            if (filterBy)
-                params.filter_by = filterBy;
-            if (options.page != null)
-                params.page = options.page;
-            if (options.limit != null)
-                params.per_page = options.limit;
-            const facetBy = (_c = options.facetBy) === null || _c === void 0 ? void 0 : _c.join(",");
-            if (facetBy)
-                params.facet_by = facetBy;
-            if ("pick" in options && options.pick) {
-                params.include_fields = options.pick.join(",");
+    async search(options) {
+        await this.ensureSynced();
+        const queryByFields = options.queryBy ?? [
+            this.options.defaultSearchField,
+        ];
+        this.validateFields(queryByFields);
+        if (options.sortBy) {
+            this.validateFields(options.sortBy
+                .map((s) => s.split(":")[0])
+                .filter((f) => f !== "undefined"));
+        }
+        if (options.facetBy) {
+            this.validateFields(options.facetBy);
+        }
+        const queryBy = queryByFields.join(",");
+        const params = {
+            q: options.query ?? "*",
+            query_by: queryBy,
+        };
+        const sortBy = this.buildSort(options);
+        if (sortBy)
+            params.sort_by = sortBy;
+        const filterBy = this.buildFilter(options.filter).join("&&");
+        if (filterBy)
+            params.filter_by = filterBy;
+        if (options.page != null)
+            params.page = options.page;
+        if (options.limit != null)
+            params.per_page = options.limit;
+        const facetBy = options.facetBy?.join(",");
+        if (facetBy)
+            params.facet_by = facetBy;
+        if ("pick" in options && options.pick) {
+            params.include_fields = options.pick.join(",");
+        }
+        if ("omit" in options && options.omit) {
+            params.exclude_fields = options.omit.join(",");
+        }
+        const highlight = options.highlight;
+        const highlightOpts = typeof highlight === "object" ? highlight : undefined;
+        if (highlightOpts) {
+            if (highlightOpts.fields) {
+                params.highlight_fields = highlightOpts.fields.join(",");
             }
-            if ("omit" in options && options.omit) {
-                params.exclude_fields = options.omit.join(",");
+            if (highlightOpts.startTag) {
+                params.highlight_start_tag = highlightOpts.startTag;
             }
-            const highlight = options.highlight;
-            const highlightEnabled = !!highlight;
-            let highlightOpts;
-            if (typeof highlight === "object") {
-                highlightOpts = highlight;
-                if (highlightOpts.fields) {
-                    params.highlight_fields = highlightOpts.fields.join(",");
-                }
-                if (highlightOpts.startTag) {
-                    params.highlight_start_tag = highlightOpts.startTag;
-                }
-                if (highlightOpts.endTag) {
-                    params.highlight_end_tag = highlightOpts.endTag;
-                }
+            if (highlightOpts.endTag) {
+                params.highlight_end_tag = highlightOpts.endTag;
             }
-            const { data: res } = yield this.axios({
-                method: "GET",
-                url: `/collections/${this.options.name}/documents/search`,
-                params,
-            });
-            const data = [];
-            const scores = [];
-            for (const hit of (_d = res.hits) !== null && _d !== void 0 ? _d : []) {
-                if (highlightEnabled) {
-                    const fieldsToHighlight = highlightOpts === null || highlightOpts === void 0 ? void 0 : highlightOpts.fields;
-                    for (const [key, value] of Object.entries((_e = hit.highlight) !== null && _e !== void 0 ? _e : {})) {
-                        if (!(value === null || value === void 0 ? void 0 : value.snippet))
-                            continue;
-                        if (fieldsToHighlight && !fieldsToHighlight.includes(key))
-                            continue;
-                        hit.document[key] = value.snippet;
-                    }
+        }
+        const { data: res } = await this.axios({
+            method: "GET",
+            url: `/collections/${this.options.name}/documents/search`,
+            params,
+        });
+        const data = [];
+        const scores = [];
+        for (const hit of res.hits ?? []) {
+            if (highlight) {
+                const fieldsToHighlight = highlightOpts?.fields;
+                for (const [key, value] of Object.entries(hit.highlight ?? {})) {
+                    if (!value?.snippet)
+                        continue;
+                    if (fieldsToHighlight && !fieldsToHighlight.includes(key))
+                        continue;
+                    hit.document[key] = value.snippet;
                 }
-                const doc = this.deserializeDoc(hit.document);
-                data.push(doc);
-                scores.push((_f = hit.text_match) !== null && _f !== void 0 ? _f : 0);
             }
-            const facets = {};
-            for (const facetCount of (_g = res.facet_counts) !== null && _g !== void 0 ? _g : []) {
-                const fieldName = facetCount.field_name;
-                facets[fieldName] = {};
-                for (const item of facetCount.counts) {
-                    facets[fieldName][item.value] = item.count;
-                }
+            const doc = this.deserializeDoc(hit.document);
+            data.push(doc);
+            scores.push(hit.text_match ?? 0);
+        }
+        const facets = {};
+        for (const facetCount of res.facet_counts ?? []) {
+            const fieldName = facetCount.field_name;
+            facets[fieldName] = {};
+            for (const item of facetCount.counts) {
+                facets[fieldName][item.value] = item.count;
             }
-            return {
-                count: res.found,
-                data,
-                facets,
-                scores,
-            };
-        });
+        }
+        return {
+            count: res.found,
+            data,
+            facets,
+            scores,
+        };
     }
-    searchList(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            yield this.ensureSynced();
-            const limit = Math.min((_a = options.limit) !== null && _a !== void 0 ? _a : 20, 100);
-            const field = options.sort.field;
-            const page = options.cursor ? Number(options.cursor) : 1;
-            const params = {
-                q: (_b = options.query) !== null && _b !== void 0 ? _b : "",
-                query_by: ((_c = options.queryBy) !== null && _c !== void 0 ? _c : [this.options.defaultSearchField]).join(","),
-                per_page: limit,
-                page,
-                sort_by: `${field}:${options.sort.direction}`,
-            };
-            const filterParts = this.buildFilter(options.filter);
-            const filterBy = filterParts.join("&&");
-            if (filterBy)
-                params.filter_by = filterBy;
-            const { data: res } = yield this.axios({
-                method: "GET",
-                url: `/collections/${this.options.name}/documents/search`,
-                params,
-            });
-            const hits = (_d = res.hits) !== null && _d !== void 0 ? _d : [];
-            const data = [];
-            for (const hit of hits) {
-                const doc = this.deserializeDoc(hit.document);
-                data.push(doc);
-            }
-            const hasMore = page * limit < res.found;
-            const nextCursor = hasMore ? String(page + 1) : null;
-            return { data, nextCursor, total: res.found };
+    async searchList(options) {
+        const page = options.cursor ? Number(options.cursor) : 1;
+        const limit = Math.min(options.limit ?? 20, 100);
+        const result = await this.search({
+            query: options.query,
+            queryBy: options.queryBy,
+            filter: options.filter,
+            sortBy: [options.sortBy],
+            page,
+            limit,
         });
+        const hasMore = page * limit < result.count;
+        return {
+            data: result.data,
+            nextCursor: hasMore ? String(page + 1) : null,
+            total: result.count,
+        };
     }
-    count(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const filterBy = this.buildFilter(filter).join("&&");
-            if (!filterBy) {
-                const { data } = yield this.axios({
-                    method: "GET",
-                    url: `/collections/${this.options.name}`,
-                });
-                return data.num_documents;
-            }
-            const { data } = yield this.axios({
+    async count(filter) {
+        await this.ensureSynced();
+        const filterBy = this.buildFilter(filter).join("&&");
+        if (!filterBy) {
+            const { data } = await this.axios({
                 method: "GET",
-                url: `/collections/${this.options.name}/documents/search`,
-                params: {
-                    q: "*",
-                    query_by: this.options.defaultSearchField,
-                    per_page: 0,
-                    filter_by: filterBy,
-                },
+                url: `/collections/${this.options.name}`,
             });
-            return data.found;
+            return data.num_documents;
+        }
+        const params = {
+            q: "*",
+            query_by: this.options.defaultSearchField,
+            per_page: 0,
+            filter_by: filterBy,
+        };
+        const { data } = await this.axios({
+            method: "GET",
+            url: `/collections/${this.options.name}/documents/search`,
+            params,
         });
+        return data.found;
     }
-    upsert(docs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureSynced();
-            const items = Array.isArray(docs) ? docs : [docs];
-            if (!items.length)
-                return [];
-            if (this.options.validateOnUpsert) {
-                for (const item of items) {
-                    this.options.schema.assert(item);
-                }
-            }
-            const payload = items.map((item) => JSON.stringify(this.serializeDoc(item))).join("\n");
-            const params = { action: "upsert" };
-            if (this.options.batchSize) {
-                params.batch_size = this.options.batchSize;
+    async upsert(docs) {
+        await this.ensureSynced();
+        const items = Array.isArray(docs) ? docs : [docs];
+        if (!items.length)
+            return [];
+        if (this.options.validateOnUpsert) {
+            for (const item of items) {
+                this.options.schema.assert(item);
             }
-            const { data } = yield this.axios({
-                method: "POST",
-                url: `/collections/${this.options.name}/documents/import`,
-                headers: { "Content-Type": "text/plain" },
-                params,
-                data: payload,
-            });
-            if (typeof data === "string") {
-                return data.split("\n").map((v) => JSON.parse(v));
-            }
-            return [data];
+        }
+        const payload = items
+            .map((item) => JSON.stringify(this.serializeDoc(item)))
+            .join("\n");
+        const params = { action: "upsert" };
+        if (this.options.batchSize) {
+            params.batch_size = this.options.batchSize;
+        }
+        const { data } = await this.axios({
+            method: "POST",
+            url: `/collections/${this.options.name}/documents/import`,
+            headers: { "Content-Type": "text/plain" },
+            params,
+            data: payload,
         });
+        if (typeof data === "string") {
+            return data.split("\n").map((v) => JSON.parse(v));
+        }
+        return [data];
     }
-    syncData(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            if (!this.dataSyncConfig) {
-                throw new Error("DATA_SYNC_NOT_CONFIGURED");
-            }
-            const chunkSize = (_b = (_a = options === null || options === void 0 ? void 0 : options.chunkSize) !== null && _a !== void 0 ? _a : this.dataSyncConfig.chunkSize) !== null && _b !== void 0 ? _b : 500;
-            const ids = (_c = options === null || options === void 0 ? void 0 : options.ids) !== null && _c !== void 0 ? _c : (yield this.dataSyncConfig.getAllIds());
-            let upserted = 0;
-            let failed = 0;
-            for (const chunk of chunkArray(ids, chunkSize)) {
-                const items = yield this.dataSyncConfig.getItems(chunk);
-                const results = yield this.upsert(items);
-                for (const r of results) {
-                    if (r.success)
-                        upserted++;
-                    else
-                        failed++;
-                }
-            }
-            let deleted = 0;
-            if (options === null || options === void 0 ? void 0 : options.purge) {
-                deleted = yield this.purgeOrphans(ids, chunkSize);
+    async syncData(options) {
+        if (!this.dataSyncConfig) {
+            throw new Error("DATA_SYNC_NOT_CONFIGURED");
+        }
+        const chunkSize = options?.chunkSize ?? this.dataSyncConfig.chunkSize ?? 500;
+        const ids = options?.ids ?? (await this.dataSyncConfig.getAllIds());
+        let upserted = 0;
+        let failed = 0;
+        for (const chunk of chunkArray(ids, chunkSize)) {
+            const items = await this.dataSyncConfig.getItems(chunk);
+            const results = await this.upsert(items);
+            for (const r of results) {
+                if (r.success)
+                    upserted++;
+                else
+                    failed++;
             }
-            return { upserted, deleted, failed };
-        });
+        }
+        let deleted = 0;
+        if (options?.purge) {
+            deleted = await this.purgeOrphans(ids, chunkSize);
+        }
+        return { upserted, deleted, failed };
     }
-    purgeOrphans(validIds, chunkSize) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const validSet = new Set(validIds);
-            const remoteIds = yield this.exportIds();
-            const orphans = remoteIds.filter((id) => !validSet.has(id));
-            if (!orphans.length)
-                return 0;
-            let deleted = 0;
-            for (const chunk of chunkArray(orphans, chunkSize)) {
-                const result = yield this.deleteMany({ id: chunk });
-                deleted += result.deleted;
-            }
-            return deleted;
-        });
+    async purgeOrphans(validIds, chunkSize) {
+        const validSet = new Set(validIds);
+        const remoteIds = await this.exportIds();
+        const orphans = remoteIds.filter((id) => !validSet.has(id));
+        if (!orphans.length)
+            return 0;
+        let deleted = 0;
+        for (const chunk of chunkArray(orphans, chunkSize)) {
+            const result = await this.deleteMany({ id: chunk });
+            deleted += result.deleted;
+        }
+        return deleted;
     }
-    exportIds() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.axios({
-                method: "GET",
-                url: `/collections/${this.options.name}/documents/export`,
-                params: { include_fields: "id" },
-            });
-            return data
-                .split("\n")
-                .filter((line) => line.length)
-                .map((line) => JSON.parse(line).id);
+    async exportIds() {
+        const { data } = await this.axios({
+            method: "GET",
+            url: `/collections/${this.options.name}/documents/export`,
+            params: { include_fields: "id" },
         });
+        return data
+            .split("\n")
+            .filter((line) => line.length)
+            .map((line) => JSON.parse(line).id);
+    }
+    scoped(baseFilter) {
+        return {
+            search: (options) => this.search({
+                ...options,
+                filter: { ...options.filter, ...baseFilter },
+            }),
+            searchList: (options) => this.searchList({
+                ...options,
+                filter: { ...options.filter, ...baseFilter },
+            }),
+            count: (filter) => this.count({ ...filter, ...baseFilter }),
+            deleteMany: (filter) => this.deleteMany({ ...filter, ...baseFilter }),
+            updateMany: (filter, data) => this.updateMany({ ...filter, ...baseFilter }, data),
+        };
     }
 }