Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -12,6 +12,15 @@ import { seedRolesAndPermissions, type RolesAndPermissionsSeedDiagnosticEvent }
import { db } from "~/utils/db.server";
import { seedShkCustomFieldTemplate } from "~/utils/integrations/crm/customFieldService.server";
import { createScopedLogger } from "~/utils/logger.server";
import {
assertLocalCredentialsDatabaseMarker,
assertLocalCredentialsEnvironment,
} from "./localCredentialsEnvironment.server";
import { seedStagingDomainDemo } from "./stagingDomainDemoSeed.server";
import {
automationTemplateCatalog,
automationTemplateFlowData,
} from "~/services/automation/automation.registry";
const seedLogger = createScopedLogger("seed");
@@ -32,6 +41,7 @@ const localDemoSeedUsers = [
lastName: "Doe",
email: "john.doe@company.com",
password: "password",
reactivateExisting: true,
},
{
userType: "app" as const,
@@ -39,6 +49,7 @@ const localDemoSeedUsers = [
lastName: "Davis",
email: "luna.davis@company.com",
password: "password",
reactivateExisting: true,
},
];
const demoCrmTenants = [
@@ -46,6 +57,7 @@ const demoCrmTenants = [
{ slug: "demo-pro-crm", name: "Demo Pro CRM", planId: entitlementPlanIds.pro },
{ slug: "demo-business-crm", name: "Demo Business CRM", planId: entitlementPlanIds.business },
] as const;
const managedDemoProTenantSlug = "demo-pro-crm";
const demoTenantRoleSeeds = [
{
name: "CRM Manager",
@@ -68,7 +80,94 @@ const demoSupportTicketSubjects = {
const demoSupportTicketPlanGatesMessage =
"Use this ticket to confirm blueprint, plan, tenant override, and tenant-owned role access in the seeded workspace.";
function getAdminSeedUser() {
// AK-P16a/AK-P16b: booking + calendar demo data for the demo tenants so
// /bookings, /bookings/pages, /availability and /calendar are populated out of
// the box. The rich local demo seed (scripts/seed-hivegrid-demo.ts) refuses to
// run with NODE_ENV=production, so the staging demo path lives here.
// Deterministic `seed-<tenant>-*` ids keep every upsert idempotent across
// SEED_ON_BOOT runs; day offsets are re-resolved on each run so "upcoming"
// appointments stay upcoming.
const demoBookingTimezone = "Europe/Berlin";
const demoBookingPageSeeds = [
{
slug: "beratungstermin",
title: "Beratungstermin", // demo seed copy
description: "Kostenloses Erstgespräch für neue Anfragen (Demo).",
durationMinutes: 30,
isPublished: true,
},
{
slug: "vor-ort-termin",
title: "Vor-Ort-Termin", // demo seed copy
description: "Termin beim Endkunden vor Ort (Demo, unveröffentlicht).",
durationMinutes: 60,
isPublished: false,
},
] as const;
const demoAppointmentSeeds = [
{
key: "upcoming-consult",
pageSlug: "beratungstermin",
providerIndex: 0,
dayOffset: 2,
startHour: 10,
status: "scheduled",
intakeAnswers: { vorname: "Sabine", nachname: "Wagner", email: "sabine.wagner@example.test", anliegen: "Bad-Sanierung besprechen." },
},
{
key: "upcoming-onsite",
pageSlug: "vor-ort-termin",
providerIndex: 1,
dayOffset: 5,
startHour: 8,
status: "scheduled",
intakeAnswers: { vorname: "Thomas", nachname: "Schneider", email: "thomas.schneider@example.test", anliegen: "Heizungstausch vor Ort ansehen." },
},
{
key: "past-held",
pageSlug: "beratungstermin",
providerIndex: 0,
dayOffset: -3,
startHour: 14,
status: "held",
intakeAnswers: { vorname: "Birgit", nachname: "Sommer", email: "birgit.sommer@example.test", anliegen: "Jahreswartung planen." },
},
{
key: "cancelled-consult",
pageSlug: "beratungstermin",
providerIndex: 1,
dayOffset: -1,
startHour: 9,
status: "cancelled",
intakeAnswers: { vorname: "Peter", nachname: "Krause", email: "peter.krause@example.test", anliegen: "Terminanfrage (storniert)." },
},
] as const;
const demoAvailabilityWeekdays = ["monday", "tuesday", "wednesday", "thursday", "friday"] as const;
const demoAvailabilityExceptionSeeds = [
{ key: "day-off", providerIndex: 0, dayOffset: 7, kind: "unavailable", startTime: null, endTime: null, reason: "Urlaubstag (Demo)" },
{ key: "short-day", providerIndex: 1, dayOffset: 3, kind: "custom_window", startTime: "10:00", endTime: "14:00", reason: "Verkürzter Tag (Demo)" },
] as const;
async function useCanonicalLocalCredentials() {
if (process.env.LOCAL_DEV_CREDENTIALS !== "1") {
return false;
}
assertLocalCredentialsEnvironment(process.env);
await assertLocalCredentialsDatabaseMarker(db);
return true;
}
function getAdminSeedUser(canonicalLocalCredentials: boolean) {
if (canonicalLocalCredentials) {
return {
email: DEFAULT_ADMIN_EMAIL,
password: DEFAULT_ADMIN_PASSWORD,
firstName: "Admin",
lastName: "User",
};
}
return {
email: process.env.SEED_ADMIN_EMAIL ?? DEFAULT_ADMIN_EMAIL,
password: process.env.SEED_ADMIN_PASSWORD ?? DEFAULT_ADMIN_PASSWORD,
@@ -78,8 +177,10 @@ function getAdminSeedUser() {
}
async function seed() {
const adminUser = getAdminSeedUser();
const canonicalLocalCredentials = await useCanonicalLocalCredentials();
const adminUser = getAdminSeedUser(canonicalLocalCredentials);
const shouldSeedDemoData = shouldSeedCrmDemoData();
const bootSeedDemoCrmTenants = getBootSeedDemoCrmTenants();
const seedCredentials = shouldSeedDemoData
? [
{ label: "admin", email: adminUser.email, password: adminUser.password },
@@ -94,16 +195,16 @@ async function seed() {
seedCredentials,
diagnostics: logDbSeedDiagnostic,
seed: async () => {
const admin = await createUser({ userType: "admin", ...adminUser });
const admin = await createUser({ userType: "admin", canonicalLocalCredentials, ...adminUser });
let demoUsers: Awaited<ReturnType<typeof createUser>>[] = [];
if (shouldSeedDemoData) {
seedLogger.info({ op: "seed.createDemoUsers", count: localDemoSeedUsers.length }, "Creating CRM SaaS demo users with tenants");
demoUsers = await Promise.all(localDemoSeedUsers.map((user) => createUser(user)));
demoUsers = await Promise.all(localDemoSeedUsers.map((user) => createUser({ ...user, canonicalLocalCredentials })));
const [user1, user2] = demoUsers;
await Promise.all(
demoCrmTenants.map((tenant, index) =>
bootSeedDemoCrmTenants.map((tenant, index) =>
createTenant(tenant.slug, tenant.name, [
{ ...admin, type: TenantUserType.ADMIN },
{ ...user1, type: index === 0 ? TenantUserType.ADMIN : TenantUserType.OWNER },
@@ -117,25 +218,40 @@ async function seed() {
await seedRolesAndPermissions({
adminEmail: adminUser.email,
diagnostics: logRolesAndPermissionsSeedDiagnostic,
...(process.env.SEED_DEMO_PRO_MANAGED === "true" ? { excludedTenantSlugs: [managedDemoProTenantSlug] } : {}),
});
await seedStandardEntitlements({
client: db,
includeCustomerPortalCommercialProducts: true,
includeEmailMarketingCommercialProducts: true,
diagnostics: logEntitlementsSeedDiagnostic,
});
// R-P5: global App definition table from the code catalog (idempotent by
// unique key; the tenant runtime keeps reading INTEGRATION_CATALOG).
await seedIntegrationCatalog();
await seedAutomationTemplateCatalog();
if (shouldSeedDemoData) {
await Promise.all(demoCrmTenants.map((tenant) => assignTenantPlan(tenant.slug, tenant.planId)));
await Promise.all(demoCrmTenants.map((tenant) => seedDemoProductCoreTenant(tenant.slug, tenant.planId, demoUsers)));
await Promise.all(bootSeedDemoCrmTenants.map((tenant) => assignTenantPlan(tenant.slug, tenant.planId)));
await Promise.all(bootSeedDemoCrmTenants.map((tenant) => seedDemoProductCoreTenant(tenant.slug, tenant.planId, demoUsers)));
}
},
});
}
function getBootSeedDemoCrmTenants() {
if (process.env.SEED_DEMO_PRO_MANAGED !== "true") {
return demoCrmTenants;
}
// The comprehensive staging seed owns every tenant-scoped row in demo-pro-crm.
// Excluding it here keeps later web boots from reintroducing legacy members,
// plans, bookings, projects, or other product-core fixtures.
return demoCrmTenants.filter((tenant) => tenant.slug !== managedDemoProTenantSlug);
}
/** Upsert the code catalog into the global `App` table (R-P5, no RLS/tenant). */
async function seedIntegrationCatalog() {
const plan = buildCatalogSeedPlan();
@@ -148,6 +264,38 @@ async function seedIntegrationCatalog() {
seedLogger.info({ op: "seed.integrationCatalog", count: plan.length }, "Upserted integration catalog into App table");
}
/** Seed global templates through the privileged deployment seed, never a tenant request. */
async function seedAutomationTemplateCatalog() {
for (const template of automationTemplateCatalog) {
const flowData = JSON.parse(JSON.stringify(automationTemplateFlowData(template))) as object;
// Matching the old key-shaped name too heals rows that were seeded before
// display text replaced the translation key.
const existing = await db.automationTemplate.findFirst({
where: { tenantId: null, name: { in: [template.defaultName, template.nameKey] }, archivedAt: null },
select: { id: true },
});
const data = {
name: template.defaultName,
description: template.defaultDescription,
category: template.category,
flowData,
isPublished: true,
isDemoData: true,
};
if (existing) {
await db.automationTemplate.update({ where: { id: existing.id }, data });
} else {
await db.automationTemplate.create({
data: { tenantId: null, ...data },
});
}
}
seedLogger.info(
{ op: "seed.automationTemplateCatalog", count: automationTemplateCatalog.length },
"Upserted global automation template catalog",
);
}
function shouldSeedCrmDemoData() {
if (process.env.SEED_DEMO_DATA !== "true") {
return false;
@@ -229,12 +377,16 @@ async function createUser({
email,
password,
userType,
reactivateExisting = false,
canonicalLocalCredentials = false,
}: {
firstName: string;
lastName: string;
email: string;
password: string;
userType: "admin" | "app";
reactivateExisting?: boolean;
canonicalLocalCredentials?: boolean;
}) {
// Never log raw `email` (PII) and never log `password` (secret).
// Use email fingerprint hash so operators can still correlate seed events.
@@ -248,7 +400,24 @@ async function createUser({
where: { email },
});
if (user) {
const isAdmin = await db.adminUser.findUnique({ where: { userId: user.id } });
if (canonicalLocalCredentials) {
user = await db.user.update({
where: { id: user.id },
data: {
passwordHash,
...(userType === "admin" || reactivateExisting ? { active: true } : {}),
},
});
}
// Only explicitly managed demo identities opt into reactivation. Existing
// admin or customer accounts may have been disabled intentionally.
if (!canonicalLocalCredentials && reactivateExisting && user.active === false) {
user = await db.user.update({
where: { id: user.id },
data: { active: true },
});
}
const isAdmin = await db.adminUser.findUnique({ where: { id: user.id } });
if (!isAdmin && userType === "admin") {
if (process.env.NODE_ENV === "production") {
throw new Error("Production seed refused to promote an existing non-admin user. Choose a new SEED_ADMIN_EMAIL or bootstrap the admin user explicitly.");
@@ -257,7 +426,15 @@ async function createUser({
{ op: "seed.promoteUserToAdmin", emailFingerprint: emailFingerprint(email) },
"User already exists; promoting to admin",
);
await db.adminUser.create({ data: { userId: user.id } });
await db.adminUser.create({
data: {
id: user.id,
email: user.email,
firstName: user.firstName,
lastName: user.lastName,
status: "active",
},
});
} else {
seedLogger.info(
{ op: "seed.userExists", userType, emailFingerprint: emailFingerprint(email) },
@@ -274,11 +451,18 @@ async function createUser({
firstName,
lastName,
phone: "",
active: true,
},
});
if (userType === "admin") {
await db.adminUser.create({
data: { userId: user.id },
data: {
id: user.id,
email: user.email,
firstName: user.firstName,
lastName: user.lastName,
status: "active",
},
});
}
return user;
@@ -426,10 +610,162 @@ async function seedDemoProductCoreTenant(tenantSlug: string, planId: Entitlement
// data (`isDemoData = true`) instead of the legacy entity-builder CRM
// entities. The template is intentionally empty until the Geerkens
// workshop (E3), so this is currently an idempotent no-op.
seedShkCustomFieldTemplate({ tenantId: tenant.id }),
seedShkCustomFieldTemplate({ tenantId: tenant.id, isDemoData: true }),
planId === entitlementPlanIds.business && demoUsers[0]
? seedStagingDomainDemo({ tenantId: tenant.id, ownerUserId: demoUsers[0].id })
: Promise.resolve(),
seedDemoTenantBookingData(tenant.id, tenant.slug, demoUsers),
]);
}
/** Local wall-clock date `dayOffset` days from now (mirrors the local demo seed). */
function demoBookingDate(dayOffset: number, hour: number, minute = 0): Date {
const value = new Date();
value.setDate(value.getDate() + dayOffset);
value.setHours(hour, minute, 0, 0);
return value;
}
/** Calendar-date-only value at UTC midnight (AvailabilityException stores `@db.Date`). */
function demoBookingDateOnlyUtc(dayOffset: number): Date {
const value = new Date();
value.setDate(value.getDate() + dayOffset);
return new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate()));
}
async function seedDemoTenantBookingData(tenantId: string, tenantSlug: string, demoUsers: { id: string }[]) {
const providers = demoUsers.slice(0, 2);
if (providers.length === 0) {
return;
}
// Booking pages + provider assignments (unique per tenantId+slug).
const pageBySlug = new Map<string, { id: string; durationMinutes: number }>();
for (const page of demoBookingPageSeeds) {
const data = {
title: page.title,
description: page.description,
durationMinutes: page.durationMinutes,
confirmationEmailSubject: `Terminbestätigung: ${page.title}`,
confirmationEmailBody: "Vielen Dank für deine Buchung. Die Termindetails findest du im Kalenderanhang (.ics).",
isPublished: page.isPublished,
isDemoData: true,
createdByUserId: providers[0].id,
};
const row = await db.bookingPage.upsert({
where: { tenantId_slug: { tenantId, slug: page.slug } },
create: { tenantId, slug: page.slug, ...data },
update: data,
select: { id: true },
});
pageBySlug.set(page.slug, { id: row.id, durationMinutes: page.durationMinutes });
for (const [index, provider] of providers.entries()) {
await db.bookingPageProvider.upsert({
where: { bookingPageId_providerUserId: { bookingPageId: row.id, providerUserId: provider.id } },
create: { tenantId, bookingPageId: row.id, providerUserId: provider.id, displayOrder: index, isActive: true },
update: { displayOrder: index, isActive: true },
});
}
}
// Weekly Mo–Fr availability per provider so the public slot engine and the
// /availability editor have data. AvailabilityRule has no natural unique key,
// so deterministic ids keep the upserts idempotent.
for (const [providerIndex, provider] of providers.entries()) {
for (const day of demoAvailabilityWeekdays) {
const id = `seed-${tenantSlug}-avail-${providerIndex}-${day}`;
const data = { tenantId, providerUserId: provider.id, dayOfWeek: day, startTime: "09:00", endTime: "17:00", timezone: demoBookingTimezone };
await db.availabilityRule.upsert({ where: { id }, create: { id, ...data }, update: data });
}
}
for (const exception of demoAvailabilityExceptionSeeds) {
const provider = providers[exception.providerIndex % providers.length];
const id = `seed-${tenantSlug}-exception-${exception.key}`;
const data = {
tenantId,
providerUserId: provider.id,
date: demoBookingDateOnlyUtc(exception.dayOffset),
kind: exception.kind,
startTime: exception.startTime,
endTime: exception.endTime,
reason: exception.reason,
timezone: demoBookingTimezone,
};
await db.availabilityException.upsert({ where: { id }, create: { id, ...data }, update: data });
}
// Appointments across the list tabs (upcoming/past/cancelled) + a local
// CalendarEvent mirror per active appointment so /calendar shows sources
// (mirrors what BookingSubmitService does on a real booking).
for (const appointment of demoAppointmentSeeds) {
const page = pageBySlug.get(appointment.pageSlug);
const provider = providers[appointment.providerIndex % providers.length];
if (!page) {
continue;
}
const appointmentId = `seed-${tenantSlug}-appt-${appointment.key}`;
const calendarEventId = `seed-${tenantSlug}-cal-${appointment.key}`;
const startAt = demoBookingDate(appointment.dayOffset, appointment.startHour);
const endAt = new Date(startAt.getTime() + page.durationMinutes * 60_000);
const cancelled = appointment.status === "cancelled";
if (cancelled) {
// Real cancels remove the availability-blocking mirror — keep parity.
await db.calendarEvent.deleteMany({ where: { id: calendarEventId } });
} else {
const eventData = {
tenantId,
userId: provider.id,
source: "hivegrid_internal" as const,
title: `${demoBookingPageSeeds.find((p) => p.slug === appointment.pageSlug)?.title ?? "Buchung"} (Demo)`,
startsAt: startAt,
endsAt: endAt,
timeZone: demoBookingTimezone,
isBusyForAvailability: true,
internalEntityLink: { type: "appointment", id: appointmentId },
isDemoData: true,
};
await db.calendarEvent.upsert({ where: { id: calendarEventId }, create: { id: calendarEventId, ...eventData }, update: eventData });
}
const data = {
tenantId,
bookingPageId: page.id,
providerUserId: provider.id,
startAt,
endAt,
timezone: demoBookingTimezone,
status: appointment.status,
intakeAnswers: { ...appointment.intakeAnswers },
internalCalendarEventId: cancelled ? null : calendarEventId,
cancelledAt: cancelled ? demoBookingDate(appointment.dayOffset - 1, 12) : null,
cancelledByKind: cancelled ? ("customer" as const) : null,
cancellationReason: cancelled ? "Vom Endkunden storniert (Demo)." : null,
isDemoData: true,
};
await db.appointment.upsert({ where: { id: appointmentId }, create: { id: appointmentId, ...data }, update: data });
}
// One external busy block per tenant so the calendar grid shows both source
// markers (internal + external) without a live Google connection.
const externalEventId = `seed-${tenantSlug}-cal-external`;
const externalStartsAt = demoBookingDate(1, 12);
const externalData = {
tenantId,
userId: providers[0].id,
source: "external_synced" as const,
title: "Externer Termin (Demo)",
startsAt: externalStartsAt,
endsAt: new Date(externalStartsAt.getTime() + 90 * 60_000),
timeZone: demoBookingTimezone,
isBusyForAvailability: true,
isDemoData: true,
};
await db.calendarEvent.upsert({ where: { id: externalEventId }, create: { id: externalEventId, ...externalData }, update: externalData });
}
async function seedDemoTenantProductConfiguration(tenantId: string, planId: EntitlementPlanId) {
await db.tenantProductConfiguration.upsert({
where: { tenantId },