@fern-api/fdr-sdk 1.2.35-07f6dfd14f → 1.2.35-09eb5b04f6

package/dist/api-definition/snippets/graphql-snippets.test.js

@@ -0,0 +1,973 @@
+import { generateGraphQlSnippet } from "./graphql-snippets";
+// Helper to create a TypeId
+function typeId(id) {
+    return id;
+}
+// Helper for primitive alias shapes
+function primitiveAlias(primitiveType) {
+    return {
+        type: "alias",
+        value: {
+            type: "primitive",
+            value: { type: primitiveType }
+        }
+    };
+}
+// Helper for type ID reference alias
+function idAlias(id) {
+    return {
+        type: "alias",
+        value: { type: "id", id: typeId(id) }
+    };
+}
+// Helper for optional alias shapes (wraps inner shape in optional)
+function optionalAlias(innerShape) {
+    return {
+        type: "alias",
+        value: { type: "optional", shape: innerShape }
+    };
+}
+// Helper for list alias shapes
+function listAlias(itemShape) {
+    return {
+        type: "alias",
+        value: { type: "list", itemShape }
+    };
+}
+describe("generateGraphQlSnippet", () => {
+    it("generates variables with primitive arguments", () => {
+        const operation = {
+            id: "op1",
+            operationType: "QUERY",
+            name: "getUser",
+            arguments: [
+                { name: "id", type: primitiveAlias("string"), defaultValue: undefined },
+                { name: "includeEmail", type: primitiveAlias("boolean"), defaultValue: undefined }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.variables).toEqual({
+            id: "example",
+            includeEmail: true
+        });
+    });
+    it("generates variables for object arguments with populated properties", () => {
+        const types = {
+            [typeId("UserInput")]: {
+                name: "UserInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "name", valueShape: primitiveAlias("string") },
+                        { key: "age", valueShape: primitiveAlias("integer") },
+                        { key: "active", valueShape: primitiveAlias("boolean") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op2",
+            operationType: "MUTATION",
+            name: "createUser",
+            arguments: [{ name: "input", type: idAlias("UserInput"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        expect(result.variables).toEqual({
+            input: {
+                name: "example",
+                age: 0,
+                active: true
+            }
+        });
+    });
+    it("generates variables for nested object arguments", () => {
+        const types = {
+            [typeId("Address")]: {
+                name: "Address",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "street", valueShape: primitiveAlias("string") },
+                        { key: "city", valueShape: primitiveAlias("string") },
+                        { key: "zip", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("UserInput")]: {
+                name: "UserInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "name", valueShape: primitiveAlias("string") },
+                        { key: "address", valueShape: idAlias("Address") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op3",
+            operationType: "MUTATION",
+            name: "createUser",
+            arguments: [{ name: "input", type: idAlias("UserInput"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        expect(result.variables).toEqual({
+            input: {
+                name: "example",
+                address: {
+                    street: "example",
+                    city: "example",
+                    zip: "example"
+                }
+            }
+        });
+    });
+    it("generates variables for inline object type arguments", () => {
+        const operation = {
+            id: "op-inline",
+            operationType: "MUTATION",
+            name: "updateSettings",
+            arguments: [
+                {
+                    name: "settings",
+                    type: {
+                        type: "object",
+                        extends: [],
+                        properties: [
+                            { key: "theme", valueShape: primitiveAlias("string") },
+                            { key: "fontSize", valueShape: primitiveAlias("integer") }
+                        ],
+                        extraProperties: undefined
+                    },
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.variables).toEqual({
+            settings: {
+                theme: "example",
+                fontSize: 0
+            }
+        });
+    });
+    it("generates variables for objects with extends (inheritance)", () => {
+        const types = {
+            [typeId("BaseInput")]: {
+                name: "BaseInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "id", valueShape: primitiveAlias("string") },
+                        { key: "createdAt", valueShape: primitiveAlias("datetime") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("UserInput")]: {
+                name: "UserInput",
+                shape: {
+                    type: "object",
+                    extends: [typeId("BaseInput")],
+                    properties: [
+                        { key: "name", valueShape: primitiveAlias("string") },
+                        { key: "email", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op4",
+            operationType: "MUTATION",
+            name: "createUser",
+            arguments: [{ name: "input", type: idAlias("UserInput"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        // Inherited properties should appear before own properties
+        expect(result.variables.input).toEqual(expect.objectContaining({
+            id: "example",
+            name: "example",
+            email: "example"
+        }));
+        expect(Object.keys(result.variables.input)).toEqual([
+            "id",
+            "createdAt",
+            "name",
+            "email"
+        ]);
+    });
+    it("handles circular type references without infinite recursion", () => {
+        const types = {
+            [typeId("Node")]: {
+                name: "Node",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "value", valueShape: primitiveAlias("string") },
+                        {
+                            key: "children",
+                            valueShape: { type: "alias", value: { type: "list", itemShape: idAlias("Node") } }
+                        }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op5",
+            operationType: "QUERY",
+            name: "getTree",
+            arguments: [{ name: "root", type: idAlias("Node"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        // Should not throw or loop infinitely
+        const result = generateGraphQlSnippet({ operation, types });
+        expect(result.variables.root).toBeDefined();
+        const root = result.variables.root;
+        expect(root.value).toBe("example");
+        // children should be an array; inner items eventually hit cycle detection
+        expect(Array.isArray(root.children)).toBe(true);
+    });
+    it("generates variables for enum arguments", () => {
+        const operation = {
+            id: "op6",
+            operationType: "QUERY",
+            name: "getItems",
+            arguments: [
+                {
+                    name: "sortOrder",
+                    type: {
+                        type: "enum",
+                        values: [{ value: "ASC" }, { value: "DESC" }]
+                    },
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.variables).toEqual({
+            sortOrder: "ASC"
+        });
+    });
+    it("generates variables for discriminated union arguments", () => {
+        const operation = {
+            id: "op7",
+            operationType: "MUTATION",
+            name: "processPayment",
+            arguments: [
+                {
+                    name: "method",
+                    type: {
+                        type: "discriminatedUnion",
+                        discriminant: "type",
+                        variants: [
+                            {
+                                discriminantValue: "credit_card",
+                                displayName: "Credit Card",
+                                extends: [],
+                                properties: [
+                                    { key: "cardNumber", valueShape: primitiveAlias("string") },
+                                    { key: "expiry", valueShape: primitiveAlias("string") }
+                                ],
+                                extraProperties: undefined
+                            },
+                            {
+                                discriminantValue: "bank_transfer",
+                                displayName: "Bank Transfer",
+                                extends: [],
+                                properties: [{ key: "accountNumber", valueShape: primitiveAlias("string") }],
+                                extraProperties: undefined
+                            }
+                        ]
+                    },
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.variables).toEqual({
+            method: {
+                type: "credit_card",
+                cardNumber: "example",
+                expiry: "example"
+            }
+        });
+    });
+    it("generates variables for undiscriminated union arguments", () => {
+        const operation = {
+            id: "op8",
+            operationType: "MUTATION",
+            name: "setValue",
+            arguments: [
+                {
+                    name: "value",
+                    type: {
+                        type: "undiscriminatedUnion",
+                        variants: [
+                            {
+                                displayName: "String Value",
+                                shape: primitiveAlias("string")
+                            },
+                            {
+                                displayName: "Number Value",
+                                shape: primitiveAlias("integer")
+                            }
+                        ]
+                    },
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        // Uses first variant
+        expect(result.variables).toEqual({
+            value: "example"
+        });
+    });
+    it("generates variables for list of objects", () => {
+        const types = {
+            [typeId("TagInput")]: {
+                name: "TagInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "key", valueShape: primitiveAlias("string") },
+                        { key: "value", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op9",
+            operationType: "MUTATION",
+            name: "setTags",
+            arguments: [
+                {
+                    name: "tags",
+                    type: {
+                        type: "alias",
+                        value: {
+                            type: "list",
+                            itemShape: idAlias("TagInput")
+                        }
+                    },
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        expect(result.variables).toEqual({
+            tags: [
+                {
+                    key: "example",
+                    value: "example"
+                }
+            ]
+        });
+    });
+    it("respects default values over generated ones", () => {
+        const operation = {
+            id: "op10",
+            operationType: "QUERY",
+            name: "getUsers",
+            arguments: [
+                { name: "limit", type: primitiveAlias("integer"), defaultValue: 10 },
+                { name: "offset", type: primitiveAlias("integer"), defaultValue: undefined }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.variables).toEqual({
+            limit: 10,
+            offset: 0
+        });
+    });
+    it("generates variables for optional object arguments", () => {
+        const types = {
+            [typeId("FilterInput")]: {
+                name: "FilterInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "field", valueShape: primitiveAlias("string") },
+                        { key: "value", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op11",
+            operationType: "QUERY",
+            name: "search",
+            arguments: [
+                {
+                    name: "filter",
+                    type: {
+                        type: "alias",
+                        value: {
+                            type: "optional",
+                            shape: idAlias("FilterInput")
+                        }
+                    },
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        expect(result.variables).toEqual({
+            filter: {
+                field: "example",
+                value: "example"
+            }
+        });
+    });
+    it("handles deeply nested objects with depth limiting", () => {
+        // Create a chain of nested objects: Level1 -> Level2 -> Level3 -> Level4 -> Level5 -> Level6
+        const types = {
+            [typeId("Level6")]: {
+                name: "Level6",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "deepValue", valueShape: primitiveAlias("string") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("Level5")]: {
+                name: "Level5",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "nested", valueShape: idAlias("Level6") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("Level4")]: {
+                name: "Level4",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "nested", valueShape: idAlias("Level5") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("Level3")]: {
+                name: "Level3",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "nested", valueShape: idAlias("Level4") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("Level2")]: {
+                name: "Level2",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "nested", valueShape: idAlias("Level3") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            },
+            [typeId("Level1")]: {
+                name: "Level1",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "nested", valueShape: idAlias("Level2") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op12",
+            operationType: "QUERY",
+            name: "getDeep",
+            arguments: [{ name: "input", type: idAlias("Level1"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        // depth=5: Level1 (depth 5) -> Level2 (depth 4) -> Level3 (depth 3) -> Level4 (depth 2) -> Level5 (depth 1) -> Level6 (depth 0 = null)
+        expect(result.variables).toEqual({
+            input: {
+                nested: {
+                    nested: {
+                        nested: {
+                            nested: {
+                                nested: null
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    });
+    it("does not include field-level arguments in snippet variables", () => {
+        // Field-level arguments (on object properties, e.g. GraphQL connection args like `first`, `after`)
+        // are distinct from operation-level arguments and must not appear as top-level variables
+        // in the generated snippet — they are resolved by the server, not passed as query variables.
+        const types = {
+            [typeId("UserEdge")]: {
+                name: "UserEdge",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        {
+                            key: "connections",
+                            valueShape: primitiveAlias("string"),
+                            description: undefined,
+                            availability: undefined,
+                            propertyAccess: undefined,
+                            arguments: [
+                                {
+                                    name: "first",
+                                    type: primitiveAlias("integer"),
+                                    description: undefined,
+                                    availability: undefined,
+                                    defaultValue: undefined
+                                },
+                                {
+                                    name: "after",
+                                    type: primitiveAlias("string"),
+                                    description: undefined,
+                                    availability: undefined,
+                                    defaultValue: undefined
+                                }
+                            ]
+                        }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "op-field-args",
+            operationType: "QUERY",
+            name: "getUsers",
+            arguments: [{ name: "id", type: primitiveAlias("string"), defaultValue: undefined }],
+            returnType: idAlias("UserEdge"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        // Only the operation-level `id` arg should appear as a variable
+        expect(Object.keys(result.variables)).toEqual(["id"]);
+        expect(result.variables).not.toHaveProperty("first");
+        expect(result.variables).not.toHaveProperty("after");
+    });
+    it("appends ! for required argument types and omits it for optional", () => {
+        const operation = {
+            id: "op-nonNull",
+            operationType: "MUTATION",
+            name: "doSomething",
+            arguments: [
+                { name: "requiredStr", type: primitiveAlias("string"), defaultValue: undefined },
+                { name: "optionalStr", type: optionalAlias(primitiveAlias("string")), defaultValue: undefined },
+                { name: "requiredInt", type: primitiveAlias("integer"), defaultValue: undefined },
+                { name: "optionalInt", type: optionalAlias(primitiveAlias("integer")), defaultValue: undefined },
+                { name: "requiredObj", type: idAlias("SomeInput"), defaultValue: undefined },
+                { name: "optionalObj", type: optionalAlias(idAlias("SomeInput")), defaultValue: undefined },
+                { name: "requiredList", type: listAlias(primitiveAlias("string")), defaultValue: undefined },
+                {
+                    name: "optionalList",
+                    type: optionalAlias(listAlias(primitiveAlias("string"))),
+                    defaultValue: undefined
+                }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const types = {
+            [typeId("SomeInput")]: {
+                name: "SomeInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "field", valueShape: primitiveAlias("string") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        // Required args get ! suffix
+        expect(result.query).toContain("$requiredStr: String!");
+        expect(result.query).toContain("$requiredInt: Int!");
+        expect(result.query).toContain("$requiredObj: SomeInput!");
+        expect(result.query).toContain("$requiredList: [String!]!");
+        // Optional args do NOT get ! suffix
+        expect(result.query).toContain("$optionalStr: String,");
+        expect(result.query).toContain("$optionalInt: Int,");
+        expect(result.query).toContain("$optionalObj: SomeInput,");
+        expect(result.query).toContain("$optionalList: [String!])");
+        // Double-check: optional args must not have trailing !
+        expect(result.query).not.toMatch(/\$optionalStr: String!/);
+        expect(result.query).not.toMatch(/\$optionalInt: Int!/);
+        expect(result.query).not.toMatch(/\$optionalObj: SomeInput!/);
+        expect(result.query).not.toMatch(/\$optionalList: \[String!\]!/);
+    });
+    it("generates empty variables for operations without arguments", () => {
+        const operation = {
+            id: "op13",
+            operationType: "QUERY",
+            name: "getStatus",
+            arguments: [],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.variables).toEqual({});
+    });
+    it("generates nested query when fieldPath is set", () => {
+        const operation = {
+            id: "mutation_registerCompany",
+            operationType: "MUTATION",
+            name: "registerCompany",
+            fieldPath: ["company"],
+            arguments: [{ name: "input", type: primitiveAlias("string"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.query).toContain("mutation ExampleMutation($input: String!)");
+        expect(result.query).toContain("  company {");
+        expect(result.query).toContain("    registerCompany(input: $input)");
+        expect(result.query).toContain("  }");
+    });
+    it("generates deeply nested query when fieldPath has multiple levels", () => {
+        const operation = {
+            id: "mutation_deeplyNested",
+            operationType: "MUTATION",
+            name: "doSomething",
+            fieldPath: ["level1", "level2"],
+            arguments: [],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.query).toContain("  level1 {");
+        expect(result.query).toContain("    level2 {");
+        expect(result.query).toContain("      doSomething");
+        expect(result.query).toContain("    }");
+        expect(result.query).toContain("  }");
+    });
+    it("generates nested response when fieldPath is set", () => {
+        const operation = {
+            id: "mutation_addCartLineItems",
+            operationType: "MUTATION",
+            name: "addCartLineItems",
+            fieldPath: ["cart"],
+            arguments: [],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.response).toEqual({
+            data: {
+                cart: {
+                    addCartLineItems: "example"
+                }
+            }
+        });
+    });
+    it("generates correctly indented selection set when fieldPath is set", () => {
+        const types = {
+            [typeId("RegisterCompanyResult")]: {
+                name: "RegisterCompanyResult",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "entityId", valueShape: primitiveAlias("integer") },
+                        { key: "status", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "mutation_registerCompany",
+            operationType: "MUTATION",
+            name: "registerCompany",
+            fieldPath: ["company"],
+            arguments: [{ name: "input", type: primitiveAlias("string"), defaultValue: undefined }],
+            returnType: idAlias("RegisterCompanyResult"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        const expectedQuery = [
+            "mutation ExampleMutation($input: String!) {",
+            "  company {",
+            "    registerCompany(input: $input) {",
+            "      entityId",
+            "      status",
+            "    }",
+            "  }",
+            "}"
+        ].join("\n");
+        expect(result.query).toBe(expectedQuery);
+    });
+    it("generates nested query with fieldPath + args + selection set (geography.countries case)", () => {
+        const types = {
+            [typeId("Country")]: {
+                name: "Country",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "entityId", valueShape: primitiveAlias("integer") },
+                        { key: "name", valueShape: primitiveAlias("string") },
+                        { key: "code", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "query_countries",
+            operationType: "QUERY",
+            name: "countries",
+            fieldPath: ["geography"],
+            arguments: [{ name: "filters", type: primitiveAlias("string"), defaultValue: undefined }],
+            returnType: idAlias("Country"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        const expectedQuery = [
+            "query ExampleQuery($filters: String!) {",
+            "  geography {",
+            "    countries(filters: $filters) {",
+            "      entityId",
+            "      name",
+            "      code",
+            "    }",
+            "  }",
+            "}"
+        ].join("\n");
+        expect(result.query).toBe(expectedQuery);
+        expect(result.response).toEqual({
+            data: {
+                geography: {
+                    countries: { entityId: 0, name: "example", code: "example" }
+                }
+            }
+        });
+    });
+    it("generates nested subscription with fieldPath consistently", () => {
+        const operation = {
+            id: "subscription_onOrderUpdate",
+            operationType: "SUBSCRIPTION",
+            name: "onOrderUpdate",
+            fieldPath: ["orders"],
+            arguments: [{ name: "orderId", type: primitiveAlias("string"), defaultValue: undefined }],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.query).toContain("subscription ExampleSubscription($orderId: String!)");
+        expect(result.query).toContain("  orders {");
+        expect(result.query).toContain("    onOrderUpdate(orderId: $orderId)");
+        expect(result.query).toContain("  }");
+        expect(result.response).toEqual({
+            data: {
+                orders: {
+                    onOrderUpdate: "example"
+                }
+            }
+        });
+    });
+    it("generates deeply nested query with selection set (inventory.locations case)", () => {
+        const types = {
+            [typeId("LocationConnection")]: {
+                name: "LocationConnection",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [
+                        { key: "entityId", valueShape: primitiveAlias("integer") },
+                        { key: "code", valueShape: primitiveAlias("string") },
+                        { key: "label", valueShape: primitiveAlias("string") }
+                    ],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const operation = {
+            id: "query_locations",
+            operationType: "QUERY",
+            name: "locations",
+            fieldPath: ["inventory"],
+            arguments: [{ name: "entityIds", type: primitiveAlias("integer"), defaultValue: undefined }],
+            returnType: idAlias("LocationConnection"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        const expectedQuery = [
+            "query ExampleQuery($entityIds: Int!) {",
+            "  inventory {",
+            "    locations(entityIds: $entityIds) {",
+            "      entityId",
+            "      code",
+            "      label",
+            "    }",
+            "  }",
+            "}"
+        ].join("\n");
+        expect(result.query).toBe(expectedQuery);
+        expect(result.response).toEqual({
+            data: {
+                inventory: {
+                    locations: { entityId: 0, code: "example", label: "example" }
+                }
+            }
+        });
+    });
+    it("generates consistent output across operation types with same fieldPath", () => {
+        const makeOperation = (opType, keyword, exampleName) => {
+            const operation = {
+                id: `${opType.toLowerCase()}_doAction`,
+                operationType: opType,
+                name: "doAction",
+                fieldPath: ["parent"],
+                arguments: [{ name: "id", type: primitiveAlias("string"), defaultValue: undefined }],
+                returnType: primitiveAlias("string"),
+                examples: undefined
+            };
+            const result = generateGraphQlSnippet({ operation, types: {} });
+            return result;
+        };
+        const queryResult = makeOperation("QUERY", "query", "ExampleQuery");
+        const mutationResult = makeOperation("MUTATION", "mutation", "ExampleMutation");
+        const subscriptionResult = makeOperation("SUBSCRIPTION", "subscription", "ExampleSubscription");
+        // All three should have identical nesting structure, differing only in keyword/name
+        expect(queryResult.query).toBe("query ExampleQuery($id: String!) {\n  parent {\n    doAction(id: $id)\n  }\n}");
+        expect(mutationResult.query).toBe("mutation ExampleMutation($id: String!) {\n  parent {\n    doAction(id: $id)\n  }\n}");
+        expect(subscriptionResult.query).toBe("subscription ExampleSubscription($id: String!) {\n  parent {\n    doAction(id: $id)\n  }\n}");
+        // Response structure should be identical across all operation types
+        const expectedResponse = { data: { parent: { doAction: "example" } } };
+        expect(queryResult.response).toEqual(expectedResponse);
+        expect(mutationResult.response).toEqual(expectedResponse);
+        expect(subscriptionResult.response).toEqual(expectedResponse);
+        // Variables should be identical
+        expect(queryResult.variables).toEqual(mutationResult.variables);
+        expect(mutationResult.variables).toEqual(subscriptionResult.variables);
+    });
+    it("generates flat query when fieldPath is null or empty", () => {
+        const operation = {
+            id: "query_topLevel",
+            operationType: "QUERY",
+            name: "getUser",
+            fieldPath: null,
+            arguments: [],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const result = generateGraphQlSnippet({ operation, types: {} });
+        expect(result.query).toBe("query ExampleQuery {\n  getUser\n}");
+    });
+    it("appends ! for required arguments and omits it for optional", () => {
+        const operation = {
+            id: "mutation_deleteCart",
+            operationType: "MUTATION",
+            name: "deleteCart",
+            fieldPath: ["cart"],
+            arguments: [
+                { name: "input", type: idAlias("DeleteCartInput"), defaultValue: undefined },
+                { name: "note", type: optionalAlias(primitiveAlias("string")), defaultValue: undefined }
+            ],
+            returnType: primitiveAlias("string"),
+            examples: undefined
+        };
+        const types = {
+            [typeId("DeleteCartInput")]: {
+                name: "DeleteCartInput",
+                shape: {
+                    type: "object",
+                    extends: [],
+                    properties: [{ key: "cartEntityId", valueShape: primitiveAlias("string") }],
+                    extraProperties: undefined
+                },
+                description: undefined,
+                availability: undefined
+            }
+        };
+        const result = generateGraphQlSnippet({ operation, types });
+        expect(result.query).toContain("$input: DeleteCartInput!");
+        expect(result.query).toContain("$note: String)");
+        expect(result.query).not.toContain("$note: String!)");
+    });
+});
+//# sourceMappingURL=graphql-snippets.test.js.map