tsense 0.2.0-next.3 → 0.2.0-next.5

package/dist/filters/filter-state.js

@@ -86,17 +86,19 @@ export function applyPreset(state, descriptor, field, name) {
     if (!preset) {
         return state;
     }
-    const rows = [];
+    const presetRows = [];
     for (const [key, value] of Object.entries(preset.filter)) {
         const row = filterValueToRow(key, value);
         if (row) {
-            rows.push(row);
+            presetRows.push(row);
         }
     }
-    if (!rows.length) {
+    if (!presetRows.length) {
         return state;
     }
-    return { rows };
+    const presetFields = new Set(presetRows.map((r) => r.field));
+    const preserved = state.rows.filter((r) => !r.field || !presetFields.has(r.field));
+    return { rows: [...preserved, ...presetRows] };
 }
 export function conditionsFor(descriptor, field) {
     const column = descriptor.columns.find((c) => c.key === field);

package/dist/filters/index.d.ts

@@ -1,13 +1,14 @@
-export { deserializeFilter, serializeFilter } from "./url.js";
-import type { Type } from "arktype";
-import type { TSense } from "../tsense.js";
-import type { FilterFor, SearchInput } from "../types.js";
+export { isRelativeDate, resolveRelativeDate } from './relative-dates.js';
+export { deserializeFilter, serializeFilter } from './url.js';
+import type { Type } from 'arktype';
+import type { TSense } from '../tsense.js';
+import type { FilterFor, SearchInput } from '../types.js';
 export type FilterDescriptor<T = Record<string, unknown>> = {
     infer: FilterFor<T>;
     columns: {
         key: keyof T & string;
         label: string;
-        type: "string" | "number" | "boolean" | "date";
+        type: 'string' | 'number' | 'boolean' | 'date';
         conditions: {
             key: string;
             label: string;
@@ -31,10 +32,10 @@ type FilterBuilderReturn<T> = {
     describe(): FilterDescriptor<T>;
     schema(): Type<SearchInput<T>>;
 };
-type ColumnType = FilterDescriptor["columns"][number]["type"];
+type ColumnType = FilterDescriptor['columns'][number]['type'];
 type FilterBuilderOptions = {
-    conditionLabels?: Partial<Record<ColumnType | "enum", Partial<Record<string, string>>>>;
+    conditionLabels?: Partial<Record<ColumnType | 'enum', Partial<Record<string, string>>>>;
 };
 export declare function createFilterBuilder<T extends Type>(collection: TSense<T>, config: {
-    [K in keyof T["infer"]]?: FilterBuilderFieldConfig<T["infer"]>;
-}, options?: FilterBuilderOptions): FilterBuilderReturn<T["infer"]>;
+    [K in keyof T['infer']]?: FilterBuilderFieldConfig<T['infer']>;
+}, options?: FilterBuilderOptions): FilterBuilderReturn<T['infer']>;

package/dist/filters/index.js

@@ -1,45 +1,46 @@
-export { deserializeFilter, serializeFilter } from "./url.js";
-import { type } from "arktype";
+export { isRelativeDate, resolveRelativeDate } from './relative-dates.js';
+export { deserializeFilter, serializeFilter } from './url.js';
+import { type } from 'arktype';
 const tsenseTypeMap = {
-    string: "string",
-    "string*": "string",
-    "string[]": "string",
-    int32: "number",
-    int64: "number",
-    float: "number",
-    "int32[]": "number",
-    "int64[]": "number",
-    "float[]": "number",
-    bool: "boolean",
-    "bool[]": "boolean",
-    auto: "string",
-    image: "string",
+    string: 'string',
+    'string*': 'string',
+    'string[]': 'string',
+    int32: 'number',
+    int64: 'number',
+    float: 'number',
+    'int32[]': 'number',
+    'int64[]': 'number',
+    'float[]': 'number',
+    bool: 'boolean',
+    'bool[]': 'boolean',
+    auto: 'string',
+    image: 'string',
 };
 const enumConditions = [
-    { key: "is_in", label: "is in" },
-    { key: "is_not_in", label: "is not in" },
+    { key: 'is_in', label: 'is in' },
+    { key: 'is_not_in', label: 'is not in' },
 ];
 const conditionsByType = {
     string: [
-        { key: "equals", label: "equals" },
-        { key: "not_equals", label: "not equals" },
+        { key: 'equals', label: 'equals' },
+        { key: 'not_equals', label: 'not equals' },
     ],
     number: [
-        { key: "equals", label: "equals" },
-        { key: "not_equals", label: "not equals" },
-        { key: "gt", label: "greater than" },
-        { key: "gte", label: "greater than or equal" },
-        { key: "lt", label: "less than" },
-        { key: "lte", label: "less than or equal" },
-        { key: "between", label: "between" },
+        { key: 'equals', label: 'equals' },
+        { key: 'not_equals', label: 'not equals' },
+        { key: 'gt', label: 'greater than' },
+        { key: 'gte', label: 'greater than or equal' },
+        { key: 'lt', label: 'less than' },
+        { key: 'lte', label: 'less than or equal' },
+        { key: 'between', label: 'between' },
     ],
-    boolean: [{ key: "equals", label: "equals" }],
+    boolean: [{ key: 'equals', label: 'equals' }],
     date: [
-        { key: "equals", label: "equals" },
-        { key: "not_equals", label: "not equals" },
-        { key: "gt", label: "after" },
-        { key: "lt", label: "before" },
-        { key: "between", label: "between" },
+        { key: 'equals', label: 'equals' },
+        { key: 'not_equals', label: 'not equals' },
+        { key: 'gt', label: 'after' },
+        { key: 'lt', label: 'before' },
+        { key: 'between', label: 'between' },
     ],
 };
 export function createFilterBuilder(collection, config, options) {
@@ -47,34 +48,37 @@ export function createFilterBuilder(collection, config, options) {
     return {
         schema() {
             const numberOps = type.raw({
-                "not?": "number",
-                "gt?": "number",
-                "gte?": "number",
-                "lt?": "number",
-                "lte?": "number",
-                "notIn?": "number[]",
+                'not?': 'number',
+                'gt?': 'number',
+                'gte?': 'number',
+                'lt?': 'number',
+                'lte?': 'number',
+                'notIn?': 'number[]',
             });
             const stringOps = type.raw({
-                "not?": "string",
-                "notIn?": "string[]",
+                'not?': 'string',
+                'notIn?': 'string[]',
             });
-            const dateInput = "number | string | Date";
+            const relativeDateUnit = "'day' | 'week' | 'month'";
+            const relativeDate = type
+                .raw({ startOf: relativeDateUnit })
+                .or(type.raw({ endOf: relativeDateUnit }));
+            const concreteDateInput = type.raw('number | string | Date');
+            const dateInput = concreteDateInput.or(relativeDate);
+            const dateArrayInput = dateInput.array();
             const dateOps = type.raw({
-                "not?": dateInput,
-                "gt?": dateInput,
-                "gte?": dateInput,
-                "lt?": dateInput,
-                "lte?": dateInput,
-                "notIn?": `(${dateInput})[]`,
+                'not?': dateInput,
+                'gt?': dateInput,
+                'gte?': dateInput,
+                'lt?': dateInput,
+                'lte?': dateInput,
+                'notIn?': dateArrayInput,
             });
             const fieldSchemas = {
-                number: type.raw("number").or(type.raw("number[]")).or(numberOps),
-                string: type.raw("string").or(type.raw("string[]")).or(stringOps),
-                boolean: type.raw("boolean"),
-                date: type
-                    .raw(dateInput)
-                    .or(type.raw(`(${dateInput})[]`))
-                    .or(dateOps),
+                number: type.raw('number').or(type.raw('number[]')).or(numberOps),
+                string: type.raw('string').or(type.raw('string[]')).or(stringOps),
+                boolean: type.raw('boolean'),
+                date: dateInput.or(dateArrayInput).or(dateOps),
             };
             const descriptor = this.describe();
             const filterDef = {};
@@ -83,10 +87,10 @@ export function createFilterBuilder(collection, config, options) {
             }
             return type
                 .raw({
-                "query?": "string",
-                "filter?": type.raw(filterDef),
-                "page?": "number",
-                "limit?": "number",
+                'query?': 'string',
+                'filter?': type.raw(filterDef),
+                'page?': 'number',
+                'limit?': 'number',
             })
                 .as();
         },
@@ -106,8 +110,8 @@ export function createFilterBuilder(collection, config, options) {
                 const fieldConfig = config[field.name];
                 if (!fieldConfig)
                     continue;
-                const columnType = field.sourceExpression === "Date"
-                    ? "date"
+                const columnType = field.sourceExpression === 'Date'
+                    ? 'date'
                     : tsenseTypeMap[field.type];
                 if (!columnType)
                     continue;
@@ -122,12 +126,12 @@ export function createFilterBuilder(collection, config, options) {
                         value: v,
                         label: fieldConfig.labels?.[v] ?? v,
                     }));
-                    column.conditions = withLabels(enumConditions, "enum");
+                    column.conditions = withLabels(enumConditions, 'enum');
                 }
                 if (fieldConfig.presets) {
                     column.presets = Object.entries(fieldConfig.presets).map(([name, filterOrFn]) => ({
                         name,
-                        filter: (typeof filterOrFn === "function"
+                        filter: (typeof filterOrFn === 'function'
                             ? filterOrFn()
                             : filterOrFn),
                     }));

package/dist/filters/relative-dates.d.ts

@@ -0,0 +1,3 @@
+import type { RelativeDate } from '../types.js';
+export declare function isRelativeDate(value: unknown): value is RelativeDate;
+export declare function resolveRelativeDate(expr: RelativeDate, tz: string, now?: Date): Date;

package/dist/filters/relative-dates.js

@@ -0,0 +1,20 @@
+import dayjs from 'dayjs';
+import timezone from 'dayjs/plugin/timezone.js';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+export function isRelativeDate(value) {
+    if (typeof value !== 'object' || value === null || value instanceof Date) {
+        return false;
+    }
+    const obj = value;
+    return (('startOf' in obj && typeof obj.startOf === 'string') ||
+        ('endOf' in obj && typeof obj.endOf === 'string'));
+}
+export function resolveRelativeDate(expr, tz, now) {
+    const base = now ? dayjs(now).tz(tz) : dayjs().tz(tz);
+    if ('startOf' in expr) {
+        return base.startOf(expr.startOf).toDate();
+    }
+    return base.endOf(expr.endOf).toDate();
+}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export type { TsenseFieldMeta, TsenseFieldType } from "./env.js";
-export { rank } from "./rank.js";
-export { DateTransformer } from "./transformers/date.js";
-export { defaultTransformers } from "./transformers/defaults.js";
-export type { FieldTransformer } from "./transformers/types.js";
-export { TSense } from "./tsense.js";
-export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.js";
+export type { TsenseFieldMeta, TsenseFieldType } from './env.js';
+export { rank } from './rank.js';
+export { DateTransformer } from './transformers/date.js';
+export { defaultTransformers } from './transformers/defaults.js';
+export type { FieldTransformer } from './transformers/types.js';
+export { TSense } from './tsense.js';
+export { isRelativeDate, resolveRelativeDate, } from './filters/relative-dates.js';
+export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, RelativeDate, RelativeDateUnit, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from './types.js';

package/dist/index.js

@@ -1,4 +1,5 @@
-export { rank } from "./rank.js";
-export { DateTransformer } from "./transformers/date.js";
-export { defaultTransformers } from "./transformers/defaults.js";
-export { TSense } from "./tsense.js";
+export { rank } from './rank.js';
+export { DateTransformer } from './transformers/date.js';
+export { defaultTransformers } from './transformers/defaults.js';
+export { TSense } from './tsense.js';
+export { isRelativeDate, resolveRelativeDate, } from './filters/relative-dates.js';

package/dist/tsense.d.ts

@@ -1,6 +1,6 @@
-import type { Type } from "arktype";
-import redaxios from "redaxios";
-import type { DeleteResult, FieldSchema, FilterFor, ProjectSearch, ScopedCollection, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult } from "./types.js";
+import type { Type } from 'arktype';
+import redaxios from 'redaxios';
+import type { DeleteResult, FieldSchema, FilterFor, ProjectSearch, ScopedCollection, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, 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>>);
@@ -64,7 +64,7 @@ export declare class TSense<T extends Type> {
     private synced;
     private fieldTransformers;
     private dataSyncConfig?;
-    infer: T["infer"];
+    infer: T['infer'];
     constructor(options: TsenseOptions<T>);
     private getBaseType;
     private inferType;
@@ -78,28 +78,30 @@ export declare class TSense<T extends Type> {
     private buildFilter;
     private validateFilterFields;
     private validateFields;
+    private resolveFilterValue;
+    private resolveFilterDates;
     private buildFilterExpression;
     private combineFilterExpressions;
     private buildSort;
     create(): Promise<this>;
     drop(): Promise<void>;
-    get(id: string): Promise<T["infer"] | null>;
+    get(id: string): Promise<T['infer'] | null>;
     delete(id: string): Promise<boolean>;
     private deleteManyWithFilterBy;
-    deleteMany(filter: FilterFor<T["infer"]>): Promise<DeleteResult>;
-    update(id: string, data: Partial<T["infer"]>): Promise<T["infer"]>;
+    deleteMany(filter: FilterFor<T['infer']>): Promise<DeleteResult>;
+    update(id: string, data: Partial<T['infer']>): Promise<T['infer']>;
     private updateManyWithFilterBy;
-    updateMany(filter: FilterFor<T["infer"]>, data: Partial<T["infer"]>): Promise<UpdateResult>;
+    updateMany(filter: FilterFor<T['infer']>, data: Partial<T['infer']>): Promise<UpdateResult>;
     private searchWithFilterBy;
-    search<const O extends SearchOptions<T["infer"]> = SearchOptionsPlain<T["infer"]>>(options: O): Promise<SearchResult<ProjectSearch<T["infer"], O>>>;
+    search<const O extends SearchOptions<T['infer']> = SearchOptionsPlain<T['infer']>>(options: O): Promise<SearchResult<ProjectSearch<T['infer'], O>>>;
     private searchListWithFilterBy;
-    searchList(options: SearchListOptions<T["infer"]>): Promise<SearchListResult<T["infer"]>>;
+    searchList(options: SearchListOptions<T['infer']>): Promise<SearchListResult<T['infer']>>;
     private countWithFilterBy;
-    count(filter?: FilterFor<T["infer"]>): Promise<number>;
-    upsert(docs: T["infer"] | T["infer"][]): Promise<UpsertResult[]>;
+    count(filter?: FilterFor<T['infer']>): Promise<number>;
+    upsert(docs: T['infer'] | T['infer'][]): Promise<UpsertResult[]>;
     syncData(options?: SyncOptions): Promise<SyncResult>;
     private purgeOrphans;
     exportIds(): Promise<string[]>;
-    scoped(baseFilter: FilterFor<T["infer"]>): ScopedCollection<T["infer"]>;
+    scoped(baseFilter: FilterFor<T['infer']>): ScopedCollection<T['infer']>;
 }
 export {};

package/dist/tsense.js

@@ -1,6 +1,7 @@
-import redaxios from "redaxios";
-import { TSenseMigrator } from "./migrator.js";
-import { defaultTransformers } from "./transformers/defaults.js";
+import redaxios from 'redaxios';
+import { isRelativeDate, resolveRelativeDate, } from './filters/relative-dates.js';
+import { TSenseMigrator } from './migrator.js';
+import { defaultTransformers } from './transformers/defaults.js';
 function chunkArray(arr, size) {
     const chunks = [];
     for (let i = 0; i < arr.length; i += size) {
@@ -10,8 +11,8 @@ function chunkArray(arr, size) {
 }
 const redaxiosInstance = redaxios.default ?? redaxios;
 function escapeFilterValue(value) {
-    if (typeof value === "string") {
-        return `\`${value.replaceAll("`", "")}\``;
+    if (typeof value === 'string') {
+        return `\`${value.replaceAll('`', '')}\``;
     }
     if (Array.isArray(value)) {
         return value.map(escapeFilterValue);
@@ -24,17 +25,17 @@ const filterOperators = {
     gte: (k, v) => `${k}:>=${v}`,
     lt: (k, v) => `${k}:<${v}`,
     lte: (k, v) => `${k}:<=${v}`,
-    notIn: (k, v) => `${k}:!=[${v.join(",")}]`,
+    notIn: (k, v) => `${k}:!=[${v.join(',')}]`,
 };
 const arkToTsense = {
-    string: "string",
-    number: "float",
-    "number.integer": "int64",
-    "number % 1": "int64",
-    boolean: "bool",
-    "string[]": "string[]",
-    "number[]": "float[]",
-    "boolean[]": "bool[]",
+    string: 'string',
+    number: 'float',
+    'number.integer': 'int64',
+    'number % 1': 'int64',
+    boolean: 'bool',
+    'string[]': 'string[]',
+    'number[]': 'float[]',
+    'boolean[]': 'bool[]',
 };
 export class TSense {
     options;
@@ -48,27 +49,27 @@ export class TSense {
         this.options = options;
         this.axios = redaxiosInstance.create({
             baseURL: `${options.connection.protocol}://${options.connection.host}:${options.connection.port}`,
-            headers: { "X-TYPESENSE-API-KEY": options.connection.apiKey },
+            headers: { 'X-TYPESENSE-API-KEY': options.connection.apiKey },
         });
         this.fields = this.extractFields(options.transformers ?? defaultTransformers);
         this.dataSyncConfig = options.dataSync;
     }
     getBaseType(expression, domain) {
-        if (domain && domain !== "undefined")
+        if (domain && domain !== 'undefined')
             return domain;
-        return expression.replace(/ \| undefined$/, "");
+        return expression.replace(/ \| undefined$/, '');
     }
     inferType(arkType) {
         const direct = arkToTsense[arkType];
         if (direct)
             return direct;
-        if (arkType.includes("[]"))
-            return "object[]";
+        if (arkType.includes('[]'))
+            return 'object[]';
         if (arkType.includes("'") || arkType.includes('"'))
-            return "string";
-        if (arkType.includes("{") || arkType.includes("|"))
-            return "object";
-        return "string";
+            return 'string';
+        if (arkType.includes('{') || arkType.includes('|'))
+            return 'object';
+        return 'string';
     }
     serializeDoc(doc) {
         const result = { ...doc };
@@ -99,7 +100,7 @@ export class TSense {
         if (Array.isArray(value)) {
             return value.map((v) => transformer.serialize(v));
         }
-        if (typeof value === "object" &&
+        if (typeof value === 'object' &&
             value !== null &&
             Object.getPrototypeOf(value) === Object.prototype) {
             const result = {};
@@ -126,7 +127,7 @@ export class TSense {
             const branches = prop.value.branches ?? [];
             const enumValues = [];
             for (const branch of branches) {
-                if (typeof branch.unit === "string") {
+                if (typeof branch.unit === 'string') {
                     enumValues.push(branch.unit);
                 }
             }
@@ -142,7 +143,7 @@ export class TSense {
                     name: prop.key,
                     type: transformer.storageType,
                     sourceExpression: expression,
-                    optional: prop.kind === "optional",
+                    optional: prop.kind === 'optional',
                     facet: meta?.facet,
                     sort: meta?.sort,
                     index: meta?.index,
@@ -155,7 +156,7 @@ export class TSense {
                 name: prop.key,
                 type,
                 sourceExpression: expression,
-                optional: prop.kind === "optional",
+                optional: prop.kind === 'optional',
                 facet: meta?.facet,
                 sort: meta?.sort,
                 index: meta?.index,
@@ -179,7 +180,7 @@ export class TSense {
             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)
+                if (op === 'gte' || op === 'lte' || opValue == null)
                     continue;
                 const builder = filterOperators[op];
                 if (builder) {
@@ -205,34 +206,34 @@ export class TSense {
             const [key, rawValue] = entry;
             if (rawValue == null)
                 continue;
-            if (key === "OR") {
+            if (key === 'OR') {
                 const orParts = [];
                 for (const condition of rawValue) {
                     const inner = this.buildFilter(condition);
                     if (!inner.length) {
                         continue;
                     }
-                    orParts.push(`(${inner.join("&&")})`);
+                    orParts.push(`(${inner.join('&&')})`);
                 }
                 if (!orParts.length) {
                     continue;
                 }
-                result.push(`(${orParts.join("||")})`);
+                result.push(`(${orParts.join('||')})`);
                 continue;
             }
             const value = this.serializeFilterValue(key, rawValue);
             const escaped = escapeFilterValue(value);
-            if (typeof escaped === "string" ||
-                typeof escaped === "number" ||
-                typeof escaped === "boolean") {
+            if (typeof escaped === 'string' ||
+                typeof escaped === 'number' ||
+                typeof escaped === 'boolean') {
                 result.push(`${key}:=${escaped}`);
                 continue;
             }
             if (Array.isArray(escaped)) {
-                result.push(`${key}:[${escaped.join(",")}]`);
+                result.push(`${key}:[${escaped.join(',')}]`);
                 continue;
             }
-            if (typeof value === "object" && value !== null) {
+            if (typeof value === 'object' && value !== null) {
                 result.push(...this.buildObjectFilter(key, value));
             }
         }
@@ -247,7 +248,7 @@ export class TSense {
             if (value == null) {
                 continue;
             }
-            if (key === "OR") {
+            if (key === 'OR') {
                 for (const condition of value) {
                     this.validateFilterFields(condition);
                 }
@@ -263,43 +264,79 @@ export class TSense {
     validateFields(fields) {
         const valid = new Set(this.fields.map((f) => f.name));
         for (const field of fields) {
-            if (field !== "score" && !valid.has(field)) {
+            if (field !== 'score' && !valid.has(field)) {
                 throw new Error(`INVALID_FIELD: ${field}`);
             }
         }
     }
+    resolveFilterValue(value) {
+        if (isRelativeDate(value)) {
+            return resolveRelativeDate(value, this.options.timezone);
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => isRelativeDate(v) ? resolveRelativeDate(v, this.options.timezone) : v);
+        }
+        if (typeof value === 'object' &&
+            value !== null &&
+            !(value instanceof Date)) {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = this.resolveFilterValue(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    resolveFilterDates(filter) {
+        if (!filter || !this.options.timezone) {
+            return filter;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(filter)) {
+            if (value == null) {
+                continue;
+            }
+            if (key === 'OR') {
+                result.OR = value.map((f) => this.resolveFilterDates(f));
+                continue;
+            }
+            result[key] = this.resolveFilterValue(value);
+        }
+        return result;
+    }
     buildFilterExpression(filter) {
-        this.validateFilterFields(filter);
-        const parts = this.buildFilter(filter);
+        const resolved = this.resolveFilterDates(filter);
+        this.validateFilterFields(resolved);
+        const parts = this.buildFilter(resolved);
         if (!parts.length) {
             return;
         }
-        return `(${parts.join("&&")})`;
+        return `(${parts.join('&&')})`;
     }
     combineFilterExpressions(...filters) {
         return filters
             .map((filter) => this.buildFilterExpression(filter))
             .filter((filter) => filter != null)
-            .join("&&");
+            .join('&&');
     }
     buildSort(options) {
         if (!options.sortBy)
             return;
         const result = [];
         for (const item of options.sortBy) {
-            const [field, direction] = item.split(":");
-            if (field === "undefined")
+            const [field, direction] = item.split(':');
+            if (field === 'undefined')
                 continue;
-            const realField = field === "score" ? "_text_match" : field;
+            const realField = field === 'score' ? '_text_match' : field;
             result.push(`${realField}:${direction}`);
         }
-        return result.join(",");
+        return result.join(',');
     }
     async create() {
-        const enableNested = this.fields.some((f) => f.type === "object" || f.type === "object[]");
+        const enableNested = this.fields.some((f) => f.type === 'object' || f.type === 'object[]');
         await this.axios({
-            method: "POST",
-            url: "/collections",
+            method: 'POST',
+            url: '/collections',
             data: {
                 name: this.options.name,
                 fields: this.fields,
@@ -311,14 +348,14 @@ export class TSense {
     }
     async drop() {
         await this.axios({
-            method: "DELETE",
+            method: 'DELETE',
             url: `/collections/${this.options.name}`,
         });
     }
     async get(id) {
         await this.ensureSynced();
         const { data } = await this.axios({
-            method: "GET",
+            method: 'GET',
             url: `/collections/${this.options.name}/documents/${id}`,
         }).catch((e) => {
             if (e.status === 404)
@@ -330,7 +367,7 @@ export class TSense {
     async delete(id) {
         await this.ensureSynced();
         const { data } = await this.axios({
-            method: "DELETE",
+            method: 'DELETE',
             url: `/collections/${this.options.name}/documents/${id}`,
         }).catch((e) => {
             if (e.status === 404)
@@ -342,10 +379,10 @@ export class TSense {
     async deleteManyWithFilterBy(filterBy) {
         await this.ensureSynced();
         if (!filterBy) {
-            throw new Error("FILTER_REQUIRED");
+            throw new Error('FILTER_REQUIRED');
         }
         const { data } = await this.axios({
-            method: "DELETE",
+            method: 'DELETE',
             url: `/collections/${this.options.name}/documents`,
             params: { filter_by: filterBy },
         });
@@ -358,7 +395,7 @@ export class TSense {
         await this.ensureSynced();
         const serialized = this.serializeDoc(data);
         const { data: updated } = await this.axios({
-            method: "PATCH",
+            method: 'PATCH',
             url: `/collections/${this.options.name}/documents/${id}`,
             data: serialized,
         });
@@ -367,11 +404,11 @@ export class TSense {
     async updateManyWithFilterBy(filterBy, data) {
         await this.ensureSynced();
         if (!filterBy) {
-            throw new Error("FILTER_REQUIRED");
+            throw new Error('FILTER_REQUIRED');
         }
         const serialized = this.serializeDoc(data);
         const { data: result } = await this.axios({
-            method: "PATCH",
+            method: 'PATCH',
             url: `/collections/${this.options.name}/documents`,
             params: { filter_by: filterBy },
             data: serialized,
@@ -389,15 +426,15 @@ export class TSense {
         this.validateFields(queryByFields);
         if (options.sortBy) {
             this.validateFields(options.sortBy
-                .map((s) => s.split(":")[0])
-                .filter((f) => f !== "undefined"));
+                .map((s) => s.split(':')[0])
+                .filter((f) => f !== 'undefined'));
         }
         if (options.facetBy) {
             this.validateFields(options.facetBy);
         }
-        const queryBy = queryByFields.join(",");
+        const queryBy = queryByFields.join(',');
         const params = {
-            q: options.query ?? "*",
+            q: options.query ?? '*',
             query_by: queryBy,
         };
         const sortBy = this.buildSort(options);
@@ -409,20 +446,20 @@ export class TSense {
             params.page = options.page;
         if (options.limit != null)
             params.per_page = options.limit;
-        const facetBy = options.facetBy?.join(",");
+        const facetBy = options.facetBy?.join(',');
         if (facetBy)
             params.facet_by = facetBy;
-        if ("pick" in options && options.pick) {
-            params.include_fields = options.pick.join(",");
+        if ('pick' in options && options.pick) {
+            params.include_fields = options.pick.join(',');
         }
-        if ("omit" in options && options.omit) {
-            params.exclude_fields = options.omit.join(",");
+        if ('omit' in options && options.omit) {
+            params.exclude_fields = options.omit.join(',');
         }
         const highlight = options.highlight;
-        const highlightOpts = typeof highlight === "object" ? highlight : undefined;
+        const highlightOpts = typeof highlight === 'object' ? highlight : undefined;
         if (highlightOpts) {
             if (highlightOpts.fields) {
-                params.highlight_fields = highlightOpts.fields.join(",");
+                params.highlight_fields = highlightOpts.fields.join(',');
             }
             if (highlightOpts.startTag) {
                 params.highlight_start_tag = highlightOpts.startTag;
@@ -432,7 +469,7 @@ export class TSense {
             }
         }
         const { data: res } = await this.axios({
-            method: "GET",
+            method: 'GET',
             url: `/collections/${this.options.name}/documents/search`,
             params,
         });
@@ -495,19 +532,19 @@ export class TSense {
         await this.ensureSynced();
         if (!filterBy) {
             const { data } = await this.axios({
-                method: "GET",
+                method: 'GET',
                 url: `/collections/${this.options.name}`,
             });
             return data.num_documents;
         }
         const params = {
-            q: "*",
+            q: '*',
             query_by: this.options.defaultSearchField,
             per_page: 0,
             filter_by: filterBy,
         };
         const { data } = await this.axios({
-            method: "GET",
+            method: 'GET',
             url: `/collections/${this.options.name}/documents/search`,
             params,
         });
@@ -528,26 +565,26 @@ export class TSense {
         }
         const payload = items
             .map((item) => JSON.stringify(this.serializeDoc(item)))
-            .join("\n");
-        const params = { action: "upsert" };
+            .join('\n');
+        const params = { action: 'upsert' };
         if (this.options.batchSize) {
             params.batch_size = this.options.batchSize;
         }
         const { data } = await this.axios({
-            method: "POST",
+            method: 'POST',
             url: `/collections/${this.options.name}/documents/import`,
-            headers: { "Content-Type": "text/plain" },
+            headers: { 'Content-Type': 'text/plain' },
             params,
             data: payload,
         });
-        if (typeof data === "string") {
-            return data.split("\n").map((v) => JSON.parse(v));
+        if (typeof data === 'string') {
+            return data.split('\n').map((v) => JSON.parse(v));
         }
         return [data];
     }
     async syncData(options) {
         if (!this.dataSyncConfig) {
-            throw new Error("DATA_SYNC_NOT_CONFIGURED");
+            throw new Error('DATA_SYNC_NOT_CONFIGURED');
         }
         const chunkSize = options?.chunkSize ?? this.dataSyncConfig.chunkSize ?? 500;
         const ids = options?.ids ?? (await this.dataSyncConfig.getAllIds());
@@ -584,12 +621,12 @@ export class TSense {
     }
     async exportIds() {
         const { data } = await this.axios({
-            method: "GET",
+            method: 'GET',
             url: `/collections/${this.options.name}/documents/export`,
-            params: { include_fields: "id" },
+            params: { include_fields: 'id' },
         });
         return data
-            .split("\n")
+            .split('\n')
             .filter((line) => line.length)
             .map((line) => JSON.parse(line).id);
     }

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import type { Type } from "arktype";
-import type { FieldTransformer } from "./transformers/types.js";
+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;
@@ -32,7 +32,7 @@ export type SearchApiResponse<T> = {
 export type ConnectionConfig = {
     host: string;
     port: number;
-    protocol: "http" | "https";
+    protocol: 'http' | 'https';
     apiKey: string;
     timeout?: number;
 };
@@ -40,14 +40,22 @@ export type TsenseOptions<T extends Type> = {
     name: string;
     schema: T;
     connection: ConnectionConfig;
-    defaultSearchField?: keyof T["infer"];
-    defaultSortingField?: keyof T["infer"];
+    defaultSearchField?: keyof T['infer'];
+    defaultSortingField?: keyof T['infer'];
     batchSize?: number;
     validateOnUpsert?: boolean;
     autoSyncSchema?: boolean;
+    timezone?: string;
     transformers?: FieldTransformer[];
-    dataSync?: SyncConfig<T["infer"]>;
+    dataSync?: SyncConfig<T['infer']>;
 };
+export type RelativeDateUnit = 'day' | 'week' | 'month';
+export type RelativeDate = {
+    startOf: RelativeDateUnit;
+} | {
+    endOf: RelativeDateUnit;
+};
+type DateValue = Date | RelativeDate;
 export type StringFilter = {
     not?: string;
     notIn?: string[];
@@ -61,14 +69,14 @@ export type NumberFilter = {
     lte?: number;
 };
 type DateFilter = {
-    not?: Date;
-    notIn?: Date[];
-    gt?: Date;
-    gte?: Date;
-    lt?: Date;
-    lte?: Date;
-};
-type FilterValueFor<T> = [T] extends [boolean] ? boolean : [T] extends [Date] ? Date | Date[] | DateFilter : [T] extends [number] ? number | number[] | NumberFilter : [T] extends [string] ? T | T[] | StringFilter : never;
+    not?: DateValue;
+    notIn?: DateValue[];
+    gt?: DateValue;
+    gte?: DateValue;
+    lt?: DateValue;
+    lte?: DateValue;
+};
+type FilterValueFor<T> = [T] extends [boolean] ? boolean : [T] extends [Date] ? DateValue | DateValue[] | DateFilter : [T] extends [number] ? number | number[] | NumberFilter : [T] extends [string] ? T | T[] | StringFilter : never;
 type SingleFilter<T> = Partial<{
     [K in keyof T]: FilterValueFor<NonNullable<BaseIfArray<T[K]>>>;
 }>;
@@ -80,12 +88,12 @@ export type HighlightOptions<T> = {
     startTag?: string;
     endTag?: string;
 };
-type SortableField<T> = Extract<keyof T, string> | "score";
+type SortableField<T> = Extract<keyof T, string> | 'score';
 export type BaseSearchOptions<T> = {
     query?: string;
     queryBy?: (keyof T)[];
     filter?: FilterFor<T>;
-    sortBy?: `${SortableField<T>}:${"asc" | "desc"}`[];
+    sortBy?: `${SortableField<T>}:${'asc' | 'desc'}`[];
     facetBy?: (keyof T)[];
     page?: number;
     limit?: number;
@@ -136,7 +144,7 @@ export type SearchListOptions<T> = {
     query?: string;
     queryBy?: (keyof T)[];
     filter?: FilterFor<T>;
-    sortBy: `${Extract<keyof T, string>}:${"asc" | "desc"}`;
+    sortBy: `${Extract<keyof T, string>}:${'asc' | 'desc'}`;
     limit?: number;
     cursor?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsense",
-  "version": "0.2.0-next.3",
+  "version": "0.2.0-next.5",
   "private": false,
   "description": "Opinionated, fully typed typesense client",
   "keywords": [
@@ -43,6 +43,7 @@
     "prepublishOnly": "bun run ci"
   },
   "dependencies": {
+    "dayjs": "^1.11.20",
     "redaxios": "^0.5.1"
   },
   "devDependencies": {