Files
persionalBrand/apps/api/src/brand-release.service.ts
T

132 lines
5.0 KiB
TypeScript

import { Injectable } from "@nestjs/common";
import { Prisma } from "@prisma/client";
import {
defaultBrandTemplateKey,
getBrandTemplate,
getVisualTemplate,
getVisualTemplateManifest,
getDefaultVisualTemplateKey,
getTemplatePackageManifestForVisualKey,
} from "@personal-brand/config";
import type { TemplatePackageManifest } from "@personal-brand/config";
import { PrismaService } from "./prisma.service.js";
export interface BrandReleaseSnapshot {
schemaVersion: "1.0.0";
generatedAt: string;
templateKey: string;
templateDefinition?: ReturnType<typeof getBrandTemplate> | null;
visualTemplateDefinition?: ReturnType<typeof getVisualTemplate> | null;
visualTemplateManifest?: ReturnType<typeof getVisualTemplateManifest> | null;
templatePackageManifest?: TemplatePackageManifest | null;
brand: Record<string, unknown> | null;
installation: Record<string, unknown> | null;
fields: unknown[];
offerings: unknown[];
forms: unknown[];
trustContents: unknown[];
capabilities: unknown[];
}
export async function buildBrandReleaseSnapshot(
database: Prisma.TransactionClient,
brandId: string,
): Promise<BrandReleaseSnapshot> {
const [brand, installation, fields, offerings, forms, trustContents, capabilities] =
await Promise.all([
database.brandProfile.findUnique({ where: { id: brandId } }),
database.brandTemplateInstallation.findFirst({
where: { brandId },
orderBy: { updatedAt: "desc" },
}),
database.brandFieldDefinition.findMany({ where: { brandId }, orderBy: { sortOrder: "asc" } }),
database.offering.findMany({ where: { brandId }, orderBy: { sortOrder: "asc" } }),
database.inquiryForm.findMany({ where: { brandId }, orderBy: { updatedAt: "desc" } }),
database.trustContent.findMany({ where: { brandId }, orderBy: { sortOrder: "asc" } }),
database.capabilityInstallation.findMany({ where: { brandId } }),
]);
const templateKey = installation?.templateKey ?? brand?.templateKey ?? defaultBrandTemplateKey;
const config =
brand?.config && typeof brand.config === "object" && !Array.isArray(brand.config)
? (brand.config as Record<string, unknown>)
: {};
const visualKey =
typeof config.visualTemplateKey === "string"
? config.visualTemplateKey
: getDefaultVisualTemplateKey(brand?.templateKey ?? defaultBrandTemplateKey);
const jsonObject = (value: object): Record<string, unknown> =>
JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
return {
schemaVersion: "1.0.0",
generatedAt: new Date().toISOString(),
templateKey,
templateDefinition: getBrandTemplate(templateKey) ?? null,
visualTemplateDefinition: getVisualTemplate(visualKey) ?? null,
visualTemplateManifest: getVisualTemplateManifest(visualKey) ?? null,
templatePackageManifest: getTemplatePackageManifestForVisualKey(visualKey) ?? null,
brand: brand ? jsonObject(brand) : null,
installation: installation ? jsonObject(installation) : null,
fields: fields.map((item) => jsonObject(item)),
offerings: offerings.map((item) => jsonObject(item)),
forms: forms.map((item) => jsonObject(item)),
trustContents: trustContents.map((item) => jsonObject(item)),
capabilities: capabilities.map((item) => jsonObject(item)),
};
}
@Injectable()
export class BrandReleaseService {
constructor(private readonly prisma: PrismaService) {}
async getPublishedSnapshot(brandId: string): Promise<BrandReleaseSnapshot | null> {
const release = await this.prisma.brandRelease.findFirst({
where: { brandId, status: "published" },
orderBy: { version: "desc" },
select: { snapshot: true },
});
return release ? (release.snapshot as unknown as BrandReleaseSnapshot) : null;
}
publishedOfferingIds(snapshot: BrandReleaseSnapshot): Set<string> {
return new Set(
snapshot.offerings.flatMap((raw) => {
const item = this.record(raw);
return item.isEnabled === true && typeof item.id === "string" ? [item.id] : [];
}),
);
}
publishedForm(snapshot: BrandReleaseSnapshot, formId: string): Record<string, unknown> | null {
const offeringIds = this.publishedOfferingIds(snapshot);
return (
snapshot.forms
.map((raw) => this.record(raw))
.find((form) => {
return (
form.id === formId &&
form.isEnabled === true &&
(form.offeringId === null ||
(typeof form.offeringId === "string" && offeringIds.has(form.offeringId)))
);
}) ?? null
);
}
private record(value: unknown): Record<string, unknown> {
return value && typeof value === "object" && !Array.isArray(value)
? (value as Record<string, unknown>)
: {};
}
async buildSnapshot(
brandId: string,
database: Prisma.TransactionClient = this.prisma,
): Promise<BrandReleaseSnapshot> {
return buildBrandReleaseSnapshot(database, brandId);
}
toPrismaJson(snapshot: BrandReleaseSnapshot): Prisma.InputJsonValue {
return snapshot as unknown as Prisma.InputJsonValue;
}
}