Skip to content

OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.

10.6 KB
Raw Blame
import { expect, test } from 'bun:test';
import { TRPCError } from '@trpc/server';
import { z } from 'zod';
import { testCoreConfig } from '../../test/config-fixture';
import {
  capturingLogger,
  stubHttpCtx,
  TEST_SESSION,
} from '../../test/rpc-fixtures';
import type { CookieOptions } from '../shared/cookie';
import { createTRPCRouter, makeTrpcContext, procedure } from './base';
import { TRPCForbiddenError } from './errors';
import {
  createTrpcFetchHandler,
  createTrpcOnError,
  type TrpcErrorReport,
} from './handler';

const COOKIE_OPTIONS: CookieOptions = {
  domain: '.openpanel.dev',
  secure: true,
  sameSite: 'lax',
  httpOnly: true,
  path: '/',
};

function report(overrides: Partial<TrpcErrorReport> = {}): TrpcErrorReport {
  return {
    error: new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'boom' }),
    path: 'report.get',
    input: { projectId: 'p1' },
    type: 'query',
    ctx: undefined,
    req: new Request('https://api.openpanel.dev/trpc/report.get', {
      headers: {
        'user-agent': 'op-test/1.0',
        'cf-connecting-ip': '203.0.113.7',
      },
    }),
    ...overrides,
  };
}

test('UNAUTHORIZED on organization.list is dropped', () => {
  const logger = capturingLogger();

  createTrpcOnError(
    logger,
    testCoreConfig().ipHeaders
  )(
    report({
      error: new TRPCError({ code: 'UNAUTHORIZED' }),
      path: 'organization.list',
    })
  );

  expect(logger.lines).toHaveLength(0);
});

test('the drop is scoped to that one path', () => {
  const logger = capturingLogger();

  createTrpcOnError(
    logger,
    testCoreConfig().ipHeaders
  )(
    report({
      error: new TRPCError({ code: 'UNAUTHORIZED' }),
      path: 'organization.get',
    })
  );

  expect(logger.lines).toHaveLength(1);
  expect(logger.lines[0]?.level).toBe('error');
});

test('TOO_MANY_REQUESTS logs at warn as "trpc rate limited"', () => {
  const logger = capturingLogger();

  createTrpcOnError(
    logger,
    testCoreConfig().ipHeaders
  )(report({ error: new TRPCError({ code: 'TOO_MANY_REQUESTS' }) }));

  expect(logger.lines).toHaveLength(1);
  expect(logger.lines[0]?.level).toBe('warn');
  expect(logger.lines[0]?.message).toBe('trpc rate limited');
});

test('everything else logs at error as "trpc error", with the expected fields', () => {
  const logger = capturingLogger();
  const failure = report();

  createTrpcOnError(logger, testCoreConfig().ipHeaders)(failure);

  expect(logger.lines).toHaveLength(1);
  const [line] = logger.lines;
  expect(line?.level).toBe('error');
  expect(line?.message).toBe('trpc error');
  expect(line?.payload).toEqual({
    err: failure.error,
    path: 'report.get',
    input: { projectId: 'p1' },
    type: 'query',
    session: undefined,
    ip: '203.0.113.7',
    ipHeader: 'cf-connecting-ip',
    userAgent: 'op-test/1.0',
  });
});

test('the request logger is preferred and the resolved session is carried', async () => {
  const bootLogger = capturingLogger();
  const { ctx, logger: requestLogger } = stubHttpCtx();
  const trpcCtx = await makeTrpcContext(ctx, new Headers(), {
    cookieOptions: COOKIE_OPTIONS,
  });

  createTrpcOnError(
    bootLogger,
    testCoreConfig().ipHeaders
  )(report({ ctx: trpcCtx }));

  expect(bootLogger.lines).toHaveLength(0);
  expect(requestLogger.lines).toHaveLength(1);
  expect(
    (requestLogger.lines[0]?.payload as { session: unknown }).session
  ).toEqual(TEST_SESSION);
});

test('a ctx-less failure (createContext threw) logs through the boot logger', () => {
  const bootLogger = capturingLogger();

  expect(() =>
    createTrpcOnError(
      bootLogger,
      testCoreConfig().ipHeaders
    )(report({ ctx: undefined }))
  ).not.toThrow();

  expect(bootLogger.lines).toHaveLength(1);
  expect(bootLogger.lines[0]?.message).toBe('trpc error');
});

test('an untrusted forwarded ip is ignored', () => {
  const logger = capturingLogger();

  createTrpcOnError(
    logger,
    testCoreConfig().ipHeaders
  )(
    report({
      req: new Request('https://api.openpanel.dev/trpc/report.get', {
        headers: { 'x-client-ip': '198.51.100.9' },
      }),
    })
  );

  const payload = logger.lines[0]?.payload as { ip: string; ipHeader: string };
  expect(payload.ip).toBe('');
  expect(payload.ipHeader).toBe('');
});

const router = createTRPCRouter({
  ping: procedure.query(() => ({ pong: true })),
  signIn: procedure
    .input(z.object({ email: z.email() }))
    .mutation(({ ctx, input }) => {
      ctx.setCookie('session', `token-for-${input.email}`, { maxAge: 600 });
      return { ok: true };
    }),
  forbidden: procedure.query(() => {
    throw new TRPCForbiddenError('nope');
  }),
});

function mount() {
  // One logger for both channels: which of the two a line took is asserted by
  // the onError tests above, not here.
  const logger = capturingLogger();
  const { ctx } = stubHttpCtx({ logger });
  const handler = createTrpcFetchHandler({
    router,
    logger,
    cookieOptions: COOKIE_OPTIONS,
    ipHeaders: testCoreConfig().ipHeaders,
  });
  return { logger, call: (request: Request) => handler(request, ctx) };
}

test('a query resolves through the superjson envelope', async () => {
  const response = await mount().call(
    new Request('https://api.openpanel.dev/trpc/ping')
  );

  expect(response.status).toBe(200);
  expect(await response.json()).toEqual({
    result: { data: { json: { pong: true } } },
  });
});

test('Set-Cookie survives the raw Response the handler returns', async () => {
  const response = await mount().call(
    new Request('https://api.openpanel.dev/trpc/signIn', {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ json: { email: '[email protected]' } }),
    })
  );

  expect(response.status).toBe(200);
  expect(response.headers.get('set-cookie')).toBe(
    'session=token-for-carl%40openpanel.dev; Max-Age=600; Domain=.openpanel.dev; Path=/; HttpOnly; Secure; SameSite=Lax'
  );
});

test('a ZodError is flattened onto data.zodError', async () => {
  const response = await mount().call(
    new Request('https://api.openpanel.dev/trpc/signIn', {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ json: { email: 'not-an-email' } }),
    })
  );

  expect(response.status).toBe(400);
  const body = (await response.json()) as {
    error: {
      json: { data: { code: string; zodError: { fieldErrors: unknown } } };
    };
  };
  expect(body.error.json.data.code).toBe('BAD_REQUEST');
  expect(body.error.json.data.zodError.fieldErrors).toEqual({
    email: ['Invalid email address'],
  });
});

test('a TRPCForbiddenError is a 403 with a null zodError', async () => {
  const response = await mount().call(
    new Request('https://api.openpanel.dev/trpc/forbidden')
  );

  expect(response.status).toBe(403);
  const body = (await response.json()) as {
    error: {
      json: { message: string; data: { code: string; zodError: null } };
    };
  };
  expect(body.error.json.message).toBe('nope');
  expect(body.error.json.data.code).toBe('FORBIDDEN');
  expect(body.error.json.data.zodError).toBeNull();
});

test('an unknown procedure is a 404 and is logged', async () => {
  const mounted = mount();
  const response = await mounted.call(
    new Request('https://api.openpanel.dev/trpc/nope.nope')
  );

  expect(response.status).toBe(404);
  expect(mounted.logger.lines[0]?.message).toBe('trpc error');
});

// The client does not batch today; this guards the `.all('/trpc/*')` wildcard
// against a future httpBatchLink, whose path segment carries commas.
test('a batched request resolves every procedure in the segment', async () => {
  const response = await mount().call(
    new Request('https://api.openpanel.dev/trpc/ping,ping?batch=1&input={}')
  );

  expect(response.status).toBe(200);
  expect(await response.json()).toEqual([
    { result: { data: { json: { pong: true } } } },
    { result: { data: { json: { pong: true } } } },
  ]);
});

const SHORT_DEADLINE_MS = 20;
const NEVER_FINISHES_MS = 60_000;

const slowRouter = createTRPCRouter({
  // Ignores every signal, so only the cancellation race can answer it.
  stuck: procedure.query(
    () =>
      new Promise((resolve) => {
        setTimeout(resolve, NEVER_FINISHES_MS).unref();
      })
  ),
});

function mountCancellable() {
  const logger = capturingLogger();
  const cancellation = new AbortController();
  const { ctx } = stubHttpCtx({ logger, cancellation });
  const handler = createTrpcFetchHandler({
    router: slowRouter,
    logger,
    cookieOptions: COOKIE_OPTIONS,
    ipHeaders: testCoreConfig().ipHeaders,
    deadlineMs: SHORT_DEADLINE_MS,
  });
  return {
    logger,
    cancellation,
    call: () =>
      handler(new Request('https://api.openpanel.dev/trpc/stuck'), ctx),
  };
}

interface ErrorBody {
  error: {
    json: { message: string; data: { code: string; httpStatus: number } };
  };
}

test('a call past the deadline is answered with an explained TIMEOUT, sent as 504', async () => {
  const mounted = mountCancellable();

  const response = await mounted.call();

  expect(response.status).toBe(504);
  const body = (await response.json()) as ErrorBody;
  expect(body.error.json.data.code).toBe('TIMEOUT');
  // The dashboard reads this to decide against retrying.
  expect(body.error.json.data.httpStatus).toBe(408);
  expect(body.error.json.message).toContain('took longer than 0.02 seconds');
  expect(mounted.cancellation.signal.aborted).toBe(true);
  expect(mounted.logger.lines[0]?.level).toBe('error');
});

test('a client disconnect stops the call and is logged as abandoned', async () => {
  const mounted = mountCancellable();

  const pending = mounted.call();
  mounted.cancellation.abort(new DOMException('gone', 'AbortError'));
  const response = await pending;

  expect(response.status).toBe(499);
  const body = (await response.json()) as ErrorBody;
  expect(body.error.json.data.code).toBe('CLIENT_CLOSED_REQUEST');
  expect(mounted.logger.lines[0]?.level).toBe('warn');
  expect(mounted.logger.lines[0]?.message).toBe('trpc request abandoned');
});

test('a call that finishes in time disarms the deadline', async () => {
  const logger = capturingLogger();
  const cancellation = new AbortController();
  const { ctx } = stubHttpCtx({ logger, cancellation });
  const handler = createTrpcFetchHandler({
    router,
    logger,
    cookieOptions: COOKIE_OPTIONS,
    ipHeaders: testCoreConfig().ipHeaders,
    deadlineMs: SHORT_DEADLINE_MS,
  });

  const response = await handler(
    new Request('https://api.openpanel.dev/trpc/ping'),
    ctx
  );
  await new Promise((resolve) => setTimeout(resolve, SHORT_DEADLINE_MS * 2));

  expect(response.status).toBe(200);
  expect(cancellation.signal.aborted).toBe(false);
});