tsense 0.0.6 → 0.0.8

package/README.md

@@ -40,6 +40,8 @@ const UsersCollection = new TSense({
   validateOnUpsert: true,
 });
 
+type User = typeof UsersCollection.infer;
+
 await UsersCollection.create();
 
 await UsersCollection.upsert([
@@ -72,29 +74,6 @@ await UsersCollection.drop();
 
 ## API Reference
 
-### Constructor
-
-```typescript
-new TSense({
-  name: string,
-  schema: Type,
-  connection: ConnectionConfig,
-  defaultSearchField?: keyof T,
-  defaultSortingField?: keyof T,
-  batchSize?: number,
-  validateOnUpsert?: boolean,
-})
-```
-
-### ConnectionConfig
-
-| Option     | Type                  | Description           |
-| ---------- | --------------------- | --------------------- |
-| `host`     | `string`              | Typesense server host |
-| `port`     | `number`              | Typesense server port |
-| `protocol` | `"http"` \| `"https"` | Connection protocol   |
-| `apiKey`   | `string`              | Typesense API key     |
-
 ### Schema Configuration
 
 Use `.configure()` to set Typesense field options:
@@ -122,22 +101,6 @@ type("string").configure({
 | `upsert(docs)` | Inserts or updates documents |
 | `search(options)` | Searches the collection |
 
-### Search Options
-
-| Option      | Type                              | Description              |
-| ----------- | --------------------------------- | ------------------------ |
-| `query`     | `string`                          | Text search query        |
-| `queryBy`   | `(keyof T)[]`                     | Fields to search in      |
-| `filter`    | `FilterFor<T>`                    | Filter conditions        |
-| `sortBy`    | `"field:asc\|desc"[]`             | Sort order               |
-| `facetBy`   | `(keyof T)[]`                     | Fields to facet by       |
-| `page`      | `number`                          | Page number              |
-| `limit`     | `number`                          | Results per page         |
-| `pick`      | `(keyof T)[]`                     | Only return these fields |
-| `omit`      | `(keyof T)[]`                     | Exclude these fields     |
-| `highlight` | `boolean \| HighlightOptions<T>`  | Enable highlighting      |
-
-Note: `pick` and `omit` are mutually exclusive.
 
 ### Filter Syntax
 
@@ -148,4 +111,4 @@ filter: { age: [25, 30, 35] }               // IN
 filter: { age: { min: 20, max: 40 } }       // Range
 filter: { name: { not: "John" } }           // Not equal
 filter: { OR: [{ age: 25 }, { age: 30 }] }  // OR conditions
-```
+```

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export type { TsenseFieldMeta, TsenseFieldType } from "./env.js";
 export { TSense } from "./tsense.js";
-export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, SearchOptions, SearchResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.js";
+export { defaultTransformers } from "./transformers/defaults.js";
+export { DateTransformer } from "./transformers/date.js";
+export type { FieldTransformer } from "./transformers/types.js";
+export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, SearchListOptions, SearchListResult, SearchOptions, SearchResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.js";

package/dist/index.js

@@ -1 +1,3 @@
 export { TSense } from "./tsense.js";
+export { defaultTransformers } from "./transformers/defaults.js";
+export { DateTransformer } from "./transformers/date.js";

package/dist/migrator.d.ts

@@ -0,0 +1,17 @@
+import type { AxiosInstance } from "./tsense.js";
+import type { FieldSchema } from "./types.js";
+export declare class TSenseMigrator {
+    private collectionName;
+    private localFields;
+    private defaultSortingField;
+    private axios;
+    constructor(collectionName: string, localFields: FieldSchema[], defaultSortingField: string | undefined, axios: AxiosInstance);
+    sync(): Promise<void>;
+    private exists;
+    private getRemoteFields;
+    private diff;
+    private fieldsMatch;
+    private patch;
+    private create;
+    private drop;
+}

package/dist/migrator.js

@@ -0,0 +1,141 @@
+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());
+    });
+};
+const COMPARABLE_KEYS = ["type", "facet", "sort", "index", "optional"];
+const NESTED_TYPES = ["object", "object[]"];
+export class TSenseMigrator {
+    constructor(collectionName, localFields, defaultSortingField, axios) {
+        this.collectionName = collectionName;
+        this.localFields = localFields;
+        this.defaultSortingField = defaultSortingField;
+        this.axios = axios;
+    }
+    sync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exists = yield this.exists();
+            if (!exists) {
+                return yield this.create();
+            }
+            const remoteFields = yield this.getRemoteFields();
+            const diff = this.diff(remoteFields);
+            if (!diff.toAdd.length && !diff.toRemove.length && !diff.toModify.length) {
+                return;
+            }
+            const patched = yield this.patch(diff);
+            if (patched)
+                return;
+            yield this.drop();
+            yield this.create();
+        });
+    }
+    exists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.axios({
+                method: "GET",
+                url: `/collections/${this.collectionName}`,
+            })
+                .then(() => true)
+                .catch((e) => {
+                if (e.status === 404)
+                    return false;
+                throw e;
+            });
+        });
+    }
+    getRemoteFields() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios({
+                method: "GET",
+                url: `/collections/${this.collectionName}`,
+            });
+            return data.fields;
+        });
+    }
+    diff(remote) {
+        const remoteByName = new Map(remote.map((f) => [f.name, f]));
+        const localByName = new Map(this.localFields.map((f) => [f.name, f]));
+        const toAdd = [];
+        const toRemove = [];
+        const toModify = [];
+        for (const local of this.localFields) {
+            if (local.name === "id")
+                continue;
+            const remoteField = remoteByName.get(local.name);
+            if (!remoteField) {
+                toAdd.push(local);
+                continue;
+            }
+            if (this.fieldsMatch(local, remoteField))
+                continue;
+            toModify.push(local);
+        }
+        for (const remoteField of remote) {
+            if (remoteField.name === "id")
+                continue;
+            if (localByName.has(remoteField.name))
+                continue;
+            toRemove.push(remoteField);
+        }
+        return { toAdd, toRemove, toModify };
+    }
+    fieldsMatch(local, remote) {
+        var _a, _b;
+        for (const key of COMPARABLE_KEYS) {
+            if (((_a = local[key]) !== null && _a !== void 0 ? _a : undefined) !== ((_b = remote[key]) !== null && _b !== void 0 ? _b : undefined)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    patch(diff) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fields = [];
+            for (const field of diff.toRemove) {
+                fields.push({ name: field.name, drop: true });
+            }
+            for (const field of diff.toModify) {
+                fields.push({ name: field.name, drop: true });
+                fields.push(field);
+            }
+            for (const field of diff.toAdd) {
+                fields.push(field);
+            }
+            return yield this.axios({
+                method: "PATCH",
+                url: `/collections/${this.collectionName}`,
+                data: { fields },
+            })
+                .then(() => true)
+                .catch(() => false);
+        });
+    }
+    create() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const enable_nested_fields = this.localFields.some((f) => NESTED_TYPES.includes(f.type));
+            yield this.axios({
+                method: "POST",
+                url: "/collections",
+                data: {
+                    name: this.collectionName,
+                    fields: this.localFields,
+                    default_sorting_field: this.defaultSortingField,
+                    enable_nested_fields,
+                },
+            });
+        });
+    }
+    drop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios({
+                method: "DELETE",
+                url: `/collections/${this.collectionName}`,
+            });
+        });
+    }
+}

package/dist/transformers/date.d.ts

@@ -0,0 +1,2 @@
+import type { FieldTransformer } from "./types.js";
+export declare const DateTransformer: FieldTransformer<Date, number>;

package/dist/transformers/date.js

@@ -0,0 +1,6 @@
+export const DateTransformer = {
+    match: (expr, domain) => expr === "Date" || domain === "Date",
+    storageType: "int64",
+    serialize: (date) => date.getTime(),
+    deserialize: (ts) => new Date(ts),
+};

package/dist/transformers/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { FieldTransformer } from "./types.js";
+export declare const defaultTransformers: FieldTransformer[];

package/dist/transformers/defaults.js

@@ -0,0 +1,2 @@
+import { DateTransformer } from "./date.js";
+export const defaultTransformers = [DateTransformer];

package/dist/transformers/types.d.ts

@@ -0,0 +1,7 @@
+import type { TsenseFieldType } from "../env.js";
+export interface FieldTransformer<TJs = unknown, TStorage = unknown> {
+    match: (expression: string, domain?: string) => boolean;
+    storageType: TsenseFieldType;
+    serialize: (value: TJs) => TStorage;
+    deserialize: (value: TStorage) => TJs;
+}

package/dist/transformers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tsense.d.ts

@@ -1,14 +1,77 @@
 import type { Type } from "arktype";
-import type { DeleteResult, FilterFor, SearchOptions, SearchResult, TsenseOptions, UpdateResult, UpsertResult } from "./types.js";
+import redaxios from "redaxios";
+import type { DeleteResult, FilterFor, SearchListOptions, SearchListResult, SearchOptions, SearchResult, TsenseOptions, UpdateResult, UpsertResult } from "./types.js";
+declare const redaxiosInstance: {
+    <T>(urlOrConfig: string | redaxios.Options, config?: redaxios.Options | undefined, _method?: any, data?: any, _undefined?: undefined): Promise<redaxios.Response<T>>;
+    request: (<T_1 = any>(config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_1>>) | (<T_2 = any>(url: string, config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_2>>);
+    get<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+    delete<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+    head<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+    options<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+    post<T_4 = any>(url: string, body?: any, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_4>>;
+    put<T_4 = any>(url: string, body?: any, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_4>>;
+    patch<T_4 = any>(url: string, body?: any, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_4>>;
+    all: {
+        <T_5>(values: Iterable<T_5 | PromiseLike<T_5>>): Promise<T_5[]>;
+        <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+        <T1_1, T2_1, T3_1, T4_1, T5_1, T6_1, T7_1, T8_1, T9_1>(values: readonly [T1_1 | PromiseLike<T1_1>, T2_1 | PromiseLike<T2_1>, T3_1 | PromiseLike<T3_1>, T4_1 | PromiseLike<T4_1>, T5_1 | PromiseLike<T5_1>, T6_1 | PromiseLike<T6_1>, T7_1 | PromiseLike<T7_1>, T8_1 | PromiseLike<T8_1>, T9_1 | PromiseLike<T9_1>]): Promise<[T1_1, T2_1, T3_1, T4_1, T5_1, T6_1, T7_1, T8_1, T9_1]>;
+        <T1_2, T2_2, T3_2, T4_2, T5_2, T6_2, T7_2, T8_2>(values: readonly [T1_2 | PromiseLike<T1_2>, T2_2 | PromiseLike<T2_2>, T3_2 | PromiseLike<T3_2>, T4_2 | PromiseLike<T4_2>, T5_2 | PromiseLike<T5_2>, T6_2 | PromiseLike<T6_2>, T7_2 | PromiseLike<T7_2>, T8_2 | PromiseLike<T8_2>]): Promise<[T1_2, T2_2, T3_2, T4_2, T5_2, T6_2, T7_2, T8_2]>;
+        <T1_3, T2_3, T3_3, T4_3, T5_3, T6_3, T7_3>(values: readonly [T1_3 | PromiseLike<T1_3>, T2_3 | PromiseLike<T2_3>, T3_3 | PromiseLike<T3_3>, T4_3 | PromiseLike<T4_3>, T5_3 | PromiseLike<T5_3>, T6_3 | PromiseLike<T6_3>, T7_3 | PromiseLike<T7_3>]): Promise<[T1_3, T2_3, T3_3, T4_3, T5_3, T6_3, T7_3]>;
+        <T1_4, T2_4, T3_4, T4_4, T5_4, T6_4>(values: readonly [T1_4 | PromiseLike<T1_4>, T2_4 | PromiseLike<T2_4>, T3_4 | PromiseLike<T3_4>, T4_4 | PromiseLike<T4_4>, T5_4 | PromiseLike<T5_4>, T6_4 | PromiseLike<T6_4>]): Promise<[T1_4, T2_4, T3_4, T4_4, T5_4, T6_4]>;
+        <T1_5, T2_5, T3_5, T4_5, T5_5>(values: readonly [T1_5 | PromiseLike<T1_5>, T2_5 | PromiseLike<T2_5>, T3_5 | PromiseLike<T3_5>, T4_5 | PromiseLike<T4_5>, T5_5 | PromiseLike<T5_5>]): Promise<[T1_5, T2_5, T3_5, T4_5, T5_5]>;
+        <T1_6, T2_6, T3_6, T4_6>(values: readonly [T1_6 | PromiseLike<T1_6>, T2_6 | PromiseLike<T2_6>, T3_6 | PromiseLike<T3_6>, T4_6 | PromiseLike<T4_6>]): Promise<[T1_6, T2_6, T3_6, T4_6]>;
+        <T1_7, T2_7, T3_7>(values: readonly [T1_7 | PromiseLike<T1_7>, T2_7 | PromiseLike<T2_7>, T3_7 | PromiseLike<T3_7>]): Promise<[T1_7, T2_7, T3_7]>;
+        <T1_8, T2_8>(values: readonly [T1_8 | PromiseLike<T1_8>, T2_8 | PromiseLike<T2_8>]): Promise<[T1_8, T2_8]>;
+        <T_6>(values: readonly (T_6 | PromiseLike<T_6>)[]): Promise<T_6[]>;
+    };
+    spread<Args, R>(fn: (...args: Args[]) => R): (array: Args[]) => R;
+    CancelToken: AbortController;
+    defaults: redaxios.Options;
+    create: (defaults?: redaxios.Options | undefined) => {
+        <T>(urlOrConfig: string | redaxios.Options, config?: redaxios.Options | undefined, _method?: any, data?: any, _undefined?: undefined): Promise<redaxios.Response<T>>;
+        request: (<T_1 = any>(config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_1>>) | (<T_2 = any>(url: string, config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_2>>);
+        get<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+        delete<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+        head<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+        options<T_3 = any>(url: string, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_3>>;
+        post<T_4 = any>(url: string, body?: any, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_4>>;
+        put<T_4 = any>(url: string, body?: any, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_4>>;
+        patch<T_4 = any>(url: string, body?: any, config?: redaxios.Options | undefined): Promise<redaxios.Response<T_4>>;
+        all: {
+            <T_5>(values: Iterable<T_5 | PromiseLike<T_5>>): Promise<T_5[]>;
+            <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+            <T1_1, T2_1, T3_1, T4_1, T5_1, T6_1, T7_1, T8_1, T9_1>(values: readonly [T1_1 | PromiseLike<T1_1>, T2_1 | PromiseLike<T2_1>, T3_1 | PromiseLike<T3_1>, T4_1 | PromiseLike<T4_1>, T5_1 | PromiseLike<T5_1>, T6_1 | PromiseLike<T6_1>, T7_1 | PromiseLike<T7_1>, T8_1 | PromiseLike<T8_1>, T9_1 | PromiseLike<T9_1>]): Promise<[T1_1, T2_1, T3_1, T4_1, T5_1, T6_1, T7_1, T8_1, T9_1]>;
+            <T1_2, T2_2, T3_2, T4_2, T5_2, T6_2, T7_2, T8_2>(values: readonly [T1_2 | PromiseLike<T1_2>, T2_2 | PromiseLike<T2_2>, T3_2 | PromiseLike<T3_2>, T4_2 | PromiseLike<T4_2>, T5_2 | PromiseLike<T5_2>, T6_2 | PromiseLike<T6_2>, T7_2 | PromiseLike<T7_2>, T8_2 | PromiseLike<T8_2>]): Promise<[T1_2, T2_2, T3_2, T4_2, T5_2, T6_2, T7_2, T8_2]>;
+            <T1_3, T2_3, T3_3, T4_3, T5_3, T6_3, T7_3>(values: readonly [T1_3 | PromiseLike<T1_3>, T2_3 | PromiseLike<T2_3>, T3_3 | PromiseLike<T3_3>, T4_3 | PromiseLike<T4_3>, T5_3 | PromiseLike<T5_3>, T6_3 | PromiseLike<T6_3>, T7_3 | PromiseLike<T7_3>]): Promise<[T1_3, T2_3, T3_3, T4_3, T5_3, T6_3, T7_3]>;
+            <T1_4, T2_4, T3_4, T4_4, T5_4, T6_4>(values: readonly [T1_4 | PromiseLike<T1_4>, T2_4 | PromiseLike<T2_4>, T3_4 | PromiseLike<T3_4>, T4_4 | PromiseLike<T4_4>, T5_4 | PromiseLike<T5_4>, T6_4 | PromiseLike<T6_4>]): Promise<[T1_4, T2_4, T3_4, T4_4, T5_4, T6_4]>;
+            <T1_5, T2_5, T3_5, T4_5, T5_5>(values: readonly [T1_5 | PromiseLike<T1_5>, T2_5 | PromiseLike<T2_5>, T3_5 | PromiseLike<T3_5>, T4_5 | PromiseLike<T4_5>, T5_5 | PromiseLike<T5_5>]): Promise<[T1_5, T2_5, T3_5, T4_5, T5_5]>;
+            <T1_6, T2_6, T3_6, T4_6>(values: readonly [T1_6 | PromiseLike<T1_6>, T2_6 | PromiseLike<T2_6>, T3_6 | PromiseLike<T3_6>, T4_6 | PromiseLike<T4_6>]): Promise<[T1_6, T2_6, T3_6, T4_6]>;
+            <T1_7, T2_7, T3_7>(values: readonly [T1_7 | PromiseLike<T1_7>, T2_7 | PromiseLike<T2_7>, T3_7 | PromiseLike<T3_7>]): Promise<[T1_7, T2_7, T3_7]>;
+            <T1_8, T2_8>(values: readonly [T1_8 | PromiseLike<T1_8>, T2_8 | PromiseLike<T2_8>]): Promise<[T1_8, T2_8]>;
+            <T_6>(values: readonly (T_6 | PromiseLike<T_6>)[]): Promise<T_6[]>;
+        };
+        spread<Args, R>(fn: (...args: Args[]) => R): (array: Args[]) => R;
+        CancelToken: AbortController;
+        defaults: redaxios.Options;
+        create: any;
+    };
+};
+export type AxiosInstance = ReturnType<typeof redaxiosInstance.create>;
 export declare class TSense<T extends Type> {
     private options;
     private fields;
-    private enableNested;
-    private baseURL;
-    private headers;
+    private axios;
+    private synced;
+    private fieldTransformers;
+    infer: T["infer"];
     constructor(options: TsenseOptions<T>);
     private inferType;
+    private serializeDoc;
+    private deserializeDoc;
+    private serializeFilterValue;
     private extractFields;
+    private ensureSynced;
+    sync(): Promise<void>;
     private buildObjectFilter;
     private buildFilter;
     private buildSort;
@@ -20,5 +83,7 @@ export declare class TSense<T extends Type> {
     update(id: string, data: Partial<T["infer"]>): Promise<T["infer"]>;
     updateMany(filter: FilterFor<T["infer"]>, data: Partial<T["infer"]>): Promise<UpdateResult>;
     search(options: SearchOptions<T["infer"]>): Promise<SearchResult<T["infer"]>>;
+    searchList(options: SearchListOptions<T["infer"]>): Promise<SearchListResult<T["infer"]>>;
     upsert(docs: T["infer"] | T["infer"][]): Promise<UpsertResult[]>;
 }
+export {};

package/dist/tsense.js

@@ -9,8 +9,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var _a;
 import redaxios from "redaxios";
-const axios = (_a = redaxios.default) !== null && _a !== void 0 ? _a : redaxios;
-const requiresNested = ["object", "object[]"];
+import { TSenseMigrator } from "./migrator.js";
+import { defaultTransformers } from "./transformers/defaults.js";
+const redaxiosInstance = (_a = redaxios.default) !== null && _a !== void 0 ? _a : redaxios;
 const arkToTsense = {
     string: "string",
     number: "float",
@@ -22,13 +23,17 @@ const arkToTsense = {
 };
 export class TSense {
     constructor(options) {
+        var _a;
         this.options = options;
         this.fields = [];
-        this.enableNested = false;
-        const { connection } = options;
-        this.baseURL = `${connection.protocol}://${connection.host}:${connection.port}`;
-        this.headers = { "X-TYPESENSE-API-KEY": connection.apiKey };
-        this.extractFields();
+        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);
     }
     inferType(arkType) {
         const direct = arkToTsense[arkType];
@@ -42,20 +47,71 @@ export class TSense {
             return "string";
         return "string";
     }
-    extractFields() {
+    serializeDoc(doc) {
+        const result = Object.assign({}, doc);
+        for (const [field, transformer] of this.fieldTransformers) {
+            if (result[field] != null) {
+                result[field] = transformer.serialize(result[field]);
+            }
+        }
+        return result;
+    }
+    deserializeDoc(doc) {
+        for (const [field, transformer] of this.fieldTransformers) {
+            if (doc[field] != null) {
+                doc[field] = transformer.deserialize(doc[field]);
+            }
+        }
+        return doc;
+    }
+    serializeFilterValue(key, value) {
+        const transformer = this.fieldTransformers.get(key);
+        if (!transformer)
+            return value;
+        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);
+            }
+            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;
         const internal = this.options.schema;
         for (const prop of internal.structure.props) {
             const meta = prop.value.meta;
             const expression = String(prop.value.expression);
             const domain = prop.value.domain;
-            const tsType = (_a = meta === null || meta === void 0 ? void 0 : meta.type) !== null && _a !== void 0 ? _a : this.inferType(domain !== null && domain !== void 0 ? domain : expression);
-            if (requiresNested.includes(tsType)) {
-                this.enableNested = true;
+            const transformer = transformers.find((t) => t.match(expression, domain));
+            if (transformer) {
+                this.fieldTransformers.set(prop.key, transformer);
+                this.fields.push({
+                    name: prop.key,
+                    type: transformer.storageType,
+                    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,
+                });
+                continue;
             }
+            const type = (_a = meta === null || meta === void 0 ? void 0 : meta.type) !== null && _a !== void 0 ? _a : this.inferType(domain !== null && domain !== void 0 ? domain : expression);
             this.fields.push({
                 name: prop.key,
-                type: tsType,
+                type,
                 optional: prop.kind === "optional",
                 facet: meta === null || meta === void 0 ? void 0 : meta.facet,
                 sort: meta === null || meta === void 0 ? void 0 : meta.sort,
@@ -63,6 +119,19 @@ export class TSense {
             });
         }
     }
+    ensureSynced(force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!force && (this.synced || !this.options.autoSync))
+                return;
+            yield new TSenseMigrator(this.options.name, this.fields, this.options.defaultSortingField, this.axios).sync();
+            this.synced = true;
+        });
+    }
+    sync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureSynced(true);
+        });
+    }
     buildObjectFilter(key, value) {
         var _a, _b;
         if (Array.isArray(value)) {
@@ -87,18 +156,19 @@ export class TSense {
     buildFilter(filter) {
         const result = [];
         for (const entry of Object.entries(filter !== null && filter !== void 0 ? filter : {})) {
-            const [key, value] = entry;
-            if (value == null)
+            const [key, rawValue] = entry;
+            if (rawValue == null)
                 continue;
             if (key === "OR") {
                 const orFilter = [];
-                for (const condition of value) {
+                for (const condition of rawValue) {
                     const inner = this.buildFilter(condition);
                     orFilter.push(`(${inner.join("||")})`);
                 }
                 result.push(`(${orFilter.join("||")})`);
                 continue;
             }
+            const value = this.serializeFilterValue(key, rawValue);
             switch (typeof value) {
                 case "string":
                 case "number":
@@ -132,16 +202,15 @@ export class TSense {
     }
     create() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield axios({
+            const enableNested = this.fields.some((f) => f.type === "object" || f.type === "object[]");
+            yield this.axios({
                 method: "POST",
-                baseURL: this.baseURL,
                 url: "/collections",
-                headers: this.headers,
                 data: {
                     name: this.options.name,
                     fields: this.fields,
                     default_sorting_field: this.options.defaultSortingField,
-                    enable_nested_fields: this.enableNested,
+                    enable_nested_fields: enableNested,
                 },
             });
             return this;
@@ -149,36 +218,32 @@ export class TSense {
     }
     drop() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield axios({
+            yield this.axios({
                 method: "DELETE",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}`,
-                headers: this.headers,
             });
         });
     }
     get(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield axios({
+            yield this.ensureSynced();
+            const { data } = yield this.axios({
                 method: "GET",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents/${id}`,
-                headers: this.headers,
             }).catch((e) => {
                 if (e.status === 404)
                     return { data: null };
                 throw e;
             });
-            return data;
+            return data ? this.deserializeDoc(data) : null;
         });
     }
     delete(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield axios({
+            yield this.ensureSynced();
+            const { data } = yield this.axios({
                 method: "DELETE",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents/${id}`,
-                headers: this.headers,
             }).catch((e) => {
                 if (e.status === 404)
                     return { data: null };
@@ -189,15 +254,14 @@ export class TSense {
     }
     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 axios({
+            const { data } = yield this.axios({
                 method: "DELETE",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents`,
-                headers: this.headers,
                 params: { filter_by: filterBy },
             });
             return { deleted: data.num_deleted };
@@ -205,29 +269,29 @@ export class TSense {
     }
     update(id, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data: updated } = yield axios({
+            yield this.ensureSynced();
+            const serialized = this.serializeDoc(data);
+            const { data: updated } = yield this.axios({
                 method: "PATCH",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents/${id}`,
-                headers: this.headers,
-                data,
+                data: serialized,
             });
-            return updated;
+            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 { data: result } = yield axios({
+            const serialized = this.serializeDoc(data);
+            const { data: result } = yield this.axios({
                 method: "PATCH",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents`,
-                headers: this.headers,
                 params: { filter_by: filterBy },
-                data,
+                data: serialized,
             });
             return { updated: result.num_updated };
         });
@@ -235,11 +299,10 @@ export class TSense {
     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(","),
+                query_by: ((_b = options.queryBy) !== null && _b !== void 0 ? _b : [this.options.defaultSearchField]).join(","),
             };
             const sortBy = this.buildSort(options);
             if (sortBy)
@@ -275,11 +338,9 @@ export class TSense {
                     params.highlight_end_tag = highlightOpts.endTag;
                 }
             }
-            const { data: res } = yield axios({
+            const { data: res } = yield this.axios({
                 method: "GET",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents/search`,
-                headers: this.headers,
                 params,
             });
             const data = [];
@@ -295,7 +356,8 @@ export class TSense {
                         hit.document[key] = value.snippet;
                     }
                 }
-                data.push(hit.document);
+                const doc = this.deserializeDoc(hit.document);
+                data.push(doc);
                 scores.push((_f = hit.text_match) !== null && _f !== void 0 ? _f : 0);
             }
             const facets = {};
@@ -314,8 +376,48 @@ export class TSense {
             };
         });
     }
+    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 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,
+                sort_by: `${field}:${options.sort.direction}`,
+            };
+            const filterParts = this.buildFilter(options.filter);
+            if (options.cursor) {
+                const op = options.sort.direction === "asc" ? ">" : "<";
+                filterParts.push(`${field}:${op}${options.cursor}`);
+            }
+            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);
+            }
+            if (data.length < limit) {
+                return { data, nextCursor: null };
+            }
+            const lastHit = hits[hits.length - 1].document;
+            const nextCursor = String(lastHit[field]);
+            return { data, nextCursor };
+        });
+    }
     upsert(docs) {
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureSynced();
             const items = Array.isArray(docs) ? docs : [docs];
             if (!items.length)
                 return [];
@@ -324,16 +426,15 @@ export class TSense {
                     this.options.schema.assert(item);
                 }
             }
-            const payload = items.map((item) => JSON.stringify(item)).join("\n");
+            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 } = yield axios({
+            const { data } = yield this.axios({
                 method: "POST",
-                baseURL: this.baseURL,
                 url: `/collections/${this.options.name}/documents/import`,
-                headers: Object.assign(Object.assign({}, this.headers), { "Content-Type": "text/plain" }),
+                headers: { "Content-Type": "text/plain" },
                 params,
                 data: payload,
             });

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { Type } from "arktype";
+import type { FieldTransformer } from "./transformers/types.js";
 type BaseIfArray<T> = T extends (infer Q)[] ? Q : T;
 export type FieldSchema = {
     name: string;
@@ -41,14 +42,16 @@ export type TsenseOptions<T extends Type> = {
     defaultSortingField?: keyof T["infer"];
     batchSize?: number;
     validateOnUpsert?: boolean;
+    autoSync?: boolean;
+    transformers?: FieldTransformer[];
 };
 type SingleFilter<T> = Partial<{
     [K in keyof T]: BaseIfArray<T[K]> | NonNullable<BaseIfArray<T[K]>>[] | {
         not?: BaseIfArray<T[K]>;
-    } | (NonNullable<T[K]> extends number ? {
-        min?: number;
-        max?: number;
-    } : never);
+    } | (NonNullable<T[K]> extends number | Date ? NonNullable<T[K]> extends infer Type ? {
+        min?: Type;
+        max?: Type;
+    } : never : never);
 }>;
 export type FilterFor<T> = SingleFilter<T> & {
     OR?: FilterFor<T>[];
@@ -96,4 +99,20 @@ export type UpsertResult = {
     error?: string;
     document?: unknown;
 };
+type SearchListSort<T> = {
+    field: keyof T;
+    direction: "asc" | "desc";
+};
+export type SearchListOptions<T> = {
+    query?: string;
+    queryBy?: (keyof T)[];
+    filter?: FilterFor<T>;
+    sort: SearchListSort<T>;
+    limit?: number;
+    cursor?: string;
+};
+export type SearchListResult<T> = {
+    data: T[];
+    nextCursor: string | null;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "tsense",
-	"version": "0.0.6",
+	"version": "0.0.8",
 	"private": false,
 	"description": "Opinionated, fully typed typesense client",
 	"keywords": [
@@ -41,7 +41,9 @@
 		"@biomejs/biome": "2.1.4",
 		"@changesets/cli": "^2.29.7",
 		"@types/bun": "latest",
-		"arktype": "^2.1.29"
+		"arktype": "^2.1.29",
+		"oxfmt": "^0.23.0",
+		"oxlint": "^1.38.0"
 	},
 	"peerDependencies": {
 		"arktype": "^2.1.29",