@izumisy-tailor/tailor-data-viewer 0.2.14 → 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.14",
+  "version": "0.2.16",
   "type": "module",
   "description": "Flexible data viewer component for Tailor Platform",
   "files": [

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

@@ -243,7 +243,7 @@ describe("useCollection", () => {
   // Pagination operations
   // ---------------------------------------------------------------------------
   describe("pagination operations", () => {
-    it("navigates to next page", () => {
+    it("navigates to next page (forward)", () => {
       const { result } = renderHook(() => useCollection({ query: FAKE_QUERY }));
 
       act(() => {
@@ -251,54 +251,75 @@ describe("useCollection", () => {
       });
 
       expect(result.current.cursor).toBe("cursor1");
-      expect(result.current.hasPrevPage).toBe(true);
+      expect(result.current.paginationDirection).toBe("forward");
       expect(result.current.toQueryArgs().variables.after).toBe("cursor1");
+      expect(result.current.toQueryArgs().variables.first).toBe(20);
+      expect(result.current.toQueryArgs().variables.last).toBeUndefined();
+      expect(result.current.toQueryArgs().variables.before).toBeUndefined();
     });
 
-    it("navigates back to previous page", () => {
+    it("navigates to previous page (backward)", () => {
       const { result } = renderHook(() => useCollection({ query: FAKE_QUERY }));
 
       act(() => {
-        result.current.nextPage("cursor1");
-      });
-      act(() => {
-        result.current.nextPage("cursor2");
-      });
-      act(() => {
-        result.current.prevPage();
+        result.current.prevPage("cursor1");
       });
 
       expect(result.current.cursor).toBe("cursor1");
-      expect(result.current.hasPrevPage).toBe(true);
+      expect(result.current.paginationDirection).toBe("backward");
+      expect(result.current.toQueryArgs().variables.before).toBe("cursor1");
+      expect(result.current.toQueryArgs().variables.last).toBe(20);
+      expect(result.current.toQueryArgs().variables.first).toBeUndefined();
+      expect(result.current.toQueryArgs().variables.after).toBeUndefined();
     });
 
-    it("navigates back to first page", () => {
+    it("switches direction on nextPage after prevPage", () => {
       const { result } = renderHook(() => useCollection({ query: FAKE_QUERY }));
 
       act(() => {
-        result.current.nextPage("cursor1");
+        result.current.prevPage("cursorB");
       });
+      expect(result.current.paginationDirection).toBe("backward");
+
       act(() => {
-        result.current.prevPage();
+        result.current.nextPage("cursorA");
       });
-
-      expect(result.current.cursor).toBeNull();
-      expect(result.current.hasPrevPage).toBe(false);
+      expect(result.current.paginationDirection).toBe("forward");
+      expect(result.current.toQueryArgs().variables.after).toBe("cursorA");
+      expect(result.current.toQueryArgs().variables.first).toBe(20);
     });
 
-    it("resets page", () => {
+    it("resets page to forward direction", () => {
       const { result } = renderHook(() => useCollection({ query: FAKE_QUERY }));
 
       act(() => {
-        result.current.nextPage("cursor1");
-        result.current.nextPage("cursor2");
+        result.current.prevPage("cursor1");
       });
       act(() => {
         result.current.resetPage();
       });
 
       expect(result.current.cursor).toBeNull();
+      expect(result.current.paginationDirection).toBe("forward");
+    });
+
+    it("tracks hasPrevPage and hasNextPage from setPageInfo", () => {
+      const { result } = renderHook(() => useCollection({ query: FAKE_QUERY }));
+
       expect(result.current.hasPrevPage).toBe(false);
+      expect(result.current.hasNextPage).toBe(false);
+
+      act(() => {
+        result.current.setPageInfo({
+          hasNextPage: true,
+          endCursor: "end",
+          hasPreviousPage: true,
+          startCursor: "start",
+        });
+      });
+
+      expect(result.current.hasPrevPage).toBe(true);
+      expect(result.current.hasNextPage).toBe(true);
     });
   });
 
@@ -346,6 +367,8 @@ describe("useCollection", () => {
       expect("query" in variables).toBe(false);
       expect("order" in variables).toBe(false);
       expect("after" in variables).toBe(false);
+      expect("last" in variables).toBe(false);
+      expect("before" in variables).toBe(false);
     });
 
     it("includes query in toQueryArgs result", () => {
@@ -386,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 },
         }),
@@ -401,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,10 @@
 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,
   UseCollectionOptions,
@@ -11,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.
@@ -46,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 },
  * });
@@ -55,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>
 >;
 
 /**
@@ -98,8 +96,7 @@ export function useCollection<
 export function useCollection<TQuery>(
   options: UseCollectionOptions & {
     query: TQuery;
-    metadata?: never;
-    tableName?: never;
+    tableMetadata?: never;
   },
 ): UseCollectionReturn<
   string,
@@ -111,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 }> {
@@ -130,7 +126,15 @@ export function useCollection(
   const [sortStates, setSortStates] = useState<SortState[]>(initialSort);
   const [pageSize] = useState(initialPageSize);
   const [cursor, setCursor] = useState<string | null>(null);
-  const [cursorHistory, setCursorHistory] = useState<string[]>([]);
+  const [paginationDirection, setPaginationDirection] = useState<
+    "forward" | "backward"
+  >("forward");
+  const [currentPageInfo, setCurrentPageInfo] = useState<PageInfo>({
+    hasNextPage: false,
+    endCursor: null,
+    hasPreviousPage: false,
+    startCursor: null,
+  });
 
   // ---------------------------------------------------------------------------
   // Filter operations
@@ -153,7 +157,7 @@ export function useCollection(
       });
       // Reset pagination when filters change
       setCursor(null);
-      setCursorHistory([]);
+      setPaginationDirection("forward");
     },
     [],
   );
@@ -162,20 +166,20 @@ export function useCollection(
     setFiltersState(newFilters);
     // Reset pagination when filters change
     setCursor(null);
-    setCursorHistory([]);
+    setPaginationDirection("forward");
   }, []);
 
   const removeFilter = useCallback((field: string) => {
     setFiltersState((prev) => prev.filter((f) => f.field !== field));
     // Reset pagination when filters change
     setCursor(null);
-    setCursorHistory([]);
+    setPaginationDirection("forward");
   }, []);
 
   const clearFilters = useCallback(() => {
     setFiltersState([]);
     setCursor(null);
-    setCursorHistory([]);
+    setPaginationDirection("forward");
   }, []);
 
   // ---------------------------------------------------------------------------
@@ -194,7 +198,7 @@ export function useCollection(
       });
       // Reset pagination when sort changes
       setCursor(null);
-      setCursorHistory([]);
+      setPaginationDirection("forward");
     },
     [],
   );
@@ -202,45 +206,52 @@ export function useCollection(
   const clearSort = useCallback(() => {
     setSortStates([]);
     setCursor(null);
-    setCursorHistory([]);
+    setPaginationDirection("forward");
   }, []);
 
   // ---------------------------------------------------------------------------
   // Pagination operations
   // ---------------------------------------------------------------------------
-  const nextPage = useCallback(
-    (endCursor: string) => {
-      setCursorHistory((prev) => [...prev, cursor ?? ""]);
-      setCursor(endCursor);
-    },
-    [cursor],
-  );
+  const nextPage = useCallback((endCursor: string) => {
+    setCursor(endCursor);
+    setPaginationDirection("forward");
+  }, []);
 
-  const prevPage = useCallback(() => {
-    setCursorHistory((prev) => {
-      const newHistory = [...prev];
-      const previousCursor = newHistory.pop();
-      setCursor(
-        previousCursor && previousCursor !== "" ? previousCursor : null,
-      );
-      return newHistory;
-    });
+  const prevPage = useCallback((startCursor: string) => {
+    setCursor(startCursor);
+    setPaginationDirection("backward");
   }, []);
 
   const resetPage = useCallback(() => {
     setCursor(null);
-    setCursorHistory([]);
+    setPaginationDirection("forward");
   }, []);
 
-  const hasPrevPage = cursorHistory.length > 0;
+  const setPageInfo = useCallback((pageInfo: PageInfo) => {
+    setCurrentPageInfo(pageInfo);
+  }, []);
+
+  const hasPrevPage = currentPageInfo.hasPreviousPage;
+  const hasNextPage = currentPageInfo.hasNextPage;
 
   // ---------------------------------------------------------------------------
   // Build query variables (Tailor Platform format)
   // ---------------------------------------------------------------------------
   const variables = useMemo<QueryVariables>(() => {
-    const vars: QueryVariables = {
-      first: pageSize,
-    };
+    const vars: QueryVariables = {};
+
+    // Pagination direction determines first/after vs last/before
+    if (paginationDirection === "forward") {
+      vars.first = pageSize;
+      if (cursor) {
+        vars.after = cursor;
+      }
+    } else {
+      vars.last = pageSize;
+      if (cursor) {
+        vars.before = cursor;
+      }
+    }
 
     // Build query (filters)
     if (filters.length > 0) {
@@ -259,13 +270,8 @@ export function useCollection(
       }));
     }
 
-    // Cursor
-    if (cursor) {
-      vars.after = cursor;
-    }
-
     return vars;
-  }, [filters, sortStates, pageSize, cursor]);
+  }, [filters, sortStates, pageSize, cursor, paginationDirection]);
 
   // ---------------------------------------------------------------------------
   // toQueryArgs
@@ -291,9 +297,12 @@ export function useCollection(
     clearSort,
     pageSize,
     cursor,
+    paginationDirection,
     nextPage,
     prevPage,
     resetPage,
     hasPrevPage,
+    hasNextPage,
+    setPageInfo,
   };
 }

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

@@ -34,6 +34,8 @@ type FakeDoc<Variables> = {
 type DocOk = FakeDoc<{
   first?: number | null;
   after?: string | null;
+  last?: number | null;
+  before?: string | null;
   query?: { name?: unknown } | null;
   order?: readonly { field?: "name" | null }[] | null;
 }>;
@@ -44,12 +46,80 @@ export const assert1: Assert1 = true;
 // ❌ Query missing $first should fail
 type DocNoFirst = FakeDoc<{
   after?: string | null;
+  last?: number | null;
+  before?: string | null;
   query?: { name?: unknown } | null;
+  order?: readonly { field?: "name" | null }[] | null;
 }>;
 type Fail1 = ValidateCollectionQuery<DocNoFirst, "name">;
 type AssertFail1 = HasCollectionQueryError<Fail1> extends true ? true : never;
 export const assertFail1: AssertFail1 = true;
 
+// ❌ Query missing $after should fail
+type DocNoAfter = FakeDoc<{
+  first?: number | null;
+  last?: number | null;
+  before?: string | null;
+  query?: { name?: unknown } | null;
+  order?: readonly { field?: "name" | null }[] | null;
+}>;
+type FailNoAfter = ValidateCollectionQuery<DocNoAfter, "name">;
+type AssertFailNoAfter =
+  HasCollectionQueryError<FailNoAfter> extends true ? true : never;
+export const assertFailNoAfter: AssertFailNoAfter = true;
+
+// ❌ Query missing $last should fail
+type DocNoLast = FakeDoc<{
+  first?: number | null;
+  after?: string | null;
+  before?: string | null;
+  query?: { name?: unknown } | null;
+  order?: readonly { field?: "name" | null }[] | null;
+}>;
+type FailNoLast = ValidateCollectionQuery<DocNoLast, "name">;
+type AssertFailNoLast =
+  HasCollectionQueryError<FailNoLast> extends true ? true : never;
+export const assertFailNoLast: AssertFailNoLast = true;
+
+// ❌ Query missing $before should fail
+type DocNoBefore = FakeDoc<{
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  query?: { name?: unknown } | null;
+  order?: readonly { field?: "name" | null }[] | null;
+}>;
+type FailNoBefore = ValidateCollectionQuery<DocNoBefore, "name">;
+type AssertFailNoBefore =
+  HasCollectionQueryError<FailNoBefore> extends true ? true : never;
+export const assertFailNoBefore: AssertFailNoBefore = true;
+
+// ❌ Query missing $query should fail
+type DocNoQuery = FakeDoc<{
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  order?: readonly { field?: "name" | null }[] | null;
+}>;
+type FailNoQuery = ValidateCollectionQuery<DocNoQuery, "name">;
+type AssertFailNoQuery =
+  HasCollectionQueryError<FailNoQuery> extends true ? true : never;
+export const assertFailNoQuery: AssertFailNoQuery = true;
+
+// ❌ Query missing $order should fail
+type DocNoOrder = FakeDoc<{
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  query?: { name?: unknown } | null;
+}>;
+type FailNoOrder = ValidateCollectionQuery<DocNoOrder, "name">;
+type AssertFailNoOrder =
+  HasCollectionQueryError<FailNoOrder> extends true ? true : never;
+export const assertFailNoOrder: AssertFailNoOrder = true;
+
 // =============================================================================
 // 2. OrderInput field compatibility
 // =============================================================================
@@ -57,6 +127,10 @@ export const assertFail1: AssertFail1 = true;
 // ❌ Metadata has "name" | "email" but OrderInput only allows "name"
 type DocNarrowOrder = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  query?: { name?: unknown; email?: unknown } | null;
   order?: readonly { field?: "name" | null }[] | null;
 }>;
 type Fail2 = ValidateCollectionQuery<DocNarrowOrder, "name" | "email">;
@@ -66,6 +140,10 @@ export const assertFail2: AssertFail2 = true;
 // ✅ OrderInput allows all metadata fields
 type DocWideOrder = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  query?: { name?: unknown; email?: unknown } | null;
   order?: readonly { field?: "name" | "email" | "phone" | null }[] | null;
 }>;
 type Pass2 = ValidateCollectionQuery<DocWideOrder, "name" | "email">;
@@ -79,6 +157,9 @@ export const assertPass2: AssertPass2 = true;
 // ❌ Metadata has "name" | "phone" but QueryInput only has "name"
 type DocNarrowQuery = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
   query?: { name?: unknown } | null;
   order?: readonly { field?: "name" | "phone" | null }[] | null;
 }>;
@@ -89,6 +170,9 @@ export const assertFail3: AssertFail3 = true;
 // ✅ QueryInput has all metadata fields
 type DocWideQuery = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
   query?: { name?: unknown; phone?: unknown; email?: unknown } | null;
   order?: readonly { field?: "name" | "phone" | "email" | null }[] | null;
 }>;
@@ -100,20 +184,33 @@ export const assertPass3: AssertPass3 = true;
 // 4. Variable name typo detection
 // =============================================================================
 
-// Query uses $filter instead of $query (typo) — no $query key in variables.
-// With metadata, there is no "query" key so QueryInput check is skipped.
-// But if the order is also correct, this particular typo would not be caught
-// at the useCollection level. It WILL be caught when spreading into useQuery()
-// because urql checks that variables match the document.
+// ❌ Query uses $filter instead of $query (typo) — now caught because $query
+// is required.
 type DocFilterTypo = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
   filter?: { name?: unknown } | null;
   order?: readonly { field?: "name" | null }[] | null;
 }>;
 type Typo1 = ValidateCollectionQuery<DocFilterTypo, "name">;
-type AssertTypo1 = HasCollectionQueryError<Typo1> extends true ? never : true;
+type AssertTypo1 = HasCollectionQueryError<Typo1> extends true ? true : never;
 export const assertTypo1: AssertTypo1 = true;
 
+// ❌ Query uses $queryy instead of $query (typo) — now caught
+type DocQueryTypo = FakeDoc<{
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  queryy?: { name?: unknown } | null;
+  order?: readonly { field?: "name" | null }[] | null;
+}>;
+type Typo2 = ValidateCollectionQuery<DocQueryTypo, "name">;
+type AssertTypo2 = HasCollectionQueryError<Typo2> extends true ? true : never;
+export const assertTypo2: AssertTypo2 = true;
+
 // =============================================================================
 // 5. No gql-tada (plain DocumentNode) — all checks skipped
 // =============================================================================
@@ -124,13 +221,26 @@ type AssertPass5 = HasCollectionQueryError<Pass5> extends true ? never : true;
 export const assertPass5: AssertPass5 = true;
 
 // =============================================================================
-// 6. No metadata (string field names) — field-level checks skipped
+// 6. No metadata (string field names) — field-level checks skipped but
+//    variable existence is still required
 // =============================================================================
 
 type Pass6 = ValidateCollectionQuery<DocOk>;
 type AssertPass6 = HasCollectionQueryError<Pass6> extends true ? never : true;
 export const assertPass6: AssertPass6 = true;
 
+// ❌ No metadata but missing $query — still fails
+type DocNoMetaNoQuery = FakeDoc<{
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  order?: readonly { field?: "name" | null }[] | null;
+}>;
+type Fail6 = ValidateCollectionQuery<DocNoMetaNoQuery>;
+type AssertFail6 = HasCollectionQueryError<Fail6> extends true ? true : never;
+export const assertFail6: AssertFail6 = true;
+
 // =============================================================================
 // 7. Helper type tests
 // =============================================================================
@@ -150,36 +260,45 @@ export const qk1: QIKeys1 = "name";
 export const qk2: QIKeys1 = "email";
 
 // =============================================================================
-// 8. Mixed: $order present but no $query — only OrderInput checked
+// 8. Missing $query — now fails (previously was "Mixed: $order only")
 // =============================================================================
 
-// ✅ No $query, order fields match
+// ❌ Missing $query variable
 type DocOrderOnly = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
   order?: readonly { field?: "name" | "email" | null }[] | null;
 }>;
-type Pass8 = ValidateCollectionQuery<DocOrderOnly, "name" | "email">;
-type AssertPass8 = HasCollectionQueryError<Pass8> extends true ? never : true;
-export const assertPass8: AssertPass8 = true;
+type Fail8 = ValidateCollectionQuery<DocOrderOnly, "name" | "email">;
+type AssertFail8 = HasCollectionQueryError<Fail8> extends true ? true : never;
+export const assertFail8: AssertFail8 = true;
 
 // =============================================================================
-// 9. Mixed: $query present but no $order — only QueryInput checked
+// 9. Missing $order — now fails (previously was "Mixed: $query only")
 // =============================================================================
 
-// ✅ No $order, query keys match
+// ❌ Missing $order variable
 type DocQueryOnly = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
   query?: { name?: unknown; email?: unknown } | null;
 }>;
-type Pass9 = ValidateCollectionQuery<DocQueryOnly, "name" | "email">;
-type AssertPass9 = HasCollectionQueryError<Pass9> extends true ? never : true;
-export const assertPass9: AssertPass9 = true;
+type Fail9 = ValidateCollectionQuery<DocQueryOnly, "name" | "email">;
+type AssertFail9 = HasCollectionQueryError<Fail9> extends true ? true : never;
+export const assertFail9: AssertFail9 = true;
 
-// ❌ No $order, but query keys don't cover metadata fields
+// ❌ Missing $order, and query keys don't cover metadata fields
 type DocQueryOnlyMissing = FakeDoc<{
   first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
   query?: { name?: unknown } | null;
 }>;
-type Fail9 = ValidateCollectionQuery<DocQueryOnlyMissing, "name" | "email">;
-type AssertFail9 = HasCollectionQueryError<Fail9> extends true ? true : never;
-export const assertFail9: AssertFail9 = true;
+type Fail9b = ValidateCollectionQuery<DocQueryOnlyMissing, "name" | "email">;
+type AssertFail9b = HasCollectionQueryError<Fail9b> extends true ? true : never;
+export const assertFail9b: AssertFail9b = true;