@cosmicdrift/kumiko-bundled-features 0.363.0 → 0.364.0

package/dist/template-resolver/handlers/override-diff.js

@@ -0,0 +1,41 @@
+import { diffTemplateBlocks, splitTemplateBlocks } from "../template-diff.js";
+import { servedVersionOf } from "../template-draft.js";
+function parseStoredMeta(raw) {
+    if (raw === null)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? Object.fromEntries(Object.entries(parsed))
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function diffMeta(system, tenant) {
+    const keys = [...new Set([...Object.keys(system), ...Object.keys(tenant)])].sort();
+    return keys
+        .filter((key) => JSON.stringify(system[key]) !== JSON.stringify(tenant[key]))
+        .map((key) => ({ key, tenant: tenant[key], system: system[key] }));
+}
+// Shared by the tenant's own diff and the SystemAdmin's per-tenant diff in the overrides drawer.
+export function buildOverrideDiff(tenantRow, systemRow) {
+    const blocks = diffTemplateBlocks(splitTemplateBlocks(systemRow.content ?? "", systemRow.contentFormat), splitTemplateBlocks(tenantRow.content ?? "", tenantRow.contentFormat));
+    const meta = diffMeta(parseStoredMeta(systemRow.meta), parseStoredMeta(tenantRow.meta));
+    return {
+        tenant: {
+            templateId: String(tenantRow.id),
+            templateVersion: servedVersionOf(tenantRow),
+            contentFormat: tenantRow.contentFormat,
+        },
+        system: {
+            templateId: String(systemRow.id),
+            templateVersion: servedVersionOf(systemRow),
+            contentFormat: systemRow.contentFormat,
+        },
+        identical: meta.length === 0 && blocks.every((block) => block.change === "same"),
+        blocks,
+        meta,
+    };
+}

package/dist/template-resolver/handlers/overview.query.d.ts

@@ -1,5 +1,7 @@
 import * as z from "zod";
 import { type TemplateStatus } from "../constants.js";
+import { type TemplateResourceRow } from "../table.js";
+import { type EffectiveMailLayoutSlugs } from "../template-usage.js";
 declare const OVERVIEW_KINDS: readonly ["mail", "document-pdf", "mail-layout", "pdf-layout"];
 type OverviewKind = (typeof OVERVIEW_KINDS)[number];
 export type OverviewOrigin = "tenant" | "system";
@@ -20,6 +22,8 @@ export type OverviewRow = {
     readonly locales: readonly string[];
     readonly status: TemplateStatus;
     readonly version: number;
+    readonly draftVersion: number | null;
+    readonly activeSince: string | null;
     readonly systemVersion: number | null;
     readonly layoutSlug: string | null;
     readonly modifiedAt: string;
@@ -31,6 +35,7 @@ export type OverviewResponse = {
     readonly nextCursor: null;
     readonly total: number;
 };
+export declare function effectiveMailLayoutSlugs(rows: readonly TemplateResourceRow[]): EffectiveMailLayoutSlugs;
 export declare const overviewQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"overview", z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
     filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -43,6 +48,7 @@ export declare const overviewQuery: import("@cosmicdrift/kumiko-types/define-han
         op: z.ZodLiteral<"in">;
         value: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>>;
+    layoutSlug: z.ZodOptional<z.ZodString>;
     sort: z.ZodOptional<z.ZodString>;
     sortDirection: z.ZodOptional<z.ZodEnum<{
         asc: "asc";

package/dist/template-resolver/handlers/overview.query.js

@@ -3,6 +3,7 @@ import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { DEFAULT_MAIL_LAYOUT_SLUG, FALLBACK_LOCALE } from "../constants.js";
 import { templateResourcesTable } from "../table.js";
+import { activeSinceOf, activeVersionOf, draftViewerTenantId, isHiddenSystemDraft, parseTemplateDraft, servedVersionOf, } from "../template-draft.js";
 import { collectTemplateUsage } from "../template-usage.js";
 import { storedRecord } from "./template-gates.js";
 const OVERVIEW_KINDS = ["mail", "document-pdf", "mail-layout", "pdf-layout"];
@@ -41,6 +42,26 @@ function effectiveRowsOf(rows) {
     }
     return tenantRows.length > 0 ? { origin: "tenant", rows: tenantRows } : null;
 }
+export function effectiveMailLayoutSlugs(rows) {
+    const byLocale = new Map();
+    for (const row of rows) {
+        if (row.kind !== "mail")
+            continue;
+        const key = `${row.slug}\u0000${row.locale}`;
+        byLocale.set(key, [...(byLocale.get(key) ?? []), row]);
+    }
+    const bySlug = new Map();
+    for (const group of byLocale.values()) {
+        const effective = effectiveRowsOf(group)?.rows[0];
+        // All-archived: the renderer falls back to the code-registered template.
+        if (effective === undefined || effective.status === "archived")
+            continue;
+        const locales = bySlug.get(effective.slug) ?? new Map();
+        locales.set(effective.locale, layoutSlugOf(effective));
+        bySlug.set(effective.slug, locales);
+    }
+    return bySlug;
+}
 function modifiedAtOf(row) {
     return (row.modifiedAt ?? row.insertedAt).toString();
 }
@@ -66,7 +87,23 @@ function groupBySlugAndKind(rows) {
     }
     return groups;
 }
-function buildDrafts(groups) {
+// Another tenant's draft, including a system draft seen by a tenant, is never announced.
+function draftVersionFor(user, row) {
+    const isOwnRow = row.tenantId === draftViewerTenantId(user, row);
+    return isOwnRow && parseTemplateDraft(row.draft) !== null ? row.version : null;
+}
+// Version columns of one overview row: the served version, a waiting draft and the system version it overrides.
+function versionFieldsOf(user, preferred, groupRows) {
+    const isActive = preferred.status === "active";
+    const systemSameLocale = groupRows.find((row) => row.scope === "system" && row.locale === preferred.locale);
+    return {
+        version: servedVersionOf(preferred),
+        draftVersion: draftVersionFor(user, preferred),
+        activeSince: isActive ? activeSinceOf(preferred).toString() : null,
+        systemVersion: systemSameLocale === undefined ? null : activeVersionOf(systemSameLocale),
+    };
+}
+function buildDrafts(groups, user) {
     const layoutSlugByDocument = new Map();
     const drafts = [];
     for (const [id, groupRows] of groups) {
@@ -76,7 +113,6 @@ function buildDrafts(groups) {
             continue;
         if (!isOverviewKind(preferred.kind) || !isTemplateStatus(preferred.status))
             continue;
-        const systemSameLocale = groupRows.find((row) => row.scope === "system" && row.locale === preferred.locale);
         const isDocument = preferred.kind === "mail" || preferred.kind === "document-pdf";
         const layoutSlug = isDocument ? layoutSlugOf(preferred) : null;
         if (layoutSlug !== null && preferred.kind === "document-pdf") {
@@ -91,18 +127,17 @@ function buildDrafts(groups) {
             origin: effective.origin,
             locales: [...new Set(effective.rows.map((row) => row.locale))].sort(),
             status: preferred.status,
-            version: preferred.version,
-            systemVersion: systemSameLocale?.version ?? null,
+            ...versionFieldsOf(user, preferred, groupRows),
             layoutSlug,
             modifiedAt: modifiedAtOf(preferred),
         });
     }
     return { drafts, layoutSlugByDocument };
 }
-function withUsage(draft, layoutSlugByDocument, registry) {
+function withUsage(draft, layoutSlugByDocument, registry, effectiveLayouts) {
     let usedBy = [];
     if (draft.kind === "mail" || draft.kind === "mail-layout") {
-        usedBy = collectTemplateUsage(registry, draft.slug, draft.kind).map((entry) => ({
+        usedBy = collectTemplateUsage(registry, draft.slug, draft.kind, effectiveLayouts).map((entry) => ({
             qualifiedName: entry.qualifiedName,
             feature: entry.feature,
             notification: entry.notification,
@@ -120,9 +155,11 @@ function withUsage(draft, layoutSlugByDocument, registry) {
     }
     return { ...draft, usedBy, usedByCount: usedBy.length };
 }
-function filterRows(rows, search, filters) {
+function filterRows(rows, search, filters, layoutSlug) {
     const needle = search?.trim().toLowerCase() ?? "";
     return rows.filter((row) => {
+        if (layoutSlug !== undefined && row.layoutSlug !== layoutSlug)
+            return false;
         if (needle !== "" && !`${row.title} ${row.slug}`.toLowerCase().includes(needle))
             return false;
         return filters.every((filter) => filter.value.includes(String(row[filter.field])));
@@ -138,6 +175,7 @@ export const overviewQuery = defineQueryHandler({
     schema: z.object({
         search: z.string().optional(),
         filters: z.array(filterSchema).optional(),
+        layoutSlug: z.string().optional(),
         sort: z.string().optional(),
         sortDirection: z.enum(["asc", "desc"]).optional(),
         limit: z.number().int().min(1).max(200).default(50),
@@ -145,13 +183,15 @@ export const overviewQuery = defineQueryHandler({
         totalCount: z.boolean().optional(),
     }),
     access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Lists mail, PDF and layout templates as one row per slug and kind for the caller's tenant: where the effective version comes from (own override or system), its locales, status and version, the system version it overrides, the layout it uses and which notifications or templates use it; use it to browse and filter all templates at a glance.",
+    description: "Lists mail, PDF and layout templates as one row per slug and kind for the caller's tenant (optionally only the mails and PDFs using one layout slug): where the effective version comes from (own override or system), its locales, status and version (the served one; `draftVersion` is set when an unpublished draft waits beside it, `activeSince` says since when the served version applies), the system version it overrides, the layout it uses and which notifications or templates use it; use it to browse and filter all templates at a glance.",
     handler: async (query, ctx) => {
         const payload = query.payload;
         const rows = await selectMany(ctx.db, templateResourcesTable, { kind: { in: [...OVERVIEW_KINDS] } }, { limit: OVERVIEW_ROW_LIMIT });
-        const { drafts, layoutSlugByDocument } = buildDrafts(groupBySlugAndKind(rows));
-        const overviewRows = drafts.map((draft) => withUsage(draft, layoutSlugByDocument, ctx.registry));
-        const filtered = filterRows(overviewRows, payload.search, payload.filters ?? []);
+        const visibleRows = rows.filter((row) => !isHiddenSystemDraft(query.user, row));
+        const { drafts, layoutSlugByDocument } = buildDrafts(groupBySlugAndKind(visibleRows), query.user);
+        const effectiveLayouts = effectiveMailLayoutSlugs(visibleRows);
+        const overviewRows = drafts.map((draft) => withUsage(draft, layoutSlugByDocument, ctx.registry, effectiveLayouts));
+        const filtered = filterRows(overviewRows, payload.search, payload.filters ?? [], payload.layoutSlug);
         const sortField = payload.sort !== undefined && isSortField(payload.sort) ? payload.sort : "modifiedAt";
         const direction = (payload.sortDirection ?? "desc") === "desc" ? -1 : 1;
         filtered.sort((a, b) => direction * compareBy(sortField, a, b) || a.id.localeCompare(b.id));

package/dist/template-resolver/handlers/reset-to-system.write.d.ts

@@ -5,4 +5,4 @@ export declare const resetToSystemWrite: import("@cosmicdrift/kumiko-types/defin
     id: string;
     status: "archived";
     systemTemplateId: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/resource-link-pdf.write.d.ts

@@ -5,4 +5,4 @@ export declare const resourceLinkPdfWrite: import("@cosmicdrift/kumiko-types/def
     templateSlug: z.ZodString;
     fileName: z.ZodString;
     tenantIdOverride: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, import("../store-template-resource.js").LinkedTemplatePdfAttachment, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, z.core.$strip>, import("../store-template-resource.js").LinkedTemplatePdfAttachment, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/resource-remove.write.d.ts

@@ -6,4 +6,4 @@ export declare const resourceRemoveWrite: import("@cosmicdrift/kumiko-types/defi
 }, z.core.$strip>, {
     key: string;
     removed: boolean;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/resource-upload.write.d.ts

@@ -10,4 +10,4 @@ export declare const resourceUploadWrite: import("@cosmicdrift/kumiko-types/defi
         image: "image";
     }>>;
     fileName: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, StoredTemplateAttachment | StoredTemplateResource, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, z.core.$strip>, StoredTemplateAttachment | StoredTemplateResource, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/resource-upload.write.js

@@ -55,7 +55,7 @@ export const resourceUploadWrite = defineWriteHandler({
         try {
             source = await readFileRefContent({
                 db: ctx.db,
-                filesForTenant: (tid) => fileContextForTenant(ctx, tid),
+                filesForTenant: (tid) => fileContextForTenant(ctx, ctx.user.tenantId, tid),
                 fileRefId: sourceFileRefId,
                 allowedTenantIds: [event.user.tenantId],
                 unclaimedUploadOf: event.user.id,

package/dist/template-resolver/handlers/send-test.write.d.ts

@@ -5,7 +5,9 @@ export declare const sendTestWrite: import("@cosmicdrift/kumiko-types/define-han
     content: z.ZodOptional<z.ZodString>;
     meta: z.ZodOptional<z.ZodUnknown>;
     variableSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    includeAttachments: z.ZodDefault<z.ZodBoolean>;
+    prefixSubject: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {
     subject: string;
     checks: readonly import("../template-preview.js").PreviewCheck[];
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/send-test.write.js

@@ -18,6 +18,10 @@ function testMailFailed(code) {
         details: { code },
     }));
 }
+function errorCodeOf(error) {
+    const code = error instanceof Error ? Reflect.get(error, "code") : undefined;
+    return typeof code === "string" ? code : undefined;
+}
 // The only recipient is the caller's own address, resolved server-side, so the handler can never mail a third party.
 export const sendTestWrite = defineWriteHandler({
     name: "send-test",
@@ -27,18 +31,24 @@ export const sendTestWrite = defineWriteHandler({
         content: z.string().max(200_000).optional(),
         meta: z.unknown().optional(),
         variableSchema: z.record(z.string(), z.unknown()).default({}),
+        includeAttachments: z.boolean().default(true),
+        prefixSubject: z.boolean().default(true),
     }),
     access: { roles: ["TenantAdmin", "SystemAdmin"] },
     rateLimit: { per: "user+handler", ...TEST_MAIL_RATE_LIMIT },
-    description: "Sends the rendered preview of a mail template draft, or of the stored template when no content is given, to the calling user's own address with the subject prefixed by [TEST], carrying the inline images and the files attached to the template; there is no recipient input, the sample values come from the declared variable examples, and a draft that fails the write rules is rejected without sending.",
+    description: "Sends the rendered preview of a mail template draft, or of the stored template when no content is given, to the calling user's own address with the subject prefixed by [TEST] unless prefixSubject is false, carrying the inline images and, unless includeAttachments is false, the files attached to the template; there is no recipient input, the sample values come from the declared variable examples, and a draft that fails the write rules is rejected without sending.",
     handler: async (event, ctx) => {
+        const { includeAttachments, prefixSubject, ...previewPayload } = event.payload;
         const outcome = await renderTemplatePreview(ctx, event.user, {
-            ...event.payload,
+            ...previewPayload,
             kind: "mail",
         });
         if (!outcome.ok)
             return writeFailure(outcome.error);
-        const { preview, mailAttachments } = outcome;
+        const { preview, sender } = outcome;
+        const mailAttachments = includeAttachments
+            ? outcome.mailAttachments
+            : outcome.mailAttachments.filter((ref) => ref.kind === "inline");
         const channel = emailChannelOf(ctx.registry);
         if (channel === undefined) {
             return writeFailure(new UnprocessableError(TemplateResolverErrors.testMailNoChannel, {
@@ -51,7 +61,7 @@ export const sendTestWrite = defineWriteHandler({
             sseBroker: undefined,
             tenantId: event.user.tenantId,
             secrets: ctx.secrets,
-            readAttachment: createEmailAttachmentReader(ctx.db, ctx.registry, event.user.tenantId, ctx.config, (tenantId) => fileContextForTenant(ctx, tenantId)),
+            readAttachment: createEmailAttachmentReader(ctx.db, ctx.registry, event.user.tenantId, ctx.config, (tenantId) => fileContextForTenant(ctx, ctx.user.tenantId, tenantId)),
         };
         const address = (await channel.resolve?.(event.user.id, channelContext)) ?? null;
         if (address === null) {
@@ -59,8 +69,8 @@ export const sendTestWrite = defineWriteHandler({
                 i18nKey: "templateResolver.errors.testMail.noAddress",
             }));
         }
-        const subject = `${TEST_MAIL_SUBJECT_PREFIX}${preview.subject ?? ""}`;
-        let sent;
+        const subject = `${prefixSubject ? TEST_MAIL_SUBJECT_PREFIX : ""}${preview.subject ?? ""}`;
+        let sentStatus;
         try {
             const result = await channel.send(address, {
                 notificationType: TEST_MAIL_NOTIFICATION_TYPE,
@@ -68,14 +78,31 @@ export const sendTestWrite = defineWriteHandler({
                 body: undefined,
                 data: undefined,
                 locale: event.payload.locale,
-            }, channelContext, { subject, html: preview.html, text: preview.text ?? "", attachments: mailAttachments });
-            sent = result.status === "sent";
+            }, channelContext, {
+                subject,
+                html: preview.html,
+                text: preview.text ?? "",
+                ...sender,
+                attachments: mailAttachments,
+            });
+            sentStatus = result.status;
         }
-        catch {
+        catch (error) {
+            // Class and code only: the message can carry the address or a provider response body.
+            ctx.log?.warn("template test mail: channel threw", {
+                tenantId: event.user.tenantId,
+                errorClass: error instanceof Error ? error.name : typeof error,
+                errorCode: errorCodeOf(error),
+            });
             return testMailFailed("channel_error");
         }
-        if (!sent)
+        if (sentStatus !== "sent") {
+            ctx.log?.warn("template test mail: channel did not send", {
+                tenantId: event.user.tenantId,
+                status: sentStatus,
+            });
             return testMailFailed("not_sent");
+        }
         return { isSuccess: true, data: { subject, checks: preview.checks } };
     },
 });

package/dist/template-resolver/handlers/set.write.d.ts

@@ -27,4 +27,4 @@ export declare const setWrite: import("@cosmicdrift/kumiko-types/define-handler"
     slug: string;
     locale: string;
     isNew: boolean;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/template-gates.js

@@ -10,12 +10,23 @@ const PLACEHOLDER_VALIDATED_KINDS = new Set([
     "document-pdf",
     "pdf-layout",
 ]);
+// The parser's wording is English and meant for logs; the UI gets a key per setting instead.
+const META_FIELDS_WITH_MESSAGES = new Set([
+    "subject",
+    "previewText",
+    "senderName",
+    "replyTo",
+    "layoutSlug",
+    "fileName",
+]);
 function metaIssueToFieldIssue(issue) {
+    const hasMessage = META_FIELDS_WITH_MESSAGES.has(issue.field);
     return {
         path: issue.path,
         code: "invalid_meta",
-        i18nKey: "templateResolver.errors.template.invalidMeta",
-        params: { detail: issue.message },
+        i18nKey: hasMessage
+            ? `templateResolver.errors.template.meta.${issue.field}.${issue.missing ? "required" : "invalid"}`
+            : "templateResolver.errors.template.invalidMeta",
     };
 }
 export function placeholderIssues(validation, opts) {

package/dist/template-resolver/handlers/template-write.js

@@ -3,6 +3,7 @@ import { SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
 import { AccessDeniedError, ValidationError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
 import { requireForTenant } from "../../shared/index.js";
 import { templateResourcesTable } from "../table.js";
+import { activationChanges, serializeTemplateDraft } from "../template-draft.js";
 import { executor } from "./shared.js";
 import { evaluateTemplateWrite, } from "./template-gates.js";
 // The tenant-scope-under-system-tenant ban lives here so no write path can
@@ -33,6 +34,29 @@ export function gateTemplateWrite(input, status) {
     }
     return { ok: true, evaluated };
 }
+// A draft over an active row is stored beside it; every other write replaces the main fields.
+function updateChanges(existing, status, fields) {
+    if (status === "active")
+        return { ...fields, ...activationChanges(existing) };
+    if (existing.status !== "active")
+        return { ...fields, status, draft: null };
+    const draft = serializeTemplateDraft({
+        content: fields.content,
+        contentFormat: fields.contentFormat,
+        variableSchema: fields.variableSchema,
+        meta: fields.meta,
+        title: fields.title,
+        folder: fields.folder,
+        parentTemplateId: fields.parentTemplateId,
+    });
+    return existing.activeVersion === null
+        ? {
+            draft,
+            activeVersion: existing.version,
+            activeSince: existing.modifiedAt ?? existing.insertedAt,
+        }
+        : { draft };
+}
 // Shared by every template write: validate through the one pipeline, then
 // create or update the (tenant, slug, kind, locale) row via the event-store
 // executor. linkedResources is never part of an update; resources are attached
@@ -75,7 +99,11 @@ export async function writeTemplateRow(args) {
         status,
     };
     if (existing) {
-        const result = await executor.update({ id: existing.id, version: existing.version, changes: fields }, user, db, { streamTenantId });
+        const result = await executor.update({
+            id: existing.id,
+            version: existing.version,
+            changes: updateChanges(existing, status, fields),
+        }, user, db, { streamTenantId });
         if (!result.isSuccess)
             return result;
         return {
@@ -88,9 +116,13 @@ export async function writeTemplateRow(args) {
             },
         };
     }
-    const result = await executor.create({ ...fields, linkedResources: "{}", tenantId }, user, db, {
-        streamTenantId,
-    });
+    const result = await executor.create({
+        ...fields,
+        linkedResources: "{}",
+        tenantId,
+        draft: null,
+        ...(status === "active" ? activationChanges(null) : {}),
+    }, user, db, { streamTenantId });
     if (!result.isSuccess)
         return result;
     // @cast-boundary db-row — executor.create returnt Record-row aus

package/dist/template-resolver/handlers/tenant-overrides.query.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod";
+type OverrideStatus = "active" | "draft";
 export declare const tenantOverridesQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"tenant-overrides", z.ZodObject<{
     slug: z.ZodString;
     kind: z.ZodEnum<{
@@ -10,8 +11,39 @@ export declare const tenantOverridesQuery: import("@cosmicdrift/kumiko-types/def
         "pdf-layout": "pdf-layout";
     }>;
     locale: z.ZodOptional<z.ZodString>;
+    diffTenantId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, {
     activeOverrides: number;
     draftOverrides: number;
     totalTenants: number | null;
+    rows: {
+        tenantId: string;
+        tenantName: string;
+        templateId: string;
+        locale: string;
+        status: OverrideStatus;
+        version: number;
+        changedAt: string;
+        changedBy: string | null;
+    }[];
+    diff: {
+        tenant: {
+            templateId: string;
+            templateVersion: number;
+            contentFormat: string;
+        };
+        system: {
+            templateId: string;
+            templateVersion: number;
+            contentFormat: string;
+        };
+        identical: boolean;
+        blocks: import("../template-diff.js").TemplateDiffBlock[];
+        meta: {
+            key: string;
+            tenant: unknown;
+            system: unknown;
+        }[];
+    } | null;
 }, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+export {};

package/dist/template-resolver/handlers/tenant-overrides.query.js

@@ -3,22 +3,72 @@ import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framew
 import * as z from "zod";
 import { TenantQueries } from "../../tenant/index.js";
 import { templateResourcesTable } from "../table.js";
+import { servedVersionOf } from "../template-draft.js";
+import { buildOverrideDiff } from "./override-diff.js";
 import { kindSchema, localeSchema, templateSlugSchema } from "./shared.js";
-const TENANT_OVERRIDES_REASON = "SystemAdmin template overview counts how many tenants override one system template; it reads tenant-scope template rows of every tenant and returns only counts, never tenant ids or content";
+const TENANT_OVERRIDES_REASON = "SystemAdmin template overview lists which tenants override one system template; it reads tenant-scope template rows of every tenant (and the system row for the optional per-tenant diff), which the tenant-scoped db cannot reach";
 const tenantIdsSchema = z.array(z.string());
+const directorySchema = z.object({
+    rows: z.array(z.object({ id: z.string(), label: z.string() })),
+});
+function labelsOf(raw) {
+    return new Map(directorySchema.parse(raw).rows.map((row) => [row.id, row.label]));
+}
+// One row per tenant: its active override wins over a draft, then the newest version.
+function isBetterRow(candidate, current) {
+    if ((candidate.status === "active") !== (current.status === "active")) {
+        return candidate.status === "active";
+    }
+    return candidate.version > current.version;
+}
+function statusOf(row) {
+    return row.status === "active" ? "active" : "draft";
+}
+function isCountedTenantRow(row, enabledTenantIds) {
+    if (row.tenantId === SYSTEM_TENANT_ID || row.status === "archived")
+        return false;
+    return enabledTenantIds === null || enabledTenantIds.has(row.tenantId);
+}
+function pickBestRowPerTenant(found, enabledTenantIds) {
+    const bestByTenant = new Map();
+    for (const row of found) {
+        if (!isCountedTenantRow(row, enabledTenantIds))
+            continue;
+        const current = bestByTenant.get(row.tenantId);
+        if (current === undefined || isBetterRow(row, current))
+            bestByTenant.set(row.tenantId, row);
+    }
+    return bestByTenant;
+}
+function toOverrideRow(row, tenantLabels, userLabels) {
+    const changedById = row.modifiedById ?? row.insertedById;
+    return {
+        tenantId: row.tenantId,
+        tenantName: tenantLabels.get(row.tenantId) ?? row.tenantId,
+        templateId: String(row.id),
+        locale: row.locale,
+        status: statusOf(row),
+        version: servedVersionOf(row),
+        changedAt: (row.modifiedAt ?? row.insertedAt).toString(),
+        changedBy: changedById === null ? null : (userLabels.get(changedById) ?? null),
+    };
+}
 export const tenantOverridesQuery = defineQueryHandler({
     name: "tenant-overrides",
     schema: z.object({
         slug: templateSlugSchema,
         kind: kindSchema,
         locale: localeSchema.optional(),
+        /** Adds the block diff of this tenant's override against the system template. */
+        diffTenantId: z.string().min(1).optional(),
     }),
     access: { roles: ["SystemAdmin"] },
-    description: "Counts how many enabled tenants override one template with an active or a draft version, next to the number of enabled tenants; use it before changing a system template to see how many tenants keep their own copy. Returns counts only, no tenant ids.",
+    description: "Lists the enabled tenants that override one template with an active or a draft version (tenant name, status, version, last change and who made it), next to the counts and the number of enabled tenants; use it before changing a system template to see who keeps their own copy. With diffTenantId it also returns the block diff of that tenant's override against the system template.",
     escapeHatch: { grants: ["unsafeRaw"], reason: TENANT_OVERRIDES_REASON },
     handler: async (query, ctx) => {
-        const { slug, kind, locale } = query.payload;
-        const rows = await selectMany(ctx.db.unsafeRaw(), templateResourcesTable, {
+        const { slug, kind, locale, diffTenantId } = query.payload;
+        const raw = ctx.db.unsafeRaw();
+        const found = await selectMany(raw, templateResourcesTable, {
             slug,
             kind,
             scope: "tenant",
@@ -28,21 +78,35 @@ export const tenantOverridesQuery = defineQueryHandler({
         const enabledTenantIds = hasTenantFeature
             ? new Set(tenantIdsSchema.parse(await ctx.query(TenantQueries.activeTenantIds, {})))
             : null;
-        const statusByTenant = new Map();
-        for (const row of rows) {
-            if (row.tenantId === SYSTEM_TENANT_ID || row.status === "archived")
-                continue;
-            if (enabledTenantIds !== null && !enabledTenantIds.has(row.tenantId))
-                continue;
-            if (statusByTenant.get(row.tenantId) === "active")
-                continue;
-            statusByTenant.set(row.tenantId, row.status === "active" ? "active" : "draft");
+        const bestByTenant = pickBestRowPerTenant(found, enabledTenantIds);
+        const best = [...bestByTenant.values()];
+        const tenantLabels = hasTenantFeature
+            ? labelsOf(await ctx.query(TenantQueries.tenantDirectory, {}))
+            : new Map();
+        const userLabels = hasTenantFeature
+            ? labelsOf(await ctx.query(TenantQueries.memberDirectory, {}))
+            : new Map();
+        const rows = best
+            .map((row) => toOverrideRow(row, tenantLabels, userLabels))
+            .sort((a, b) => a.tenantName.localeCompare(b.tenantName));
+        let diff = null;
+        const diffRow = diffTenantId === undefined ? undefined : bestByTenant.get(diffTenantId);
+        if (diffRow !== undefined) {
+            const [systemRow] = await selectMany(raw, templateResourcesTable, {
+                tenantId: SYSTEM_TENANT_ID,
+                slug,
+                kind,
+                locale: diffRow.locale,
+            });
+            if (systemRow !== undefined)
+                diff = buildOverrideDiff(diffRow, systemRow);
         }
-        const statuses = [...statusByTenant.values()];
         return {
-            activeOverrides: statuses.filter((status) => status === "active").length,
-            draftOverrides: statuses.filter((status) => status === "draft").length,
+            activeOverrides: best.filter((row) => row.status === "active").length,
+            draftOverrides: best.filter((row) => row.status !== "active").length,
             totalTenants: enabledTenantIds === null ? null : enabledTenantIds.size,
+            rows,
+            diff,
         };
     },
 });