Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/config/src/index.ts
T

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,
};
}