Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/scripts/ops/seed-hr-demo.mts
T

206 lines
12 KiB
TypeScript

// Ops seed — HR-Hub demo data (AK-P17a/b), idempotent, DEMO-TENANTS ONLY.
//
// Purpose: populate the employee directory, locations, the encrypted emergency
// contacts and an encrypted team password-safe so the HR screens render with
// real data on staging. Personnel-document rows are intentionally NOT seeded:
// they require real File bytes and are created through the wired upload flow.
//
// Self-contained on purpose: it inlines the AD-8 envelope crypto (a faithful copy
// of packages/foundation/src/crypto/{envelope,key-wrapper}.ts) so it runs even in
// a deployed image where `@hivegrid/foundation` is bundled-not-resolvable. It
// reuses the SAME per-tenant DEK the app stores in TenantEncryptionKey (read, or
// create+wrap with CRYPTO_SECRET exactly like getOrCreateTenantDek), so every
// ciphertext it writes is decryptable by the running app 1:1.
//
// Prisma writes to RLS-protected HR tables go through a transaction that sets the
// tenant GUC (mirrors withTenantRLS). Safe to re-run: keyed on natural keys +
// isDemoData=true, upserts where a unique constraint exists.
//
// Run (inside the staging web container, which has CRYPTO_SECRET + DATABASE_URL):
// docker exec <web> sh -lc 'cd /myapp && node_modules/.bin/tsx scripts/ops/seed-hr-demo.mts'
// Flags: --dry-run (no writes, report only) · --verify (decrypt one value back).
import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
import { getDbClient } from "@hivegrid/db/client.server";
// ---- inlined AD-8 crypto (exact copy of the app primitives) -----------------
const ALGO = "aes-256-gcm";
const IV = 12;
const DEK_BYTES = 32;
const FMT = "v1";
function masterKey(): Buffer {
const secret = process.env.CRYPTO_SECRET;
if (!secret) throw new Error("CRYPTO_SECRET env variable not set");
return createHash("sha256").update(secret).digest();
}
function wrapDek(dek: Buffer): Buffer {
const iv = randomBytes(IV);
const c = createCipheriv(ALGO, masterKey(), iv);
const ct = Buffer.concat([c.update(dek), c.final()]);
return Buffer.concat([iv, c.getAuthTag(), ct]);
}
function unwrapDek(blob: Buffer): Buffer {
const iv = blob.subarray(0, IV);
const tag = blob.subarray(IV, IV + 16);
const ct = blob.subarray(IV + 16);
const d = createDecipheriv(ALGO, masterKey(), iv);
d.setAuthTag(tag);
return Buffer.concat([d.update(ct), d.final()]);
}
function seal(dek: Buffer, plaintext: string, keyVersion = 1): string {
const iv = randomBytes(IV);
const c = createCipheriv(ALGO, dek, iv);
const ct = Buffer.concat([c.update(plaintext, "utf8"), c.final()]);
return [FMT, String(keyVersion), iv.toString("base64url"), c.getAuthTag().toString("base64url"), ct.toString("base64url")].join(":");
}
function open(dek: Buffer, envelope: string): string {
const [v, , ivB, tagB, ctB] = envelope.split(":");
if (v !== FMT) throw new Error("malformed envelope");
const d = createDecipheriv(ALGO, dek, Buffer.from(ivB, "base64url"));
d.setAuthTag(Buffer.from(tagB, "base64url"));
return Buffer.concat([d.update(Buffer.from(ctB, "base64url")), d.final()]).toString("utf8");
}
// ---- config -----------------------------------------------------------------
const MANAGED_STAGING_TENANT_SLUG = "demo-pro-crm";
const DEMO_SLUGS = ["demo-starter-crm", "demo-business-crm"];
const DRY = process.argv.includes("--dry-run");
const VERIFY = process.argv.includes("--verify");
const db = getDbClient() as any;
/** Get-or-create the tenant DEK exactly like getOrCreateTenantDek (envelope). */
async function tenantDek(tenantId: string): Promise<{ dek: Buffer; keyVersion: number }> {
const row = await db.tenantEncryptionKey.findUnique({ where: { tenantId }, select: { wrappedDek: true, keyVersion: true } });
if (row) return { dek: unwrapDek(Buffer.from(row.wrappedDek)), keyVersion: row.keyVersion };
const dek = randomBytes(DEK_BYTES);
if (DRY) return { dek, keyVersion: 1 };
await db.tenantEncryptionKey.create({ data: { tenantId, wrappedDek: wrapDek(dek), keyVersion: 1 } });
return { dek, keyVersion: 1 };
}
/** Run a callback inside a tenant-scoped RLS transaction (mirrors withTenantRLS). */
async function rls<T>(tenantId: string, cb: (tx: any) => Promise<T>): Promise<T> {
return db.$transaction(async (tx: any) => {
await tx.$executeRaw`SELECT set_config('app.tenant_id', ${tenantId}, true)`;
return cb(tx);
});
}
type Member = { userId: string; email: string; first: string; last: string };
function memberData(members: Member[]) {
// Resolve the three canonical staging users by email; fall back by order.
const byEmail = (e: string) => members.find((m) => m.email.toLowerCase() === e);
const admin = byEmail("staging-admin@hivegrid.de") ?? members[0];
const john = byEmail("john.doe@company.com") ?? members[1];
const luna = byEmail("luna.davis@company.com") ?? members[2];
return { admin, john, luna };
}
async function seedTenant(t: { id: string; slug: string }) {
if (t.slug === MANAGED_STAGING_TENANT_SLUG) {
throw new Error(`${MANAGED_STAGING_TENANT_SLUG} is owned by the comprehensive normal-data seed and must not receive legacy demo rows`);
}
const tenantId = t.id;
const tus = await db.tenantUser.findMany({ where: { tenantId }, select: { userId: true } });
const users: any[] = await db.user.findMany({ where: { id: { in: tus.map((x: any) => x.userId) } }, select: { id: true, email: true, firstName: true, lastName: true } });
const members: Member[] = users.map((u) => ({ userId: u.id, email: u.email, first: u.firstName, last: u.lastName }));
const { admin, john, luna } = memberData(members);
const { dek, keyVersion } = await tenantDek(tenantId);
const enc = (plain: string) => seal(dek, plain, keyVersion);
const summary: string[] = [];
await rls(tenantId, async (tx) => {
// --- Locations (idempotent by tenantId+name) ---
async function ensureLocation(name: string, data: Record<string, unknown>, isDefault: boolean): Promise<string> {
const existing = await tx.hrLocation.findFirst({ where: { tenantId, name }, select: { id: true } });
if (existing) return existing.id;
if (DRY) { summary.push(`+location ${name}`); return "dry"; }
const created = await tx.hrLocation.create({ data: { tenantId, name, isDefault, isDemoData: true, ...data }, select: { id: true } });
summary.push(`+location ${name}`);
return created.id;
}
const berlin = await ensureLocation("Zentrale Berlin", { addressLine1: "Torstraße 1", postalCode: "10119", city: "Berlin", country: "DE", phone: "+49 30 1234000" }, true);
const muc = await ensureLocation("Standort München", { addressLine1: "Sendlinger Str. 12", postalCode: "80331", city: "München", country: "DE", phone: "+49 89 9876000" }, false);
// --- Profiles (upsert on tenantId_userId) ---
async function ensureProfile(m: Member, p: { position: string; team: string; locationId: string; personalNumber: string; managerUserId?: string; emergency?: { name: string; phone: string; relation: string } }) {
const data: Record<string, unknown> = {
position: p.position, team: p.team, locationId: p.locationId === "dry" ? null : p.locationId,
personalNumber: p.personalNumber, managerUserId: p.managerUserId ?? null, isDemoData: true,
};
if (p.emergency) data.emergencyContactCiphertext = enc(JSON.stringify(p.emergency));
if (DRY) { summary.push(`~profile ${m.email}`); return; }
await tx.hrEmployeeProfile.upsert({
where: { tenantId_userId: { tenantId, userId: m.userId } },
update: data,
create: { tenantId, userId: m.userId, ...data },
});
summary.push(`~profile ${m.email}${p.emergency ? " (+emergency)" : ""}`);
}
if (admin) await ensureProfile(admin, { position: "Geschäftsführung", team: "Leitung", locationId: berlin, personalNumber: "P-0001", emergency: { name: "Sabine Berger", phone: "+49 170 1112233", relation: "Ehepartnerin" } });
if (john) await ensureProfile(john, { position: "Vertriebsmitarbeiter", team: "Sales", locationId: berlin, personalNumber: "P-0002", managerUserId: admin?.userId, emergency: { name: "Maria Doe", phone: "+49 171 4455667", relation: "Schwester" } });
if (luna) await ensureProfile(luna, { position: "HR-Managerin", team: "People", locationId: muc, personalNumber: "P-0003", managerUserId: admin?.userId, emergency: { name: "Tom Davis", phone: "+49 172 8899001", relation: "Ehepartner" } });
// --- Password safe: one vault + access + entries ---
const vaultName = "Team-Zugänge (Demo)";
let vaultId = (await tx.employeePasswordSafeVault.findFirst({ where: { tenantId, name: vaultName }, select: { id: true } }))?.id ?? null;
if (!vaultId && !DRY && admin) {
vaultId = (await tx.employeePasswordSafeVault.create({ data: { tenantId, name: vaultName, description: "Gemeinsame Zugangsdaten des Teams.", createdByUserId: admin.userId, isDemoData: true }, select: { id: true } })).id;
summary.push(`+vault ${vaultName}`);
}
if (vaultId && !DRY) {
// Access grants: admin=admin, john=read, luna=write.
async function grant(m: Member | undefined, level: "read" | "write" | "admin") {
if (!m || !admin) return;
await tx.employeePasswordSafeAccess.upsert({
where: { vaultId_userId: { vaultId, userId: m.userId } },
update: { permissionLevel: level, grantedByUserId: admin.userId },
create: { tenantId, vaultId, userId: m.userId, permissionLevel: level, grantedByUserId: admin.userId },
});
}
await grant(admin, "admin"); await grant(john, "read"); await grant(luna, "write");
summary.push("~access admin/read/write");
// Entries (idempotent by tenantId+vaultId+title), secrets encrypted.
async function ensureEntry(title: string, url: string | null, username: string, password: string, notes: string) {
const exists = await tx.employeePasswordSafeEntry.findFirst({ where: { tenantId, vaultId, title }, select: { id: true } });
if (exists) return;
await tx.employeePasswordSafeEntry.create({
data: { tenantId, vaultId, title, url, tags: [], isDemoData: true, usernameCiphertext: enc(username), passwordCiphertext: enc(password), notesCiphertext: notes ? enc(notes) : null },
});
summary.push(`+entry ${title}`);
}
await ensureEntry("Firmen-WLAN", null, "hivegrid-guest", "Sommer2026!", "Nur für Gäste, monatlich wechseln.");
await ensureEntry("Microsoft 365 Sammelkonto", "https://portal.office.com", "team@company.com", "Xk9$mPq2Lz7w", "Nicht für Einzel-Logins verwenden.");
await ensureEntry("Newsletter-Tool", "https://newsletter.example.com", "marketing", "N3wsL!2026#", "");
}
return null;
});
// --- optional verify: decrypt one emergency contact back ---
if (VERIFY && !DRY) {
const prof = await rls(tenantId, (tx) => tx.hrEmployeeProfile.findFirst({ where: { tenantId, emergencyContactCiphertext: { not: null } }, select: { userId: true, emergencyContactCiphertext: true } }));
if (prof?.emergencyContactCiphertext) {
const back = open(dek, prof.emergencyContactCiphertext);
summary.push(`verify decrypt ok: ${back}`);
}
}
console.log(`\n[${t.slug}] (${tenantId})`);
for (const line of summary) console.log(" " + line);
}
async function main() {
const tenants = await db.tenant.findMany({ where: { slug: { in: DEMO_SLUGS } }, select: { id: true, slug: true } });
if (tenants.length === 0) { console.error("No demo tenants found — aborting (safety guard)."); process.exit(1); }
console.log(`HR demo seed — ${DRY ? "DRY RUN" : "WRITE"}${VERIFY ? " +verify" : ""} — tenants: ${tenants.map((t: any) => t.slug).join(", ")}`);
for (const t of tenants) await seedTenant(t);
console.log("\nDone.");
}
main().then(() => process.exit(0)).catch((e) => { console.error("SEED-ERR", e); process.exit(1); });