tsense 0.2.0-next.0 → 0.2.0-next.2

package/dist/filters/filter-state.d.ts

@@ -11,6 +11,7 @@ export type FilterState = {
 };
 export declare function createInitialState(): FilterState;
 export declare function addRow(state: FilterState): FilterState;
+export declare function addRowWithField(state: FilterState, field: string): FilterState;
 export declare function removeRow(state: FilterState, index: number): FilterState;
 export declare function setRowField(state: FilterState, index: number, field: string): FilterState;
 export declare function setRowCondition(state: FilterState, index: number, condition: string): FilterState;

package/dist/filters/filter-state.js

@@ -11,11 +11,14 @@ const conditionToOperator = {
 };
 let nextRowId = 0;
 export function createInitialState() {
-    return { rows: [{ id: ++nextRowId }] };
+    return { rows: [] };
 }
 export function addRow(state) {
     return { rows: [...state.rows, { id: ++nextRowId }] };
 }
+export function addRowWithField(state, field) {
+    return { rows: [...state.rows, { id: ++nextRowId, field }] };
+}
 export function removeRow(state, index) {
     return { rows: state.rows.filter((_, i) => i !== index) };
 }
@@ -37,54 +40,58 @@ export function setRowValue(state, index, value) {
 export function clearState() {
     return { rows: [] };
 }
-export function applyPreset(state, descriptor, field, name) {
-    const column = descriptor.columns.find((c) => c.key === field);
-    const preset = column?.presets?.find((p) => p.name === name);
-    if (!preset)
-        return state;
-    const filterValue = preset.filter[field];
-    if (filterValue == null)
-        return state;
+function filterValueToRow(field, filterValue) {
+    if (filterValue == null) {
+        return null;
+    }
     if (Array.isArray(filterValue)) {
         return {
-            rows: [
-                ...state.rows,
-                { id: ++nextRowId, field, condition: "is_in", value: filterValue },
-            ],
+            id: ++nextRowId,
+            field,
+            condition: "is_in",
+            value: filterValue,
         };
     }
     if (typeof filterValue !== "object" || filterValue instanceof Date) {
         return {
-            rows: [
-                ...state.rows,
-                { id: ++nextRowId, field, condition: "equals", value: filterValue },
-            ],
+            id: ++nextRowId,
+            field,
+            condition: "equals",
+            value: filterValue,
         };
     }
     const ops = filterValue;
     const keys = Object.keys(ops);
     if (keys.includes("gte") && keys.includes("lte")) {
         return {
-            rows: [
-                ...state.rows,
-                {
-                    id: ++nextRowId,
-                    field,
-                    condition: "between",
-                    value: [ops.gte, ops.lte],
-                },
-            ],
+            id: ++nextRowId,
+            field,
+            condition: "between",
+            value: [ops.gte, ops.lte],
         };
     }
     if (keys[0]) {
-        return {
-            rows: [
-                ...state.rows,
-                { id: ++nextRowId, field, condition: keys[0], value: ops[keys[0]] },
-            ],
-        };
+        return { id: ++nextRowId, field, condition: keys[0], value: ops[keys[0]] };
+    }
+    return null;
+}
+export function applyPreset(state, descriptor, field, name) {
+    const column = descriptor.columns.find((c) => c.key === field);
+    const preset = column?.presets?.find((p) => p.name === name);
+    if (!preset) {
+        return state;
+    }
+    const rows = [];
+    for (const [key, value] of Object.entries(preset.filter)) {
+        const row = filterValueToRow(key, value);
+        if (row) {
+            rows.push(row);
+        }
+    }
+    if (!rows.length) {
+        return state;
     }
-    return state;
+    return { rows };
 }
 export function conditionsFor(descriptor, field) {
     const column = descriptor.columns.find((c) => c.key === field);

package/dist/filters/index.js

@@ -58,11 +58,23 @@ export function createFilterBuilder(collection, config, options) {
                 "not?": "string",
                 "notIn?": "string[]",
             });
+            const dateInput = "number | string | Date";
+            const dateOps = type.raw({
+                "not?": dateInput,
+                "gt?": dateInput,
+                "gte?": dateInput,
+                "lt?": dateInput,
+                "lte?": dateInput,
+                "notIn?": `(${dateInput})[]`,
+            });
             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("number").or(type.raw("number[]")).or(numberOps),
+                date: type
+                    .raw(dateInput)
+                    .or(type.raw(`(${dateInput})[]`))
+                    .or(dateOps),
             };
             const descriptor = this.describe();
             const filterDef = {};

package/dist/index.d.ts

@@ -4,4 +4,4 @@ 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 { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, WithNull, } from "./types.js";

package/dist/react/filter-builder.js

@@ -1,12 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment, useEffect, useRef } from "react";
 import { useFilterBuilder } from "./use-filter-builder.js";
-function defaultFieldSelect({ columns, value, onChange, }) {
-    return (_jsxs("select", { className: "rounded border px-2 py-1", value: value ?? "", onChange: (e) => onChange(e.target.value), children: [_jsx("option", { value: "", children: "Column" }), columns.map((col) => (_jsx("option", { value: col.key, children: col.label }, col.key)))] }));
-}
-function defaultConditionSelect({ conditions, value, onChange, disabled, }) {
-    return (_jsxs("select", { className: "rounded border px-2 py-1", value: value ?? "", onChange: (e) => onChange(e.target.value), disabled: disabled, children: [_jsx("option", { value: "", children: "Condition" }), conditions.map((c) => (_jsx("option", { value: c.key, children: c.label }, c.key)))] }));
-}
+// ======== Helpers ========
 function formatDateForInput(date) {
     if (!(date instanceof Date))
         return "";
@@ -23,6 +18,18 @@ function asTuple(value) {
     }
     return [undefined, undefined];
 }
+function renderSelectOptions(options, defaultValue) {
+    const opts = defaultValue
+        ? [{ key: "", label: defaultValue }, ...options]
+        : options;
+    return opts.map((o) => (_jsx("option", { value: o.key, children: o.label }, o.key)));
+}
+function defaultFieldSelect({ columns, value, onChange, }) {
+    return (_jsx("select", { className: "rounded border px-2 py-1", value: value ?? "", onChange: (e) => onChange(e.target.value), children: renderSelectOptions(columns, "Column") }));
+}
+function defaultConditionSelect({ conditions, value, onChange, disabled, }) {
+    return (_jsx("select", { className: "rounded border px-2 py-1", value: value ?? "", onChange: (e) => onChange(e.target.value), disabled: disabled, children: renderSelectOptions(conditions, "Condition") }));
+}
 function defaultValueInput({ column, condition, value, onChange, }) {
     if (condition === "between" && column.type === "date") {
         const tuple = asTuple(value);
@@ -36,7 +43,7 @@ function defaultValueInput({ column, condition, value, onChange, }) {
         const selected = Array.isArray(value) ? value : [];
         return (_jsx("div", { className: "flex flex-wrap gap-2", children: column.values.map((v) => {
                 const checked = selected.includes(v.value);
-                return (_jsxs("label", { className: "flex items-center gap-1 text-sm", children: [_jsx("input", { type: "checkbox", checked: checked, onChange: () => onChange(checked
+                return (_jsxs("label", { className: "flex cursor-pointer select-none items-center gap-1 text-sm", children: [_jsx("input", { type: "checkbox", checked: checked, onChange: () => onChange(checked
                                 ? selected.filter((s) => s !== v.value)
                                 : [...selected, v.value]) }), v.label] }, v.value));
             }) }));
@@ -48,7 +55,12 @@ function defaultValueInput({ column, condition, value, onChange, }) {
         return (_jsx("input", { className: "rounded border px-2 py-1", type: "number", value: String(value ?? ""), onChange: (e) => onChange(Number(e.target.value)) }));
     }
     if (column.type === "boolean") {
-        return (_jsxs("select", { className: "rounded border px-2 py-1", value: value == null ? "" : String(value), onChange: (e) => onChange(e.target.value === "true"), children: [_jsx("option", { value: "", children: "Value" }), _jsx("option", { value: "true", children: "true" }), _jsx("option", { value: "false", children: "false" })] }));
+        const options = [
+            { key: "", label: "Value" },
+            { key: "true", label: "true" },
+            { key: "false", label: "false" },
+        ];
+        return (_jsx("select", { className: "rounded border px-2 py-1", value: value == null ? "" : String(value), onChange: (e) => onChange(e.target.value === "true"), children: renderSelectOptions(options) }));
     }
     return (_jsx("input", { className: "rounded border px-2 py-1", type: "text", value: typeof value === "string" ? value : "", onChange: (e) => onChange(e.target.value) }));
 }

package/dist/react/use-filter-builder.d.ts

@@ -8,6 +8,7 @@ type UseFilterBuilderReturn = {
     columns: FilterDescriptor["columns"];
     rows: FilterRow[];
     add: () => void;
+    addWithField: (field: string) => void;
     remove: (index: number) => void;
     setField: (index: number, field: string) => void;
     setCondition: (index: number, condition: string) => void;

package/dist/react/use-filter-builder.js

@@ -1,5 +1,5 @@
 import { useMemo, useState } from "react";
-import { addRow, applyPreset as applyPresetState, buildResult, clearState, columnFor, conditionsFor, createInitialState, removeRow, setRowCondition, setRowField, setRowValue, } from "../filters/filter-state.js";
+import { addRow, addRowWithField, applyPreset as applyPresetState, buildResult, clearState, columnFor, conditionsFor, createInitialState, removeRow, setRowCondition, setRowField, setRowValue, } from "../filters/filter-state.js";
 export function useFilterBuilder(descriptor) {
     const [state, setState] = useState(createInitialState);
     const presets = useMemo(() => descriptor.columns.flatMap((col) => (col.presets ?? []).map((p) => ({ field: col.key, name: p.name }))), [descriptor]);
@@ -8,6 +8,7 @@ export function useFilterBuilder(descriptor) {
         columns: descriptor.columns,
         rows: state.rows,
         add: () => setState(addRow),
+        addWithField: (field) => setState((s) => addRowWithField(s, field)),
         remove: (index) => setState((s) => removeRow(s, index)),
         setField: (index, field) => setState((s) => setRowField(s, index, field)),
         setCondition: (index, condition) => setState((s) => setRowCondition(s, index, condition)),

package/dist/transformers/date.js

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

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 { DeleteResult, FieldSchema, FilterFor, ProjectSearch, ScopedCollection, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, WithNull } 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>>);
@@ -88,7 +88,7 @@ export declare class TSense<T extends Type> {
     search<const O extends SearchOptions<T["infer"]> = SearchOptionsPlain<T["infer"]>>(options: O): Promise<SearchResult<ProjectSearch<T["infer"], O>>>;
     searchList(options: SearchListOptions<T["infer"]>): Promise<SearchListResult<T["infer"]>>;
     count(filter?: FilterFor<T["infer"]>): Promise<number>;
-    upsert(docs: T["infer"] | T["infer"][]): Promise<UpsertResult[]>;
+    upsert(docs: WithNull<T["infer"]> | WithNull<T["infer"]>[]): Promise<UpsertResult[]>;
     syncData(options?: SyncOptions): Promise<SyncResult>;
     private purgeOrphans;
     exportIds(): Promise<string[]>;

package/dist/tsense.js

@@ -72,6 +72,11 @@ export class TSense {
     }
     serializeDoc(doc) {
         const result = { ...doc };
+        for (const key of Object.keys(result)) {
+            if (result[key] == null) {
+                delete result[key];
+            }
+        }
         for (const [field, transformer] of this.fieldTransformers) {
             if (result[field] != null) {
                 result[field] = transformer.serialize(result[field]);

package/dist/types.d.ts

@@ -1,6 +1,9 @@
 import type { Type } from "arktype";
 import type { FieldTransformer } from "./transformers/types.js";
 type BaseIfArray<T> = T extends (infer Q)[] ? Q : T;
+export type WithNull<T> = {
+    [K in keyof T]: undefined extends T[K] ? T[K] | null : T[K];
+};
 export type FieldSchema = {
     name: string;
     type: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsense",
-  "version": "0.2.0-next.0",
+  "version": "0.2.0-next.2",
   "private": false,
   "description": "Opinionated, fully typed typesense client",
   "keywords": [