OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.
import { expect, test } from 'bun:test';
import { TRPCError } from '@trpc/server';
import { z } from 'zod';
import { testCoreConfig } from '../../test/config-fixture';
import { stubHttpCtx, TEST_SESSION } from '../../test/rpc-fixtures';
import type { CookieOptions } from '../shared/cookie';
import { BadRequestError } from '../shared/errors';
import * as baseModule from './base';
import {
createRateLimitMiddleware,
createTRPCRouter,
makeTrpcContext,
procedure,
} from './base';
import { createTrpcFetchHandler } from './handler';
const COOKIE_OPTIONS: CookieOptions = {
domain: '.openpanel.dev',
secure: true,
sameSite: 'lax',
httpOnly: true,
path: '/',
};
function build(options: Partial<Parameters<typeof makeTrpcContext>[2]> = {}) {
const { ctx, logger } = stubHttpCtx();
const resHeaders = new Headers();
return {
resHeaders,
logger,
trpcCtx: makeTrpcContext(ctx, resHeaders, {
cookieOptions: COOKIE_OPTIONS,
...options,
}),
};
}
test('setCookie writes through resHeaders with the documented option precedence', async () => {
const { trpcCtx, resHeaders } = build();
// Only maxAge and signed are caller-controlled; the rest is ignored.
(await trpcCtx).setCookie('session', 'the-token', {
maxAge: 600,
domain: 'evil.example',
path: '/hijack',
secure: false,
sameSite: 'none',
httpOnly: false,
});
expect(resHeaders.get('set-cookie')).toBe(
'session=the-token; Max-Age=600; Domain=.openpanel.dev; Path=/; HttpOnly; Secure; SameSite=Lax'
);
});
test('maxAge 0 survives (deleteSessionTokenCookie)', async () => {
const { trpcCtx, resHeaders } = build();
(await trpcCtx).setCookie('session', '', { maxAge: 0 });
expect(resHeaders.get('set-cookie')).toBe(
'session=; Max-Age=0; Domain=.openpanel.dev; Path=/; HttpOnly; Secure; SameSite=Lax'
);
});
test('cookies append rather than overwrite', async () => {
const { trpcCtx, resHeaders } = build();
const ctx = await trpcCtx;
ctx.setCookie('gsc_oauth_state', 'a', { maxAge: 600 });
ctx.setCookie('gsc_code_verifier', 'b', { maxAge: 600 });
ctx.setCookie('gsc_project_id', 'c', { maxAge: 600 });
const all = resHeaders.getSetCookie();
expect(all).toHaveLength(3);
expect(all.map((line) => line.split('=')[0])).toEqual([
'gsc_oauth_state',
'gsc_code_verifier',
'gsc_project_id',
]);
});
test('values are url-encoded', async () => {
const { trpcCtx, resHeaders } = build();
(await trpcCtx).setCookie('last-auth-provider', 'a b;c');
expect(resHeaders.get('set-cookie')).toStartWith(
'last-auth-provider=a%20b%3Bc;'
);
});
test('signed cookies use the injected signer and emit no extra attribute', async () => {
const { trpcCtx, resHeaders } = build({
signCookie: (value) => `${value}.sig`,
});
(await trpcCtx).setCookie('gsc_oauth_state', 'state', {
maxAge: 600,
signed: true,
});
const header = resHeaders.get('set-cookie') ?? '';
expect(header).toStartWith('gsc_oauth_state=state.sig;');
expect(header.toLowerCase()).not.toContain('signed');
});
test('a signed cookie with no signer throws instead of going out unsigned', async () => {
const { trpcCtx, resHeaders } = build();
const ctx = await trpcCtx;
expect(() =>
ctx.setCookie('gsc_oauth_state', 'state', { signed: true })
).toThrow(/signCookie/);
expect(resHeaders.getSetCookie()).toHaveLength(0);
});
// The session is resolved eagerly because every procedure reads `ctx.session`
// as a plain value and `onError` logs it without awaiting.
test('the session is resolved once, before any procedure runs', async () => {
const stub = stubHttpCtx();
expect(stub.sessionCalls).toBe(0);
const ctx = await makeTrpcContext(stub.ctx, new Headers(), {
cookieOptions: COOKIE_OPTIONS,
});
expect(stub.sessionCalls).toBe(1);
expect(ctx.session).toEqual(TEST_SESSION);
});
// tRPC merges middleware context with a spread, which copies own enumerable
// properties ONLY: a prototype-chained context would lose every inherited
// field the first time a middleware called `next({ ctx })`.
test('the HttpCtx is flattened onto own properties, and services stay lazy', async () => {
const { ctx } = stubHttpCtx();
const trpcCtx = await makeTrpcContext(ctx, new Headers(), {
cookieOptions: COOKIE_OPTIONS,
});
expect(trpcCtx.requestId).toBe(ctx.requestId);
expect(trpcCtx.logger).toBe(ctx.logger);
expect(Object.hasOwn(trpcCtx, 'logger')).toBe(true);
expect(Object.hasOwn(trpcCtx, 'db')).toBe(true);
expect(Object.hasOwn(trpcCtx, 'queues')).toBe(true);
// `services` is copied as a DESCRIPTOR, not read, so the container is still
// built on first access rather than by the context builder.
expect(
Object.getOwnPropertyDescriptor(trpcCtx, 'services')?.get
).toBeDefined();
});
test('a middleware spread of the context keeps every field', async () => {
const { ctx } = stubHttpCtx();
const trpcCtx = await makeTrpcContext(ctx, new Headers(), {
cookieOptions: COOKIE_OPTIONS,
});
// Exactly what tRPC does in `next({ ctx })`.
const merged = { ...trpcCtx, session: trpcCtx.session };
expect(merged.logger).toBe(ctx.logger);
expect(merged.requestId).toBe(ctx.requestId);
expect(merged.queues).toBe(trpcCtx.queues);
});
test('simulateLatency delays the context, and is off by default', async () => {
const random = Math.random;
Math.random = () => 1; // -> min(500, 200) = 200ms, deterministically
try {
const withoutStart = performance.now();
await build().trpcCtx;
const withoutMs = performance.now() - withoutStart;
const withStart = performance.now();
await build({ simulateLatency: true }).trpcCtx;
const withMs = performance.now() - withStart;
expect(withoutMs).toBeLessThan(50);
expect(withMs).toBeGreaterThanOrEqual(150);
} finally {
Math.random = random;
}
});
function mountWith(
build: (
base: typeof import('./base')
) => Parameters<typeof createTRPCRouter>[0]
) {
const { ctx, logger } = stubHttpCtx();
const router = createTRPCRouter(build(baseModule));
const handler = createTrpcFetchHandler({
router,
logger,
cookieOptions: COOKIE_OPTIONS,
ipHeaders: testCoreConfig().ipHeaders,
});
return {
logger,
call: (request: Request) => handler(request, ctx),
};
}
const postTo = (path: string) =>
new Request(`https://api.openpanel.dev/trpc/${path}`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{}',
});
function stubCache() {
const store = new Map<string, unknown>();
const reads: string[] = [];
const writes: { key: string; ttl: number; value: unknown }[] = [];
return {
store,
reads,
writes,
cache: {
getJson: (key: string) => {
reads.push(key);
return Promise.resolve((store.get(key) ?? null) as never);
},
setJson: (key: string, expireInSec: number, value: unknown) => {
writes.push({ key, ttl: expireInSec, value });
store.set(key, value);
return Promise.resolve();
},
},
};
}
test('the cache middleware keys on path + raw input and honours the ttl', async () => {
const { cache, reads, writes } = stubCache();
let hits = 0;
const mounted = mountWith(({ procedure: base, createCacheMiddleware }) => ({
overview: base
.use(createCacheMiddleware({ cache, serveFromCache: true })(60))
.input(z.object({ projectId: z.string() }))
.query(() => {
hits++;
return { visitors: 1 };
}),
}));
const url =
'https://api.openpanel.dev/trpc/overview?input=' +
encodeURIComponent(JSON.stringify({ json: { projectId: 'p1' } }));
await mounted.call(new Request(url));
await mounted.call(new Request(url));
expect(hits).toBe(1);
expect(reads[0]).toBe("trpc:overview:{'projectId':'p1'}");
expect(writes).toHaveLength(1);
expect(writes[0]?.ttl).toBe(60);
});
test('the cache is written but not served when serveFromCache is off', async () => {
const { cache, writes } = stubCache();
let hits = 0;
const mounted = mountWith(({ procedure: base, createCacheMiddleware }) => ({
overview: base
.use(createCacheMiddleware({ cache, serveFromCache: false })(60))
.query(() => {
hits++;
return { visitors: 1 };
}),
}));
await mounted.call(new Request('https://api.openpanel.dev/trpc/overview'));
await mounted.call(new Request('https://api.openpanel.dev/trpc/overview'));
expect(hits).toBe(2);
expect(writes).toHaveLength(2);
});
test('a zero ttl bypasses the cache entirely', async () => {
const { cache, reads, writes } = stubCache();
const mounted = mountWith(({ procedure: base, createCacheMiddleware }) => ({
overview: base
.use(createCacheMiddleware({ cache, serveFromCache: true })(() => 0))
.query(() => ({ visitors: 1 })),
}));
await mounted.call(new Request('https://api.openpanel.dev/trpc/overview'));
expect(reads).toHaveLength(0);
expect(writes).toHaveLength(0);
});
test('mutations are never cached', async () => {
const { cache, writes } = stubCache();
const mounted = mountWith(({ procedure: base, createCacheMiddleware }) => ({
save: base
.use(createCacheMiddleware({ cache, serveFromCache: true })(60))
.mutation(() => ({ ok: true })),
}));
await mounted.call(postTo('save'));
expect(writes).toHaveLength(0);
});
test('the rate limit middleware hands the limiter ctx fields, not a request', async () => {
const calls: unknown[] = [];
const { ctx, logger } = stubHttpCtx({
ip: '203.0.113.7',
headers: new Headers({ 'user-agent': 'op-test/1.0' }),
});
const router = createTRPCRouter({
signIn: procedure
.use(
createRateLimitMiddleware(async (args) => {
calls.push(args);
await Promise.resolve();
})({ max: 5, windowMs: 60_000 })
)
.mutation(() => ({ ok: true })),
});
const handler = createTrpcFetchHandler({
router,
logger,
cookieOptions: COOKIE_OPTIONS,
ipHeaders: testCoreConfig().ipHeaders,
});
await handler(postTo('signIn'), ctx);
expect(calls).toHaveLength(1);
expect(calls[0]).toEqual({
headers: ctx.headers,
ip: '203.0.113.7',
ipHeaders: ctx.config.ipHeaders,
logger: ctx.logger,
path: 'signIn',
max: 5,
windowMs: 60_000,
});
});
test('a limiter rejection stops the procedure and surfaces as 429', async () => {
let ran = false;
const { ctx, logger } = stubHttpCtx();
const router = createTRPCRouter({
signIn: procedure
.use(
createRateLimitMiddleware(() =>
Promise.reject(new TRPCError({ code: 'TOO_MANY_REQUESTS' }))
)({ max: 5, windowMs: 60_000 })
)
.mutation(() => {
ran = true;
return { ok: true };
}),
});
const handler = createTrpcFetchHandler({
router,
logger,
cookieOptions: COOKIE_OPTIONS,
ipHeaders: testCoreConfig().ipHeaders,
});
const response = await handler(postTo('signIn'), ctx);
expect(ran).toBe(false);
expect(response.status).toBe(429);
expect(logger.lines[0]?.message).toBe('trpc rate limited');
});
test('a BadRequestError from below the transport answers BAD_REQUEST with its message', async () => {
const { ctx } = stubHttpCtx();
const router = createTRPCRouter({
series: procedure.query(() => {
throw new BadRequestError('Pick a shorter range.');
}),
});
const caller = router.createCaller(
await makeTrpcContext(ctx, new Headers(), { cookieOptions: COOKIE_OPTIONS })
);
await expect(caller.series()).rejects.toMatchObject({
code: 'BAD_REQUEST',
message: 'Pick a shorter range.',
});
});