@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.364.0

package/dist/template-resolver/feature.d.ts

@@ -18,13 +18,33 @@ export declare function createTemplateResolverFeature(opts?: TemplateResolverOpt
             upsertTenant: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             publish: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             archive: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            publishSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            archiveSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            discardDraft: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            discardDraftSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            resetToSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             set: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            importBundle: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            importBundleSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            copyLocale: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            resourceUpload: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            resourceRemove: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            resourceLinkPdf: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            sendTest: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
         };
         queries: {
             findById: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             list: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             bySlug: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             byTenant: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            usage: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            overview: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            layoutSource: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            tenantOverrides: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            diffToSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            validate: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            preview: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            exportBundle: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
         };
         treeHandle: import("@cosmicdrift/kumiko-types/tree-node").TreeActionsHandle<"template-resolver", {
             readonly edit: {

package/dist/template-resolver/feature.js

@@ -1,15 +1,32 @@
-import { defineFeature, } from "@cosmicdrift/kumiko-framework/engine";
+import { createSystemConfig, defineFeature, } from "@cosmicdrift/kumiko-framework/engine";
 import { bySlugQuery } from "./handlers/by-slug.query.js";
 import { byTenantQuery } from "./handlers/by-tenant.query.js";
 import { makeCollectionItemQuery } from "./handlers/collection-item.query.js";
 import { makeCollectionListQuery } from "./handlers/collection-list.query.js";
 import { makeCollectionSetWrite } from "./handlers/collection-set.write.js";
+import { copyLocaleWrite } from "./handlers/copy-locale.write.js";
+import { diffToSystemQuery } from "./handlers/diff-to-system.query.js";
+import { discardDraftSystemWrite, discardDraftWrite } from "./handlers/discard-draft.write.js";
+import { exportBundleQuery } from "./handlers/export-bundle.query.js";
 import { findByIdQuery } from "./handlers/find-by-id.query.js";
+import { importBundleWrite } from "./handlers/import-bundle.write.js";
+import { importBundleSystemWrite } from "./handlers/import-bundle-system.write.js";
+import { layoutSourceQuery } from "./handlers/layout-source.query.js";
 import { listQuery } from "./handlers/list.query.js";
+import { overviewQuery } from "./handlers/overview.query.js";
+import { previewQuery } from "./handlers/preview.query.js";
+import { resetToSystemWrite } from "./handlers/reset-to-system.write.js";
+import { resourceLinkPdfWrite } from "./handlers/resource-link-pdf.write.js";
+import { resourceRemoveWrite } from "./handlers/resource-remove.write.js";
+import { resourceUploadWrite } from "./handlers/resource-upload.write.js";
+import { sendTestWrite } from "./handlers/send-test.write.js";
 import { setWrite } from "./handlers/set.write.js";
-import { archiveWrite, publishWrite } from "./handlers/toggle-status.write.js";
+import { tenantOverridesQuery } from "./handlers/tenant-overrides.query.js";
+import { archiveSystemWrite, archiveWrite, publishSystemWrite, publishWrite, } from "./handlers/toggle-status.write.js";
 import { upsertSystemWrite } from "./handlers/upsert-system.write.js";
 import { upsertTenantWrite } from "./handlers/upsert-tenant.write.js";
+import { usageQuery } from "./handlers/usage.query.js";
+import { validateQuery } from "./handlers/validate.query.js";
 import { templateResourceEntity } from "./table.js";
 import { userContentEntryEntity } from "./user-content-table.js";
 export function createTemplateResolverFeature(opts = {}) {
@@ -17,11 +34,14 @@ export function createTemplateResolverFeature(opts = {}) {
     const hasUserOwned = collections.some((c) => c.ownership === "user");
     return defineFeature("template-resolver", (r) => {
         r.describe([
-            "Every piece of editable text lives here, in one entity: mail bodies, notification texts, PDF document templates, AI prompts and plain text blocks. What a record is used for is the `kind` (`notification`, `mail-html`, `document-pdf`, `ai-prompt`, `text-block`, `image-snapshot`).",
-            "Reading is one call — `ctx.templateResolver.resolveTemplate({ tenantId, slug, kind, locale })`. It walks four levels: tenant+locale, system+locale, tenant+fallback-locale, system+fallback-locale. A tenant overrides a system default by simply having its own record; no application code changes. Writing programmatically goes through the `upsertSystem`, `upsertTenant`, `publish` and `archive` write handlers.",
+            "Every piece of editable text lives here, in one entity: mail bodies, notification texts, PDF document templates, AI prompts and plain text blocks. What a record is used for is the `kind` (`notification`, `mail`, `mail-layout`, `document-pdf`, `pdf-layout`, `ai-prompt`, `text-block`, `snippet`, `image-snapshot`).",
+            "Reading is one call — `ctx.templateResolver.resolveTemplate({ tenantId, slug, kind, locale })`. It walks four levels: tenant+locale, system+locale, tenant+fallback-locale, system+fallback-locale. A tenant overrides a system default by simply having its own record; no application code changes. Writing programmatically goes through the `upsertSystem`, `upsertTenant`, `publish` and `archive` write handlers; a SystemAdmin retires or restores a system default with `publishSystem` and `archiveSystem`, and a tenant drops its override with `resetToSystem`. Saving a draft over an active template keeps the active version served and stores the edit beside it (column `draft`); `publish` makes it the served version, `discardDraft` / `discardDraftSystem` throws it away.",
             "Text an editor should be able to change belongs in a collection, declared at mount: `createTemplateResolverFeature({ collections: [{ id, kind, access: { roles }, nav }] })`. It appears in the navigation, and `access` is part of the mount because a bundled feature cannot know the host's roles. Each collection gets its own `<id>-list` / `<id>-item` / `<id>-set` handlers, so the dispatcher enforces the separation.",
             "How a collection is edited follows from `contentFormat`: `plain` gives a text area, `rich` a small WYSIWYG (bold, italic, headings, lists, links), `markdown` a text area that stores markdown text (same insertable chips as `plain`). All three offer the collection's `variableSchema` as insertable chips and a preview rendered with sample data — an editor sees what `{{firstName}}` becomes without sending a mail. An app can register its own editor for a format; the last `clientFeature` that registers a format wins (a conflict logs a warning).",
             'A collection is tenant-wide by default. With `ownership: "user"` every user keeps their own entries — mail signatures being the obvious case. Those rows live in the separate `user-content-entry` entity and count as user data, so mounting one also requires the `template-resolver-user-data` feature and a migration on the app side.',
+            "`validate` dry-runs the write pipeline for a draft (sanitizer, layout rules, placeholders) and reports what the template uses and misses. `export-bundle` / `import-bundle` (and `import-bundle-system`) move one template with all locales and resource files between tenants or environments; `copy-locale` starts a translation from an existing locale. Layouts are structured: a mail or PDF layout is `data-header` / `data-content` / `data-signature` / `data-footer` regions, and mjml layout source is system-only.",
+            "`preview` renders a draft (or the stored template) with sample values taken from the `example` of each declared variable, through the same gates and the same mail renderer as a real send, and returns subject, html, `displayHtml` (the html with cid images as data URIs for an editor), text, attachments (inline images and files) and `checks` (images resolved, plain text present, size under 10 MiB, required placeholders used); nothing is saved or sent. `send-test` mails that rendering to the calling user's own address only, subject prefixed with `[TEST]`, at most 10 per user and hour; it needs `delivery`, `channel-email` and `renderer-mail-html` to be mounted.",
+            'Images used by a template (`<img data-resource="logo">`) are uploaded with `resourceUpload`, which re-encodes them, stores a file and links it under the key; `resourceRemove` unlinks it. `linkedResources` is written only through these two handlers. With `purpose: "attachment"` and a `fileName`, `resourceUpload` stores a PDF, PNG or JPEG as a file attachment of a mail template (original bytes, at most 10) that the mail renderer attaches after the inline images. `resourceLinkPdf` instead links a `document-pdf` template under a key: every mail sent from the template then carries that PDF, rendered at send time with the mail\'s own variables and locale, under a file name pattern such as `invoice-{{number}}.pdf`; files and linked PDFs share the limit of 10.',
             "Replaces the former `text-content` feature; its blocks now live here as kind `text-block`.",
         ].join("\n\n"));
         r.uiHints({
@@ -29,6 +49,11 @@ export function createTemplateResolverFeature(opts = {}) {
             category: "notifications",
             recommended: false,
         });
+        r.config({
+            keys: {
+                resourceMaxBytes: createSystemConfig("number", { default: 2_097_152, bounds: { min: 1 } }),
+            },
+        });
         r.entity("template-resource", templateResourceEntity);
         // Only when the app actually mounts a user-owned collection: the entity's
         // `content` is `userOwned`, which makes it subject data — the boot guard
@@ -41,13 +66,33 @@ export function createTemplateResolverFeature(opts = {}) {
             upsertTenant: r.writeHandler(upsertTenantWrite),
             publish: r.writeHandler(publishWrite),
             archive: r.writeHandler(archiveWrite),
+            publishSystem: r.writeHandler(publishSystemWrite),
+            archiveSystem: r.writeHandler(archiveSystemWrite),
+            discardDraft: r.writeHandler(discardDraftWrite),
+            discardDraftSystem: r.writeHandler(discardDraftSystemWrite),
+            resetToSystem: r.writeHandler(resetToSystemWrite),
             set: r.writeHandler(setWrite),
+            importBundle: r.writeHandler(importBundleWrite),
+            importBundleSystem: r.writeHandler(importBundleSystemWrite),
+            copyLocale: r.writeHandler(copyLocaleWrite),
+            resourceUpload: r.writeHandler(resourceUploadWrite),
+            resourceRemove: r.writeHandler(resourceRemoveWrite),
+            resourceLinkPdf: r.writeHandler(resourceLinkPdfWrite),
+            sendTest: r.writeHandler(sendTestWrite),
         };
         const queries = {
             findById: r.queryHandler(findByIdQuery),
             list: r.queryHandler(listQuery),
             bySlug: r.queryHandler(bySlugQuery),
             byTenant: r.queryHandler(byTenantQuery),
+            usage: r.queryHandler(usageQuery),
+            overview: r.queryHandler(overviewQuery),
+            layoutSource: r.queryHandler(layoutSourceQuery),
+            tenantOverrides: r.queryHandler(tenantOverridesQuery),
+            diffToSystem: r.queryHandler(diffToSystemQuery),
+            validate: r.queryHandler(validateQuery),
+            preview: r.queryHandler(previewQuery),
+            exportBundle: r.queryHandler(exportBundleQuery),
         };
         for (const collection of collections) {
             r.contentCollection(collection);
@@ -58,10 +103,12 @@ export function createTemplateResolverFeature(opts = {}) {
         // Visual-tree actions for the text-block content tree. The handle is
         // propagated through the setup export so other features can build
         // compile-time-typed cross-feature edit targets.
+        // r.treeActions keeps literal types (const generic); the args only declare string-typed slots.
+        const emptyString = "";
         const treeHandle = r.treeActions({
-            edit: { args: { slug: "", locale: "" } },
+            edit: { args: { slug: emptyString, locale: emptyString } },
             list: {},
-            create: { args: { folder: "" } },
+            create: { args: { folder: emptyString } },
         });
         return { handlers, queries, treeHandle };
     });

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

@@ -0,0 +1,20 @@
+import type { HandlerContext, SessionUser, TenantId, WriteResult } from "@cosmicdrift/kumiko-framework/engine";
+import { type FieldIssue } from "@cosmicdrift/kumiko-framework/errors";
+import type { TemplateWriteScope } from "../layout-regions.js";
+import type { TemplateBundle } from "../template-bundle.js";
+export declare function targetExistsIssue(locale: string): FieldIssue;
+type BundleImport = {
+    readonly ctx: HandlerContext;
+    readonly user: SessionUser;
+    readonly tenantId: TenantId;
+    readonly scope: TemplateWriteScope;
+    readonly bundle: TemplateBundle;
+    readonly overwrite: boolean;
+};
+type BundleImportStatus = "draft" | "active";
+export declare function importTemplateBundle(args: BundleImport & {
+    readonly status: BundleImportStatus;
+}): Promise<WriteResult<{
+    ids: Record<string, string>;
+}>>;
+export {};

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

@@ -0,0 +1,147 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { ValidationError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+import { requireForTenant } from "../../shared/index.js";
+import { attachmentLimitFailure, attachmentNeedsMailTemplate, readTemplateResourceMaxBytes, storeBundleAttachment, storeTemplateResource, } from "../store-template-resource.js";
+import { templateResourcesTable } from "../table.js";
+import { attachTemplateResources } from "../template-resources.js";
+import { resolveTemplateVariables } from "../template-validation.js";
+import { MAX_FILE_ATTACHMENTS_PER_TEMPLATE } from "./resource-shared.js";
+import { evaluateTemplateWrite } from "./template-gates.js";
+import { refuseTenantScopeUnderSystemTenant, writeTemplateRow, } from "./template-write.js";
+export function targetExistsIssue(locale) {
+    return {
+        path: "locale",
+        code: "target_exists",
+        i18nKey: "templateResolver.errors.template.targetExists",
+        params: { detail: locale },
+    };
+}
+async function collectBundleIssues(args, status) {
+    const { ctx, tenantId, scope, bundle, overwrite } = args;
+    const { db } = requireForTenant(ctx, tenantId);
+    const variables = resolveTemplateVariables(ctx.registry, bundle.slug, bundle.variableSchema ?? {});
+    const issues = [];
+    for (const [locale, entry] of Object.entries(bundle.locales)) {
+        const evaluated = evaluateTemplateWrite({
+            kind: bundle.kind,
+            scope,
+            contentFormat: bundle.contentFormat,
+            content: entry.body,
+            rawMeta: entry.meta,
+            variables,
+        });
+        const found = evaluated.ok
+            ? status === "active"
+                ? evaluated.publishIssues
+                : []
+            : evaluated.issues;
+        issues.push(...found.map((issue) => ({ ...issue, path: `locales.${locale}.${issue.path}` })));
+        if (!overwrite) {
+            const existing = await fetchOne(db, templateResourcesTable, {
+                tenantId,
+                slug: bundle.slug,
+                kind: bundle.kind,
+                locale,
+            });
+            if (existing)
+                issues.push(targetExistsIssue(locale));
+        }
+    }
+    return issues;
+}
+async function storeBundleResources(args) {
+    const linked = {};
+    const pdfLinks = Object.entries(args.bundle.pdfAttachments);
+    const attachmentCount = Object.values(args.bundle.resources).filter((resource) => resource.purpose === "attachment")
+        .length + pdfLinks.length;
+    if (attachmentCount > 0 && args.bundle.kind !== "mail")
+        return attachmentNeedsMailTemplate();
+    if (attachmentCount > MAX_FILE_ATTACHMENTS_PER_TEMPLATE)
+        return attachmentLimitFailure();
+    // The document template is not looked up: a bundle may carry it later than the mail.
+    for (const [key, link] of pdfLinks)
+        linked[key] = { kind: "rendered-pdf", ...link };
+    const maxBytes = await readTemplateResourceMaxBytes(args.ctx.config, args.ctx.registry);
+    // A bundle is untrusted input like an upload: the same re-encoding decides the stored
+    // content type, so a declared image/png can't smuggle SVG or HTML into a mail or PDF.
+    for (const [key, resource] of Object.entries(args.bundle.resources)) {
+        const bytes = Uint8Array.from(Buffer.from(resource.base64, "base64"));
+        if (resource.purpose === "attachment") {
+            const attachment = await storeBundleAttachment({
+                ctx: args.ctx,
+                user: args.user,
+                tenantId: args.tenantId,
+                bytes,
+                maxBytes,
+                key,
+                fileName: resource.fileName,
+            });
+            if (!attachment.isSuccess)
+                return attachment;
+            linked[key] = attachment.data;
+            continue;
+        }
+        const stored = await storeTemplateResource({
+            ctx: args.ctx,
+            user: args.user,
+            tenantId: args.tenantId,
+            bytes,
+            maxBytes,
+            key,
+        });
+        if (!stored.isSuccess)
+            return stored;
+        linked[key] = stored.data.fileRefId;
+    }
+    return { isSuccess: true, data: linked };
+}
+// Validates every locale first, stores the resource files, then writes one row
+// per locale, so a bad locale never leaves files or half a bundle behind. An image
+// that fails re-encoding stops the import before any row is written; files stored
+// for the resources before it stay as unlinked FileRefs, like a replaced upload.
+export async function importTemplateBundle(args) {
+    const refused = refuseTenantScopeUnderSystemTenant(args.scope, args.tenantId);
+    if (refused !== null)
+        return refused;
+    const issues = await collectBundleIssues(args, args.status);
+    if (issues.length > 0)
+        return writeFailure(new ValidationError({ fields: [...issues] }));
+    const linked = await storeBundleResources(args);
+    if (!linked.isSuccess)
+        return linked;
+    const variableSchema = args.bundle.variableSchema ?? {};
+    const variables = resolveTemplateVariables(args.ctx.registry, args.bundle.slug, variableSchema);
+    const ids = {};
+    for (const [locale, entry] of Object.entries(args.bundle.locales)) {
+        const payload = {
+            slug: args.bundle.slug,
+            kind: args.bundle.kind,
+            locale,
+            content: entry.body,
+            contentFormat: args.bundle.contentFormat,
+            variableSchema,
+            meta: entry.meta,
+        };
+        const written = await writeTemplateRow({
+            ctx: args.ctx,
+            user: args.user,
+            tenantId: args.tenantId,
+            scope: args.scope,
+            status: args.status,
+            variables,
+            payload,
+        });
+        if (!written.isSuccess)
+            return written;
+        const attached = await attachTemplateResources(args.ctx, {
+            user: args.user,
+            tenantId: args.tenantId,
+            templateId: written.data.id,
+            resources: linked.data,
+        });
+        if (!attached.isSuccess)
+            return attached;
+        ids[locale] = written.data.id;
+    }
+    return { isSuccess: true, data: { ids } };
+}

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

@@ -17,4 +17,4 @@ export declare function makeCollectionSetWrite(collection: ContentCollectionDefi
     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/collection-set.write.js

@@ -1,7 +1,10 @@
 import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineWriteHandler, } from "@cosmicdrift/kumiko-framework/engine";
+import { ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import { requireForTenant } from "../../shared/index.js";
+import { COLLECTION_REFUSED_KINDS } from "../constants.js";
+import { documentViolationsToFieldIssues, sanitizeTemplateBody } from "../document-sanitizer.js";
 import { collectionStore, DEFAULT_COLLECTION_ACCESS, } from "./collection-shared.js";
 import { contentFormatSchema, folderSchema, localeSchema, slugSchema } from "./shared.js";
 // Upsert inside one collection. Mirrors set.write for text-blocks, but the
@@ -30,6 +33,18 @@ export function makeCollectionSetWrite(collection) {
             ? `Creates or overwrites the caller's own "${collection.id}" entry at a slug and locale, live on save with no draft stage; it always writes the acting user's entry, never another user's.`
             : `Creates or overwrites the tenant-wide "${collection.id}" entry at a slug and locale, live on save with no draft stage; the change is visible to everyone who may reach this shared collection.`,
         handler: async (event, ctx) => {
+            if (COLLECTION_REFUSED_KINDS.includes(collection.kind)) {
+                return writeFailure(new ValidationError({
+                    fields: [
+                        {
+                            path: "kind",
+                            code: "kind_not_allowed",
+                            i18nKey: "templateResolver.errors.collection.kindNotAllowed",
+                            params: { detail: collection.kind },
+                        },
+                    ],
+                }));
+            }
             const override = event.payload.tenantIdOverride;
             // @cast-boundary engine-payload — override is a zod-validated string, the
             // user's own tenantId is already TenantId-branded.
@@ -39,6 +54,14 @@ export function makeCollectionSetWrite(collection) {
             // writing into another tenant still writes their own entry, never
             // someone else's signature.
             const owner = store.scopeOf(event.user);
+            const body = sanitizeTemplateBody({
+                kind: collection.kind,
+                contentFormat: event.payload.contentFormat,
+                content: event.payload.content,
+            });
+            if (!body.ok) {
+                return writeFailure(new ValidationError({ fields: documentViolationsToFieldIssues(body.violations) }));
+            }
             const existing = await fetchOne(db, store.table, {
                 tenantId,
                 slug: event.payload.slug,
@@ -55,7 +78,7 @@ export function makeCollectionSetWrite(collection) {
                     // the template upserts put on the row.
                     changes: {
                         title: event.payload.title,
-                        content: event.payload.content,
+                        content: body.content,
                         contentFormat: event.payload.contentFormat,
                         folder: event.payload.folder ?? null,
                     },
@@ -73,7 +96,7 @@ export function makeCollectionSetWrite(collection) {
                 kind: collection.kind,
                 locale: event.payload.locale,
                 title: event.payload.title,
-                content: event.payload.content,
+                content: body.content,
                 contentFormat: event.payload.contentFormat,
                 folder: event.payload.folder ?? null,
                 ...store.createDefaults(tenantId),

package/dist/template-resolver/handlers/copy-locale.write.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod";
+export declare const copyLocaleWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"copy-locale", 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";
+    }>;
+    fromLocale: z.ZodString;
+    toLocale: z.ZodString;
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        system: "system";
+        tenant: "tenant";
+    }>>;
+}, z.core.$strip>, import("./template-write.js").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

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

@@ -0,0 +1,134 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineWriteHandler, SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
+import { AccessDeniedError, NotFoundError, ValidationError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
+import * as z from "zod";
+import { requireForTenant } from "../../shared/index.js";
+import { CONTENT_FORMATS } from "../constants.js";
+import { parseLinkedResourceEntries } from "../linked-resources.js";
+import { TemplateResolverErrors } from "../qualified-names.js";
+import { templateResourcesTable } from "../table.js";
+import { toWorkingRow } from "../template-draft.js";
+import { attachTemplateResources, duplicateLinkedResourceFiles } from "../template-resources.js";
+import { resolveTemplateVariables } from "../template-validation.js";
+import { targetExistsIssue } from "./bundle-import.js";
+import { kindSchema, localeSchema, templateSlugSchema } from "./shared.js";
+import { parseStoredJson, storedRecord } from "./template-gates.js";
+import { refuseTenantScopeUnderSystemTenant, writeTemplateRow } from "./template-write.js";
+function readDbFor(ctx, scope) {
+    return scope === "system" ? requireForTenant(ctx, SYSTEM_TENANT_ID).db : ctx.db;
+}
+// A tenant copy may start from the system default; a system copy only from system rows.
+async function findCopySource(ctx, where) {
+    const { scope, tenantId, slug, kind, locale } = where;
+    const readDb = readDbFor(ctx, scope);
+    const own = await fetchOne(readDb, templateResourcesTable, {
+        tenantId,
+        slug,
+        kind,
+        locale,
+    });
+    // An archived tenant row is not an active source: the system default applies instead.
+    if (scope === "system" || (own && own.status !== "archived"))
+        return own;
+    return fetchOne(readDb, templateResourcesTable, {
+        tenantId: SYSTEM_TENANT_ID,
+        slug,
+        kind,
+        locale,
+        status: "active",
+    });
+}
+export const copyLocaleWrite = defineWriteHandler({
+    name: "copy-locale",
+    schema: z.object({
+        slug: templateSlugSchema,
+        kind: kindSchema,
+        fromLocale: localeSchema,
+        toLocale: localeSchema,
+        overwrite: z.boolean().default(false),
+        /** "system" copies between system-default rows; SystemAdmin only. */
+        scope: z.enum(["tenant", "system"]).default("tenant"),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Copies the text of one locale of a template into another locale as a draft override of the caller's tenant, taking the tenant's own row or else the system default as the source; use it as the starting point for a translation. It refuses an existing target unless overwrite is set. With scope system (SystemAdmin only) both source and target are system-default rows and the target lands as a system draft; any other caller gets a 403.",
+    handler: async (event, ctx) => {
+        const { slug, kind, fromLocale, toLocale, overwrite, scope } = event.payload;
+        if (scope === "system" && !event.user.roles.includes("SystemAdmin")) {
+            return writeFailure(new AccessDeniedError({
+                i18nKey: "errors.access.denied",
+                details: { reason: TemplateResolverErrors.systemAdminRequired },
+            }));
+        }
+        const tenantId = scope === "system" ? SYSTEM_TENANT_ID : event.user.tenantId;
+        const refused = refuseTenantScopeUnderSystemTenant(scope, tenantId);
+        if (refused !== null)
+            return refused;
+        const readDb = readDbFor(ctx, scope);
+        const storedSource = await findCopySource(ctx, {
+            scope,
+            tenantId,
+            slug,
+            kind,
+            locale: fromLocale,
+        });
+        const source = storedSource && toWorkingRow(storedSource, tenantId);
+        if (!source || !isOneOf(CONTENT_FORMATS, source.contentFormat)) {
+            return writeFailure(new NotFoundError("template-resource", `${slug}/${fromLocale}`));
+        }
+        if (!overwrite) {
+            const target = await fetchOne(readDb, templateResourcesTable, {
+                tenantId,
+                slug,
+                kind,
+                locale: toLocale,
+            });
+            if (target) {
+                return writeFailure(new ValidationError({ fields: [targetExistsIssue(toLocale)] }));
+            }
+        }
+        const variableSchema = storedRecord(source.variableSchema);
+        const written = await writeTemplateRow({
+            ctx,
+            user: event.user,
+            tenantId,
+            scope,
+            status: "draft",
+            variables: resolveTemplateVariables(ctx.registry, slug, variableSchema),
+            payload: {
+                slug,
+                kind,
+                locale: toLocale,
+                content: source.content,
+                contentFormat: source.contentFormat,
+                variableSchema,
+                meta: parseStoredJson(source.meta),
+                title: source.title,
+                folder: source.folder,
+            },
+        });
+        if (!written.isSuccess)
+            return written;
+        const sourceResources = parseLinkedResourceEntries(source.linkedResources);
+        // A system source's files belong to the system tenant: the tenant gets its own copies so
+        // previews, exports and the tenant's override keep working independent of the system row.
+        const resources = source.tenantId === tenantId
+            ? { isSuccess: true, data: sourceResources }
+            : await duplicateLinkedResourceFiles(ctx, {
+                user: event.user,
+                tenantId,
+                resources: sourceResources,
+            });
+        if (!resources.isSuccess)
+            return resources;
+        const attached = await attachTemplateResources(ctx, {
+            user: event.user,
+            tenantId,
+            templateId: written.data.id,
+            resources: resources.data,
+        });
+        if (!attached.isSuccess)
+            return attached;
+        return written;
+    },
+});

package/dist/template-resolver/handlers/diff-to-system.query.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod";
+export declare const diffToSystemQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"diff-to-system", z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>, {
+    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;
+    }[];
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/diff-to-system.query.js

@@ -0,0 +1,30 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { templateResourcesTable } from "../table.js";
+import { isHiddenSystemDraft } from "../template-draft.js";
+import { buildOverrideDiff } from "./override-diff.js";
+export const diffToSystemQuery = defineQueryHandler({
+    name: "diff-to-system",
+    schema: z.object({ id: z.string().min(1) }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Compares one tenant override with the system template of the same slug, kind and locale block by block and lists the changed meta settings; use it to show what an override changes before resetting it to the system version.",
+    handler: async (query, ctx) => {
+        const tenantRow = await fetchOne(ctx.db, templateResourcesTable, {
+            id: query.payload.id,
+        });
+        if (!tenantRow || tenantRow.tenantId !== query.user.tenantId || tenantRow.scope !== "tenant") {
+            throw new NotFoundError("template-resource", query.payload.id);
+        }
+        const systemRow = await fetchOne(ctx.db, templateResourcesTable, {
+            tenantId: SYSTEM_TENANT_ID,
+            slug: tenantRow.slug,
+            kind: tenantRow.kind,
+            locale: tenantRow.locale,
+        });
+        if (!systemRow || isHiddenSystemDraft(query.user, systemRow))
+            throw new NotFoundError("template-resource", tenantRow.slug);
+        return buildOverrideDiff(tenantRow, systemRow);
+    },
+});

package/dist/template-resolver/handlers/discard-draft.write.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod";
+export declare const discardDraftWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>, {
+    id: string;
+    discarded: boolean;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+export declare const discardDraftSystemWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>, {
+    id: string;
+    discarded: boolean;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

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

@@ -0,0 +1,37 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError, ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { TemplateResolverErrors } from "../qualified-names.js";
+import { executor } from "./shared.js";
+import { loadTargetRow, writeAccessFor } from "./toggle-status.write.js";
+function createDiscardDraftHandler(name, target, description) {
+    return defineWriteHandler({
+        name,
+        schema: z.object({ id: z.string().min(1) }),
+        access: writeAccessFor(target),
+        ...(target === "system" ? { agent: { risk: "high" } } : {}),
+        description,
+        handler: async (event, ctx) => {
+            const { db, scoped, row } = await loadTargetRow(ctx, target, event.user, event.payload.id);
+            if (!row)
+                return writeFailure(new NotFoundError("template-resource", event.payload.id));
+            if (row.draft === null) {
+                return writeFailure(new ValidationError({
+                    fields: [
+                        {
+                            path: "id",
+                            code: TemplateResolverErrors.noDraft,
+                            i18nKey: "templateResolver.errors.noDraft",
+                        },
+                    ],
+                }));
+            }
+            const result = await executor.update({ id: row.id, version: row.version, changes: { draft: null } }, event.user, db, scoped ? { streamTenantId: scoped.streamTenantId } : undefined);
+            if (!result.isSuccess)
+                return result;
+            return { isSuccess: true, data: { id: String(row.id), discarded: true } };
+        },
+    });
+}
+export const discardDraftWrite = createDiscardDraftHandler("discard-draft", "own", "Throws away the open draft of one template resource of the caller's tenant so the editor shows the active version again; the served version is untouched. Refused with no_draft when there is no draft.");
+export const discardDraftSystemWrite = createDiscardDraftHandler("discard-draft-system", "system", "Throws away the open draft of one system-default template; the served version stays. SystemAdmin only, refused with no_draft when there is no draft.");