Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/services/admin/admin-sales-tenant.server.ts
T

126 lines
3.9 KiB
TypeScript

import { createHash } from "node:crypto";
import {
linkAdminDealToTenantWithTx,
} from "@hivegrid/db/admin-sales-pipeline.server";
import type { AdminSalesActor } from "@hivegrid/db/admin-sales-core.server";
import type { Tenant } from "@hivegrid/db/prisma-browser";
import {
prepareReservedOwnerInvitation,
issueReservedOwnerInvitationWithTx,
} from "~/domain/tenant-bootstrap/ownerInvitationIssuance.server";
import { TENANT_PENDING_OWNER_REASON } from "~/domain/tenant-bootstrap/tenantBootstrap.constants";
import { db } from "~/utils/db.server";
import { createTenant } from "~/utils/db/tenants.db.server";
export type CreateAdminSalesTenantInput = {
readonly request: Request;
readonly dealId: string;
readonly tenantName: string;
readonly tenantSlug: string;
readonly ownerEmail: string;
readonly ownerFirstName: string;
readonly ownerLastName: string;
readonly admin: {
readonly id: string;
readonly firstName: string;
readonly locale: string | null;
};
readonly actor: AdminSalesActor;
};
export async function createAndLinkAdminSalesTenant(
input: CreateAdminSalesTenantInput
): Promise<Tenant> {
const replay = await resolveExistingPromotion(input.dealId);
if (replay) return replay;
const reservationKey = deriveAdminSalesTenantReservationKey(input.dealId);
const ownerInvitation = await prepareReservedOwnerInvitation({
request: input.request,
issuanceKey: reservationKey,
tenantName: input.tenantName,
email: input.ownerEmail,
firstName: input.ownerFirstName,
lastName: input.ownerLastName,
issuer: {
id: null,
firstName: input.admin.firstName,
locale: input.admin.locale,
},
});
return createTenant({
tenantId: reservationKey,
name: input.tenantName,
slug: input.tenantSlug,
rejectSlugCollision: true,
active: false,
deactivatedReason: TENANT_PENDING_OWNER_REASON,
rlsUserId: input.admin.id,
emitCreatedHook: false,
validateExistingReplay: async (tenant, tx) => {
const deal = await tx.adminDeal.findUnique({
where: { id: input.dealId },
select: { status: true, promotedTenantId: true },
});
if (
tenant.name !== input.tenantName ||
deal?.status !== "won" ||
deal.promotedTenantId !== tenant.id
) {
throw new Error("Admin sales tenant creation replay does not match.");
}
},
setup: async (tenant, tx) => {
await issueReservedOwnerInvitationWithTx(tx, {
tenantId: tenant.id,
...ownerInvitation,
});
await linkAdminDealToTenantWithTx(tx, {
dealId: input.dealId,
tenantId: tenant.id,
actor: input.actor,
allowPendingOwner: true,
});
return tenant;
},
});
}
export function deriveAdminSalesTenantReservationKey(dealId: string): string {
const normalized = dealId.trim();
if (!/^[A-Za-z0-9_:-]{1,191}$/u.test(normalized)) {
throw new Error("Admin sales deal identifier is invalid.");
}
const digest = createHash("sha256")
.update(`admin-sales:tenant:${normalized}`)
.digest("hex")
.slice(0, 32)
.split("");
digest[12] = "4";
digest[16] = "8";
const value = digest.join("");
return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
}
async function resolveExistingPromotion(dealId: string): Promise<Tenant | null> {
const deal = await db.adminDeal.findFirst({
where: { id: dealId, archivedAt: null },
select: { status: true, promotedTenantId: true },
});
if (!deal) throw new Error("Admin sales deal was not found.");
if (deal.status !== "won") {
throw new Error("Admin sales tenant promotion requires a won deal.");
}
if (!deal.promotedTenantId) return null;
const tenant = await db.tenant.findUnique({
where: { id: deal.promotedTenantId },
});
if (!tenant) {
throw new Error("Admin sales linked tenant was not found.");
}
return tenant;
}