@graphql-hive/federation-gateway-audit 0.0.0

package/dist/testkit-CAf-AsDy.cjs

@@ -0,0 +1,273 @@
+'use strict';
+
+var composition = require('@apollo/composition');
+var graphql = require('graphql');
+var fets = require('fets');
+var subgraph = require('@apollo/subgraph');
+var graphqlYoga = require('graphql-yoga');
+
+function getSupergraph(subgraphs) {
+  const result = composition.composeServices(
+    subgraphs.map((subgraph) => ({
+      name: subgraph.name,
+      typeDefs: graphql.parse(subgraph.typeDefs),
+      url: subgraph.url
+    }))
+  );
+  if (!result.supergraphSdl) {
+    result.errors?.forEach((error) => console.error(error.message));
+    throw new Error("Failed to compose supergraph");
+  }
+  return result.supergraphSdl;
+}
+function serve(id, subgraphs, tests) {
+  return {
+    id,
+    createRoutes(router) {
+      let subgraphNames = /* @__PURE__ */ new Set();
+      for (const subgraph of subgraphs) {
+        if (subgraphNames.has(subgraph.name)) {
+          throw new Error(`Duplicate subgraph name ${subgraph.name}`);
+        }
+        subgraphNames.add(subgraph.name);
+        subgraph.createRoutes(id, router);
+      }
+      function serveSupergraph(request) {
+        const supergraph = getSupergraph(
+          subgraphs.map((subgraph) => ({
+            name: subgraph.name,
+            typeDefs: subgraph.typeDefs,
+            url: `${request.parsedUrl.origin}/${id}/${subgraph.name}`
+          }))
+        );
+        const response = new fets.Response(supergraph, {
+          status: 200,
+          headers: {
+            "Content-Type": "text/plain",
+            "Cache-Control": "public, max-age=604800, stale-while-revalidate=432000"
+          }
+        });
+        return response;
+      }
+      router.route({
+        method: "GET",
+        path: `/${id}/supergraph`,
+        tags: [id],
+        description: "Supergraph SDL endpoint",
+        operationId: "supergraph",
+        schemas: {
+          responses: {
+            200: {
+              type: "string"
+            }
+          }
+        },
+        handler(req) {
+          return serveSupergraph(req);
+        }
+      });
+      router.route({
+        method: "GET",
+        path: `/${id}/supergraph.graphql`,
+        tags: [id],
+        description: "Supergraph SDL endpoint",
+        operationId: "supergraph.graphql",
+        schemas: {
+          responses: {
+            200: {
+              type: "string"
+            }
+          }
+        },
+        handler(req) {
+          return serveSupergraph(req);
+        }
+      });
+      router.route({
+        method: "GET",
+        path: `/${id}/subgraphs`,
+        tags: [id],
+        description: "A list of subgraphs with their SDLs, URLs and names",
+        operationId: "subgraphs",
+        schemas: {
+          responses: {
+            200: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  url: { type: "string" },
+                  sdl: { type: "string" }
+                },
+                required: ["name", "url", "sdl"]
+              }
+            }
+          }
+        },
+        handler(req) {
+          return fets.Response.json(
+            subgraphs.map((subgraph) => ({
+              name: subgraph.name,
+              sdl: subgraph.typeDefs,
+              url: `${req.parsedUrl.origin}/${id}/${subgraph.name}`
+            }))
+          );
+        }
+      });
+      router.route({
+        method: "GET",
+        path: `/${id}/tests`,
+        tags: [id],
+        description: "Endpoint with a list of tests",
+        operationId: "tests",
+        schemas: {
+          responses: {
+            200: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  query: { type: "string" },
+                  expected: {
+                    type: "object",
+                    properties: {
+                      data: {
+                        anyOf: [
+                          { type: "object" },
+                          {
+                            type: "null"
+                          }
+                        ]
+                      },
+                      errors: {
+                        type: "boolean",
+                        description: "Indicates that errors are expected",
+                        default: false
+                      }
+                    },
+                    additionalProperties: false
+                  }
+                },
+                additionalProperties: false,
+                required: ["query", "expected"]
+              }
+            }
+          }
+        },
+        handler() {
+          const testsArray = Array.isArray(tests) ? tests : tests();
+          return fets.Response.json(testsArray);
+        }
+      });
+      return id;
+    }
+  };
+}
+
+function createSubgraph(name, schemaParameters) {
+  let schema;
+  function lazySchema() {
+    if (!schema) {
+      schema = subgraph.buildSubgraphSchema({
+        typeDefs: graphql.parse(schemaParameters.typeDefs),
+        resolvers: schemaParameters.resolvers
+      });
+    }
+    return schema;
+  }
+  function lazyYoga() {
+    if (!yoga) {
+      yoga = graphqlYoga.createYoga({
+        schema: lazySchema(),
+        graphqlEndpoint: "*",
+        logging: false,
+        maskedErrors: false
+      });
+    }
+    return yoga;
+  }
+  let yoga;
+  return {
+    createRoutes(testCaseId, router) {
+      router.route({
+        method: "GET",
+        path: `/${testCaseId}/${name}`,
+        tags: [testCaseId],
+        operationId: "GraphiQL",
+        schemas: {
+          request: {
+            query: {
+              type: "object",
+              properties: {
+                query: { type: "string" }
+              },
+              additionalProperties: true,
+              required: ["query"]
+            }
+          }
+        },
+        handler(req) {
+          return lazyYoga()(req);
+        }
+      });
+      router.route({
+        method: "POST",
+        path: `/${testCaseId}/${name}`,
+        tags: [testCaseId],
+        operationId: `"${name}" subgraph`,
+        description: "GraphQL endpoint for the subgraph",
+        schemas: {
+          request: {
+            json: {
+              type: "object",
+              properties: {
+                query: { type: "string" },
+                variables: { type: "object" }
+              },
+              additionalProperties: true,
+              required: ["query"]
+            }
+          },
+          responses: {
+            200: {
+              type: "object",
+              properties: {
+                data: { type: "object" },
+                errors: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      message: { type: "string" }
+                    },
+                    required: ["message"],
+                    additionalProperties: false
+                  }
+                }
+              },
+              required: ["data"],
+              additionalProperties: false
+            }
+          }
+        },
+        handler(req) {
+          return lazyYoga()(req);
+        }
+      });
+    },
+    name,
+    typeDefs: schemaParameters.typeDefs
+  };
+}
+
+function createTest(query, expected) {
+  return {
+    query,
+    expected
+  };
+}
+
+exports.createSubgraph = createSubgraph;
+exports.createTest = createTest;
+exports.serve = serve;

package/dist/testkit-D0rTQ6MD.cjs

@@ -0,0 +1,286 @@
+'use strict';
+
+var composition = require('@apollo/composition');
+var graphql = require('graphql');
+var fets = require('fets');
+var subgraph = require('@apollo/subgraph');
+var graphqlYoga = require('graphql-yoga');
+
+function getSupergraph(subgraphs) {
+  const result = composition.composeServices(
+    subgraphs.map((subgraph) => ({
+      name: subgraph.name,
+      typeDefs: graphql.parse(subgraph.typeDefs),
+      url: subgraph.url
+    }))
+  );
+  if (!result.supergraphSdl) {
+    result.errors?.forEach((error) => console.error(error.message));
+    throw new Error("Failed to compose supergraph");
+  }
+  return result.supergraphSdl;
+}
+function serve(id, subgraphs, tests) {
+  return {
+    id,
+    createRoutes(router) {
+      let subgraphNames = /* @__PURE__ */ new Set();
+      for (const subgraph of subgraphs) {
+        if (subgraphNames.has(subgraph.name)) {
+          throw new Error(`Duplicate subgraph name ${subgraph.name}`);
+        }
+        subgraphNames.add(subgraph.name);
+        subgraph.createRoutes(id, router);
+      }
+      function serveSupergraph(request) {
+        const supergraph = getSupergraph(
+          subgraphs.map((subgraph) => ({
+            name: subgraph.name,
+            typeDefs: subgraph.typeDefs,
+            url: `${request.parsedUrl.origin}/${id}/${subgraph.name}`
+          }))
+        );
+        const response = new fets.Response(supergraph, {
+          status: 200,
+          headers: {
+            "Content-Type": "text/plain",
+            "Cache-Control": "public, max-age=604800, stale-while-revalidate=432000"
+          }
+        });
+        return response;
+      }
+      router.route({
+        method: "GET",
+        path: `/${id}/supergraph`,
+        tags: [id],
+        description: "Supergraph SDL endpoint",
+        operationId: "supergraph",
+        schemas: {
+          responses: {
+            200: {
+              type: "string"
+            }
+          }
+        },
+        handler(req) {
+          return serveSupergraph(req);
+        }
+      });
+      router.route({
+        method: "GET",
+        path: `/${id}/supergraph.graphql`,
+        tags: [id],
+        description: "Supergraph SDL endpoint",
+        operationId: "supergraph.graphql",
+        schemas: {
+          responses: {
+            200: {
+              type: "string"
+            }
+          }
+        },
+        handler(req) {
+          return serveSupergraph(req);
+        }
+      });
+      router.route({
+        method: "GET",
+        path: `/${id}/subgraphs`,
+        tags: [id],
+        description: "A list of subgraphs with their SDLs, URLs and names",
+        operationId: "subgraphs",
+        schemas: {
+          responses: {
+            200: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  url: { type: "string" },
+                  sdl: { type: "string" }
+                },
+                required: ["name", "url", "sdl"]
+              }
+            }
+          }
+        },
+        handler(req) {
+          return fets.Response.json(
+            subgraphs.map((subgraph) => ({
+              name: subgraph.name,
+              sdl: subgraph.typeDefs,
+              url: `${req.parsedUrl.origin}/${id}/${subgraph.name}`
+            }))
+          );
+        }
+      });
+      router.route({
+        method: "GET",
+        path: `/${id}/tests`,
+        tags: [id],
+        description: "Endpoint with a list of tests",
+        operationId: "tests",
+        schemas: {
+          responses: {
+            200: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  query: { type: "string" },
+                  expected: {
+                    type: "object",
+                    properties: {
+                      data: {
+                        anyOf: [
+                          { type: "object" },
+                          {
+                            type: "null"
+                          }
+                        ]
+                      },
+                      errors: {
+                        type: "boolean",
+                        description: "Indicates that errors are expected",
+                        default: false
+                      }
+                    },
+                    additionalProperties: false
+                  }
+                },
+                additionalProperties: false,
+                required: ["query", "expected"]
+              }
+            }
+          }
+        },
+        handler() {
+          const testsArray = Array.isArray(tests) ? tests : tests();
+          return fets.Response.json(testsArray);
+        }
+      });
+      return id;
+    }
+  };
+}
+
+try {
+  process.loadEnvFile();
+} catch (e) {
+}
+const env = {
+  PUNISH_FOR_POOR_PLANS: "1",
+  ...process.env
+};
+function shouldPunishForPoorPlans(context) {
+  return context.env.PUNISH_FOR_POOR_PLANS === "1";
+}
+
+function createSubgraph(name, schemaParameters) {
+  let schema;
+  function lazySchema() {
+    if (!schema) {
+      schema = subgraph.buildSubgraphSchema({
+        typeDefs: graphql.parse(schemaParameters.typeDefs),
+        resolvers: schemaParameters.resolvers
+      });
+    }
+    return schema;
+  }
+  function lazyYoga() {
+    if (!yoga) {
+      yoga = graphqlYoga.createYoga({
+        schema: lazySchema(),
+        graphqlEndpoint: "*",
+        logging: false,
+        maskedErrors: false
+      });
+    }
+    return yoga;
+  }
+  let yoga;
+  return {
+    createRoutes(testCaseId, router) {
+      router.route({
+        method: "GET",
+        path: `/${testCaseId}/${name}`,
+        tags: [testCaseId],
+        operationId: "GraphiQL",
+        schemas: {
+          request: {
+            query: {
+              type: "object",
+              properties: {
+                query: { type: "string" }
+              },
+              additionalProperties: true,
+              required: ["query"]
+            }
+          }
+        },
+        handler(req) {
+          return lazyYoga()(req, { env });
+        }
+      });
+      router.route({
+        method: "POST",
+        path: `/${testCaseId}/${name}`,
+        tags: [testCaseId],
+        operationId: `"${name}" subgraph`,
+        description: "GraphQL endpoint for the subgraph",
+        schemas: {
+          request: {
+            json: {
+              type: "object",
+              properties: {
+                query: { type: "string" },
+                variables: { type: "object" }
+              },
+              additionalProperties: true,
+              required: ["query"]
+            }
+          },
+          responses: {
+            200: {
+              type: "object",
+              properties: {
+                data: { type: "object" },
+                errors: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      message: { type: "string" }
+                    },
+                    required: ["message"],
+                    additionalProperties: false
+                  }
+                }
+              },
+              required: ["data"],
+              additionalProperties: false
+            }
+          }
+        },
+        handler(req) {
+          return lazyYoga()(req, { env });
+        }
+      });
+    },
+    name,
+    typeDefs: schemaParameters.typeDefs
+  };
+}
+
+function createTest(query, expected) {
+  return {
+    query,
+    expected
+  };
+}
+
+exports.createSubgraph = createSubgraph;
+exports.createTest = createTest;
+exports.serve = serve;
+exports.shouldPunishForPoorPlans = shouldPunishForPoorPlans;

package/makefile

@@ -0,0 +1,47 @@
+BASE_URL := $(or $(BASE_URL), "http://localhost:4200")
+TEST_SUITE := $(or $(TEST_SUITE), "")
+REPORTER := $(or $(REPORTER), "dot")
+GATEWAYS_DIR := $(wildcard ./gateways/*)
+GATEWAY_IDS := $(notdir $(GATEWAYS_DIR))
+
+define TEST_GATEWAY
+test-$(1):
+	npm start -- test --cwd ./gateways/$(1) --run-script ./run.sh --reporter $(REPORTER) --graphql $(shell jq -r .graphql ./gateways/$(1)/gateway.json) --healthcheck $(shell jq -r .health ./gateways/$(1)/gateway.json)
+endef
+
+define TEST_SUITE_GATEWAY
+test-suite-$(1):
+	npm start -- test-suite --test $(TEST_SUITE) --cwd ./gateways/$(1) --run-script ./run.sh --graphql $(shell jq -r .graphql ./gateways/$(1)/gateway.json) --healthcheck $(shell jq -r .health ./gateways/$(1)/gateway.json)
+endef
+
+define RUN_GATEWAY
+run-$(1):
+	npm start -- start --test $(TEST_SUITE) --cwd ./gateways/$(1) --run-script ./run.sh --graphql $(shell jq -r .graphql ./gateways/$(1)/gateway.json) --healthcheck $(shell jq -r .health ./gateways/$(1)/gateway.json)
+endef
+
+# Install all dependencies of the project and the gateways
+install:
+	npm install
+	@for dir in ./gateways/*; do \
+		if [ -d $$dir ]; then \
+			echo "Installing $$dir"; \
+			(cd $$dir && ./install.sh); \
+			echo "\n"; \
+		fi; \
+	done
+
+# Start only the subgraphs, no gateway
+subgraphs:
+	npm start -- serve
+
+# Generate the test and run targets for each gateway
+$(foreach gateway,$(GATEWAY_IDS),$(eval $(call TEST_GATEWAY,$(gateway))))
+$(foreach gateway,$(GATEWAY_IDS),$(eval $(call RUN_GATEWAY,$(gateway))))
+$(foreach gateway,$(GATEWAY_IDS),$(eval $(call TEST_SUITE_GATEWAY,$(gateway))))
+
+# Run the tests for all gateways
+test-all: $(addprefix test-,$(GATEWAY_IDS)) summary
+
+# Update the report
+summary:
+	npm run summary

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@graphql-hive/federation-gateway-audit",
+  "version": "0.0.0",
+  "description": "Audit tool for Apollo Federation Gateway",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graphql-hive/federation-gateway-audit.git"
+  },
+  "homepage": "https://the-guild.dev/graphql/hive/federation-gateway-audit",
+  "author": {
+    "email": "contact@the-guild.dev",
+    "name": "The Guild",
+    "url": "https://the-guild.dev"
+  },
+  "license": "MIT",
+  "bin": {
+    "graphql-federation-audit": "dist/cli.js"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "start": "tsx ./src/cli.ts",
+    "summary": "tsx ./src/summary.ts",
+    "build": "pkgroll",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "@apollo/composition": "2.13.1",
+    "@apollo/subgraph": "2.13.1",
+    "async-retry": "1.3.3",
+    "fets": "0.8.5",
+    "get-port": "7.1.0",
+    "graphql": "16.13.1",
+    "graphql-yoga": "5.18.1",
+    "jest-diff": "30.3.0",
+    "kill-port-process": "4.0.2",
+    "wait-on": "9.0.4",
+    "detect-port": "2.1.0",
+    "yargs": "18.0.0"
+  },
+  "devDependencies": {
+    "@apollo/gateway": "2.13.1",
+    "@apollo/server": "5.4.0",
+    "@changesets/changelog-github": "0.6.0",
+    "@changesets/cli": "2.30.0",
+    "@graphql-hive/gateway": "2.5.5",
+    "@graphql-hive/router-runtime": "1.1.15",
+    "@as-integrations/express5": "1.1.2",
+    "@types/async-retry": "1.4.9",
+    "@types/express": "5.0.6",
+    "@types/node": "24.12.0",
+    "@types/wait-on": "5.3.4",
+    "@types/yargs": "17.0.35",
+    "express": "5.2.1",
+    "prettier": "3.8.1",
+    "pkgroll": "2.27.0",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "wgc": "0.109.0"
+  },
+  "overrides": {
+    "cross-spawn": "7.0.6",
+    "graphql": "16.13.1",
+    "js-yaml": "4.1.1",
+    "tmp": "0.2.5",
+    "@modelcontextprotocol/sdk": "1.27.1"
+  },
+  "packageManager": "npm@11.11.0"
+}