Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/config/src/api.test.ts
T
2026-07-08 16:15:37 +02:00

369 lines
13 KiB
TypeScript

import { describe, expect, test } from "vitest";
import { ApiConfigError, loadApiConfig, loadRequiredApiConfig } from "./index.js";
const REQUIRED_PRODUCTION_ENV = {
APP_NAME: "Production API",
DATABASE_URL: "postgres://example.invalid/app",
APP_BASE_DOMAIN: "example.com",
WEB_APP_HOST: "app.example.com",
ADMIN_APP_HOST: "admin.example.com",
API_HOST: "api.example.com",
SESSION_SECRET: "session-secret-value",
CRYPTO_SECRET: "crypto-secret-value",
API_ACCESS_TOKEN: "api-access-token-value",
JWT_SECRET: "jwt-secret-value",
ANALYTICS_TOKEN: "analytics-token-value",
};
describe("loadRequiredApiConfig", () => {
test("returns production API config when required values are valid", () => {
const config = loadRequiredApiConfig(
{
...REQUIRED_PRODUCTION_ENV,
API_PORT: "8081",
APP_PROTOCOL: "https",
},
{ nodeEnv: "production" }
);
expect(config).toMatchObject({
appName: "Production API",
nodeEnv: "production",
listen: { port: 8081 },
routing: {
appBaseDomain: "example.com",
apiHost: "api.example.com",
protocol: "https",
},
apiAccessToken: "api-access-token-value",
jwtSecret: "jwt-secret-value",
});
});
test("throws redacted ApiConfigError for missing required API_ACCESS_TOKEN", () => {
const secretValues = ["session-secret-value", "crypto-secret-value", "jwt-secret-value", "analytics-token-value"];
expect(() =>
loadRequiredApiConfig(
{
...REQUIRED_PRODUCTION_ENV,
API_ACCESS_TOKEN: undefined,
},
{ nodeEnv: "production" }
)
).toThrow(ApiConfigError);
try {
loadRequiredApiConfig(
{
...REQUIRED_PRODUCTION_ENV,
API_ACCESS_TOKEN: undefined,
},
{ nodeEnv: "production" }
);
} catch (error) {
expect(error).toBeInstanceOf(ApiConfigError);
const apiConfigError = error as ApiConfigError;
expect(apiConfigError.message).toBe("Invalid API configuration (API_ACCESS_TOKEN:missing-required).");
expect(apiConfigError.diagnostics).toContainEqual(
expect.objectContaining({
code: "missing-required",
name: "API_ACCESS_TOKEN",
classification: "required-per-app",
})
);
const errorText = JSON.stringify({ message: apiConfigError.message, details: apiConfigError.details });
for (const secretValue of secretValues) {
expect(errorText).not.toContain(secretValue);
}
}
});
test("throws redacted ApiConfigError for invalid API_PORT", () => {
const invalidPort = "secret-like-invalid-port-value";
const secretValues = ["session-secret-value", "crypto-secret-value", "api-access-token-value", "jwt-secret-value", "analytics-token-value"];
try {
loadRequiredApiConfig(
{
...REQUIRED_PRODUCTION_ENV,
API_PORT: invalidPort,
},
{ nodeEnv: "production" }
);
} catch (error) {
expect(error).toBeInstanceOf(ApiConfigError);
const apiConfigError = error as ApiConfigError;
expect(apiConfigError.message).toBe("Invalid API configuration (API_PORT:invalid-port).");
expect(apiConfigError.details.diagnostics).toEqual([
expect.objectContaining({
code: "invalid-port",
name: "API_PORT",
}),
]);
const errorText = JSON.stringify({ message: apiConfigError.message, details: apiConfigError.details });
expect(errorText).not.toContain(invalidPort);
for (const secretValue of secretValues) {
expect(errorText).not.toContain(secretValue);
}
}
});
test("preserves default development failure behavior by throwing diagnostics", () => {
expect(() => loadRequiredApiConfig({})).toThrow(ApiConfigError);
});
});
describe("loadApiConfig", () => {
test("returns local defaults and API listen defaults", () => {
const result = loadApiConfig({});
expect(result.ok).toBe(false);
expect(result.config).toMatchObject({
appName: "HiveGrid",
nodeEnv: "development",
listen: {
port: 3001,
},
routing: {
appBaseDomain: "localhost",
webAppHost: "app.localhost",
adminAppHost: "admin.localhost",
apiHost: "api.localhost",
protocol: "http",
},
origins: {},
analytics: {},
mailjet: {},
storage: {},
});
});
test("reports missing production requirements including analytics token with redacted diagnostics", () => {
const result = loadApiConfig(
{
...REQUIRED_PRODUCTION_ENV,
API_ACCESS_TOKEN: undefined,
ANALYTICS_TOKEN: undefined,
},
{ nodeEnv: "production" }
);
expect(result.ok).toBe(false);
expect(result.diagnostics).toEqual(
expect.arrayContaining([
expect.objectContaining({ code: "missing-required", name: "API_ACCESS_TOKEN", classification: "required-per-app" }),
expect.objectContaining({ code: "missing-required", name: "ANALYTICS_TOKEN", classification: "required-per-app" }),
])
);
expect(JSON.stringify(result.diagnostics)).not.toContain("api-access-token-value");
expect(JSON.stringify(result.diagnostics)).not.toContain("analytics-token-value");
});
test("prefers API_PORT over PORT and falls back to PORT when API_PORT is empty", () => {
expect(loadApiConfig({ API_PORT: "4001", PORT: "4000" }).config.listen.port).toBe(4001);
expect(loadApiConfig({ API_PORT: " ", PORT: "4000" }).config.listen.port).toBe(4000);
expect(loadApiConfig({ PORT: "4000" }).config.listen.port).toBe(4000);
});
test("falls back for invalid API_PORT without leaking configured secrets", () => {
const secretValues = ["api-access-token-value", "jwt-secret-value", "analytics-token-value"];
const result = loadApiConfig({
API_ACCESS_TOKEN: secretValues[0],
JWT_SECRET: secretValues[1],
ANALYTICS_TOKEN: secretValues[2],
API_PORT: "not-a-port",
PORT: "4000",
});
expect(result.ok).toBe(false);
expect(result.config.listen.port).toBe(3001);
expect(result.diagnostics).toContainEqual(
expect.objectContaining({
code: "invalid-port",
name: "API_PORT",
})
);
const diagnosticText = JSON.stringify(result.diagnostics);
for (const secretValue of secretValues) {
expect(diagnosticText).not.toContain(secretValue);
}
});
test("normalizes provider values and trims empty strings to undefined", () => {
const result = loadApiConfig({
...REQUIRED_PRODUCTION_ENV,
NODE_ENV: "production",
API_PORT: "8081",
APP_PROTOCOL: "https",
WEB_ORIGIN: " ",
ADMIN_ORIGIN: "\t",
API_ACCESS_TOKEN: " api-access-token-value ",
JWT_SECRET: " jwt-secret-value ",
ANALYTICS_TOKEN: " analytics-token-value ",
MAILJET_WEBHOOK_SECRET: " mailjet-webhook-secret-value ",
LAGO_API_URL: " http://lago.internal:3000 ",
LAGO_API_KEY: " lago-api-key-value ",
LAGO_WEBHOOK_SECRET: " lago-webhook-secret-value ",
LAGO_TIMEOUT_MS: " 5000 ",
MOLLIE_API_KEY: " mollie-api-key-value ",
MOLLIE_PROFILE_ID: " mollie-profile-id-value ",
MOLLIE_TIMEOUT_MS: " 6000 ",
STORAGE_ENDPOINT: " https://storage.example.com ",
STORAGE_REGION: " us-east-1 ",
STORAGE_BUCKET: " uploads ",
STORAGE_ACCESS_KEY_ID: " storage-access-key-id-value ",
STORAGE_SECRET_ACCESS_KEY: " storage-secret-access-key-value ",
STORAGE_SESSION_TOKEN: " storage-session-token-value ",
STORAGE_PUBLIC_BASE_URL: " https://cdn.example.com/files ",
STORAGE_FORCE_PATH_STYLE: " true ",
});
expect(result.ok).toBe(true);
expect(result.diagnostics).toEqual([]);
expect(result.config).toMatchObject({
appName: "Production API",
nodeEnv: "production",
listen: { port: 8081 },
routing: {
appBaseDomain: "example.com",
webAppHost: "app.example.com",
adminAppHost: "admin.example.com",
apiHost: "api.example.com",
protocol: "https",
},
origins: {},
apiAccessToken: "api-access-token-value",
jwtSecret: "jwt-secret-value",
analytics: {
token: "analytics-token-value",
},
mailjet: {
webhookSecret: "mailjet-webhook-secret-value",
},
lago: {
apiUrl: "http://lago.internal:3000",
apiKey: "lago-api-key-value",
webhookSecret: "lago-webhook-secret-value",
timeoutMs: 5000,
},
mollie: {
apiKey: "mollie-api-key-value",
profileId: "mollie-profile-id-value",
timeoutMs: 6000,
},
storage: {
endpoint: "https://storage.example.com",
region: "us-east-1",
bucket: "uploads",
accessKeyId: "storage-access-key-id-value",
secretAccessKey: "storage-secret-access-key-value",
sessionToken: "storage-session-token-value",
publicBaseUrl: "https://cdn.example.com/files",
forcePathStyle: "true",
},
apiKeys: {
allowLegacyPlaintextFallback: false,
},
});
});
test("parses API key legacy plaintext fallback cutover flag", () => {
expect(loadApiConfig({}).config.apiKeys.allowLegacyPlaintextFallback).toBe(false);
expect(loadApiConfig({ API_KEY_LEGACY_PLAINTEXT_FALLBACK: "false" }).config.apiKeys.allowLegacyPlaintextFallback).toBe(false);
expect(loadApiConfig({ API_KEY_LEGACY_PLAINTEXT_FALLBACK: "0" }).config.apiKeys.allowLegacyPlaintextFallback).toBe(false);
expect(loadApiConfig({ API_KEY_LEGACY_PLAINTEXT_FALLBACK: "true" }).config.apiKeys.allowLegacyPlaintextFallback).toBe(true);
expect(loadApiConfig({ API_KEY_LEGACY_PLAINTEXT_FALLBACK: "invalid" }).config.apiKeys.allowLegacyPlaintextFallback).toBe(false);
});
test("defaults invalid Lago timeout without leaking Lago secrets into diagnostics", () => {
const result = loadApiConfig({
API_PORT: "not-a-port",
LAGO_API_URL: " https://lago.example.test ",
LAGO_API_KEY: " lago-secret-value ",
LAGO_WEBHOOK_SECRET: " lago-webhook-secret-value ",
LAGO_TIMEOUT_MS: "invalid",
});
expect(result.config.lago).toEqual({
apiUrl: "https://lago.example.test",
apiKey: "lago-secret-value",
webhookSecret: "lago-webhook-secret-value",
timeoutMs: 10_000,
});
const diagnosticText = JSON.stringify(result.diagnostics);
expect(diagnosticText).not.toContain("lago-secret-value");
expect(diagnosticText).not.toContain("lago-webhook-secret-value");
});
test("defaults invalid Mollie timeout without leaking Mollie secrets into diagnostics", () => {
const result = loadApiConfig({
API_PORT: "not-a-port",
MOLLIE_API_KEY: " mollie-secret-value ",
MOLLIE_PROFILE_ID: " mollie-profile-value ",
MOLLIE_TIMEOUT_MS: "invalid",
});
expect(result.config.mollie).toEqual({
apiKey: "mollie-secret-value",
profileId: "mollie-profile-value",
timeoutMs: 10_000,
});
const diagnosticText = JSON.stringify(result.diagnostics);
expect(diagnosticText).not.toContain("mollie-secret-value");
});
test("normalizes empty storage strings to undefined and redacts storage secrets from diagnostics", () => {
const storageSecretValues = ["storage-access-key-id-value", "storage-secret-access-key-value", "storage-session-token-value"];
const result = loadApiConfig({
API_PORT: "not-a-port",
STORAGE_ENDPOINT: " ",
STORAGE_REGION: "\t",
STORAGE_BUCKET: " ",
STORAGE_ACCESS_KEY_ID: ` ${storageSecretValues[0]} `,
STORAGE_SECRET_ACCESS_KEY: ` ${storageSecretValues[1]} `,
STORAGE_SESSION_TOKEN: ` ${storageSecretValues[2]} `,
STORAGE_PUBLIC_BASE_URL: "",
STORAGE_FORCE_PATH_STYLE: " ",
});
expect(result.ok).toBe(false);
expect(result.config.storage).toEqual({
accessKeyId: "storage-access-key-id-value",
secretAccessKey: "storage-secret-access-key-value",
sessionToken: "storage-session-token-value",
});
const diagnosticText = JSON.stringify(result.diagnostics);
for (const secretValue of storageSecretValues) {
expect(diagnosticText).not.toContain(secretValue);
}
});
test("preserves explicit API origins while routing hosts remain host-only", () => {
const result = loadApiConfig({
...REQUIRED_PRODUCTION_ENV,
NODE_ENV: "production",
APP_PROTOCOL: "https",
WEB_ORIGIN: " https://app.example.com ",
ADMIN_ORIGIN: " https://admin.example.com ",
WEB_APP_HOST: "web-routing.example.com",
ADMIN_APP_HOST: "admin-routing.example.com",
});
expect(result.ok).toBe(true);
expect(result.diagnostics).toEqual([]);
expect(result.config).toMatchObject({
routing: {
webAppHost: "web-routing.example.com",
adminAppHost: "admin-routing.example.com",
},
origins: {
web: "https://app.example.com",
admin: "https://admin.example.com",
},
});
});
});