feature(conditionals): made key a configuration option

packages/groq-builder/src/commands/conditional$.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { createGroqBuilder, GroqBuilder, InferResultType } from "../index";
+import {
+  createGroqBuilder,
+  GroqBuilder,
+  InferResultItem,
+  InferResultType,
+} from "../index";
 import { SchemaConfig } from "../tests/schemas/nextjs-sanity-fe";
 import { ExtractConditionalProjectionTypes } from "./conditional-types";
 import { expectType } from "../tests/expectType";
@@ -134,29 +139,41 @@ describe("conditional$", () => {
           }),
           ...qV.conditional$(
             {
-              "another == condition": { foo: q.value("FOO") },
+              "another == condition1": { foo: q.value("FOO") },
+              "another == condition2": { bar: q.value("BAR") },
             },
-            "unique-key"
+            { key: "unique-key" }
           ),
         }));
 
       it("the types should be inferred correctly", () => {
-        expectType<InferResultType<typeof qMultipleConditions>>().toStrictEqual<
-          Array<
-            | { name: string }
-            | { name: string; onSale: false }
-            | { name: string; onSale: true; price: number; msrp: number }
-            | { name: string; foo: "FOO" }
-            | { name: string; onSale: false; foo: "FOO" }
-            | {
-                name: string;
-                onSale: true;
-                price: number;
-                msrp: number;
-                foo: "FOO";
-              }
-          >
-        >();
+        type ActualItem = InferResultItem<typeof qMultipleConditions>;
+        type ExpectedItem =
+          | { name: string }
+          | { name: string; onSale: false }
+          | { name: string; onSale: true; price: number; msrp: number }
+          | { name: string; foo: "FOO" }
+          | { name: string; onSale: false; foo: "FOO" }
+          | {
+              name: string;
+              onSale: true;
+              price: number;
+              msrp: number;
+              foo: "FOO";
+            }
+          | { name: string; bar: "BAR" }
+          | { name: string; onSale: false; bar: "BAR" }
+          | {
+              name: string;
+              onSale: true;
+              price: number;
+              msrp: number;
+              bar: "BAR";
+            };
+
+        type Remainder = Exclude<ActualItem, ExpectedItem>;
+        expectType<Remainder>().toStrictEqual<never>();
+        expectType<ActualItem>().toStrictEqual<ExpectedItem>();
       });
 
       it("the query should be compiled correctly", () => {

packages/groq-builder/src/commands/conditional$.ts

@@ -1,6 +1,7 @@
 import { GroqBuilder } from "../groq-builder";
 import { ResultItem } from "../types/result-types";
 import {
+  ConditionalConfig,
   ConditionalKey,
   ConditionalProjectionMap,
   ExtractConditionalProjectionResults,
@@ -21,7 +22,7 @@ declare module "../groq-builder" {
       TKey extends string = "[$]"
     >(
       conditionalProjections: TConditionalProjections,
-      conditionalKey?: TKey
+      config?: ConditionalConfig<TKey>
     ): ExtractConditionalProjectionResults<
       ResultItem<TResult>,
       TConditionalProjections,
@@ -34,7 +35,7 @@ GroqBuilder.implement({
   conditional$<TCP extends object, TKey extends string>(
     this: GroqBuilder,
     conditionalProjections: TCP,
-    conditionalKey = "[$]" as TKey
+    config?: ConditionalConfig<TKey>
   ) {
     const root = this.root;
     const allConditionalProjections = Object.entries(
@@ -60,13 +61,16 @@ GroqBuilder.implement({
       : createConditionalParserUnion(parsers);
 
     const conditionalQuery = root.chain(query, conditionalParser);
-    const uniqueKey: ConditionalKey<TKey> = `[Conditional] ${conditionalKey}`;
+    const uniqueKey: ConditionalKey<TKey> = `[Conditional] ${
+      config?.key ?? ("[$]" as TKey)
+    }`;
 
     return {
       [uniqueKey]: conditionalQuery,
     } as unknown as SpreadableConditionals<TKey, any>;
   },
 });
+
 function createConditionalParserUnion(parsers: ParserFunction[]) {
   return function parserUnion(input: unknown) {
     for (const parser of parsers) {

packages/groq-builder/src/commands/conditional-types.ts

@@ -75,16 +75,17 @@ export type ExtractConditionalByTypeProjectionResults<
   TKey extends string
 > = SpreadableConditionals<
   TKey,
-  ValueOf<{
-    [_type in keyof TConditionalByTypeProjectionMap]: ExtractProjectionResult<
-      Extract<TResultItem, { _type: _type }>,
-      TConditionalByTypeProjectionMap[_type] extends (
-        q: any
-      ) => infer TProjectionMap
-        ? TProjectionMap
-        : TConditionalByTypeProjectionMap[_type]
-    >;
-  }>
+  | Empty
+  | ValueOf<{
+      [_type in keyof TConditionalByTypeProjectionMap]: ExtractProjectionResult<
+        Extract<TResultItem, { _type: _type }>,
+        TConditionalByTypeProjectionMap[_type] extends (
+          q: any
+        ) => infer TProjectionMap
+          ? TProjectionMap
+          : TConditionalByTypeProjectionMap[_type]
+      >;
+    }>
 >;
 
 export type ConditionalKey<TKey extends string> = `[Conditional] ${TKey}`;
@@ -97,3 +98,5 @@ export type SpreadableConditionals<
 > = {
   [UniqueConditionalKey in ConditionalKey<TKey>]: IGroqBuilder<ConditionalResultType>;
 };
+
+export type ConditionalConfig<TKey> = { key: TKey };

packages/groq-builder/src/commands/conditionalByType.test.ts

@@ -4,14 +4,15 @@ import {
   ExtractTypeNames,
   GroqBuilder,
   IGroqBuilder,
+  InferResultItem,
   InferResultType,
 } from "../index";
 import { SchemaConfig } from "../tests/schemas/nextjs-sanity-fe";
 import { ExtractConditionalProjectionTypes } from "./conditional-types";
 import { expectType } from "../tests/expectType";
 import { executeBuilder } from "../tests/mocks/executeQuery";
 import { mock } from "../tests/mocks/nextjs-sanity-fe-mocks";
-import { Empty, SimplifyDeep } from "../types/utils";
+import { Empty, Simplify, SimplifyDeep } from "../types/utils";
 
 const q = createGroqBuilder<SchemaConfig>({ indent: "  " });
 const data = mock.generateSeedData({
@@ -32,6 +33,7 @@ describe("conditionalByType", () => {
   });
 
   type ExpectedConditionalUnion =
+    | Empty
     | { _type: "variant"; name: string; price: number }
     | { _type: "product"; name: string; slug: string }
     | { _type: "category"; name: string; slug: string };
@@ -48,6 +50,59 @@ describe("conditionalByType", () => {
     });
   });
 
+  describe("multiple conditionals can be spread", () => {
+    const qMultiple = q.star.project((q) => ({
+      ...q.conditionalByType({
+        variant: { price: true },
+        product: { slug: "slug.current" },
+      }),
+      ...q.conditionalByType(
+        {
+          category: { description: true },
+          style: { name: true },
+        },
+        { key: "unique-key" }
+      ),
+    }));
+
+    it("should infer the correct type", () => {
+      type ActualItem = Simplify<InferResultItem<typeof qMultiple>>;
+      type ExpectedItem =
+        | Empty
+        | { price: number }
+        | { slug: string }
+        | { description: string | undefined }
+        | { name: string | undefined }
+        | { price: number; description: string | undefined }
+        | { price: number; name: string | undefined }
+        | { slug: string; description: string | undefined }
+        | { slug: string; name: string | undefined };
+
+      type Remainder = Exclude<ActualItem, ExpectedItem>;
+      expectType<Remainder>().toStrictEqual<never>();
+      expectType<ActualItem>().toStrictEqual<ExpectedItem>();
+    });
+
+    it("the query should be correct", () => {
+      expect(qMultiple.query).toMatchInlineSnapshot(`
+        "* {
+            _type == \\"variant\\" => {
+                price
+              },
+            _type == \\"product\\" => {
+                \\"slug\\": slug.current
+              },
+            _type == \\"category\\" => {
+                description
+              },
+            _type == \\"style\\" => {
+                name
+              }
+          }"
+      `);
+    });
+  });
+
   it("should be able to extract the return types", () => {
     type ConditionalResults = ExtractConditionalProjectionTypes<
       typeof conditionalByType

packages/groq-builder/src/commands/conditionalByType.ts

@@ -6,6 +6,7 @@ import {
   ConditionalByTypeProjectionMap,
   ConditionalKey,
   SpreadableConditionals,
+  ConditionalConfig,
 } from "./conditional-types";
 import { ProjectionMap } from "./projection-types";
 
@@ -19,7 +20,7 @@ declare module "../groq-builder" {
       TKey extends string = "[ByType]"
     >(
       conditionalProjections: TConditionalProjections,
-      conditionalKey?: TKey
+      config?: ConditionalConfig<TKey>
     ): ExtractConditionalByTypeProjectionResults<
       ResultItem<TResult>,
       TConditionalProjections,
@@ -35,7 +36,7 @@ GroqBuilder.implement({
   >(
     this: GroqBuilder<any, RootConfig>,
     conditionalProjections: TConditionalProjections,
-    conditionalKey = "[ByType]" as TKey
+    config?: ConditionalConfig<TKey>
   ) {
     const typeNames = Object.keys(conditionalProjections);
 
@@ -66,7 +67,9 @@ GroqBuilder.implement({
         };
 
     const conditionalQuery = this.root.chain(query, conditionalParser);
-    const uniqueKey: ConditionalKey<string> = `[Conditional] ${conditionalKey}`;
+    const uniqueKey: ConditionalKey<string> = `[Conditional] ${
+      config?.key ?? ("[ByType]" as TKey)
+    }`;
     return {
       [uniqueKey]: conditionalQuery,
     } as unknown as SpreadableConditionals<TKey, any>;