Final Exam

✏️ In services/policies/src/schema.graphql, add the Claim type and its status enum:

enum ClaimStatus {
  OPEN
  APPROVED
  DENIED
}

type Claim {
  id: ID!
  claimNumber: String!
  amount: Float!
  status: ClaimStatus!
  filedDate: String!
}

✏️ Add claims to Query:

type Query {
  # ...existing fields
  claims(status: ClaimStatus): [Claim!]!
}

✏️ In services/policies/src/resolvers.ts, import the claims data:

import { claims, type ClaimStatus } from "./data.js";

✏️ Add a claims resolver under Query. It filters the same way as policies:

    claims: (_: unknown, args: { status?: ClaimStatus }) =>
      claims.filter((c) => {
        // A status was requested, and this claim isn't that status
        if (args.status && c.status !== args.status) return false;
        return true;
      }),

✏️ In services/policies/src/schema.graphql, add policy to Claim and claims to Policy:

type Claim {
  # ...existing fields
  policy: Policy!
}

type Policy {
  # ...existing fields
  claims: [Claim!]!
}

✏️ In services/policies/src/resolvers.ts, add type Claim to the import from "./data.js":

import { claims, type Claim, type ClaimStatus } from "./data.js";

✏️ Add a Claim.policy resolver, and a claims resolver under Policy:

  Claim: {
    policy: (claim: Claim) => policies.find((p) => p.id === claim.policyId),
  },

    claims: (policy: Policy) => claims.filter((c) => c.policyId === policy.id),

A claim’s data has a policyId, not a policy, so the default resolver can’t answer Claim.policy. The same goes for Policy.claims. It’s the same situation as Policy.policyholder.

This part needs no server changes:

query PolicyholderClaims($policyholderId: ID!) {
  policyholder(id: $policyholderId) {
    name
    policies {
      policyNumber
      claims {
        claimNumber
        status
        amount
      }
    }
  }
}

Variables:

{ "policyholderId": "ph1" }

✏️ In services/policies/src/schema.graphql, add totalClaimed to Policy:

type Policy {
  # ...existing fields
  totalClaimed: Float!
}

✏️ In services/policies/src/resolvers.ts, add a totalClaimed resolver under Policy. The data has no totalClaimed property, so it has to be calculated:

    totalClaimed: (policy: Policy) => {
      // Add up the amounts of this policy's approved claims
      let total = 0;
      for (const claim of claims) {
        if (claim.policyId === policy.id && claim.status === "APPROVED") {
          total = total + claim.amount;
        }
      }
      return total;
    },

for (const claim of claims) runs the code inside once for each claim, calling it claim.

✏️ In services/policies/src/schema.graphql, add the input type, and add fileClaim to Mutation:

input FileClaimInput {
  policyId: ID!
  amount: Float!
}

type Mutation {
  # ...existing fields
  fileClaim(input: FileClaimInput!): Claim!
}

✏️ In services/policies/src/resolvers.ts, add saveClaims to the import from "./data.js", and describe the mutation’s input for TypeScript:

import { claims, saveClaims, type Claim, type ClaimStatus } from "./data.js";

type FileClaimInput = { policyId: string; amount: number };

✏️ Add a fileClaim resolver under Mutation. It follows the same steps as issuePolicy:

    fileClaim: (_: unknown, { input }: { input: FileClaimInput }) => {
      // 1. Check the input: the policy has to exist.
      if (!policies.some((p) => p.id === input.policyId)) {
        throw new GraphQLError(`Policy ${input.policyId} not found`, {
          extensions: { code: "BAD_USER_INPUT" },
        });
      }

      // 2. Fill in server-generated values. Every new claim starts OPEN.
      const n = claims.length + 1;
      const claim: Claim = {
        id: `c${n}`,
        claimNumber: `CLM-${5000 + n}`,
        amount: input.amount,
        status: "OPEN",
        filedDate: new Date().toISOString().slice(0, 10),
        policyId: input.policyId,
      };

      // 3. Save the claim: add it to the list, then write the list to claims.json.
      claims.push(claim);
      saveClaims();

      // 4. Return the new claim.
      return claim;
    },

Leaving out amount is rejected by the schema, because FileClaimInput.amount is Float!. The resolver never runs.

✏️ In services/policies/src/loaders.ts, import claims and add a loader alongside your others:

import { claims } from "./data.js";

    // Loads the claims for many policies at once, by policy id
    claimsByPolicy: new DataLoader(async (policyIds: readonly string[]) => {
      console.log(`[LOADER] Loading claims for policies ${policyIds.join(", ")}`);

      // One result per policy id: that policy's list of claims
      return policyIds.map((id) => claims.filter((c) => c.policyId === id));
    }),

✏️ Then replace the Part 2 Policy.claims resolver in services/policies/src/resolvers.ts:

    claims: (policy: Policy, _: unknown, contextValue: { loaders: Loaders }) => {
      console.log(`[RESOLVER] Looking up claims for policy ${policy.id}`);
      return contextValue.loaders.claimsByPolicy.load(policy.id);
    },

It’s the same pattern as policiesByPolicyholder: each id maps to a list, so the batch function uses filter.