251 lines
11 KiB
TypeScript
251 lines
11 KiB
TypeScript
export const CUSTOMER_PORTAL_UAT_TENANT_SLUG = "demo-pro-crm" as const;
|
|
export const CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG = "demo-starter-crm" as const;
|
|
export const CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG = "demo-enterprise-crm" as const;
|
|
export const CUSTOMER_PORTAL_UAT_COMMERCIAL_CONFIRMATION = "demo-starter-crm+demo-pro-crm+demo-enterprise-crm" as const;
|
|
export const CUSTOMER_PORTAL_UAT_STANDARD_ORIGIN = "https://staging-portal.hivegrid.de" as const;
|
|
export const CUSTOMER_PORTAL_UAT_ADMIN_EMAIL = "customer-portal-admin-uat@saas-ctrl.com" as const;
|
|
export const CUSTOMER_PORTAL_UAT_CUSTOMER_EMAIL = "customer-portal-uat@saas-ctrl.com" as const;
|
|
export const CUSTOMER_PORTAL_UAT_SUBCONTRACTOR_EMAIL = "customer-portal-subcontractor-uat@saas-ctrl.com" as const;
|
|
export const CUSTOMER_PORTAL_UAT_PROJECT_ID = "rheinmain-shk-v1-project-0001" as const;
|
|
export const CUSTOMER_PORTAL_UAT_FORBIDDEN_PROJECT_ID = "rheinmain-shk-v1-project-0002" as const;
|
|
|
|
export type CustomerPortalUatMode = "plan" | "verify" | "apply";
|
|
export type CustomerPortalUatTarget = "catalog" | "fixture" | "commercial-fixture";
|
|
export type CustomerPortalUatEnvironment = Readonly<Record<string, string | undefined>>;
|
|
|
|
export type CustomerPortalUatDatabaseBinding = {
|
|
readonly databaseUrl: string;
|
|
readonly expectedDatabaseHost: string;
|
|
readonly expectedDatabasePort: string;
|
|
readonly expectedDatabaseName: string;
|
|
readonly operatorUserId: string;
|
|
readonly auditChainSecret: string;
|
|
};
|
|
|
|
export type CustomerPortalCatalogCommand = CustomerPortalUatDatabaseBinding & {
|
|
readonly target: "catalog";
|
|
readonly mode: CustomerPortalUatMode;
|
|
readonly lagoApiUrl: string;
|
|
readonly lagoApiKey: string;
|
|
};
|
|
|
|
export type CustomerPortalFixtureCommand = CustomerPortalUatDatabaseBinding & {
|
|
readonly target: "fixture";
|
|
readonly mode: CustomerPortalUatMode;
|
|
readonly expectedTenantId: string;
|
|
readonly password: string;
|
|
};
|
|
|
|
export type CustomerPortalCommercialFixtureCommand = CustomerPortalUatDatabaseBinding & {
|
|
readonly target: "commercial-fixture";
|
|
readonly mode: CustomerPortalUatMode;
|
|
readonly expectedStarterTenantId: string;
|
|
readonly expectedProTenantId: string;
|
|
readonly expectedEnterpriseTenantId: string;
|
|
readonly password: string;
|
|
};
|
|
|
|
export type CustomerPortalUatCommand = CustomerPortalCatalogCommand | CustomerPortalFixtureCommand | CustomerPortalCommercialFixtureCommand;
|
|
|
|
const modeArguments = new Map<string, CustomerPortalUatMode>([
|
|
["--plan", "plan"],
|
|
["--verify", "verify"],
|
|
["--apply", "apply"],
|
|
]);
|
|
|
|
const forbiddenEnvironmentKeys = new Set(["DIRECT_URL", "MIGRATE_ON_BOOT", "SEED_ON_BOOT"]);
|
|
const allowedStagingLagoApiUrls = new Set(["http://127.0.0.1:3108", "http://10.42.0.4:3108"]);
|
|
|
|
export class CustomerPortalUatError extends Error {
|
|
constructor(message: string) {
|
|
super(message);
|
|
this.name = "CustomerPortalUatError";
|
|
}
|
|
}
|
|
|
|
function requiredEnvironmentValue(env: CustomerPortalUatEnvironment, name: string): string {
|
|
const value = env[name]?.trim();
|
|
if (!value) throw new CustomerPortalUatError(`customer-portal UAT: ${name} is required`);
|
|
return value;
|
|
}
|
|
|
|
function parseSingleValueArgument(argv: readonly string[], name: string): string | undefined {
|
|
const prefix = `${name}=`;
|
|
const values = argv.filter((argument) => argument.startsWith(prefix)).map((argument) => argument.slice(prefix.length));
|
|
if (values.length > 1) throw new CustomerPortalUatError(`customer-portal UAT: ${name} may only be provided once`);
|
|
return values[0];
|
|
}
|
|
|
|
function parseMode(argv: readonly string[]): CustomerPortalUatMode {
|
|
const modes = argv.flatMap((argument) => {
|
|
const mode = modeArguments.get(argument);
|
|
return mode ? [mode] : [];
|
|
});
|
|
if (modes.length > 1) throw new CustomerPortalUatError("customer-portal UAT: provide exactly one mode");
|
|
return modes[0] ?? "plan";
|
|
}
|
|
|
|
function assertKnownArguments(argv: readonly string[]): void {
|
|
for (const argument of argv) {
|
|
if (modeArguments.has(argument) || argument.startsWith("--confirm=")) continue;
|
|
throw new CustomerPortalUatError("customer-portal UAT: unknown argument");
|
|
}
|
|
}
|
|
|
|
function assertOperatorEnvironment(env: CustomerPortalUatEnvironment): void {
|
|
if (env.NODE_ENV?.trim() !== "production") {
|
|
throw new CustomerPortalUatError("customer-portal UAT: NODE_ENV must be production so production audit guarantees stay active");
|
|
}
|
|
if (env.SENTRY_ENVIRONMENT?.trim() !== "staging") {
|
|
throw new CustomerPortalUatError("customer-portal UAT: SENTRY_ENVIRONMENT must be staging");
|
|
}
|
|
if (env.RLS_RUNTIME_MODE?.trim() !== "required") {
|
|
throw new CustomerPortalUatError("customer-portal UAT: RLS_RUNTIME_MODE must be required");
|
|
}
|
|
if (env.DATABASE_RUNTIME_ROLE?.trim() !== "hivegrid_app") {
|
|
throw new CustomerPortalUatError("customer-portal UAT: DATABASE_RUNTIME_ROLE must be hivegrid_app");
|
|
}
|
|
const auditChainSecret = env.AUDIT_CHAIN_SECRET;
|
|
if (!auditChainSecret || Buffer.byteLength(auditChainSecret, "utf8") < 32) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: AUDIT_CHAIN_SECRET must contain the canonical staging audit secret");
|
|
}
|
|
for (const [name, value] of Object.entries(env)) {
|
|
if (!value) continue;
|
|
if (forbiddenEnvironmentKeys.has(name) || name.startsWith("SEED_") || name.startsWith("MIGRATOR_") || name.toUpperCase().startsWith("PG")) {
|
|
throw new CustomerPortalUatError(`customer-portal UAT: forbidden operator environment key ${name}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
export function normalizeCustomerPortalStagingLagoApiUrl(value: string): string {
|
|
let parsed: URL;
|
|
try {
|
|
parsed = new URL(value);
|
|
} catch {
|
|
throw new CustomerPortalUatError("customer-portal UAT: LAGO_API_URL must be the canonical staging endpoint");
|
|
}
|
|
if (parsed.username || parsed.password || parsed.search || parsed.hash || (parsed.pathname !== "" && parsed.pathname !== "/")) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: LAGO_API_URL must be the canonical staging endpoint");
|
|
}
|
|
const normalized = parsed.origin;
|
|
if (!allowedStagingLagoApiUrls.has(normalized)) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: LAGO_API_URL must be the canonical staging endpoint");
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
function requireStagingLagoApiUrl(env: CustomerPortalUatEnvironment): string {
|
|
return normalizeCustomerPortalStagingLagoApiUrl(requiredEnvironmentValue(env, "LAGO_API_URL"));
|
|
}
|
|
|
|
function parseDatabaseBinding(env: CustomerPortalUatEnvironment): CustomerPortalUatDatabaseBinding {
|
|
const databaseUrl = requiredEnvironmentValue(env, "DATABASE_URL");
|
|
const expectedDatabaseHost = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_DATABASE_HOST");
|
|
const expectedDatabasePort = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_DATABASE_PORT");
|
|
const expectedDatabaseName = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_DATABASE");
|
|
const operatorUserId = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_OPERATOR_USER_ID");
|
|
const auditChainSecret = requiredEnvironmentValue(env, "AUDIT_CHAIN_SECRET");
|
|
|
|
let parsed: URL;
|
|
try {
|
|
parsed = new URL(databaseUrl);
|
|
} catch {
|
|
throw new CustomerPortalUatError("customer-portal UAT: DATABASE_URL must be a valid PostgreSQL URL");
|
|
}
|
|
const databaseName = decodeURIComponent(parsed.pathname.replace(/^\//u, ""));
|
|
if (!new Set(["postgres:", "postgresql:"]).has(parsed.protocol)) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: DATABASE_URL must use PostgreSQL");
|
|
}
|
|
if (parsed.username !== "hivegrid_app" || !parsed.password) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: DATABASE_URL must authenticate as hivegrid_app");
|
|
}
|
|
// pg-connection-string treats URI query parameters such as host, user,
|
|
// port, database, service and options as connection-setting overrides.
|
|
// Reject the entire query/fragment surface instead of trying to maintain a
|
|
// partial deny-list that can silently grow behind this staging mutation
|
|
// boundary.
|
|
if (parsed.search || parsed.hash) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: DATABASE_URL must not contain PostgreSQL connection overrides");
|
|
}
|
|
if (parsed.hostname !== expectedDatabaseHost || parsed.port !== expectedDatabasePort || databaseName !== expectedDatabaseName) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: DATABASE_URL does not match the explicit staging database binding");
|
|
}
|
|
|
|
return { databaseUrl, expectedDatabaseHost, expectedDatabasePort, expectedDatabaseName, operatorUserId, auditChainSecret };
|
|
}
|
|
|
|
function assertMutationConfirmation(argv: readonly string[], mode: CustomerPortalUatMode, target: CustomerPortalUatTarget): void {
|
|
const confirmation = parseSingleValueArgument(argv, "--confirm");
|
|
const expectedConfirmation = target === "commercial-fixture" ? CUSTOMER_PORTAL_UAT_COMMERCIAL_CONFIRMATION : CUSTOMER_PORTAL_UAT_TENANT_SLUG;
|
|
if (mode === "apply") {
|
|
if (confirmation !== expectedConfirmation) {
|
|
throw new CustomerPortalUatError(`customer-portal UAT: apply requires --confirm=${expectedConfirmation}`);
|
|
}
|
|
return;
|
|
}
|
|
if (confirmation !== undefined) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: --confirm is valid only with --apply");
|
|
}
|
|
}
|
|
|
|
function requireStrongUatPassword(env: CustomerPortalUatEnvironment): string {
|
|
const password = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_PASSWORD");
|
|
if (password.length < 20 || new Set(password).size < 10 || /^(?:password|passwort|demo|hivegrid)/iu.test(password)) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: CUSTOMER_PORTAL_UAT_PASSWORD must be a strong random secret of at least 20 characters");
|
|
}
|
|
return password;
|
|
}
|
|
|
|
export function parseCustomerPortalUatCommand(
|
|
target: CustomerPortalUatTarget,
|
|
argv: readonly string[],
|
|
env: CustomerPortalUatEnvironment
|
|
): CustomerPortalUatCommand {
|
|
assertKnownArguments(argv);
|
|
const mode = parseMode(argv);
|
|
assertMutationConfirmation(argv, mode, target);
|
|
assertOperatorEnvironment(env);
|
|
const database = parseDatabaseBinding(env);
|
|
|
|
if (target === "catalog") {
|
|
return {
|
|
...database,
|
|
target,
|
|
mode,
|
|
lagoApiUrl: requireStagingLagoApiUrl(env),
|
|
lagoApiKey: requiredEnvironmentValue(env, "LAGO_API_KEY"),
|
|
};
|
|
}
|
|
|
|
if (target === "fixture") {
|
|
return {
|
|
...database,
|
|
target,
|
|
mode,
|
|
expectedTenantId: requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_TENANT_ID"),
|
|
password: requireStrongUatPassword(env),
|
|
};
|
|
}
|
|
|
|
const expectedStarterTenantId = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_STARTER_TENANT_ID");
|
|
const expectedProTenantId = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_PRO_TENANT_ID");
|
|
const expectedEnterpriseTenantId = requiredEnvironmentValue(env, "CUSTOMER_PORTAL_UAT_EXPECTED_ENTERPRISE_TENANT_ID");
|
|
if (new Set([expectedStarterTenantId, expectedProTenantId, expectedEnterpriseTenantId]).size !== 3) {
|
|
throw new CustomerPortalUatError("customer-portal UAT: starter, pro, and Enterprise tenant bindings must be distinct");
|
|
}
|
|
return {
|
|
...database,
|
|
target,
|
|
mode,
|
|
expectedStarterTenantId,
|
|
expectedProTenantId,
|
|
expectedEnterpriseTenantId,
|
|
password: requireStrongUatPassword(env),
|
|
};
|
|
}
|
|
|
|
export function safeCustomerPortalUatError(error: unknown): string {
|
|
if (error instanceof CustomerPortalUatError) return error.message;
|
|
return "customer-portal UAT: operator command failed; inspect redacted service logs";
|
|
}
|