Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/scripts/customer-portal-uat/provision-catalog.ts
T

239 lines
11 KiB
TypeScript

import { pathToFileURL } from "node:url";
import { createAuditEvent, type AuditEventWriterClient } from "@hivegrid/db/audit-events.server";
import { seedStandardEntitlements, type EntitlementsSeedClient } from "@hivegrid/db/entitlements-seed.server";
import {
assessDatabaseCatalog,
buildCustomerPortalCatalogPlan,
customerPortalCatalogPlanIsBlocked,
customerPortalCatalogPlanIsComplete,
LagoCatalogClient,
readDatabaseCatalog,
reconcileBasePlanPortalFeatures,
type CustomerPortalCatalogPlan,
} from "./catalog";
import { CustomerPortalUatError, parseCustomerPortalUatCommand, safeCustomerPortalUatError, type CustomerPortalCatalogCommand } from "./contracts";
import { withCustomerPortalOperatorDatabase } from "./database";
type CatalogExecutionResult = {
readonly mode: CustomerPortalCatalogCommand["mode"];
readonly complete: boolean;
readonly plan: CustomerPortalCatalogPlan;
};
const providerAuditActions = [
"customer_portal.catalog.provider_requested",
"customer_portal.catalog.provider_created",
"customer_portal.catalog.provider_failed",
"customer_portal.catalog.provider_reconciled",
] as const;
const catalogAuditActions = [...providerAuditActions, "customer_portal.catalog.database_reconciled", "customer_portal.catalog.provisioned"] as const;
export type CatalogAuditRecoveryRow = {
readonly id: string;
readonly action: (typeof catalogAuditActions)[number];
readonly targetId: string | null;
readonly createdAt: Date;
};
export type CatalogAuditRecovery = {
readonly providerCodesNeedingReconciliation: readonly string[];
readonly providerCodesNeedingProvisionedAudit: readonly string[];
readonly databaseNeedsProvisionedAudit: boolean;
readonly needsProvisionedAudit: boolean;
};
export function assessCatalogAuditRecovery(rows: readonly CatalogAuditRecoveryRow[], plan: CustomerPortalCatalogPlan): CatalogAuditRecovery {
const ordered = [...rows].sort((left, right) => left.createdAt.getTime() - right.createdAt.getTime() || left.id.localeCompare(right.id));
const lastIndex = (predicate: (row: CatalogAuditRecoveryRow) => boolean): number => {
for (let index = ordered.length - 1; index >= 0; index -= 1) {
if (predicate(ordered[index]!)) return index;
}
return -1;
};
const lastProvisioned = lastIndex((row) => row.action === "customer_portal.catalog.provisioned");
const providerCodesNeedingReconciliation: string[] = [];
const providerCodesNeedingProvisionedAudit: string[] = [];
for (const action of plan.provider) {
const requested = lastIndex((row) => row.targetId === action.code && row.action === "customer_portal.catalog.provider_requested");
const completed = lastIndex(
(row) =>
row.targetId === action.code &&
(row.action === "customer_portal.catalog.provider_created" || row.action === "customer_portal.catalog.provider_reconciled")
);
if (action.action === "noop" && requested > completed) providerCodesNeedingReconciliation.push(action.code);
if (completed > lastProvisioned) providerCodesNeedingProvisionedAudit.push(action.code);
}
const lastDatabaseReconciled = lastIndex((row) => row.action === "customer_portal.catalog.database_reconciled");
const databaseNeedsProvisionedAudit = lastDatabaseReconciled > lastProvisioned;
return {
providerCodesNeedingReconciliation,
providerCodesNeedingProvisionedAudit,
databaseNeedsProvisionedAudit,
needsProvisionedAudit: providerCodesNeedingProvisionedAudit.length > 0 || databaseNeedsProvisionedAudit,
};
}
function writeResult(result: CatalogExecutionResult): void {
process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
}
async function executeCatalogCommand(command: CustomerPortalCatalogCommand): Promise<CatalogExecutionResult> {
const lago = new LagoCatalogClient({ apiUrl: command.lagoApiUrl, apiKey: command.lagoApiKey });
return withCustomerPortalOperatorDatabase(command, async (db) => {
const inspect = async () => buildCustomerPortalCatalogPlan(await lago.readCatalog(), await readDatabaseCatalog(db));
const initialPlan = await inspect();
const priorAuditRows = await db.auditEvent.findMany({
where: {
tenantId: null,
sourceModule: "customer-portal-uat",
action: { in: [...catalogAuditActions] },
},
select: { id: true, action: true, targetId: true, createdAt: true },
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
});
const recovery = assessCatalogAuditRecovery(priorAuditRows as CatalogAuditRecoveryRow[], initialPlan);
const auditComplete = recovery.providerCodesNeedingReconciliation.length === 0 && !recovery.needsProvisionedAudit;
if (command.mode === "plan") {
return { mode: command.mode, complete: customerPortalCatalogPlanIsComplete(initialPlan) && auditComplete, plan: initialPlan };
}
if (command.mode === "verify") {
if (!customerPortalCatalogPlanIsComplete(initialPlan) || !auditComplete) {
throw new CustomerPortalUatError("customer-portal UAT: catalog verification found missing, drifted, or incompletely audited state");
}
return { mode: command.mode, complete: true, plan: initialPlan };
}
if (customerPortalCatalogPlanIsBlocked(initialPlan)) {
throw new CustomerPortalUatError("customer-portal UAT: catalog apply is blocked by existing drift; no mutation was attempted");
}
let mutated = false;
const providerResourcesAudited = new Set<string>();
for (const action of initialPlan.provider) {
const audit = async (phase: "requested" | "created" | "failed" | "reconciled", outcome: "success" | "failure") =>
createAuditEvent(
{
tenantId: null,
actorId: command.operatorUserId,
actorType: "operator",
action: `customer_portal.catalog.provider_${phase}`,
targetType: action.resource === "plan" ? "LagoPlan" : "LagoAddOn",
targetId: action.code,
sourceModule: "customer-portal-uat",
outcome,
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: { resource: action.resource },
},
db as unknown as AuditEventWriterClient
);
if (action.action === "noop" && recovery.providerCodesNeedingReconciliation.includes(action.code)) {
await audit("reconciled", "success");
providerResourcesAudited.add(action.code);
mutated = true;
continue;
}
if (action.action !== "create" && action.action !== "update") continue;
await audit("requested", "success");
try {
if (action.resource === "plan") {
if (action.action === "create") await lago.createPlan();
else await lago.updatePlan();
} else if (action.action === "create") {
await lago.createAddOn();
} else {
await lago.updateAddOn();
}
} catch (error) {
await audit("failed", "failure");
throw error;
}
await audit(action.action === "create" ? "created" : "reconciled", "success");
providerResourcesAudited.add(action.code);
mutated = true;
}
if (initialPlan.database.action === "reconcile") {
await db.$transaction(async (tx) => {
await seedStandardEntitlements({
client: tx as unknown as EntitlementsSeedClient,
plans: [],
includeCustomerPortalCommercialProducts: true,
});
const basePlanFeaturesCreated = await reconcileBasePlanPortalFeatures(tx as unknown as Parameters<typeof reconcileBasePlanPortalFeatures>[0]);
const databaseAssessment = assessDatabaseCatalog(await readDatabaseCatalog(tx as unknown as Parameters<typeof readDatabaseCatalog>[0]));
if (databaseAssessment.blockingIssues.length > 0 || databaseAssessment.reconcileIssues.length > 0) {
const residualIssues = [...databaseAssessment.blockingIssues, ...databaseAssessment.reconcileIssues].join(", ");
throw new CustomerPortalUatError(`customer-portal UAT: database catalog did not converge inside the audited transaction: ${residualIssues}`);
}
// The app-role outbox intentionally rejects global events. This is an
// operator-only, low-volume mutation, so persist its platform audit
// directly through the canonical hash-chain writer inside the same
// transaction instead of weakening the tenant-scoped outbox policy.
await createAuditEvent(
{
tenantId: null,
actorId: command.operatorUserId,
actorType: "operator",
action: "customer_portal.catalog.database_reconciled",
targetType: "CustomerPortalCatalog",
sourceModule: "customer-portal-uat",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: {
productCodes: initialPlan.database.reconcileIssues.map((issue) => issue.split(":", 1)[0] ?? "unknown"),
basePlanFeaturesCreated,
},
},
tx as unknown as AuditEventWriterClient
);
});
mutated = true;
}
const finalPlan = await inspect();
if (!customerPortalCatalogPlanIsComplete(finalPlan)) {
throw new CustomerPortalUatError("customer-portal UAT: catalog did not converge to the canonical contract");
}
if (mutated || recovery.needsProvisionedAudit) {
for (const code of recovery.providerCodesNeedingProvisionedAudit) providerResourcesAudited.add(code);
await createAuditEvent(
{
tenantId: null,
actorId: command.operatorUserId,
actorType: "operator",
action: "customer_portal.catalog.provisioned",
targetType: "CustomerPortalCatalog",
sourceModule: "customer-portal-uat",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: {
providerResources: [...providerResourcesAudited].sort(),
databaseReconciled: initialPlan.database.action === "reconcile" || recovery.databaseNeedsProvisionedAudit,
},
},
db as unknown as AuditEventWriterClient
);
}
return { mode: command.mode, complete: true, plan: finalPlan };
});
}
export async function main(argv: readonly string[] = process.argv.slice(2), env: NodeJS.ProcessEnv = process.env): Promise<void> {
const command = parseCustomerPortalUatCommand("catalog", argv, env);
if (command.target !== "catalog") throw new CustomerPortalUatError("customer-portal UAT: invalid catalog command");
writeResult(await executeCatalogCommand(command));
}
const directEntry = process.argv[1] ? pathToFileURL(process.argv[1]).href === import.meta.url : false;
if (directEntry) {
void main().catch((error) => {
process.stderr.write(`${safeCustomerPortalUatError(error)}\n`);
process.exitCode = 1;
});
}