@izumisy-tailor/tailor-data-viewer 0.2.15 → 0.2.16

package/README.md

@@ -215,7 +215,7 @@ export default defineConfig({
 tailor-sdk generate
 ```
 
-### `inferColumnHelper(metadata, tableName)`
+### `inferColumnHelper(tableMetadata)`
 
 `field()` requires manually specifying `sort`/`filter` type configs and enum `options` for every column. `inferColumnHelper()` eliminates this boilerplate by automatically deriving these from the generated table metadata. Based on each field's type (string, number, date, enum, etc.), the appropriate `SortConfig` / `FilterConfig` is set automatically, and enum fields get their options populated from the schema.
 
@@ -223,7 +223,7 @@ tailor-sdk generate
 import { inferColumnHelper, display } from "@izumisy-tailor/tailor-data-viewer/component";
 import { tableMetadata } from "./generated/data-viewer-metadata.generated";
 
-const { column, columns } = inferColumnHelper(tableMetadata, "task");
+const { column, columns } = inferColumnHelper(tableMetadata.task);
 
 const taskColumns = [
   column("title"),                     // sort/filter auto-configured from metadata

package/package.json

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

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

@@ -409,11 +409,10 @@ describe("useCollection", () => {
       },
     } as const satisfies TableMetadataMap;
 
-    it("works with metadata and tableName", () => {
+    it("works with tableMetadata", () => {
       const { result } = renderHook(() =>
         useCollection({
-          metadata: testMetadata,
-          tableName: "task",
+          tableMetadata: testMetadata.task,
           query: FAKE_QUERY,
           params: { pageSize: 10 },
         }),
@@ -424,8 +423,7 @@ describe("useCollection", () => {
     it("applies typed initialSort", () => {
       const { result } = renderHook(() =>
         useCollection({
-          metadata: testMetadata,
-          tableName: "task",
+          tableMetadata: testMetadata.task,
           query: FAKE_QUERY,
           params: {
             initialSort: [{ field: "dueDate", direction: "Desc" }],

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

@@ -1,9 +1,9 @@
 import { useCallback, useMemo, useState } from "react";
-import type { TableMetadataMap } from "../../generator/metadata-generator";
+import type { TableMetadata } from "../../generator/metadata-generator";
 import type {
   Filter,
   FilterOperator,
-  MetadataFilter,
+  TableMetadataFilter,
   PageInfo,
   QueryVariables,
   SortState,
@@ -12,7 +12,7 @@ import type {
   ExtractQueryVariables,
   ValidateCollectionQuery,
 } from "../types";
-import type { FieldName, OrderableFieldName } from "../types";
+import type { TableFieldName, TableOrderableFieldName } from "../types";
 
 /**
  * Resolves the variables type for `toQueryArgs()` return value.
@@ -47,8 +47,7 @@ type ResolveVariables<TQuery> =
  * import { tableMetadata } from "./generated/data-viewer-metadata.generated";
  *
  * const collection = useCollection({
- *   metadata: tableMetadata,
- *   tableName: "task",
+ *   tableMetadata: tableMetadata.task,
  *   query: GET_TASKS,
  *   params: { pageSize: 20 },
  * });
@@ -56,29 +55,27 @@ type ResolveVariables<TQuery> =
  * ```
  */
 export function useCollection<
-  const TMetadata extends TableMetadataMap,
-  TTableName extends string & keyof TMetadata,
+  const TTable extends TableMetadata,
   TQuery,
 >(
   options: UseCollectionOptions<
-    FieldName<TMetadata, TTableName>,
-    MetadataFilter<TMetadata, TTableName>
+    TableFieldName<TTable>,
+    TableMetadataFilter<TTable>
   > & {
-    metadata: TMetadata;
-    tableName: TTableName;
+    tableMetadata: TTable;
     query: ValidateCollectionQuery<
       TQuery,
-      FieldName<TMetadata, TTableName>,
-      OrderableFieldName<TMetadata, TTableName>
+      TableFieldName<TTable>,
+      TableOrderableFieldName<TTable>
     >;
   },
 ): UseCollectionReturn<
-  FieldName<TMetadata, TTableName>,
+  TableFieldName<TTable>,
   {
     query: TQuery;
     variables: ResolveVariables<TQuery>;
   },
-  MetadataFilter<TMetadata, TTableName>
+  TableMetadataFilter<TTable>
 >;
 
 /**
@@ -99,8 +96,7 @@ export function useCollection<
 export function useCollection<TQuery>(
   options: UseCollectionOptions & {
     query: TQuery;
-    metadata?: never;
-    tableName?: never;
+    tableMetadata?: never;
   },
 ): UseCollectionReturn<
   string,
@@ -112,8 +108,7 @@ export function useCollection<TQuery>(
 // -----------------------------------------------------------------------------
 export function useCollection(
   options: UseCollectionOptions & {
-    metadata?: TableMetadataMap;
-    tableName?: string;
+    tableMetadata?: TableMetadata;
     query: unknown;
   },
 ): UseCollectionReturn<string, { query: unknown; variables: QueryVariables }> {

package/src/component/field-helpers.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, expectTypeOf } from "vitest";
 import { createColumnHelper, inferColumnHelper } from "./field-helpers";
 import type { TableMetadataMap } from "../generator/metadata-generator";
 import { fieldTypeToSortConfig, fieldTypeToFilterConfig } from "./types";
-import type { NodeType } from "./types";
+import type { NodeType, TableFieldName } from "./types";
 
 describe("NodeType", () => {
   it("extracts node type from a collection result", () => {
@@ -167,10 +167,7 @@ describe("inferColumnHelper()", () => {
   } as const satisfies TableMetadataMap;
 
   it("creates a column with auto-detected sort/filter", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
 
     const titleCol = column("title");
     expect(titleCol.kind).toBe("field");
@@ -180,10 +177,7 @@ describe("inferColumnHelper()", () => {
   });
 
   it("auto-detects enum options", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     const statusCol = column("status");
     expect(statusCol.filter).toEqual({
       type: "enum",
@@ -198,60 +192,42 @@ describe("inferColumnHelper()", () => {
   });
 
   it("auto-detects date type", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     const dateCol = column("dueDate");
     expect(dateCol.sort).toEqual({ type: "date" });
     expect(dateCol.filter).toEqual({ type: "date" });
   });
 
   it("disables sort with sort: false", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     const col = column("title", { sort: false });
     expect(col.sort).toBeUndefined();
     expect(col.filter).toEqual({ type: "string" });
   });
 
   it("disables filter with filter: false", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     const col = column("title", { filter: false });
     expect(col.sort).toEqual({ type: "string" });
     expect(col.filter).toBeUndefined();
   });
 
   it("uuid has no sort, has uuid filter", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     const col = column("id");
     expect(col.sort).toBeUndefined();
     expect(col.filter).toEqual({ type: "uuid" });
   });
 
   it("array type has no sort/filter", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     const col = column("tags");
     expect(col.sort).toBeUndefined();
     expect(col.filter).toBeUndefined();
   });
 
   it("columns() creates multiple columns at once", () => {
-    const { columns } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { columns } = inferColumnHelper(testMetadata.task);
     const cols = columns(["title", "status", "dueDate"]);
     expect(cols).toHaveLength(3);
     expect(cols[0].dataKey).toBe("title");
@@ -260,10 +236,7 @@ describe("inferColumnHelper()", () => {
   });
 
   it("columns() applies overrides", () => {
-    const { columns } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { columns } = inferColumnHelper(testMetadata.task);
     const cols = columns(["title", "status"], {
       overrides: {
         title: { label: "Custom Title", width: 300 },
@@ -274,10 +247,7 @@ describe("inferColumnHelper()", () => {
   });
 
   it("columns() applies global sort/filter options", () => {
-    const { columns } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { columns } = inferColumnHelper(testMetadata.task);
     const cols = columns(["title", "status"], { sort: false });
     expect(cols[0].sort).toBeUndefined();
     expect(cols[1].sort).toBeUndefined();
@@ -286,13 +256,17 @@ describe("inferColumnHelper()", () => {
   });
 
   it("throws for non-existent field", () => {
-    const { column } = inferColumnHelper({
-      metadata: testMetadata,
-      tableName: "task",
-    });
+    const { column } = inferColumnHelper(testMetadata.task);
     // @ts-expect-error - intentionally testing invalid field name
     expect(() => column("nonExistent")).toThrow(
       'Field "nonExistent" not found in table "task" metadata',
     );
   });
+
+  it("infers TableFieldName type correctly", () => {
+    type TaskFieldNames = TableFieldName<(typeof testMetadata)["task"]>;
+    expectTypeOf<TaskFieldNames>().toEqualTypeOf<
+      "id" | "title" | "status" | "dueDate" | "count" | "isActive" | "tags"
+    >();
+  });
 });

package/src/component/field-helpers.ts

@@ -1,11 +1,11 @@
-import type { TableMetadataMap } from "../generator/metadata-generator";
+import type { TableMetadata } from "../generator/metadata-generator";
 import type {
   CellRenderer,
   DisplayColumn,
   DisplayColumnOptions,
   FieldColumn,
   FieldColumnOptions,
-  FieldName,
+  TableFieldName,
   FilterConfig,
   MetadataFieldOptions,
   MetadataFieldsOptions,
@@ -130,16 +130,13 @@ export function createColumnHelper<TRow extends Record<string, unknown>>(): {
  * Automatically infers sort/filter configuration from field types,
  * including enum options.
  *
- * @param options - Object containing `metadata` (the generated map) and `tableName`.
+ * @param tableMetadata - A single table metadata object from the generated map.
  *
  * @example
  * ```tsx
  * import { tableMetadata } from "./generated/data-viewer-metadata.generated";
  *
- * const { column, columns } = inferColumnHelper({
- *   metadata: tableMetadata,
- *   tableName: "task",
- * });
+ * const { column, columns } = inferColumnHelper(tableMetadata.task);
  *
  * const taskColumns = [
  *   column("title"),           // sort/filter auto-detected
@@ -149,35 +146,29 @@ export function createColumnHelper<TRow extends Record<string, unknown>>(): {
  * ];
  * ```
  */
-export function inferColumnHelper<
-  const TMetadata extends TableMetadataMap,
-  TTableName extends string & keyof TMetadata,
->(options: {
-  metadata: TMetadata;
-  tableName: TTableName;
-}): {
+export function inferColumnHelper<const TTable extends TableMetadata>(
+  tableMetadata: TTable,
+): {
   column: (
-    dataKey: FieldName<TMetadata, TTableName>,
+    dataKey: TableFieldName<TTable>,
     options?: MetadataFieldOptions,
   ) => FieldColumn<Record<string, unknown>>;
 
   columns: (
-    dataKeys: FieldName<TMetadata, TTableName>[],
+    dataKeys: TableFieldName<TTable>[],
     options?: MetadataFieldsOptions,
   ) => FieldColumn<Record<string, unknown>>[];
 } {
-  const { metadata, tableName } = options;
-  const tableMeta = metadata[tableName];
-  const fields = tableMeta.fields;
+  const fields = tableMetadata.fields;
 
   const column = (
-    dataKey: FieldName<TMetadata, TTableName>,
+    dataKey: TableFieldName<TTable>,
     columnOptions?: MetadataFieldOptions,
   ): FieldColumn<Record<string, unknown>> => {
     const fieldMeta = fields.find((f) => f.name === dataKey);
     if (!fieldMeta) {
       throw new Error(
-        `Field "${String(dataKey)}" not found in table "${String(tableName)}" metadata`,
+        `Field "${String(dataKey)}" not found in table "${tableMetadata.name}" metadata`,
       );
     }
 
@@ -213,7 +204,7 @@ export function inferColumnHelper<
   };
 
   const columnsHelper = (
-    dataKeys: FieldName<TMetadata, TTableName>[],
+    dataKeys: TableFieldName<TTable>[],
     options?: MetadataFieldsOptions,
   ): FieldColumn<Record<string, unknown>>[] => {
     return dataKeys.map((dataKey) => {

package/src/component/index.ts

@@ -5,7 +5,6 @@ export type {
   SelectOption,
   FilterOperator,
   Filter,
-  MetadataFilter,
   SortState,
   PageInfo,
   QueryVariables,
@@ -28,7 +27,9 @@ export type {
   DataTableRowProps,
   DataTableCellProps,
   FieldName,
+  TableFieldName,
   OrderableFieldName,
+  TableOrderableFieldName,
   ExtractOrderField,
   ExtractQueryVariables,
   ExtractQueryInputKeys,
@@ -37,6 +38,8 @@ export type {
   MatchingTableName,
   MetadataFieldOptions,
   MetadataFieldsOptions,
+  MetadataFilter,
+  TableMetadataFilter,
   ColumnSelectorProps,
   CsvButtonProps,
   SearchFilterFormProps,

package/src/component/types.ts

@@ -1,6 +1,7 @@
 import type { ReactNode } from "react";
 import type {
   FieldType,
+  TableMetadata,
   TableMetadataMap,
 } from "../generator/metadata-generator";
 
@@ -144,24 +145,40 @@ export interface Filter<TFieldName extends string = string> {
  * //   | { field: "status"; operator: "eq" | "ne" | "in" | "notIn"; value: unknown }
  * ```
  */
+/**
+ * Metadata-aware filter type from a single table metadata object.
+ *
+ * Given table metadata, produces a discriminated union over each field
+ * where the `operator` is narrowed to only those valid for that field's type.
+ *
+ * @typeParam TTable - A single table metadata object (as const).
+ */
+export type TableMetadataFilter<TTable extends TableMetadata> =
+  TTable["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;
+
+/**
+ * Metadata-aware filter type.
+ *
+ * @deprecated Use `TableMetadataFilter<TMetadata[TTableName]>` instead.
+ */
 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;
+> = TableMetadataFilter<TMetadata[TTableName]>;
 
 /**
  * Active sort state for a single field.
@@ -599,16 +616,30 @@ export interface UseDataTableReturn<TRow extends Record<string, unknown>> {
 // =============================================================================
 
 /**
- * Extract field names from table metadata.
+ * Extract field names from a single table metadata object.
+ *
+ * @example
+ * ```ts
+ * type Names = TableFieldName<typeof tableMetadata.task>;
+ * // → "id" | "title" | "status" | "dueDate" | ...
+ * ```
+ */
+export type TableFieldName<TTable extends TableMetadata> =
+  TTable["fields"][number] extends { readonly name: infer N }
+    ? N extends string
+      ? N
+      : never
+    : never;
+
+/**
+ * Extract field names from table metadata map + table name.
+ *
+ * @deprecated Use `TableFieldName<TMetadata[TTableName]>` instead.
  */
 export type FieldName<
   TMetadata extends TableMetadataMap,
   TTableName extends keyof TMetadata,
-> = TMetadata[TTableName]["fields"][number] extends { readonly name: infer N }
-  ? N extends string
-    ? N
-    : never
-  : never;
+> = TableFieldName<TMetadata[TTableName]>;
 
 /**
  * Field types that support ordering.
@@ -625,19 +656,16 @@ type OrderableFieldType =
   | "enum";
 
 /**
- * Extract only orderable field names from table metadata.
+ * Extract only orderable field names from a single table metadata object.
  *
  * Fields whose `type` is not in `OrderableFieldType` (e.g. `uuid`, `array`,
  * `nested`, `file`) are excluded.  This allows `CheckOrderField` to compare
  * only the fields that Tailor Platform actually exposes in the
  * `OrderFieldEnum`, avoiding false positives for fields like `id`.
  */
-export type OrderableFieldName<
-  TMetadata extends TableMetadataMap,
-  TTableName extends keyof TMetadata,
-> =
+export type TableOrderableFieldName<TTable extends TableMetadata> =
   Extract<
-    TMetadata[TTableName]["fields"][number],
+    TTable["fields"][number],
     { readonly type: OrderableFieldType }
   > extends { readonly name: infer N }
     ? N extends string
@@ -645,6 +673,16 @@ export type OrderableFieldName<
       : never
     : never;
 
+/**
+ * Extract only orderable field names from table metadata map + table name.
+ *
+ * @deprecated Use `TableOrderableFieldName<TMetadata[TTableName]>` instead.
+ */
+export type OrderableFieldName<
+  TMetadata extends TableMetadataMap,
+  TTableName extends keyof TMetadata,
+> = TableOrderableFieldName<TMetadata[TTableName]>;
+
 /**
  * Extract the `order[].field` union type from a GraphQL variables type.
  *