tsense 0.1.0 → 0.2.0-next.2

package/dist/filters/url.js

@@ -0,0 +1,93 @@
+const ARRAY_OPERATORS = new Set(["notIn"]);
+function serializeValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    return String(value);
+}
+function coerceValue(raw, columnType) {
+    if (columnType === "number") {
+        return Number(raw);
+    }
+    if (columnType === "boolean") {
+        return raw === "true";
+    }
+    if (columnType === "date") {
+        return new Date(raw);
+    }
+    return raw;
+}
+export function serializeFilter(filter, descriptor) {
+    const params = new URLSearchParams();
+    const columnMap = new Map(descriptor.columns.map((c) => [c.key, c]));
+    for (const [key, value] of Object.entries(filter)) {
+        const column = columnMap.get(key);
+        if (!column || value == null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 1) {
+                params.set(key, serializeValue(value[0]));
+            }
+            else if (value.length > 1) {
+                params.set(key, value.map((v) => serializeValue(v)).join(","));
+            }
+            continue;
+        }
+        if (typeof value === "object" && !(value instanceof Date)) {
+            for (const [op, opValue] of Object.entries(value)) {
+                if (opValue == null) {
+                    continue;
+                }
+                if (Array.isArray(opValue)) {
+                    params.set(`${key}.${op}`, opValue.map((v) => serializeValue(v)).join(","));
+                }
+                else {
+                    params.set(`${key}.${op}`, serializeValue(opValue));
+                }
+            }
+            continue;
+        }
+        params.set(key, serializeValue(value));
+    }
+    return params;
+}
+export function deserializeFilter(params, descriptor) {
+    const result = {};
+    const columnMap = new Map(descriptor.columns.map((c) => [c.key, c]));
+    for (const [paramKey, rawValue] of params.entries()) {
+        const dotIndex = paramKey.indexOf(".");
+        if (dotIndex !== -1) {
+            const field = paramKey.slice(0, dotIndex);
+            const operator = paramKey.slice(dotIndex + 1);
+            const column = columnMap.get(field);
+            if (!column) {
+                continue;
+            }
+            const existing = (result[field] ?? {});
+            if (ARRAY_OPERATORS.has(operator)) {
+                existing[operator] = rawValue
+                    .split(",")
+                    .map((v) => coerceValue(v, column.type));
+            }
+            else {
+                existing[operator] = coerceValue(rawValue, column.type);
+            }
+            result[field] = existing;
+            continue;
+        }
+        const column = columnMap.get(paramKey);
+        if (!column) {
+            continue;
+        }
+        if (rawValue.includes(",")) {
+            result[paramKey] = rawValue
+                .split(",")
+                .map((v) => coerceValue(v, column.type));
+        }
+        else {
+            result[paramKey] = coerceValue(rawValue, column.type);
+        }
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 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, ProjectSearch, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, 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/index.js

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

package/dist/migrator.d.ts

@@ -5,7 +5,7 @@ export declare class TSenseMigrator {
     private localFields;
     private defaultSortingField;
     private axios;
-    constructor(collectionName: string, localFields: FieldSchema[], defaultSortingField: string | undefined, axios: AxiosInstance);
+    constructor(collectionName: string, localFields: readonly FieldSchema[], defaultSortingField: string | undefined, axios: AxiosInstance);
     sync(): Promise<void>;
     private exists;
     private getRemoteFields;

package/dist/migrator.js

@@ -1,5 +1,5 @@
 const COMPARABLE_KEYS = ["type", "facet", "sort", "index", "optional"];
-const NESTED_TYPES = ["object", "object[]"];
+const NESTED_TYPES = new Set(["object", "object[]"]);
 export class TSenseMigrator {
     collectionName;
     localFields;
@@ -102,7 +102,7 @@ export class TSenseMigrator {
             .catch(() => false);
     }
     async create() {
-        const enable_nested_fields = this.localFields.some((f) => NESTED_TYPES.includes(f.type));
+        const enable_nested_fields = this.localFields.some((f) => NESTED_TYPES.has(f.type));
         await this.axios({
             method: "POST",
             url: "/collections",

package/dist/rank.d.ts

@@ -0,0 +1,7 @@
+export declare function rank<T>({ db, id_key, ts }: {
+    db: T[];
+    id_key: keyof T;
+    ts: {
+        id: string;
+    }[];
+}): T[];

package/dist/rank.js

@@ -0,0 +1,12 @@
+export function rank({ db, id_key, ts, }) {
+    const mapped = new Map(ts.map((t, i) => [t.id, i]));
+    const result = [];
+    for (const item of db) {
+        const position = mapped.get(String(item[id_key]));
+        if (position == null) {
+            continue;
+        }
+        result[position] = item;
+    }
+    return result.filter(Boolean);
+}

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

@@ -0,0 +1,60 @@
+import { type ReactNode } from "react";
+import type { FilterValue } from "../filters/filter-state.js";
+import type { FilterDescriptor } from "../filters/index.js";
+import type { FilterFor } from "../types.js";
+export type FieldSelectSlotProps = {
+    columns: FilterDescriptor["columns"];
+    value: string | undefined;
+    onChange: (field: string) => void;
+};
+export type ConditionSelectSlotProps = {
+    conditions: FilterDescriptor["columns"][number]["conditions"];
+    value: string | undefined;
+    onChange: (condition: string) => void;
+    disabled: boolean;
+};
+export type ValueInputSlotProps = {
+    column: FilterDescriptor["columns"][number];
+    condition: string;
+    value: FilterValue;
+    onChange: (value: FilterValue) => void;
+};
+export type RemoveButtonSlotProps = {
+    onClick: () => void;
+};
+export type AddButtonSlotProps = {
+    onClick: () => void;
+};
+export type PresetButtonSlotProps = {
+    preset: {
+        field: string;
+        name: string;
+    };
+    onClick: () => void;
+};
+export type RowSlotProps = {
+    index: number;
+    fieldSelect: ReactNode;
+    conditionSelect: ReactNode;
+    valueInput: ReactNode | null;
+    removeButton: ReactNode;
+};
+export type RootSlotProps = {
+    rows: ReactNode;
+    addButton: ReactNode;
+    presets: ReactNode | null;
+};
+type FilterBuilderProps<T> = {
+    descriptor: FilterDescriptor<T>;
+    onChange?: (filter: FilterFor<T>) => void;
+    renderRoot?: (props: RootSlotProps) => ReactNode;
+    renderRow?: (props: RowSlotProps) => ReactNode;
+    renderFieldSelect?: (props: FieldSelectSlotProps) => ReactNode;
+    renderConditionSelect?: (props: ConditionSelectSlotProps) => ReactNode;
+    renderValueInput?: (props: ValueInputSlotProps) => ReactNode;
+    renderAddButton?: (props: AddButtonSlotProps) => ReactNode;
+    renderRemoveButton?: (props: RemoveButtonSlotProps) => ReactNode;
+    renderPresetButton?: (props: PresetButtonSlotProps) => ReactNode;
+};
+export declare function FilterBuilder<T>({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton }: FilterBuilderProps<T>): ReactNode;
+export {};

package/dist/react/filter-builder.js

@@ -0,0 +1,114 @@
+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";
+// ======== Helpers ========
+function formatDateForInput(date) {
+    if (!(date instanceof Date))
+        return "";
+    return date.toISOString().slice(0, 10);
+}
+function parseDateInput(str) {
+    if (!str)
+        return undefined;
+    return new Date(str + "T00:00:00Z");
+}
+function asTuple(value) {
+    if (Array.isArray(value)) {
+        return [value[0], value[1]];
+    }
+    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);
+        return (_jsxs("div", { className: "flex items-center gap-1", children: [_jsx("input", { className: "rounded border px-2 py-1", type: "date", value: formatDateForInput(tuple[0]), onChange: (e) => onChange([parseDateInput(e.target.value), tuple[1]]) }), _jsx("span", { className: "text-sm text-gray-500", children: "and" }), _jsx("input", { className: "rounded border px-2 py-1", type: "date", value: formatDateForInput(tuple[1]), onChange: (e) => onChange([tuple[0], parseDateInput(e.target.value)]) })] }));
+    }
+    if (condition === "between") {
+        const tuple = asTuple(value);
+        return (_jsxs("div", { className: "flex items-center gap-1", children: [_jsx("input", { className: "w-24 rounded border px-2 py-1", type: "number", value: String(tuple[0] ?? ""), onChange: (e) => onChange([Number(e.target.value), tuple[1]]) }), _jsx("span", { className: "text-sm text-gray-500", children: "and" }), _jsx("input", { className: "w-24 rounded border px-2 py-1", type: "number", value: String(tuple[1] ?? ""), onChange: (e) => onChange([tuple[0], Number(e.target.value)]) })] }));
+    }
+    if (column.values) {
+        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 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));
+            }) }));
+    }
+    if (column.type === "date") {
+        return (_jsx("input", { className: "rounded border px-2 py-1", type: "date", value: formatDateForInput(value), onChange: (e) => onChange(parseDateInput(e.target.value)) }));
+    }
+    if (column.type === "number") {
+        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") {
+        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) }));
+}
+function defaultRemoveButton({ onClick }) {
+    return (_jsx("button", { className: "text-red-500 hover:text-red-700", onClick: onClick, children: "\u00D7" }));
+}
+function defaultAddButton({ onClick }) {
+    return (_jsx("button", { className: "text-blue-500 hover:text-blue-700", onClick: onClick, children: "+ Add filter" }));
+}
+function defaultPresetButton({ preset, onClick }) {
+    return (_jsx("button", { className: "rounded bg-gray-100 px-2 py-1 text-sm hover:bg-gray-200", onClick: onClick, children: preset.name }));
+}
+export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton, }) {
+    const filters = useFilterBuilder(descriptor);
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    useEffect(() => {
+        onChangeRef.current?.(filters.result);
+    }, [filters.result]);
+    const FieldSelect = renderFieldSelect ?? defaultFieldSelect;
+    const ConditionSelect = renderConditionSelect ?? defaultConditionSelect;
+    const ValueInput = renderValueInput ?? defaultValueInput;
+    const RemoveButton = renderRemoveButton ?? defaultRemoveButton;
+    const AddButton = renderAddButton ?? defaultAddButton;
+    const PresetButton = renderPresetButton ?? defaultPresetButton;
+    const rows = filters.rows.map((row, i) => {
+        const fieldSelect = (_jsx(FieldSelect, { columns: filters.columns, value: row.field, onChange: (field) => filters.setField(i, field) }));
+        const conditionSelect = (_jsx(ConditionSelect, { conditions: row.field ? filters.conditionsFor(row.field) : [], value: row.condition, onChange: (condition) => filters.setCondition(i, condition), disabled: !row.field }));
+        const column = row.field
+            ? filters.columns.find((c) => c.key === row.field)
+            : undefined;
+        const valueInput = row.field && row.condition && column ? (_jsx(ValueInput, { column: column, condition: row.condition, value: row.value, onChange: (v) => filters.setValue(i, v) })) : null;
+        const removeButton = _jsx(RemoveButton, { onClick: () => filters.remove(i) });
+        if (renderRow) {
+            return (_jsx(Fragment, { children: renderRow({
+                    index: i,
+                    fieldSelect,
+                    conditionSelect,
+                    valueInput,
+                    removeButton,
+                }) }, row.id));
+        }
+        return (_jsxs("div", { className: "flex items-center gap-2", children: [fieldSelect, conditionSelect, valueInput, removeButton] }, row.id));
+    });
+    const addButton = _jsx(AddButton, { onClick: filters.add });
+    const presets = filters.presets.length > 0 ? (_jsx("div", { className: "flex flex-wrap gap-1 border-t pt-2", children: filters.presets.map((preset) => (_jsx(Fragment, { children: _jsx(PresetButton, { preset: preset, onClick: () => filters.applyPreset(preset.field, preset.name) }) }, `${preset.field}-${preset.name}`))) })) : null;
+    if (renderRoot) {
+        return _jsx(_Fragment, { children: renderRoot({ rows: _jsx(_Fragment, { children: rows }), addButton, presets }) });
+    }
+    return (_jsxs("div", { className: "flex flex-col gap-2", children: [rows, addButton, presets] }));
+}

package/dist/react/index.d.ts

@@ -0,0 +1,4 @@
+export { FilterBuilder } from "./filter-builder.js";
+export type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, PresetButtonSlotProps, RemoveButtonSlotProps, RootSlotProps, RowSlotProps, ValueInputSlotProps, } from "./filter-builder.js";
+export type { FilterValue } from "../filters/filter-state.js";
+export { useFilterBuilder } from "./use-filter-builder.js";

package/dist/react/index.js

@@ -0,0 +1,2 @@
+export { FilterBuilder } from "./filter-builder.js";
+export { useFilterBuilder } from "./use-filter-builder.js";

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

@@ -0,0 +1,24 @@
+import { type FilterRow, type FilterValue } from "../filters/filter-state.js";
+import type { FilterDescriptor } from "../filters/index.js";
+type Preset = {
+    field: string;
+    name: string;
+};
+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;
+    setValue: (index: number, value: FilterValue) => void;
+    clear: () => void;
+    conditionsFor: (field: string) => FilterDescriptor["columns"][number]["conditions"];
+    columnFor: (field: string) => FilterDescriptor["columns"][number];
+    presets: Preset[];
+    applyPreset: (field: string, name: string) => void;
+    result: Record<string, unknown>;
+};
+export declare function useFilterBuilder<T>(descriptor: FilterDescriptor<T>): UseFilterBuilderReturn;
+export {};

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

@@ -0,0 +1,23 @@
+import { useMemo, useState } from "react";
+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]);
+    const result = useMemo(() => buildResult(state), [state]);
+    return {
+        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)),
+        setValue: (index, value) => setState((s) => setRowValue(s, index, value)),
+        clear: () => setState(clearState),
+        conditionsFor: (field) => conditionsFor(descriptor, field),
+        columnFor: (field) => columnFor(descriptor, field),
+        presets,
+        applyPreset: (field, name) => setState((s) => applyPresetState(s, descriptor, field, name)),
+        result,
+    };
+}

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, 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>>);
@@ -53,19 +53,18 @@ declare const redaxiosInstance: {
         spread<Args, R>(fn: (...args: Args[]) => R): (array: Args[]) => R;
         CancelToken: AbortController;
         defaults: redaxios.Options;
-        create: any;
+        create: /*elided*/ any;
     };
 };
 export type AxiosInstance = ReturnType<typeof redaxiosInstance.create>;
 export declare class TSense<T extends Type> {
     private options;
-    fields: FieldSchema[];
+    readonly fields: readonly FieldSchema[];
     private axios;
     private synced;
     private fieldTransformers;
     private dataSyncConfig?;
     infer: T["infer"];
-    getFields(): FieldSchema[];
     constructor(options: TsenseOptions<T>);
     private getBaseType;
     private inferType;
@@ -77,6 +76,7 @@ export declare class TSense<T extends Type> {
     syncSchema(): Promise<void>;
     private buildObjectFilter;
     private buildFilter;
+    private validateFields;
     private buildSort;
     create(): Promise<this>;
     drop(): Promise<void>;
@@ -88,9 +88,10 @@ 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[]>;
+    scoped(baseFilter: FilterFor<T["infer"]>): ScopedCollection<T["infer"]>;
 }
 export {};