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

package/src/test-suites/mutations/a.subgraph.ts

@@ -0,0 +1,136 @@
+import { createSubgraph } from "../../subgraph.js";
+import {
+  addCategory,
+  addProduct,
+  deleteProduct,
+  getCategories,
+  getProducts,
+  initProducts,
+  multiplyNumber,
+} from "./data.js";
+
+export default createSubgraph("a", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@shareable"]
+      )
+
+    type Mutation {
+      addProduct(input: AddProductInput!): Product!
+      addCategory(name: String!, requestId: String!): Category! @shareable
+      multiply(by: Int!, requestId: String!): Int!
+    }
+
+    type Query {
+      product(id: ID!): Product!
+      products: [Product!]!
+    }
+
+    input AddProductInput {
+      name: String!
+      price: Float!
+    }
+
+    type Product @key(fields: "id") {
+      id: ID!
+      name: String!
+      price: Float!
+    }
+
+    type Category @key(fields: "id") {
+      id: ID!
+    }
+  `,
+  resolvers: {
+    Query: {
+      async product(_: {}, { id }: { id: string }) {
+        initProducts();
+        const product = (await getProducts()).find((p) => p.id === id);
+
+        if (!product) {
+          return null;
+        }
+
+        return {
+          id: product.id,
+          name: product.name,
+          price: product.price,
+        };
+      },
+      async products() {
+        initProducts();
+        return getProducts();
+      },
+    },
+    Mutation: {
+      async multiply(
+        _: {},
+        args: {
+          by: number;
+          requestId: string;
+        },
+      ) {
+        return multiplyNumber(args.by, args.requestId);
+      },
+      async addProduct(
+        _: {},
+        {
+          input,
+        }: {
+          input: {
+            name: string;
+            price: number;
+          };
+        },
+      ) {
+        return addProduct(input.name, input.price);
+      },
+      async addCategory(
+        _: {},
+        {
+          name,
+          requestId,
+        }: {
+          name: string;
+          requestId: string;
+        },
+      ) {
+        return addCategory(name, requestId);
+      },
+    },
+    Product: {
+      async __resolveReference(key: { id: string }) {
+        const products = await getProducts();
+        const product = products.find((p) => p.id === key.id);
+
+        if (!product) {
+          return null;
+        }
+
+        await deleteProduct(product.id);
+
+        return {
+          id: product.id,
+          name: product.name,
+          price: product.price,
+        };
+      },
+    },
+    Category: {
+      __resolveReference(key: { id: string }) {
+        const categories = getCategories();
+        const category = categories.find((p) => p.id === key.id);
+
+        if (!category) {
+          return null;
+        }
+
+        return {
+          id: category.id,
+        };
+      },
+    },
+  },
+});

package/src/test-suites/mutations/b.subgraph.ts

@@ -0,0 +1,107 @@
+import { createSubgraph } from "../../subgraph.js";
+import {
+  addCategory,
+  deleteNumber,
+  deleteProduct,
+  getCategories,
+  getProducts,
+} from "./data.js";
+
+export default createSubgraph("b", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@external", "@requires", "@shareable"]
+      )
+
+    type Product @key(fields: "id") {
+      id: ID!
+      price: Float! @external
+      isExpensive: Boolean! @requires(fields: "price")
+      isAvailable: Boolean!
+    }
+
+    type Mutation {
+      delete(requestId: String!): Int!
+      addCategory(name: String!, requestId: String!): Category! @shareable
+    }
+
+    type Category @key(fields: "id") {
+      id: ID!
+      name: String!
+    }
+  `,
+  resolvers: {
+    Mutation: {
+      delete(
+        _: {},
+        args: {
+          requestId: string;
+        },
+      ) {
+        return deleteNumber(args.requestId);
+      },
+      async addCategory(
+        _: {},
+        {
+          name,
+          requestId,
+        }: {
+          name: string;
+          requestId: string;
+        },
+      ) {
+        return addCategory(name, requestId);
+      },
+    },
+    Product: {
+      async __resolveReference(key: { id: string; price?: number }) {
+        const product = (await getProducts()).find(
+          (product) => product.id === key.id,
+        );
+
+        if (!product) {
+          return null;
+        }
+
+        await deleteProduct(product.id);
+
+        if (typeof product.price === "number") {
+          return {
+            id: product.id,
+            isAvailable: true,
+            price: product.price,
+          };
+        }
+
+        return {
+          id: product.id,
+          isAvailable: false,
+        };
+      },
+      isExpensive(product: { price?: number }) {
+        if (typeof product.price !== "number") {
+          throw new Error("Price is not available");
+        }
+
+        return product.price > 100;
+      },
+    },
+    Category: {
+      __resolveReference(key: { id: string }) {
+        const categories = getCategories();
+        const category = categories.find((p) => p.id === key.id);
+
+        if (!category) {
+          return null;
+        }
+
+        return {
+          id: category.id,
+          name: category.name,
+        };
+      },
+    },
+  },
+});

package/src/test-suites/mutations/c.subgraph.ts

@@ -0,0 +1,26 @@
+import { createSubgraph } from "../../subgraph.js";
+import { addNumber } from "./data.js";
+
+export default createSubgraph("c", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key"])
+
+    type Mutation {
+      add(num: Int!, requestId: String!): Int!
+    }
+  `,
+  resolvers: {
+    Mutation: {
+      add(
+        _: {},
+        args: {
+          num: number;
+          requestId: string;
+        },
+      ) {
+        return addNumber(args.num, args.requestId);
+      },
+    },
+  },
+});

package/src/test-suites/mutations/data.ts

@@ -0,0 +1,91 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+}
+
+interface Category {
+  id: string;
+  name: string;
+}
+
+let products: Product[] = [];
+let categories: Category[] = [];
+const numbers: Record<string, number> = {};
+
+export async function getProducts(): Promise<Product[]> {
+  return products;
+}
+
+export function getCategories(): Category[] {
+  return categories;
+}
+
+export async function addProduct(name: string, price: number) {
+  const newProduct = {
+    id: "p-added-" + products.length,
+    name: name,
+    price: price,
+  };
+  products.push(newProduct);
+  return newProduct;
+}
+
+export async function addCategory(name: string, requestId: string) {
+  if (categories.some((c) => c.id === "c-added-" + requestId)) {
+    throw new Error("Category with this requestId was already added");
+  }
+
+  const newCategory = {
+    id: "c-added-" + requestId,
+    name: name,
+  };
+  categories.push(newCategory);
+  return newCategory;
+}
+
+export async function deleteProduct(id: string) {
+  const after = products.filter((p) => p.id !== id);
+  products = after;
+}
+
+export function initProducts() {
+  const product = {
+    id: "p1",
+    name: "p1-name",
+    price: 9.99,
+  };
+
+  if (products.some((p) => p.id === product.id)) {
+    return;
+  }
+
+  products.push(product);
+}
+
+function getNumber(requestId: string) {
+  const num = numbers[requestId];
+  return num ?? 0;
+}
+
+export function addNumber(num: number, requestId: string) {
+  const existingNumber = getNumber(requestId);
+  const sum = existingNumber + num;
+  numbers[requestId] = sum;
+  return sum;
+}
+
+export function multiplyNumber(by: number, requestId: string) {
+  const existingNumber = getNumber(requestId);
+  const result = existingNumber * by;
+  numbers[requestId] = result;
+  return result;
+}
+
+export function deleteNumber(requestId: string) {
+  const num = getNumber(requestId);
+  if (typeof numbers[requestId] === "number") {
+    delete numbers[requestId];
+  }
+  return num;
+}

package/src/test-suites/mutations/index.ts

@@ -0,0 +1,7 @@
+import { serve } from "../../supergraph.js";
+import a from "./a.subgraph.js";
+import b from "./b.subgraph.js";
+import c from "./c.subgraph.js";
+import test from "./test.js";
+
+export default serve("mutations", [a, b, c], test);

package/src/test-suites/mutations/test.ts

@@ -0,0 +1,94 @@
+import { createTest } from "../../testkit.js";
+
+export default () => {
+  const randomId = Math.random().toString(16).substr(2);
+
+  return [
+    createTest(
+      /* GraphQL */ `
+        mutation {
+          addProduct(input: { name: "new", price: 599.99 }) {
+            name
+            price
+            isExpensive
+            isAvailable
+          }
+        }
+      `,
+      {
+        data: {
+          addProduct: {
+            name: "new",
+            price: 599.99,
+            isExpensive: true,
+            isAvailable: true,
+          },
+        },
+      },
+    ),
+    createTest(
+      /* GraphQL */ `
+        query {
+          product(id: "p1") {
+            id
+            name
+            price
+            isExpensive
+            isAvailable
+          }
+        }
+      `,
+      {
+        data: {
+          product: {
+            id: "p1",
+            name: "p1-name",
+            price: 9.99,
+            isExpensive: false,
+            isAvailable: true,
+          },
+        },
+      },
+    ),
+    // Test correct order of execution
+    // It obviously does not solve a problem with shared state and race conditions,
+    // but at least it reduces the risk a bit
+    createTest(
+      /* GraphQL */ `
+      mutation {
+        five: add(num: 5, requestId: "${randomId}")
+        ten: multiply(by: 2, requestId: "${randomId}")
+        twelve: add(num: 2, requestId: "${randomId}")
+        final: delete(requestId: "${randomId}")
+      }
+    `,
+      {
+        data: {
+          five: 5,
+          ten: 10,
+          twelve: 12,
+          final: 12,
+        },
+      },
+    ),
+    // shared-root (mutation)
+    createTest(
+      /* GraphQL */ `
+        mutation {
+          addCategory(name: "new", requestId: "${randomId}") {
+            id
+            name
+          }
+        }
+      `,
+      {
+        data: {
+          addCategory: {
+            id: "c-added-" + randomId,
+            name: "new",
+          },
+        },
+      },
+    ),
+  ];
+};

package/src/test-suites/mysterious-external/data.ts

@@ -0,0 +1,12 @@
+export const products = [
+  {
+    id: "1",
+    name: "name-1",
+    price: 100,
+  },
+  {
+    id: "2",
+    name: "name-2",
+    price: 200,
+  },
+];

package/src/test-suites/mysterious-external/index.ts

@@ -0,0 +1,6 @@
+import { serve } from "../../supergraph.js";
+import price from "./price.subgraph.js";
+import product from "./product.subgraph.js";
+import test from "./test.js";
+
+export default serve("mysterious-external", [price, product], test);

package/src/test-suites/mysterious-external/price.subgraph.ts

@@ -0,0 +1,55 @@
+import { createSubgraph } from "../../subgraph.js";
+import { products } from "./data.js";
+
+export default createSubgraph("price", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@external"]
+      )
+
+    # Composition will fail if it's not an extension (I have no idea why this is the case)
+    extend type Product @key(fields: "id") {
+      id: ID! @external
+      price: Float
+    }
+
+    type Query {
+      cheapestProduct: Product
+    }
+  `,
+  resolvers: {
+    Product: {
+      __resolveReference(key: { id: string }) {
+        const product = products.find((product) => product.id === key.id);
+
+        if (!product) {
+          return null;
+        }
+
+        return {
+          id: product.id,
+          price: product.price,
+        };
+      },
+    },
+    Query: {
+      cheapestProduct() {
+        let cheapest: (typeof products)[number] | null = null;
+
+        for (const product of products) {
+          if (cheapest) {
+            if (product.price < cheapest.price) {
+              cheapest = product;
+            }
+          } else {
+            cheapest = product;
+          }
+        }
+
+        return cheapest;
+      },
+    },
+  },
+});

package/src/test-suites/mysterious-external/product.subgraph.ts

@@ -0,0 +1,45 @@
+import { createSubgraph } from "../../subgraph.js";
+import { products } from "./data.js";
+
+export default createSubgraph("product", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@external"]
+      )
+
+    type Product @key(fields: "id") {
+      id: ID!
+      name: String!
+    }
+
+    type Query {
+      products: [Product!]!
+    }
+  `,
+  resolvers: {
+    Product: {
+      __resolveReference(key: { id: string }) {
+        const product = products.find((product) => product.id === key.id);
+
+        if (!product) {
+          return null;
+        }
+
+        return {
+          id: product.id,
+          name: product.name,
+        };
+      },
+    },
+    Query: {
+      products() {
+        return products.map((p) => ({
+          id: p.id,
+          name: p.name,
+        }));
+      },
+    },
+  },
+});

package/src/test-suites/mysterious-external/test.ts

@@ -0,0 +1,51 @@
+import { createTest } from "../../testkit.js";
+
+export default [
+  createTest(
+    /* GraphQL */ `
+      query {
+        cheapestProduct {
+          id
+          price
+          name
+        }
+      }
+    `,
+    {
+      data: {
+        cheapestProduct: {
+          id: "1",
+          price: 100,
+          name: "name-1",
+        },
+      },
+    },
+  ),
+  createTest(
+    /* GraphQL */ `
+      query {
+        products {
+          name
+          price
+          id
+        }
+      }
+    `,
+    {
+      data: {
+        products: [
+          {
+            name: "name-1",
+            price: 100,
+            id: "1",
+          },
+          {
+            name: "name-2",
+            price: 200,
+            id: "2",
+          },
+        ],
+      },
+    },
+  ),
+];

package/src/test-suites/nested-provides/all-products.subgraph.ts

@@ -0,0 +1,37 @@
+import { shouldPunishForPoorPlans } from "../../env.js";
+import { createSubgraph } from "../../subgraph.js";
+import { products } from "./data.js";
+
+// I deliberately name it all-products to make sure it's first in the list of subgraphs (in case the order matters)
+export default createSubgraph("all-products", {
+  typeDefs: /* GraphQL */ `
+    extend schema
+      @link(
+        url: "https://specs.apollo.dev/federation/v2.3"
+        import: ["@key", "@shareable"]
+      )
+
+    type Product @key(fields: "id") {
+      id: ID!
+    }
+  `,
+  resolvers: {
+    Product: {
+      __resolveReference(key: { id: string }) {
+        if (shouldPunishForPoorPlans()) {
+          throw new Error("You should be using the categories subgraph!");
+        }
+
+        const product = products.find((p) => p.id === key.id);
+
+        if (!product) {
+          return null;
+        }
+
+        return {
+          id: product.id,
+        };
+      },
+    },
+  },
+});