Files

210 lines
9.3 KiB
TypeScript

#!/usr/bin/env tsx
import "dotenv/config";
import { disconnectDbClients, getDbClient } from "@hivegrid/db/client.server";
import { invalidateUserPermissionCacheScopes } from "../apps/web/app/utils/db/permissions/permission-cache.server";
import { closeSharedStores } from "../apps/web/app/shared-store.server";
import { resolveStorageBinding } from "../apps/web/app/utils/integrations/storageService";
import { parseSeedCommand } from "./demo-pro-seed/cli";
import { deleteDemoProTenantFileObjects, uploadDemoProSeedFileObjects, verifyDemoProSeedFileObjects } from "./demo-pro-seed/file-objects";
import { generateDemoProSeed } from "./demo-pro-seed/generator";
import { generateOperationalGraph, OPERATIONAL_COUNTS } from "./demo-pro-seed/operations";
import {
abandonDemoProSeedRun,
beginDemoProSeedRun,
type DemoProSeedLease,
type DemoProSeedLeaseHeartbeat,
finishDemoProSeedRun,
resetDemoProTenant,
seedDemoProBusinessCore,
seedDemoProIdentity,
seedDemoProOperations,
startDemoProSeedLeaseHeartbeat,
verifyDemoProTenant,
waitForSearchOutbox,
} from "./demo-pro-seed/persistence";
import { expectedDemoProSearchIds, waitForDemoProSearch } from "./demo-pro-seed/search-verification";
function printJson(value: unknown): void {
process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
}
function searchWaitTimeoutMs(): number {
const configured = Number(process.env.SEED_DEMO_PRO_WAIT_MS ?? "300000");
return Number.isFinite(configured) ? Math.max(0, Math.min(600_000, Math.floor(configured))) : 300_000;
}
function assertDatabaseBinding(expectedDatabaseName: string, expectedDatabaseHost: string): void {
const databaseUrl = process.env.DATABASE_URL;
if (!databaseUrl) throw new Error("demo-pro seed: DATABASE_URL is missing");
let actualDatabaseName: string;
let actualDatabaseHost: string;
try {
const parsed = new URL(databaseUrl);
actualDatabaseName = decodeURIComponent(parsed.pathname.replace(/^\//u, ""));
actualDatabaseHost = parsed.host;
} catch {
throw new Error("demo-pro seed: DATABASE_URL is invalid");
}
if (!actualDatabaseName || actualDatabaseName !== expectedDatabaseName || actualDatabaseHost !== expectedDatabaseHost) {
throw new Error("demo-pro seed: database does not match the configured staging database binding");
}
}
function normalizeEndpoint(value: string): string {
return value.trim().replace(/\/+$/u, "");
}
function assertStorageBinding(expectedBucket: string, expectedEndpoint: string): void {
const binding = resolveStorageBinding();
if (binding.provider !== "s3" || binding.bucket !== expectedBucket || normalizeEndpoint(binding.endpoint) !== normalizeEndpoint(expectedEndpoint)) {
throw new Error("demo-pro seed: storage does not match the configured staging storage binding");
}
}
async function main(): Promise<void> {
const command = parseSeedCommand(process.argv.slice(2), process.env);
const graph = generateDemoProSeed();
const operational = generateOperationalGraph(graph);
const expectedSearchIds = expectedDemoProSearchIds(graph, operational);
if (command.mode === "dry-run") {
printJson({
mode: command.mode,
tenant: command.tenantSlug,
namespace: graph.namespace,
counts: {
employees: graph.employees.length,
officeEmployees: graph.employees.filter(({ seatCategory }) => seatCategory === "office").length,
fieldEmployees: graph.employees.filter(({ seatCategory }) => seatCategory === "field").length,
organizations: graph.organizations.length,
persons: graph.persons.length,
contactRelations: graph.contactRelations.length,
projects: graph.projects.length,
leads: graph.leads.length,
...OPERATIONAL_COUNTS,
},
});
return;
}
const db = getDbClient({ poolMax: 5, poolConnectionTimeoutMs: 15_000 });
let lease: DemoProSeedLease | null = null;
let heartbeat: DemoProSeedLeaseHeartbeat | null = null;
let leaseFinished = false;
try {
if (command.mode === "verify") {
const tenant = await db.tenant.findUnique({ where: { slug: command.tenantSlug }, select: { id: true } });
if (!tenant) throw new Error(`demo-pro seed: tenant ${command.tenantSlug} does not exist`);
const [storageVerification, searchCounts] = await Promise.all([
verifyDemoProSeedFileObjects({ tenantId: tenant.id, files: operational.files }),
waitForDemoProSearch({
tenantId: tenant.id,
mode: "apply",
timeoutMs: searchWaitTimeoutMs(),
expectedIdsByIndex: expectedSearchIds,
}),
]);
const report = await verifyDemoProTenant(db, command.tenantSlug, { graph, operational, expectTenantActive: true });
printJson({ report, storageVerification, searchCounts });
if (!report.valid) process.exitCode = 1;
return;
}
if (command.mode !== "apply" && command.mode !== "cleanup") throw new Error("demo-pro seed: unsupported command mode");
assertDatabaseBinding(command.expectedDatabaseName, command.expectedDatabaseHost);
assertStorageBinding(command.expectedStorageBucket, command.expectedStorageEndpoint);
const seedEmployees = graph.employees.map(({ id, email }) => ({ id, email }));
const seedEmployeeIds = seedEmployees.map(({ id }) => id);
lease = await beginDemoProSeedRun(db, command.tenantSlug, command.expectedTenantId, seedEmployees);
heartbeat = startDemoProSeedLeaseHeartbeat(db, lease);
await heartbeat.assertHealthy();
const removedFileObjects = await deleteDemoProTenantFileObjects({ tenantId: lease.tenantId });
await heartbeat.assertHealthy();
const tenant = await resetDemoProTenant(db, command.tenantSlug, seedEmployeeIds);
await invalidateUserPermissionCacheScopes(tenant.previousMemberIds.map((userId) => ({ userId, tenantId: tenant.id })));
await heartbeat.assertHealthy();
const resetPendingSearchEvents = await waitForSearchOutbox(db, tenant.id, searchWaitTimeoutMs());
await heartbeat.assertHealthy();
if (resetPendingSearchEvents > 0) throw new Error("demo-pro seed: tenant search clear events did not leave the outbox in time");
const resetSearchCounts = await waitForDemoProSearch({ tenantId: tenant.id, mode: "cleanup", timeoutMs: searchWaitTimeoutMs() });
await heartbeat.assertHealthy();
if (command.mode === "cleanup") {
await heartbeat.stop();
heartbeat = null;
await finishDemoProSeedRun(db, lease, false);
leaseFinished = true;
printJson({
mode: command.mode,
tenant: tenant.slug,
deleted: true,
fileObjects: removedFileObjects,
pendingSearchEvents: resetPendingSearchEvents,
searchCounts: resetSearchCounts,
});
return;
}
if (command.mode !== "apply") throw new Error("demo-pro seed: unsupported mutation mode");
await seedDemoProIdentity(db, tenant, graph, command.userPassword);
await heartbeat.assertHealthy();
await invalidateUserPermissionCacheScopes(graph.employees.map(({ id: userId }) => ({ userId, tenantId: tenant.id })));
await heartbeat.assertHealthy();
await seedDemoProBusinessCore(db, tenant, graph);
await heartbeat.assertHealthy();
const fileObjects = await uploadDemoProSeedFileObjects({ tenantId: tenant.id, files: operational.files });
await heartbeat.assertHealthy();
await seedDemoProOperations(db, tenant, graph, operational);
await heartbeat.assertHealthy();
const storageVerification = await verifyDemoProSeedFileObjects({ tenantId: tenant.id, files: operational.files });
await heartbeat.assertHealthy();
const pendingSearchEvents = await waitForSearchOutbox(db, tenant.id, searchWaitTimeoutMs());
await heartbeat.assertHealthy();
if (pendingSearchEvents > 0) throw new Error("demo-pro seed: search upsert events did not leave the outbox in time");
const searchCounts = await waitForDemoProSearch({
tenantId: tenant.id,
mode: "apply",
timeoutMs: searchWaitTimeoutMs(),
expectedIdsByIndex: expectedSearchIds,
});
await heartbeat.assertHealthy();
const report = await verifyDemoProTenant(db, command.tenantSlug, { graph, operational, expectTenantActive: false });
if (report.valid) {
await heartbeat.stop();
heartbeat = null;
await finishDemoProSeedRun(db, lease, true);
leaseFinished = true;
}
printJson({ mode: command.mode, tenant: tenant.slug, removedFileObjects, fileObjects, storageVerification, pendingSearchEvents, searchCounts, report });
if (!report.valid) process.exitCode = 1;
} finally {
let cleanupError: unknown;
if (heartbeat) {
try {
await heartbeat.stop();
} catch (error) {
// The lease remains fail-closed; abandon below only removes a lock still owned by this run.
cleanupError = error;
}
}
if (lease && !leaseFinished) {
try {
await abandonDemoProSeedRun(db, lease);
} catch (error) {
cleanupError ??= error;
}
}
const closeResults = await Promise.allSettled([closeSharedStores(), db.$disconnect(), disconnectDbClients()]);
cleanupError ??= closeResults.find((result): result is PromiseRejectedResult => result.status === "rejected")?.reason;
if (cleanupError) throw cleanupError;
}
}
main().catch((error: unknown) => {
const message = error instanceof Error ? error.message : "unknown seed failure";
process.stderr.write(`demo-pro seed failed: ${message}\n`);
process.exitCode = 1;
});