160 lines
5.5 KiB
TypeScript
160 lines
5.5 KiB
TypeScript
import { envVariableDefinitions } from "./catalog.js";
|
|
export { getDomainRoutingConfig, hostMatches, normalizeHost, normalizeHostForProtocol } from "./routing.js";
|
|
export { ApiConfigError, loadApiConfig, loadRequiredApiConfig } from "./api.js";
|
|
export { WebConfigError, loadRequiredWebConfig, loadWebConfig } from "./web.js";
|
|
export { normalizeGdprExportSseCKey, PORTAL_GDPR_EXPORT_MAX_BYTES, PRIVACY_GDPR_EXPORT_MAX_BYTES, requireGdprExportSseCKey } from "./gdpr-export-storage.js";
|
|
export { resolveApiSessionCookiePolicy, resolveHostOnlyCookiePolicy, resolveSessionCookiePolicy, resolveWebSessionCookiePolicy } from "./session-cookie.js";
|
|
export type { ResolveHostOnlyCookiePolicyOptions, ResolveWebSessionCookiePolicyOptions, WebSessionCookieSurface } from "./session-cookie.js";
|
|
export { WorkerConfigError, loadRequiredWorkerConfig, loadWorkerConfig } from "./worker.js";
|
|
export { resolvePluginLifecycleRuntimeEnv } from "./plugin-lifecycle.js";
|
|
export { resolveKwpRuntimeEnv } from "./kwp.js";
|
|
export { resolveSharedRedisUrl } from "./shared-redis.js";
|
|
export { validateBooleanFlag, validateOptionalSecretString, validateOptionalSecretUrl, validateRequiredSecretString } from "./secret-validator.js";
|
|
import type { EnvClassification, EnvRecord, EnvValidationOptions, EnvValidationResult, EnvVariableDefinition, RuntimeTarget } from "./types.js";
|
|
export type { DomainRoutingConfig, DomainRoutingEnv } from "./routing.js";
|
|
export type { PluginLifecycleRuntimeEnv } from "./plugin-lifecycle.js";
|
|
export type { KwpRuntimeEnv } from "./kwp.js";
|
|
export type { ResolveApiSessionCookiePolicyOptions, ResolveSessionCookiePolicyOptions, SessionCookiePolicy, SessionCookieSameSite } from "./session-cookie.js";
|
|
|
|
const definitions: readonly EnvVariableDefinition[] = envVariableDefinitions;
|
|
|
|
export { envVariableDefinitions } from "./catalog.js";
|
|
export type {
|
|
ApiConfig,
|
|
ApiConfigAnalytics,
|
|
ApiConfigDiagnostic,
|
|
ApiConfigDiagnosticCode,
|
|
ApiConfigErrorDetails,
|
|
ApiConfigLago,
|
|
ApiConfigListen,
|
|
ApiConfigMailjet,
|
|
ApiConfigMollie,
|
|
ApiConfigOptions,
|
|
ApiConfigOrigins,
|
|
ApiConfigResult,
|
|
ApiConfigStorage,
|
|
RequiredApiConfigOptions,
|
|
WorkerConfig,
|
|
WorkerConfigDiagnostic,
|
|
WorkerConfigDiagnosticCode,
|
|
WorkerConfigOptions,
|
|
WorkerConfigQueues,
|
|
WorkerConfigRedis,
|
|
WorkerConfigRedisParseStatus,
|
|
WorkerConfigRedisSource,
|
|
WorkerConfigResult,
|
|
RequiredWorkerConfigOptions,
|
|
RequiredWebConfigOptions,
|
|
WebConfig,
|
|
WebConfigDiagnostic,
|
|
WebConfigDiagnosticCode,
|
|
WebConfigErrorDetails,
|
|
WebConfigListen,
|
|
WebConfigOptions,
|
|
WebConfigResult,
|
|
WebConfigRouting,
|
|
WebConfigStorage,
|
|
WebRuntimeSurface,
|
|
EnvAuditSource,
|
|
EnvClassification,
|
|
EnvRecord,
|
|
EnvValidationIssue,
|
|
EnvValidationOptions,
|
|
EnvValidationResult,
|
|
EnvValueKind,
|
|
SecretUrlValidationOptions,
|
|
SecretValidationDiagnostic,
|
|
SecretValidationDiagnosticCode,
|
|
SecretValidationResult,
|
|
EnvVariableDefinition,
|
|
RuntimeTarget,
|
|
} from "./types.js";
|
|
|
|
export function listEnvVariables(options: { classification?: EnvClassification; target?: RuntimeTarget } = {}) {
|
|
return definitions.filter((definition) => {
|
|
if (options.classification && definition.classification !== options.classification) {
|
|
return false;
|
|
}
|
|
if (options.target && !definition.targets.includes(options.target)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
export function getEnvVariableDefinition(name: string): EnvVariableDefinition | undefined {
|
|
return definitions.find((definition) => {
|
|
if (definition.name === name) {
|
|
return true;
|
|
}
|
|
return definition.dynamicPrefix ? name.startsWith(definition.dynamicPrefix) : false;
|
|
});
|
|
}
|
|
|
|
export function groupEnvVariablesByClassification() {
|
|
return definitions.reduce<Record<EnvClassification, EnvVariableDefinition[]>>(
|
|
(groups, definition) => {
|
|
groups[definition.classification].push(definition);
|
|
return groups;
|
|
},
|
|
{
|
|
"required-core": [],
|
|
"required-per-app": [],
|
|
"optional-provider": [],
|
|
"local-development-only": [],
|
|
"production-only": [],
|
|
"deprecated-remove": [],
|
|
}
|
|
);
|
|
}
|
|
|
|
export function getRequiredEnvVariableNames(options: EnvValidationOptions = {}) {
|
|
const target = options.target ?? "web";
|
|
const nodeEnv = options.nodeEnv ?? "development";
|
|
const required = new Set(options.extraRequired ?? []);
|
|
|
|
for (const definition of definitions) {
|
|
if (!definition.targets.includes(target) && !definition.targets.includes("shared")) {
|
|
continue;
|
|
}
|
|
|
|
if (
|
|
(definition.classification === "required-core" || definition.classification === "required-per-app") &&
|
|
!(nodeEnv !== "production" && definition.defaultValue)
|
|
) {
|
|
required.add(definition.name);
|
|
continue;
|
|
}
|
|
|
|
if (nodeEnv === "production" && (definition.requiredInProduction || definition.requiredInProductionTargets?.includes(target))) {
|
|
required.add(definition.name);
|
|
continue;
|
|
}
|
|
|
|
if (options.includeOptionalProviders && definition.classification === "optional-provider") {
|
|
required.add(definition.name);
|
|
}
|
|
}
|
|
|
|
return [...required].sort();
|
|
}
|
|
|
|
export function validateEnv(input: EnvRecord, options: EnvValidationOptions = {}): EnvValidationResult {
|
|
const missing = getRequiredEnvVariableNames(options)
|
|
.filter((name) => !name.includes("*"))
|
|
.filter((name) => !input[name])
|
|
.map((name) => {
|
|
const definition = getEnvVariableDefinition(name);
|
|
return {
|
|
name,
|
|
classification: definition?.classification,
|
|
message: `${name} is required${options.target ? ` for ${options.target}` : ""}.`,
|
|
};
|
|
});
|
|
|
|
return {
|
|
ok: missing.length === 0,
|
|
missing,
|
|
};
|
|
}
|