sailfork / t3code-github / packages/ shared/ src/ relayJwt.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import { describe, expect, it } from "@effect/vitest";
import * as Clock from "effect/Clock";
import * as Effect from "effect/Effect";
import * as Jwk from "effect/jose/Jwk";
import * as Jws from "effect/jose/Jws";
import * as Redacted from "effect/Redacted";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";

import { decodeRelayJwt, RelayJwtError, signRelayJwt, verifyRelayJwt } from "./relayJwt.ts";

const Claims = Schema.Struct({ sub: Schema.String });

const keyPair = Effect.gen(function* () {
  const pair = yield* Jwk.generateKeyPair({ algorithm: "EdDSA" });
  const publicKey = yield* Jwk.importPublic(pair.publicKey, "EdDSA").pipe(
    Effect.flatMap((key) => Jwk.exportSpki(key, { format: "pem" })),
  );
  const privateKey = yield* Jwk.importPrivate(pair.privateKey, "EdDSA").pipe(
    Effect.flatMap((key) => Jwk.exportPkcs8(key, { format: "pem" })),
  );
  return { publicKey, privateKey: Redacted.value(privateKey) };
});

describe("relayJwt", () => {
  it.effect("verifies against the ambient clock and reports claim diagnostics", () =>
    Effect.gen(function* () {
      yield* TestClock.setTime(1_000_000);
      const keys = yield* keyPair;
      const token = yield* signRelayJwt({
        privateKey: keys.privateKey,
        typ: "test+jwt",
        payload: { sub: "user", iss: "relay", aud: "env", iat: 1_000, exp: 1_100 },
      });
      const verify = verifyRelayJwt(Claims, {
        publicKey: keys.publicKey,
        token,
        typ: "test+jwt",
        issuer: "relay",
        audience: "env",
      });

      expect(yield* verify).toEqual({ sub: "user" });
      expect((yield* decodeRelayJwt(token)).sub).toBe("user");

      yield* TestClock.adjust("161 seconds");
      const error = yield* Effect.flip(verify);
      expect(RelayJwtError.diagnosticCode(error)).toBe("ClaimValidationFailed.exp.expired");
      expect(error.message).toBe('Failed to verify relay JWT of type "test+jwt".');

      const es256 = yield* Jwk.generateKeyPair({ algorithm: "ES256" });
      const es256Private = yield* Jwk.importPrivate(es256.privateKey, "ES256");
      const signWrong = yield* Effect.flip(
        signRelayJwt({ privateKey: es256Private, typ: "test+jwt", payload: { sub: "user" } }),
      );
      expect(RelayJwtError.diagnosticCode(signWrong)).toBe("AlgorithmNotAllowed");
      const es256Token = yield* Jws.sign(
        new TextEncoder().encode(
          JSON.stringify({
            sub: "user",
            iss: "relay",
            aud: "env",
            iat: Math.floor((yield* Clock.currentTimeMillis) / 1_000),
          }),
        ),
        es256Private,
        { typ: "test+jwt" },
      );
      const verifyWrong = yield* Effect.flip(
        verifyRelayJwt(Claims, {
          publicKey: yield* Jwk.importPublic(es256.publicKey, "ES256"),
          token: Redacted.value(es256Token),
          typ: "test+jwt",
          issuer: "relay",
          audience: "env",
        }),
      );
      expect(RelayJwtError.diagnosticCode(verifyWrong)).toBe("AlgorithmNotAllowed");
    }).pipe(Effect.provide(NodeCrypto.layerSignature)),
  );
});