@fern-api/fdr-sdk 1.2.35-e58b8c0e40 → 1.2.35-eaea1f74f7

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

@@ -1,973 +0,0 @@
-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