Fix: ensure we can get fields from blocks and references (#373)

* feature(blocks): ensure we can grab fields from blocks and references, when needed

* changeset

Author: scottrippey

.changeset/hungry-ligers-provide.md

@@ -0,0 +1,5 @@
+---
+"groqd": patch
+---
+
+Fix: ensure we can get fields from `block` and `reference` objects

packages/groqd/src/tests/mocks/nextjs-sanity-fe-mocks.ts

@@ -152,6 +152,8 @@ export class MockFactory {
       children: [{ _type: "span", _key: "", text: "", marks: [] }],
       markDefs: [],
       style: undefined,
+      listItem: undefined,
+      level: undefined,
       ...data,
     };
   }

packages/groqd/src/types/projection-paths.test.ts

@@ -1,12 +1,12 @@
-import { describe, it, expectTypeOf } from "vitest";
+import { describe, expectTypeOf, it } from "vitest";
+import { SanitySchema } from "../tests/schemas/nextjs-sanity-fe";
+import { Slug } from "../tests/schemas/nextjs-sanity-fe.sanity-typegen";
 import {
   ProjectionPathEntries,
   ProjectionPaths,
   ProjectionPathsByType,
   ProjectionPathValue,
 } from "./projection-paths";
-import { SanitySchema } from "../tests/schemas/nextjs-sanity-fe";
-import { Slug } from "../tests/schemas/nextjs-sanity-fe.sanity-typegen";
 import { UndefinedToNull } from "./utils";
 
 type TestObject = {
@@ -252,12 +252,65 @@ describe("ProjectionPathEntries", () => {
     >();
   });
 
+  describe("built-in types should not be deeply parsed", () => {
+    type Block = SanitySchema.Description[number];
+    type Reference = NonNullable<SanitySchema.Variant["flavour"]>[number];
+    type Example = {
+      blocks: Block[];
+      ref: Reference;
+      optionalRef?: Reference;
+      deep: { foo: "bar" };
+    };
+    it("should not show deep results for built-in types", () => {
+      expectTypeOf<ProjectionPathEntries<Example>>().toEqualTypeOf<{
+        "blocks[]": Block[];
+        ref: Reference;
+        optionalRef: Reference | null;
+        deep: Example["deep"];
+        "deep.foo": "bar";
+      }>();
+    });
+    describe("when at the top level", () => {
+      it("should show deep results for a 'block'", () => {
+        type Actual = ProjectionPathEntries<Block>;
+        type Expected = {
+          _type: "block";
+          _key: string;
+          style: UndefinedToNull<Block["style"]>;
+          level: UndefinedToNull<Block["level"]>;
+          listItem: UndefinedToNull<Block["listItem"]>;
+          "children[]": UndefinedToNull<Block["children"]>;
+          "children[]._type": null | Array<"span">;
+          "children[]._key": null | Array<string>;
+          "children[].text": null | Array<string | null>;
+          "children[].marks[]": null | Array<string[] | null>;
+          "markDefs[]": UndefinedToNull<Block["markDefs"]>;
+          "markDefs[]._type": null | Array<"link">;
+          "markDefs[]._key": null | Array<string>;
+          "markDefs[].href": null | Array<string | null>;
+        };
+
+        expectTypeOf<Actual>().toEqualTypeOf<Expected>();
+      });
+      it("should show deep results for a 'reference'", () => {
+        type Actual = ProjectionPathEntries<Reference>;
+        type Expected = {
+          _type: "reference";
+          _key: string;
+          _ref: string;
+          _weak: null | boolean;
+        };
+        expectTypeOf<Actual>().toEqualTypeOf<Expected>();
+      });
+    });
+  });
+
   describe("when dealing with unions", () => {
     type Union = { _type: "TypeA"; a: "A" } | { _type: "TypeB"; b: "B" };
 
     it("should only return types for common properties", () => {
-      type Result = ProjectionPathEntries<Union>;
-      expectTypeOf<Result>().toEqualTypeOf<{
+      type Actual = ProjectionPathEntries<Union>;
+      expectTypeOf<Actual>().toEqualTypeOf<{
         _type: "TypeA" | "TypeB";
       }>();
     });

packages/groqd/src/types/projection-paths.ts

@@ -13,24 +13,35 @@ import { CompatibleKeys, CompatiblePick } from "./compatible-types";
 
 /**
  * These types are ignored when calculating projection paths,
- * since they're rarely traversed into
+ * since they're rarely traversed into.
+ *
+ * This interface is extensible, if you want to add your
+ * own shallow types.
  */
-export type ProjectionPathIgnoreTypes =
-  | { _type: "reference" }
-  | { _type: "block" };
+export interface ProjectionPathShallowTypes {
+  "reference blocks": { _type: "reference" };
+  "portable text blocks": { _type: "block" };
+}
+
+type ShouldBeShallow<Value, CurrentPath> =
+  // When at the top-level, we should allow deep nesting:
+  CurrentPath extends ""
+    ? false
+    : // These types should not be deeply-traversed:
+    NonNullable<Value> extends ValueOf<ProjectionPathShallowTypes>
+    ? true
+    : false;
 
 /**
  * These simple types are shallow, and do not need to
  * include any deeper entries.
  */
-type IsShallowType<Value> = IsAny<Value> extends true
+type IsSimpleType<Value> = IsAny<Value> extends true
   ? true
   : IsNever<Value> extends true
   ? true
   : Value extends Primitive
   ? true
-  : Value extends ProjectionPathIgnoreTypes
-  ? true
   : false;
 
 /**
@@ -58,7 +69,9 @@ export type ProjectionPathEntries<Value> = IsAny<Value> extends true
 type _ProjectionPathEntries<
   CurrentPath extends string,
   Value
-> = IsShallowType<Value> extends true
+> = IsSimpleType<Value> extends true
+  ? never
+  : ShouldBeShallow<Value, CurrentPath> extends true
   ? never
   : Value extends { _type: "slug" }
   ? Record<JoinPath<CurrentPath, "current">, string>