import { Hono } from "hono"; import type { ApiConfig } from "@hivegrid/config"; import type { LegacyApiKeySimple } from "@hivegrid/db/api-keys.server"; import { SUBSCRIPTION_FEATURE_LIMIT, type TenantApiUsageFeature } from "@hivegrid/db/usage.server"; import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"; import { resetApiRuntimeConfigForTests, setApiRuntimeConfigForTests } from "../config.js"; import type { ApiErrorEnv } from "../middleware/error-envelope.js"; import { getUsageRequest } from "./usage-route.js"; type UsageRouteDependencies = Parameters[1]; const TEST_API_CONFIG: ApiConfig = { appName: "Usage Route Test API", nodeEnv: "test", revision: "unknown", listen: { port: 3001 }, routing: { appBaseDomain: "localhost:3000", webAppHost: "app.localhost:3000", adminAppHost: "admin.localhost:3000", apiHost: "api.localhost:3000", protocol: "http", }, origins: {}, apiAccessToken: "service-secret", jwtSecret: "usage-route-secret", analytics: {}, mailjet: {}, lago: { timeoutMs: 10000 }, mollie: { timeoutMs: 10000 }, apiKeys: { allowLegacyPlaintextFallback: true, }, storage: {}, }; beforeEach(() => { setApiRuntimeConfigForTests(TEST_API_CONFIG); }); afterEach(() => { resetApiRuntimeConfigForTests(); vi.restoreAllMocks(); }); function createApiKeyFixture(patch: Partial = {}): LegacyApiKeySimple { const tenantId = patch.tenantId ?? patch.tenant?.id ?? "tenant_usage_1"; return { id: "api_key_usage_1", alias: "Primary usage key", expires: null, tenantId, createdByUserId: "user_usage_1", active: true, scopes: ["*"], tenant: { id: tenantId, name: "Acme Usage", slug: "acme-usage", deactivatedReason: null }, ...patch, }; } function createUsageFixture(patch: Partial = {}): TenantApiUsageFeature { return { title: "Plan with {0} calls", type: SUBSCRIPTION_FEATURE_LIMIT.monthly, value: 100, used: 10, remaining: 90, enabled: true, message: "", ...patch, }; } function buildDeps(options: { apiKey?: LegacyApiKeySimple | null; usage?: TenantApiUsageFeature; ipLoggingError?: Error } = {}) { const apiKey = options.apiKey === undefined ? createApiKeyFixture() : options.apiKey; const mocks = { findLegacyApiKeyByKey: vi.fn(async () => apiKey), createLegacyApiKeyLog: vi.fn(async (data: { tenantId?: string | null }) => ({ id: "api_key_log_usage_1", tenantId: data.tenantId ?? null })), setLegacyApiKeyLogStatus: vi.fn(async () => ({ count: 1 })), createUniqueLegacyTenantIpAddress: vi.fn(async () => { if (options.ipLoggingError) { throw options.ipLoggingError; } return { id: "tenant_ip_usage_1" }; }), getTenantSubscription: vi.fn(async () => null), getTenantApiUsage: vi.fn(async () => options.usage), }; const dependencies: UsageRouteDependencies = { findLegacyApiKeyByKey: mocks.findLegacyApiKeyByKey as never, createLegacyApiKeyLog: mocks.createLegacyApiKeyLog as never, setLegacyApiKeyLogStatus: mocks.setLegacyApiKeyLogStatus as never, createUniqueLegacyTenantIpAddress: mocks.createUniqueLegacyTenantIpAddress as never, getTenantSubscription: mocks.getTenantSubscription as never, getTenantApiUsage: mocks.getTenantApiUsage as never, }; return { dependencies, mocks }; } function buildApp(dependencies: UsageRouteDependencies) { const app = new Hono(); app.use("*", async (c, next) => { c.set("requestId", "req_usage_route"); await next(); }); app.get("/v1/usage", (c) => getUsageRequest(c, dependencies)); return app; } async function requestUsage(dependencies: UsageRouteDependencies, headers: Record = {}) { return buildApp(dependencies).request("/v1/usage?source=test", { headers }); } describe("getUsageRequest", () => { test("rejects missing API keys and records an unauthenticated usage log", async () => { const { dependencies, mocks } = buildDeps(); const response = await requestUsage(dependencies); expect(response.status).toBe(401); await expect(response.json()).resolves.toEqual({ error: { code: "unauthorized", message: "Valid API key credentials are required.", requestId: "req_usage_route", }, }); expect(mocks.findLegacyApiKeyByKey).not.toHaveBeenCalled(); expect(mocks.createLegacyApiKeyLog).toHaveBeenCalledWith({ tenantId: null, apiKeyId: null, endpoint: "/v1/usage", ip: "", method: "GET", params: "source=test", error: "Invalid API Key", status: 401, }); expect(mocks.setLegacyApiKeyLogStatus).not.toHaveBeenCalled(); }); test("rejects invalid API keys after lookup and records an unauthenticated usage log", async () => { const { dependencies, mocks } = buildDeps({ apiKey: null }); const response = await requestUsage(dependencies, { "x-api-key": "invalid-secret" }); expect(response.status).toBe(401); await expect(response.json()).resolves.toEqual({ error: { code: "unauthorized", message: "Valid API key credentials are required.", requestId: "req_usage_route", }, }); expect(mocks.findLegacyApiKeyByKey).toHaveBeenCalledWith("invalid-secret", undefined, "usage-route-secret", { allowPlaintextFallback: true }); expect(mocks.createLegacyApiKeyLog).toHaveBeenCalledWith( expect.objectContaining({ tenantId: null, apiKeyId: null, endpoint: "/v1/usage", error: "Invalid API Key", status: 401, }), ); expect(mocks.setLegacyApiKeyLogStatus).not.toHaveBeenCalled(); }); test("blocks inactive tenants before usage checks", async () => { const apiKey = createApiKeyFixture({ tenant: { id: "tenant_usage_1", name: "Acme Usage", slug: "acme-usage", deactivatedReason: "billing_past_due" }, }); const { dependencies, mocks } = buildDeps({ apiKey }); const response = await requestUsage(dependencies, { "x-api-key": "tenant-secret" }); expect(response.status).toBe(403); await expect(response.json()).resolves.toEqual({ error: { code: "tenant_inactive", message: "Account is inactive.", requestId: "req_usage_route", }, }); expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith( { id: "api_key_log_usage_1", tenantId: "tenant_usage_1" }, expect.objectContaining({ status: 403, error: "Account is inactive." }), ); expect(mocks.createUniqueLegacyTenantIpAddress).not.toHaveBeenCalled(); expect(mocks.getTenantApiUsage).not.toHaveBeenCalled(); }); test("blocks inactive API keys before usage checks", async () => { const { dependencies, mocks } = buildDeps({ apiKey: createApiKeyFixture({ active: false }) }); const response = await requestUsage(dependencies, { "x-api-key": "inactive-secret" }); expect(response.status).toBe(400); await expect(response.json()).resolves.toEqual({ error: { code: "api_key_inactive", message: "API key is inactive.", requestId: "req_usage_route", }, }); expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith( { id: "api_key_log_usage_1", tenantId: "tenant_usage_1" }, expect.objectContaining({ status: 400, error: "API key is inactive." }), ); expect(mocks.createUniqueLegacyTenantIpAddress).not.toHaveBeenCalled(); expect(mocks.getTenantApiUsage).not.toHaveBeenCalled(); }); test("blocks expired API keys before usage checks", async () => { const { dependencies, mocks } = buildDeps({ apiKey: createApiKeyFixture({ expires: new Date("2020-01-01T00:00:00.000Z") }) }); const response = await requestUsage(dependencies, { "x-api-key": "expired-secret" }); expect(response.status).toBe(400); await expect(response.json()).resolves.toEqual({ error: { code: "api_key_expired", message: "API key is expired.", requestId: "req_usage_route", }, }); expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith( { id: "api_key_log_usage_1", tenantId: "tenant_usage_1" }, expect.objectContaining({ status: 400, error: "API key is expired." }), ); expect(mocks.createUniqueLegacyTenantIpAddress).not.toHaveBeenCalled(); expect(mocks.getTenantApiUsage).not.toHaveBeenCalled(); }); test("swallows IP logging failures and still returns usage", async () => { const { dependencies, mocks } = buildDeps({ ipLoggingError: new Error("ip write failed") }); const response = await requestUsage(dependencies, { "x-api-key": "valid-secret", "cf-connecting-ip": "203.0.113.10" }); expect(response.status).toBe(200); await expect(response.json()).resolves.toEqual({ plan: "" }); expect(mocks.createUniqueLegacyTenantIpAddress).toHaveBeenCalledWith({ ip: "203.0.113.10", fromUrl: "/v1/usage", tenantId: "tenant_usage_1", apiKeyId: "api_key_usage_1", }); expect(mocks.getTenantSubscription).toHaveBeenCalledWith("tenant_usage_1"); expect(mocks.getTenantApiUsage).toHaveBeenCalledWith("tenant_usage_1", null); expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith( { id: "api_key_log_usage_1", tenantId: "tenant_usage_1" }, expect.objectContaining({ status: 200 }), ); }); test("returns payment required when API usage is disabled or exhausted", async () => { const usage = createUsageFixture({ enabled: false, remaining: 0, message: "Usage exhausted." }); const { dependencies, mocks } = buildDeps({ usage }); const response = await requestUsage(dependencies, { "x-api-key": "valid-secret" }); expect(response.status).toBe(402); await expect(response.json()).resolves.toEqual({ error: { code: "payment_required", message: "API usage is disabled or exhausted.", requestId: "req_usage_route", }, }); expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith( { id: "api_key_log_usage_1", tenantId: "tenant_usage_1" }, expect.objectContaining({ status: 402, error: "API usage is disabled or exhausted." }), ); }); test("omits remaining for included-plan usage", async () => { const usage = createUsageFixture({ title: "Included plan with {0} calls", type: SUBSCRIPTION_FEATURE_LIMIT.included, value: 25, remaining: 25, }); const { dependencies, mocks } = buildDeps({ usage }); const response = await requestUsage(dependencies, { "x-api-key": "valid-secret" }); const body = await response.json(); expect(response.status).toBe(200); expect(body).toEqual({ plan: "Included plan with 25 calls" }); expect(body).not.toHaveProperty("remaining"); expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith( { id: "api_key_log_usage_1", tenantId: "tenant_usage_1" }, expect.objectContaining({ status: 200 }), ); }); });