@graphql-hive/federation-gateway-audit 0.0.0 → 0.0.1

package/src/supergraph.ts

@@ -0,0 +1,195 @@
+import { composeServices } from "@apollo/composition";
+import { parse } from "graphql";
+import type { createRouter } from "fets";
+import { Response } from "fets";
+import type { createSubgraph } from "./subgraph.js";
+
+export function getSupergraph(
+  subgraphs: Array<{
+    name: string;
+    url: string;
+    typeDefs: string;
+  }>,
+) {
+  const result = composeServices(
+    subgraphs.map((subgraph) => ({
+      name: subgraph.name,
+      typeDefs: 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;
+}
+
+export function serve(
+  id: string,
+  subgraphs: Array<ReturnType<typeof createSubgraph>>,
+  tests:
+    | (() => Array<{
+        query: string;
+        expected: any;
+      }>)
+    | Array<{
+        query: string;
+        expected: any;
+      }>,
+) {
+  return {
+    id,
+    createRoutes(router: ReturnType<typeof createRouter>) {
+      let subgraphNames = new Set<string>();
+      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: { url: string; parsedUrl: URL }) {
+        const supergraph = getSupergraph(
+          subgraphs.map((subgraph) => ({
+            name: subgraph.name,
+            typeDefs: subgraph.typeDefs,
+            url: `${request.parsedUrl.origin}/${id}/${subgraph.name}`,
+          })),
+        );
+
+        const response = new 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 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 Response.json(testsArray);
+        },
+      });
+
+      return id;
+    },
+  };
+}

package/src/test-suites/abstract-types/agency.subgraph.ts

@@ -0,0 +1,43 @@
+import { createSubgraph } from "../../subgraph.js";
+import { agencies } from "./data.js";
+
+export default createSubgraph("agency", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key"])
+
+    type Agency @key(fields: "id") {
+      id: ID!
+      companyName: String
+      email: Email
+    }
+
+    type Email {
+      address: String
+    }
+
+    type Group @key(fields: "id") {
+      id: ID!
+      name: String
+      email: String
+    }
+
+    extend union PublisherType = Agency | Group
+  `,
+  resolvers: {
+    Agency: {
+      __resolveReference(key: { id: string }) {
+        return agencies.find((a) => a.id === key.id);
+      },
+    },
+    Group: {
+      __resolveReference(key: { id: string }) {
+        return {
+          id: key.id,
+          name: "Group " + key.id,
+          email: "group" + key.id + "@example.com",
+        };
+      },
+    },
+  },
+});

package/src/test-suites/abstract-types/books.subgraph.ts

@@ -0,0 +1,47 @@
+import { createSubgraph } from "../../subgraph.js";
+import { books } from "./data.js";
+
+export default createSubgraph("books", {
+  typeDefs: /* GraphQL */ `
+    schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@shareable", "@external", "@requires"]
+      ) {
+      query: Query
+    }
+
+    type Book @key(fields: "id") {
+      id: ID!
+      title: String
+    }
+
+    type Query {
+      books: [Book]
+    }
+  `,
+  resolvers: {
+    Query: {
+      books() {
+        return books.map((book) => ({
+          __typename: "Book",
+          id: book.id,
+          title: book.title,
+        }));
+      },
+    },
+    Book: {
+      __resolveReference(key: { id: string }) {
+        const book = books.find((book) => book.id === key.id);
+
+        return book
+          ? {
+              __typename: "Book",
+              id: book.id,
+              title: book.title,
+            }
+          : null;
+      },
+    },
+  },
+});

package/src/test-suites/abstract-types/data.ts

@@ -0,0 +1,120 @@
+export const users = [
+  {
+    id: "u1",
+    email: "u1@example.com",
+    name: "u1-name",
+  },
+  {
+    id: "u2",
+    email: "u2@example.com",
+    name: "u2-name",
+  },
+  {
+    id: "u3",
+    email: "u3@example.com",
+    name: "u3-name",
+  },
+] as const;
+
+export const books = [
+  {
+    __typename: "Book",
+    id: "p1",
+    sku: "sku-1",
+    title: "Book 1",
+    createdBy: "u1",
+    dimensions: {
+      size: "small",
+      weight: 0.5,
+    },
+    publisher: {
+      __typename: "Self",
+      email: users[0].email,
+    },
+    hidden: false,
+  },
+  {
+    __typename: "Book",
+    id: "p3",
+    sku: "sku-3",
+    title: "Book 2",
+    createdBy: "u2",
+    dimensions: {
+      size: "small",
+      weight: 0.6,
+    },
+    publisher: {
+      __typename: "Agency",
+      id: "a1",
+    },
+    hidden: false,
+  },
+];
+
+export const magazines = [
+  {
+    __typename: "Magazine",
+    id: "p2",
+    sku: "sku-2",
+    title: "Magazine 1",
+    createdBy: "u1",
+    dimensions: {
+      size: "small",
+      weight: 0.2,
+    },
+    publisher: {
+      __typename: "Agency",
+      id: "a1",
+    },
+    hidden: false,
+  },
+  {
+    __typename: "Magazine",
+    id: "p4",
+    sku: "sku-4",
+    title: "Magazine 2",
+    createdBy: "u2",
+    dimensions: {
+      size: "small",
+      weight: 0.3,
+    },
+    publisher: {
+      __typename: "Self",
+      email: users[0].email,
+    },
+    hidden: true,
+  },
+];
+
+export const products = [...books, ...magazines] as const;
+
+export const reviews = [
+  {
+    id: 1,
+    body: "review 1",
+    productId: "p1",
+    score: 3,
+  },
+  {
+    id: 2,
+    body: "review 2",
+    productId: "p1",
+    score: 4,
+  },
+  {
+    id: 3,
+    body: "review 3",
+    productId: "p2",
+    score: 5,
+  },
+] as const;
+
+export const agencies = [
+  {
+    id: "a1",
+    companyName: "Agency 1",
+    email: {
+      address: "a1@example.com",
+    },
+  },
+] as const;

package/src/test-suites/abstract-types/index.ts

@@ -0,0 +1,23 @@
+import { serve } from "../../supergraph.js";
+import inventorySubgraph from "./inventory.subgraph.js";
+import booksSubgraph from "./books.subgraph.js";
+import usersSubgraph from "./users.subgraph.js";
+import productsSubgraph from "./products.subgraph.js";
+import reviewsSubgraph from "./reviews.subgraph.js";
+import magazinesSubgraph from "./magazines.subgraph.js";
+import agencySubgraph from "./agency.subgraph.js";
+import test from "./test.js";
+
+export default serve(
+  "abstract-types",
+  [
+    agencySubgraph,
+    inventorySubgraph,
+    booksSubgraph,
+    usersSubgraph,
+    reviewsSubgraph,
+    productsSubgraph,
+    magazinesSubgraph,
+  ],
+  test,
+);

package/src/test-suites/abstract-types/inventory.subgraph.ts

@@ -0,0 +1,142 @@
+import { createSubgraph } from "../../subgraph.js";
+import { books, magazines } from "./data.js";
+
+export default createSubgraph("inventory", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@shareable", "@external", "@requires"]
+      )
+
+    interface Product {
+      id: ID!
+      dimensions: ProductDimension
+      delivery(zip: String): DeliveryEstimates
+    }
+
+    type Book implements Product @key(fields: "id") {
+      id: ID!
+      dimensions: ProductDimension @external
+      delivery(zip: String): DeliveryEstimates
+        @requires(fields: "dimensions { size weight }")
+    }
+
+    type Magazine implements Product @key(fields: "id") {
+      id: ID!
+      dimensions: ProductDimension @external
+      delivery(zip: String): DeliveryEstimates
+        @requires(fields: "dimensions { size weight }")
+    }
+
+    type ProductDimension @shareable {
+      size: String
+      weight: Float
+    }
+
+    type DeliveryEstimates {
+      estimatedDelivery: String
+      fastestDelivery: String
+    }
+  `,
+  resolvers: {
+    Book: {
+      __resolveReference(key: {
+        id: string;
+        dimensions?: {
+          size: string;
+          weight: number;
+        };
+      }) {
+        const book = books.find((book) => book.id === key.id);
+
+        if (!book) {
+          return null;
+        }
+
+        return {
+          __typename: book.__typename,
+          id: book.id,
+          dimensions: key.dimensions,
+        };
+      },
+      delivery(
+        { dimensions }: { dimensions?: { size: string; weight: number } },
+        { zip }: { zip?: string },
+      ) {
+        if (!zip) {
+          return null;
+        }
+
+        if (!dimensions) {
+          return null;
+        }
+
+        if (dimensions.size === "small" && dimensions.weight < 1) {
+          return {
+            estimatedDelivery: "1 day",
+            fastestDelivery: "same day",
+          };
+        }
+
+        if (dimensions.size === "large" && dimensions.weight >= 1) {
+          return {
+            estimatedDelivery: "3 days",
+            fastestDelivery: "2 days",
+          };
+        }
+
+        return null;
+      },
+    },
+    Magazine: {
+      __resolveReference(key: {
+        id: string;
+        dimensions?: {
+          size: string;
+          weight: number;
+        };
+      }) {
+        const magazine = magazines.find((magazine) => magazine.id === key.id);
+
+        if (!magazine) {
+          return null;
+        }
+
+        return {
+          __typename: magazine.__typename,
+          id: magazine.id,
+          dimensions: key.dimensions,
+        };
+      },
+      delivery(
+        { dimensions }: { dimensions?: { size: string; weight: number } },
+        { zip }: { zip?: string },
+      ) {
+        if (!zip) {
+          return null;
+        }
+
+        if (!dimensions) {
+          return null;
+        }
+
+        if (dimensions.size === "small" && dimensions.weight < 1) {
+          return {
+            estimatedDelivery: "1 day",
+            fastestDelivery: "same day",
+          };
+        }
+
+        if (dimensions.size === "large" && dimensions.weight >= 1) {
+          return {
+            estimatedDelivery: "3 days",
+            fastestDelivery: "2 days",
+          };
+        }
+
+        return null;
+      },
+    },
+  },
+});

package/src/test-suites/abstract-types/magazines.subgraph.ts

@@ -0,0 +1,47 @@
+import { createSubgraph } from "../../subgraph.js";
+import { magazines } from "./data.js";
+
+export default createSubgraph("magazines", {
+  typeDefs: /* GraphQL */ `
+    schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@shareable"]
+      ) {
+      query: Query
+    }
+
+    type Magazine @key(fields: "id") {
+      id: ID!
+      title: String
+    }
+
+    type Query {
+      magazines: [Magazine]
+    }
+  `,
+  resolvers: {
+    Query: {
+      magazines() {
+        return magazines.map((magazine) => ({
+          __typename: magazine.__typename,
+          id: magazine.id,
+          title: magazine.title,
+        }));
+      },
+    },
+    Magazine: {
+      __resolveReference(key: { id: string }) {
+        const magazine = magazines.find((magazine) => magazine.id === key.id);
+
+        return magazine
+          ? {
+              __typename: magazine.__typename,
+              id: magazine.id,
+              title: magazine.title,
+            }
+          : null;
+      },
+    },
+  },
+});