@izumisy-tailor/tailor-data-viewer 0.2.6 → 0.2.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@izumisy-tailor/tailor-data-viewer",
   "private": false,
-  "version": "0.2.6",
+  "version": "0.2.7",
   "type": "module",
   "description": "Flexible data viewer component for Tailor Platform",
   "files": [

package/src/component/collection-params/use-collection-params.test.ts

@@ -44,7 +44,6 @@ describe("useCollectionParams", () => {
           initialFilters: [
             {
               field: "status",
-              fieldType: "enum",
               operator: "eq",
               value: "ACTIVE",
             },
@@ -101,13 +100,11 @@ describe("useCollectionParams", () => {
         result.current.setFilters([
           {
             field: "status",
-            fieldType: "enum",
             operator: "eq",
             value: "ACTIVE",
           },
           {
             field: "amount",
-            fieldType: "number",
             operator: "gte",
             value: 1000,
           },
@@ -308,7 +305,6 @@ describe("useCollectionParams", () => {
           initialFilters: [
             {
               field: "status",
-              fieldType: "enum",
               operator: "eq",
               value: "ACTIVE",
             },
@@ -374,81 +370,6 @@ describe("useCollectionParams", () => {
       expect(result.current.variables).toEqual({ first: 10 });
     });
 
-    it("auto-detects fieldType from metadata for string field", () => {
-      const { result } = renderHook(() =>
-        useCollectionParams({
-          metadata: testMetadata,
-          tableName: "task",
-        }),
-      );
-
-      act(() => {
-        result.current.addFilter("title", "foo");
-      });
-
-      expect(result.current.filters[0].fieldType).toBe("string");
-    });
-
-    it("auto-detects fieldType from metadata for enum field", () => {
-      const { result } = renderHook(() =>
-        useCollectionParams({
-          metadata: testMetadata,
-          tableName: "task",
-        }),
-      );
-
-      act(() => {
-        result.current.addFilter("status", "todo");
-      });
-
-      expect(result.current.filters[0].fieldType).toBe("enum");
-    });
-
-    it("auto-detects fieldType from metadata for date field", () => {
-      const { result } = renderHook(() =>
-        useCollectionParams({
-          metadata: testMetadata,
-          tableName: "task",
-        }),
-      );
-
-      act(() => {
-        result.current.addFilter("dueDate", "2026-01-01");
-      });
-
-      expect(result.current.filters[0].fieldType).toBe("date");
-    });
-
-    it("auto-detects fieldType from metadata for uuid field", () => {
-      const { result } = renderHook(() =>
-        useCollectionParams({
-          metadata: testMetadata,
-          tableName: "task",
-        }),
-      );
-
-      act(() => {
-        result.current.addFilter("id", "some-uuid");
-      });
-
-      expect(result.current.filters[0].fieldType).toBe("uuid");
-    });
-
-    it("auto-detects fieldType from metadata for number field", () => {
-      const { result } = renderHook(() =>
-        useCollectionParams({
-          metadata: testMetadata,
-          tableName: "task",
-        }),
-      );
-
-      act(() => {
-        result.current.addFilter("count", 42);
-      });
-
-      expect(result.current.filters[0].fieldType).toBe("number");
-    });
-
     it("applies typed initialSort", () => {
       const { result } = renderHook(() =>
         useCollectionParams({

package/src/component/collection-params/use-collection-params.ts

@@ -1,18 +1,15 @@
-import { useCallback, useMemo, useRef, useState } from "react";
-import type {
-  FieldType,
-  TableMetadataMap,
-} from "../../generator/metadata-generator";
+import { useCallback, useMemo, useState } from "react";
+import type { TableMetadataMap } from "../../generator/metadata-generator";
 import type {
   Filter,
   FilterOperator,
+  MetadataFilter,
   QueryVariables,
   SortState,
   UseCollectionParamsOptions,
   UseCollectionParamsReturn,
   ExtractQueryVariables,
 } from "../types";
-import { fieldTypeToFilterConfig } from "../types";
 import type { FieldName } from "../types";
 
 // -----------------------------------------------------------------------------
@@ -52,7 +49,10 @@ export function useCollectionParams<
   TTableName extends string & keyof TMetadata,
   TQuery = never,
 >(
-  options: UseCollectionParamsOptions<FieldName<TMetadata, TTableName>> & {
+  options: UseCollectionParamsOptions<
+    FieldName<TMetadata, TTableName>,
+    MetadataFilter<TMetadata, TTableName>
+  > & {
     metadata: TMetadata;
     tableName: TTableName;
     query?: TQuery;
@@ -106,15 +106,8 @@ export function useCollectionParams(
     initialFilters = [],
     initialSort = [],
     pageSize: initialPageSize = 20,
-    metadata,
-    tableName,
   } = options;
 
-  // Keep a ref to the resolved fields list so callbacks can look up fieldType.
-  const fieldsRef = useRef(
-    metadata && tableName ? metadata[tableName]?.fields : undefined,
-  );
-
   // ---------------------------------------------------------------------------
   // State
   // ---------------------------------------------------------------------------
@@ -131,17 +124,8 @@ export function useCollectionParams(
     (field: string, value: unknown, operator: FilterOperator = "eq") => {
       setFiltersState((prev) => {
         const existing = prev.findIndex((f) => f.field === field);
-        // Auto-detect fieldType from metadata when available
-        const fieldMeta = fieldsRef.current?.find((f) => f.name === field);
-        const detectedType: Filter["fieldType"] = fieldMeta
-          ? (fieldTypeToFilterConfig(
-              fieldMeta.type as FieldType,
-              fieldMeta.enumValues as readonly string[] | undefined,
-            )?.type ?? "string")
-          : "string";
         const newFilter: Filter = {
           field,
-          fieldType: detectedType,
           operator,
           value,
         };

package/src/component/index.ts

@@ -5,6 +5,7 @@ export type {
   SelectOption,
   FilterOperator,
   Filter,
+  MetadataFilter,
   SortState,
   PageInfo,
   QueryVariables,

package/src/component/search-filter-form.tsx

@@ -116,7 +116,9 @@ export function SearchFilterForm<TRow extends Record<string, unknown>>({
   // Reset operator when field changes
   useEffect(() => {
     if (selectedFilterConfig) {
-      const ops = OPERATORS_BY_FILTER_TYPE[selectedFilterConfig.type];
+      const ops = OPERATORS_BY_FILTER_TYPE[
+        selectedFilterConfig.type
+      ] as readonly FilterOperator[];
       if (ops.length > 0 && !ops.includes(selectedOperator)) {
         setSelectedOperator(ops[0]);
       }

package/src/component/types.ts

@@ -39,39 +39,60 @@ export type FilterConfig =
   | { type: "uuid" };
 
 // =============================================================================
-// Filter Operators
+// Filter Operators (Single Source of Truth)
 // =============================================================================
 
-/**
- * Available filter operators (Tailor Platform compliant).
- */
-export type FilterOperator =
-  | "eq"
-  | "ne"
-  | "contains"
-  | "startsWith"
-  | "endsWith"
-  | "gt"
-  | "gte"
-  | "lt"
-  | "lte"
-  | "between"
-  | "in"
-  | "notIn";
-
 /**
  * Operators available per filter type (Tailor Platform schema).
+ *
+ * This `as const satisfies` definition is the **single source of truth**.
+ * Both the `FilterOperator` union and the `OperatorForFilterType` mapping
+ * are derived from it, eliminating duplication.
  */
-export const OPERATORS_BY_FILTER_TYPE: Record<
-  FilterConfig["type"],
-  FilterOperator[]
-> = {
+export const OPERATORS_BY_FILTER_TYPE = {
   string: ["eq", "ne", "contains", "startsWith", "endsWith"],
   number: ["eq", "ne", "gt", "gte", "lt", "lte", "between"],
   date: ["eq", "ne", "gt", "gte", "lt", "lte", "between"],
   enum: ["eq", "ne", "in", "notIn"],
   boolean: ["eq", "ne"],
   uuid: ["eq", "ne", "in", "notIn"],
+} as const satisfies Record<FilterConfig["type"], readonly string[]>;
+
+/**
+ * Maps each filter type to the union of operators it supports.
+ * Derived from `OPERATORS_BY_FILTER_TYPE`.
+ */
+export type OperatorForFilterType = {
+  [T in FilterConfig["type"]]: (typeof OPERATORS_BY_FILTER_TYPE)[T][number];
+};
+
+/**
+ * Union of all available filter operators.
+ * Derived from `OPERATORS_BY_FILTER_TYPE`.
+ */
+export type FilterOperator = OperatorForFilterType[FilterConfig["type"]];
+
+// =============================================================================
+// Filter Type → FieldType Mapping (type-level)
+// =============================================================================
+
+/**
+ * Type-level mapping from `FieldType` (metadata) to `FilterConfig["type"]`.
+ * Mirrors the runtime `fieldTypeToFilterConfig` function.
+ * Types that don't support filtering map to `never`.
+ */
+export type FieldTypeToFilterConfigType = {
+  string: "string";
+  number: "number";
+  boolean: "boolean";
+  uuid: "uuid";
+  datetime: "date";
+  date: "date";
+  time: "date";
+  enum: "enum";
+  array: never;
+  nested: never;
+  file: never;
 };
 
 // =============================================================================
@@ -80,14 +101,53 @@ export const OPERATORS_BY_FILTER_TYPE: Record<
 
 /**
  * Active filter state.
+ *
+ * @typeParam TFieldName - Union of allowed field name strings (default: `string`).
  */
-export interface Filter {
-  field: string;
-  fieldType: FilterConfig["type"];
+export interface Filter<TFieldName extends string = string> {
+  field: TFieldName;
   operator: FilterOperator;
   value: unknown;
 }
 
+/**
+ * Metadata-aware filter type.
+ *
+ * Given table metadata, produces a discriminated union over each field
+ * where the `operator` is narrowed to only those valid for that field's type.
+ * Fields whose `FieldType` doesn't support filtering (array, nested, file) are excluded.
+ *
+ * @typeParam TMetadata - The `tableMetadata` object type (as const).
+ * @typeParam TTableName - The table name key in `TMetadata`.
+ *
+ * @example
+ * ```ts
+ * // If table "task" has fields: name (string), priority (number), status (enum)
+ * type F = MetadataFilter<typeof tableMetadata, "task">;
+ * //   | { field: "name"; operator: "eq" | "ne" | "contains" | ...; value: unknown }
+ * //   | { field: "priority"; operator: "eq" | "ne" | "gt" | ...; value: unknown }
+ * //   | { field: "status"; operator: "eq" | "ne" | "in" | "notIn"; value: unknown }
+ * ```
+ */
+export type MetadataFilter<
+  TMetadata extends TableMetadataMap,
+  TTableName extends string & keyof TMetadata,
+> = TMetadata[TTableName]["fields"][number] extends infer F
+  ? F extends { readonly name: infer N; readonly type: infer T }
+    ? N extends string
+      ? T extends keyof FieldTypeToFilterConfigType
+        ? FieldTypeToFilterConfigType[T] extends never
+          ? never
+          : {
+              field: N;
+              operator: OperatorForFilterType[FieldTypeToFilterConfigType[T]];
+              value: unknown;
+            }
+        : never
+      : never
+    : never
+  : never;
+
 /**
  * Active sort state for a single field.
  */
@@ -270,9 +330,10 @@ export type ColumnDefinition<TRow extends Record<string, unknown>> =
  */
 export interface UseCollectionParamsOptions<
   TFieldName extends string = string,
+  TFilter extends Filter<TFieldName> = Filter<TFieldName>,
 > {
   /** Initial filters to apply */
-  initialFilters?: Filter[];
+  initialFilters?: TFilter[];
   /** Initial sort states */
   initialSort?: { field: TFieldName; direction: "Asc" | "Desc" }[];
   /** Number of items per page (default: 20) */