@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.363.0

package/dist/template-resolver/handlers/import-bundle-system.write.js

@@ -0,0 +1,36 @@
+import { defineWriteHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { templateBundleSchema } from "../template-bundle.js";
+import { importTemplateBundle } from "./bundle-import.js";
+export const importBundleSystemWrite = defineWriteHandler({
+    name: "import-bundle-system",
+    schema: z.object({ bundle: templateBundleSchema }),
+    access: { roles: ["SystemAdmin"] },
+    // A system template change reaches every tenant without an override.
+    agent: { risk: "high" },
+    description: "Imports a template bundle as system-default templates, active straight away and overwriting existing system rows; SystemAdmin only. Bundles with resource files need a caller in the system tenant, because the files are stored in the caller's file space.",
+    handler: (event, ctx) => {
+        const { bundle } = event.payload;
+        if (Object.keys(bundle.resources).length > 0 && event.user.tenantId !== SYSTEM_TENANT_ID) {
+            return Promise.resolve(writeFailure(new ValidationError({
+                fields: [
+                    {
+                        path: "bundle.resources",
+                        code: "system_resources_need_system_tenant",
+                        i18nKey: "templateResolver.errors.template.systemResourcesNeedSystemTenant",
+                    },
+                ],
+            })));
+        }
+        return importTemplateBundle({
+            ctx,
+            user: event.user,
+            tenantId: SYSTEM_TENANT_ID,
+            scope: "system",
+            status: "active",
+            bundle,
+            overwrite: true,
+        });
+    },
+});

package/dist/template-resolver/handlers/import-bundle.write.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod";
+export declare const importBundleWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"import-bundle", z.ZodObject<{
+    bundle: z.ZodObject<{
+        slug: z.ZodString;
+        kind: z.ZodEnum<{
+            "ai-prompt": "ai-prompt";
+            "document-pdf": "document-pdf";
+            "image-snapshot": "image-snapshot";
+            mail: "mail";
+            "mail-layout": "mail-layout";
+            "pdf-layout": "pdf-layout";
+        }>;
+        contentFormat: z.ZodEnum<{
+            html: "html";
+            markdown: "markdown";
+            mjml: "mjml";
+            plain: "plain";
+        }>;
+        variableSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        locales: z.ZodRecord<z.ZodString, z.ZodObject<{
+            body: z.ZodString;
+            meta: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>;
+        resources: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            fileName: z.ZodString;
+            contentType: z.ZodString;
+            base64: z.ZodString;
+            purpose: z.ZodOptional<z.ZodEnum<{
+                attachment: "attachment";
+            }>>;
+        }, z.core.$strict>>>;
+        pdfAttachments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            templateSlug: z.ZodString;
+            fileName: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    ids: Record<string, string>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

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

@@ -0,0 +1,19 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { templateBundleSchema } from "../template-bundle.js";
+import { importTemplateBundle } from "./bundle-import.js";
+export const importBundleWrite = defineWriteHandler({
+    name: "import-bundle",
+    schema: z.object({ bundle: templateBundleSchema, overwrite: z.boolean().default(false) }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Imports a template bundle (all locales plus resource files, as produced by export-bundle) into the caller's tenant as drafts; it refuses a locale that already has an override unless overwrite is set, and publish makes the drafts live.",
+    handler: (event, ctx) => importTemplateBundle({
+        ctx,
+        user: event.user,
+        tenantId: event.user.tenantId,
+        scope: "tenant",
+        status: "draft",
+        bundle: event.payload.bundle,
+        overwrite: event.payload.overwrite,
+    }),
+});

package/dist/template-resolver/handlers/layout-source.query.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod";
+import { type LayoutRegions } from "../layout-regions.js";
+export type LayoutSourceRow = {
+    readonly id: string;
+    readonly version: number;
+    readonly status: string;
+    readonly locale: string;
+};
+export type LayoutSourceResponse = {
+    readonly tenant: LayoutSourceRow | null;
+    readonly system: (LayoutSourceRow & {
+        readonly contentFormat: string;
+    }) | null;
+    readonly regions: LayoutRegions;
+    readonly effectiveFormat: "html" | "mjml" | null;
+    readonly mjmlSource: string | null;
+    readonly locale: string;
+};
+export declare const layoutSourceQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"layout-source", z.ZodObject<{
+    kind: z.ZodEnum<{
+        "mail-layout": "mail-layout";
+        "pdf-layout": "pdf-layout";
+    }>;
+    slug: z.ZodDefault<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, LayoutSourceResponse, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/layout-source.query.js

@@ -0,0 +1,64 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { FALLBACK_LOCALE } from "../constants.js";
+import { readLayoutRegions } from "../layout-regions.js";
+import { templateResourcesTable } from "../table.js";
+import { localeSchema, templateSlugSchema } from "./shared.js";
+const EMPTY_REGIONS = { header: "", signature: "", footer: "" };
+function pickByLocale(rows, requested) {
+    const live = rows.filter((row) => row.status !== "archived");
+    const candidates = live.length > 0 ? live : rows;
+    return (candidates.find((row) => row.locale === requested) ??
+        candidates.find((row) => row.locale === FALLBACK_LOCALE) ??
+        candidates[0] ??
+        null);
+}
+function toSourceRow(row) {
+    return { id: String(row.id), version: row.version, status: row.status, locale: row.locale };
+}
+function layoutFormat(row) {
+    return row.contentFormat === "html" || row.contentFormat === "mjml" ? row.contentFormat : null;
+}
+function pickEditedRows(rows, isSystemAdmin, locale) {
+    const tenantRow = isSystemAdmin
+        ? null
+        : pickByLocale(rows.filter((row) => row.scope === "tenant"), locale);
+    const systemRow = pickByLocale(rows.filter((row) => row.scope === "system"), locale);
+    return { tenantRow, systemRow };
+}
+export const layoutSourceQuery = defineQueryHandler({
+    name: "layout-source",
+    schema: z.object({
+        kind: z.enum(["mail-layout", "pdf-layout"]),
+        slug: templateSlugSchema.default("default"),
+        locale: localeSchema.optional(),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Reads the layout the caller edits: the tenant's own version and the system version of one layout slug, the header, signature and footer regions of the effective html version, and the locale a save has to use; a SystemAdmin edits the system version and also receives its mjml source. Use it to load the layout editor.",
+    handler: async (query, ctx) => {
+        const { kind, slug, locale } = query.payload;
+        const isSystemAdmin = query.user.roles.includes("SystemAdmin");
+        const rows = await selectMany(ctx.db, templateResourcesTable, {
+            kind,
+            slug,
+        });
+        const { tenantRow, systemRow } = pickEditedRows(rows, isSystemAdmin, locale);
+        const effective = tenantRow ?? systemRow;
+        const effectiveFormat = effective === null ? null : layoutFormat(effective);
+        return {
+            tenant: tenantRow === null ? null : toSourceRow(tenantRow),
+            system: systemRow === null
+                ? null
+                : { ...toSourceRow(systemRow), contentFormat: systemRow.contentFormat },
+            regions: effective !== null && effectiveFormat === "html"
+                ? readLayoutRegions(effective.content ?? "")
+                : EMPTY_REGIONS,
+            effectiveFormat,
+            mjmlSource: isSystemAdmin && systemRow !== null && layoutFormat(systemRow) === "mjml"
+                ? (systemRow.content ?? "")
+                : null,
+            locale: effective?.locale ?? locale ?? FALLBACK_LOCALE,
+        };
+    },
+});

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

@@ -4,8 +4,11 @@ export declare const listQuery: import("@cosmicdrift/kumiko-types/define-handler
         "ai-prompt": "ai-prompt";
         "document-pdf": "document-pdf";
         "image-snapshot": "image-snapshot";
-        "mail-html": "mail-html";
+        mail: "mail";
+        "mail-layout": "mail-layout";
         notification: "notification";
+        "pdf-layout": "pdf-layout";
+        snippet: "snippet";
         "text-block": "text-block";
     }>>;
     locale: z.ZodOptional<z.ZodString>;

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

@@ -3,9 +3,8 @@ import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { TEMPLATE_KINDS, TEMPLATE_STATUSES } from "../constants.js";
 import { templateResourcesTable } from "../table.js";
-// List für Admin-UI: filterbar nach kind / locale / status. Liefert
-// system-templates + tenant's eigene zusammen — Admin-UI rendert beide
-// Spalten mit scope-marker. SystemAdmin sieht alle (auch andere Tenants).
+// ctx.db is tenant-scoped even for SystemAdmin: every caller sees its own
+// tenant's rows plus the system defaults, never another tenant's rows.
 export const listQuery = defineQueryHandler({
     name: "list",
     schema: z.object({
@@ -18,10 +17,9 @@ export const listQuery = defineQueryHandler({
     description: "Lists template resources of the caller's tenant alongside the system defaults as summaries without content, filterable by kind, locale and status; use it to browse the catalogue, then find-by-id to read one row.",
     handler: async (query, ctx) => {
         const where = {};
-        // includeSystem=false narrows to own tenant AT THE DB — for non-SystemAdmin
-        // TenantDb permits narrowing within its enforced [own, SYSTEM] scope, for
-        // SystemAdmin (system-scoped db) the where applies verbatim. Filtering at
-        // the DB keeps the limit meaningful (no post-filter starvation).
+        // includeSystem=false narrows to own tenant AT THE DB — TenantDb permits
+        // narrowing within its enforced [own, SYSTEM] scope. Filtering at the DB
+        // keeps the limit meaningful (no post-filter starvation).
         if (!query.payload.includeSystem) {
             where["tenantId"] = query.user.tenantId;
         }

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

@@ -0,0 +1,59 @@
+import * as z from "zod";
+import { type TemplateStatus } from "../constants.js";
+declare const OVERVIEW_KINDS: readonly ["mail", "document-pdf", "mail-layout", "pdf-layout"];
+type OverviewKind = (typeof OVERVIEW_KINDS)[number];
+export type OverviewOrigin = "tenant" | "system";
+export type OverviewKindGroup = "mail" | "pdf" | "layout";
+export type OverviewUsage = {
+    readonly qualifiedName: string;
+    readonly feature: string;
+    readonly notification: string;
+    readonly trigger: string | null;
+};
+export type OverviewRow = {
+    readonly id: string;
+    readonly slug: string;
+    readonly kind: OverviewKind;
+    readonly kindGroup: OverviewKindGroup;
+    readonly title: string;
+    readonly origin: OverviewOrigin;
+    readonly locales: readonly string[];
+    readonly status: TemplateStatus;
+    readonly version: number;
+    readonly systemVersion: number | null;
+    readonly layoutSlug: string | null;
+    readonly modifiedAt: string;
+    readonly usedBy: readonly OverviewUsage[];
+    readonly usedByCount: number;
+};
+export type OverviewResponse = {
+    readonly rows: readonly OverviewRow[];
+    readonly nextCursor: null;
+    readonly total: number;
+};
+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<{
+        field: z.ZodEnum<{
+            kind: "kind";
+            kindGroup: "kindGroup";
+            origin: "origin";
+            status: "status";
+        }>;
+        op: z.ZodLiteral<"in">;
+        value: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    sort: z.ZodOptional<z.ZodString>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    totalCount: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    rows: OverviewRow[];
+    nextCursor: null;
+    total: number;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+export {};

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

@@ -0,0 +1,165 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+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 { collectTemplateUsage } from "../template-usage.js";
+import { storedRecord } from "./template-gates.js";
+const OVERVIEW_KINDS = ["mail", "document-pdf", "mail-layout", "pdf-layout"];
+const OVERVIEW_ROW_LIMIT = 5000;
+const SORT_FIELDS = ["title", "slug", "kind", "origin", "status", "modifiedAt"];
+const KIND_GROUP = {
+    mail: "mail",
+    "document-pdf": "pdf",
+    "mail-layout": "layout",
+    "pdf-layout": "layout",
+};
+function isOverviewKind(kind) {
+    return OVERVIEW_KINDS.some((candidate) => candidate === kind);
+}
+function isTemplateStatus(status) {
+    return status === "draft" || status === "active" || status === "archived";
+}
+function layoutSlugOf(row) {
+    const layoutSlug = storedRecord(row.meta)["layoutSlug"];
+    return typeof layoutSlug === "string" ? layoutSlug : DEFAULT_MAIL_LAYOUT_SLUG;
+}
+function preferredRow(rows) {
+    return (rows.find((row) => row.locale === FALLBACK_LOCALE) ??
+        [...rows].sort((a, b) => a.locale.localeCompare(b.locale))[0]);
+}
+function effectiveRowsOf(rows) {
+    const tenantRows = rows.filter((row) => row.scope === "tenant");
+    const systemRows = rows.filter((row) => row.scope === "system");
+    const live = (list) => list.filter((row) => row.status !== "archived");
+    const liveTenant = live(tenantRows);
+    if (liveTenant.length > 0)
+        return { origin: "tenant", rows: liveTenant };
+    if (systemRows.length > 0) {
+        const liveSystem = live(systemRows);
+        return { origin: "system", rows: liveSystem.length > 0 ? liveSystem : systemRows };
+    }
+    return tenantRows.length > 0 ? { origin: "tenant", rows: tenantRows } : null;
+}
+function modifiedAtOf(row) {
+    return (row.modifiedAt ?? row.insertedAt).toString();
+}
+function splitDocumentSlug(slug) {
+    const separator = slug.indexOf(":");
+    return separator === -1
+        ? { feature: "", notification: slug }
+        : { feature: slug.slice(0, separator), notification: slug.slice(separator + 1) };
+}
+function compareBy(field, a, b) {
+    return String(a[field]).localeCompare(String(b[field]));
+}
+function isSortField(value) {
+    return SORT_FIELDS.some((candidate) => candidate === value);
+}
+function groupBySlugAndKind(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        if (!isOverviewKind(row.kind))
+            continue;
+        const key = `${row.kind}|${row.slug}`;
+        groups.set(key, [...(groups.get(key) ?? []), row]);
+    }
+    return groups;
+}
+function buildDrafts(groups) {
+    const layoutSlugByDocument = new Map();
+    const drafts = [];
+    for (const [id, groupRows] of groups) {
+        const effective = effectiveRowsOf(groupRows);
+        const preferred = effective === null ? undefined : preferredRow(effective.rows);
+        if (effective === null || preferred === undefined)
+            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") {
+            layoutSlugByDocument.set(preferred.slug, layoutSlug);
+        }
+        drafts.push({
+            id,
+            slug: preferred.slug,
+            kind: preferred.kind,
+            kindGroup: KIND_GROUP[preferred.kind],
+            title: preferred.title ?? preferred.slug,
+            origin: effective.origin,
+            locales: [...new Set(effective.rows.map((row) => row.locale))].sort(),
+            status: preferred.status,
+            version: preferred.version,
+            systemVersion: systemSameLocale?.version ?? null,
+            layoutSlug,
+            modifiedAt: modifiedAtOf(preferred),
+        });
+    }
+    return { drafts, layoutSlugByDocument };
+}
+function withUsage(draft, layoutSlugByDocument, registry) {
+    let usedBy = [];
+    if (draft.kind === "mail" || draft.kind === "mail-layout") {
+        usedBy = collectTemplateUsage(registry, draft.slug, draft.kind).map((entry) => ({
+            qualifiedName: entry.qualifiedName,
+            feature: entry.feature,
+            notification: entry.notification,
+            trigger: entry.trigger,
+        }));
+    }
+    else if (draft.kind === "pdf-layout") {
+        usedBy = [...layoutSlugByDocument]
+            .filter(([, layoutSlug]) => layoutSlug === draft.slug)
+            .map(([documentSlug]) => ({
+            qualifiedName: documentSlug,
+            ...splitDocumentSlug(documentSlug),
+            trigger: null,
+        }));
+    }
+    return { ...draft, usedBy, usedByCount: usedBy.length };
+}
+function filterRows(rows, search, filters) {
+    const needle = search?.trim().toLowerCase() ?? "";
+    return rows.filter((row) => {
+        if (needle !== "" && !`${row.title} ${row.slug}`.toLowerCase().includes(needle))
+            return false;
+        return filters.every((filter) => filter.value.includes(String(row[filter.field])));
+    });
+}
+const filterSchema = z.object({
+    field: z.enum(["kindGroup", "kind", "origin", "status"]),
+    op: z.literal("in"),
+    value: z.array(z.string()),
+});
+export const overviewQuery = defineQueryHandler({
+    name: "overview",
+    schema: z.object({
+        search: z.string().optional(),
+        filters: z.array(filterSchema).optional(),
+        sort: z.string().optional(),
+        sortDirection: z.enum(["asc", "desc"]).optional(),
+        limit: z.number().int().min(1).max(200).default(50),
+        offset: z.number().int().min(0).optional(),
+        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.",
+    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 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));
+        const offset = payload.offset ?? 0;
+        return {
+            rows: filtered.slice(offset, offset + payload.limit),
+            nextCursor: null,
+            total: filtered.length,
+        };
+    },
+});

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

@@ -0,0 +1,12 @@
+import * as z from "zod";
+export declare const previewQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"preview", z.ZodObject<{
+    slug: z.ZodString;
+    kind: z.ZodEnum<{
+        "document-pdf": "document-pdf";
+        mail: "mail";
+    }>;
+    locale: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+    variableSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, import("../template-preview.js").TemplatePreview, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

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

@@ -0,0 +1,24 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { renderTemplatePreview } from "../template-preview.js";
+import { localeSchema, templateSlugSchema } from "./shared.js";
+export const previewQuery = defineQueryHandler({
+    name: "preview",
+    schema: z.object({
+        slug: templateSlugSchema,
+        kind: z.enum(["mail", "document-pdf"]),
+        locale: localeSchema,
+        /** Without content the stored template is previewed. */
+        content: z.string().max(200_000).optional(),
+        meta: z.unknown().optional(),
+        variableSchema: z.record(z.string(), z.unknown()).default({}),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Renders a template draft, or the stored template when no content is given, with sample values taken from the declared variable examples, without saving or sending anything: returns the mail subject, html and plain text with its inline images (a PDF template returns its body and layout regions instead), the sample values used, and checks for unresolved images, missing plain text, mail size and unused required placeholders; a draft that fails the write rules is rejected with the same problems as a save.",
+    handler: async (query, ctx) => {
+        const outcome = await renderTemplatePreview(ctx, query.user, query.payload);
+        if (!outcome.ok)
+            throw outcome.error;
+        return outcome.preview;
+    },
+});

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

@@ -0,0 +1,8 @@
+import * as z from "zod";
+export declare const resetToSystemWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"reset-to-system", z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>, {
+    id: string;
+    status: "archived";
+    systemTemplateId: string;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

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

@@ -0,0 +1,50 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineWriteHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError, ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { templateResourcesTable } from "../table.js";
+import { executor } from "./shared.js";
+export const resetToSystemWrite = defineWriteHandler({
+    name: "reset-to-system",
+    schema: z.object({ id: z.string().min(1) }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Retires a tenant override by archiving it so the resolver serves the active system template again; the override and its content survive and can be published again. Refused when there is no active system template to fall back to.",
+    handler: async (event, ctx) => {
+        const existing = await fetchOne(ctx.db, templateResourcesTable, {
+            id: event.payload.id,
+        });
+        if (!existing || existing.tenantId !== event.user.tenantId || existing.scope !== "tenant") {
+            return writeFailure(new NotFoundError("template-resource", event.payload.id));
+        }
+        const systemRow = await fetchOne(ctx.db, templateResourcesTable, {
+            tenantId: SYSTEM_TENANT_ID,
+            slug: existing.slug,
+            kind: existing.kind,
+            locale: existing.locale,
+            status: "active",
+        });
+        if (!systemRow) {
+            return writeFailure(new ValidationError({
+                fields: [
+                    {
+                        path: "id",
+                        code: "no_system_template",
+                        i18nKey: "templateResolver.errors.noSystemTemplate",
+                    },
+                ],
+            }));
+        }
+        const response = {
+            isSuccess: true,
+            data: {
+                id: String(existing.id),
+                status: "archived",
+                systemTemplateId: String(systemRow.id),
+            },
+        };
+        if (existing.status === "archived")
+            return response;
+        const result = await executor.update({ id: existing.id, version: existing.version, changes: { status: "archived" } }, event.user, ctx.db);
+        return result.isSuccess ? response : result;
+    },
+});

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

@@ -0,0 +1,8 @@
+import * as z from "zod";
+export declare const resourceLinkPdfWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"resource-link-pdf", z.ZodObject<{
+    templateId: z.ZodString;
+    key: z.ZodString;
+    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>;

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

@@ -0,0 +1,32 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { linkTemplatePdfAttachment } from "../store-template-resource.js";
+import { resourceKeySchema, resourceTargetTenantId } from "./resource-shared.js";
+export const resourceLinkPdfWrite = defineWriteHandler({
+    name: "resource-link-pdf",
+    schema: z.object({
+        templateId: z.string().min(1),
+        key: resourceKeySchema,
+        /** Slug of a document-pdf template of the tenant or the system. */
+        templateSlug: z.string().min(1),
+        /** Name pattern of the attached PDF; may hold {{placeholders}}, must end with .pdf. */
+        fileName: z.string().min(1),
+        /** Cross-tenant target — SystemAdmin only. */
+        tenantIdOverride: z.string().min(1).optional(),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Links a PDF rendered from a document-pdf template into a mail template under the key. Every mail sent from the template then carries that PDF, rendered at send time with the mail's own variables and locale; nothing is uploaded or stored. fileName is a pattern that may use the mail's {{placeholders}} and must end with .pdf. The document template must exist for the tenant or the system. Counts toward the 10 attachments per mail template together with uploaded files.",
+    handler: async (event, ctx) => {
+        const { templateId, key, templateSlug, fileName } = event.payload;
+        const tenantId = resourceTargetTenantId(event.payload.tenantIdOverride, event.user.tenantId);
+        return linkTemplatePdfAttachment({
+            ctx,
+            user: event.user,
+            tenantId,
+            templateId,
+            key,
+            templateSlug,
+            fileName,
+        });
+    },
+});

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

@@ -0,0 +1,9 @@
+import * as z from "zod";
+export declare const resourceRemoveWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"resource-remove", z.ZodObject<{
+    templateId: z.ZodString;
+    key: z.ZodString;
+    tenantIdOverride: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    key: string;
+    removed: boolean;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

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

@@ -0,0 +1,44 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { requireForTenant } from "../../shared/index.js";
+import { parseLinkedResourceEntries } from "../linked-resources.js";
+import { templateResourcesTable } from "../table.js";
+import { resourceKeySchema, resourceTargetTenantId } from "./resource-shared.js";
+import { executor } from "./shared.js";
+// The FileRef itself stays: copy-locale and tenant overrides can share ids and there is
+// no reference count to tell when the last user is gone.
+export const resourceRemoveWrite = defineWriteHandler({
+    name: "resource-remove",
+    schema: z.object({
+        templateId: z.string().min(1),
+        key: resourceKeySchema,
+        /** Cross-tenant target — SystemAdmin only. */
+        tenantIdOverride: z.string().min(1).optional(),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Unlinks a resource key from a template, whether it holds an image, an attached file or a linked PDF template; removing a key the template does not have succeeds without a change.",
+    handler: async (event, ctx) => {
+        const { templateId, key } = event.payload;
+        const tenantId = resourceTargetTenantId(event.payload.tenantIdOverride, event.user.tenantId);
+        const { db, streamTenantId } = requireForTenant(ctx, tenantId);
+        const row = await fetchOne(db, templateResourcesTable, {
+            tenantId,
+            id: templateId,
+        });
+        if (row === undefined)
+            return writeFailure(new NotFoundError("template-resource", templateId));
+        const { [key]: removed, ...remaining } = parseLinkedResourceEntries(row.linkedResources);
+        if (removed === undefined)
+            return { isSuccess: true, data: { key, removed: false } };
+        const updated = await executor.update({
+            id: row.id,
+            version: row.version,
+            changes: { linkedResources: JSON.stringify(remaining) },
+        }, event.user, db, { streamTenantId });
+        if (!updated.isSuccess)
+            return updated;
+        return { isSuccess: true, data: { key, removed: true } };
+    },
+});