@cosmicdrift/kumiko-samples 0.363.0 → 0.365.0

package/packages/bundled-features/src/template-resolver/constants.ts

@@ -51,7 +51,15 @@ export const TEXT_BLOCK_KIND = "text-block" as const;
 // Kinds a content collection must not write: a tenant row of these kinds would
 // shadow the system notification template or layout without the meta and
 // placeholder gates that upsertTenant applies.
-export const COLLECTION_REFUSED_KINDS: readonly string[] = ["mail", "mail-layout", "pdf-layout"];
+export const COLLECTION_REFUSED_KINDS = [
+  "mail",
+  "mail-layout",
+  "pdf-layout",
+] as const satisfies readonly TemplateKind[];
+
+export function isCollectionRefusedKind(kind: string): boolean {
+  return COLLECTION_REFUSED_KINDS.some((refused) => refused === kind);
+}
 
 export const CONTENT_FORMATS = ["markdown", "mjml", "html", "plain"] as const;
 export type ContentFormat = (typeof CONTENT_FORMATS)[number];
@@ -61,11 +69,23 @@ export type TemplateScope = (typeof TEMPLATE_SCOPES)[number];
 
 export const TEMPLATE_STATUSES = ["draft", "active", "archived"] as const;
 export type TemplateStatus = (typeof TEMPLATE_STATUSES)[number];
+export const ACTIVE_TEMPLATE_STATUS = "active" satisfies TemplateStatus;
+
+export {
+  PDF_DEFAULT_MARGIN_MM,
+  PDF_FOOTER_MARGIN_MM,
+  PDF_HEADER_MARGIN_MM,
+  PDF_ORIENTATIONS,
+  PDF_PAGE_FORMATS,
+  type PdfOrientation,
+  type PdfPageFormat,
+} from "./pdf-constants.js";
 
-export const PDF_PAGE_FORMATS = ["A4", "Letter"] as const;
-export type PdfPageFormat = (typeof PDF_PAGE_FORMATS)[number];
+// Colors end up inside MJML attributes, so only a strict hex is ever written there.
+export const HEX_COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
 
 export const DEFAULT_MAIL_LAYOUT_SLUG = "default";
+export const DEFAULT_PDF_LAYOUT_SLUG = "default";
 
 // The mail transport enforces no size limit of its own; 10 MiB is a common provider ceiling.
 export const MAIL_PREVIEW_MAX_BYTES = 10 * 1024 * 1024;

package/packages/bundled-features/src/template-resolver/document-sanitizer.ts

@@ -13,6 +13,7 @@ import {
   isDocumentReferenceName,
   isDocumentResourceKey,
 } from "./document-schema.js";
+import { isDocumentStepKey } from "./document-steps.js";
 
 export type DocumentViolationCode =
   | "script_element"
@@ -138,6 +139,8 @@ const REFERENCE_ATTRIBUTES: ReadonlyArray<readonly [string, (value: string) => b
   ["data-variable", isDocumentReferenceName],
   ["data-each", isDocumentReferenceName],
   ["data-resource", isDocumentResourceKey],
+  ["data-steps", isDocumentReferenceName],
+  ["data-step", isDocumentStepKey],
 ];
 
 function scanReferences(tag: string, element: ScanElement, out: DocumentViolation[]): void {

package/packages/bundled-features/src/template-resolver/document-schema.ts

@@ -8,14 +8,16 @@ import { Extension, type Extensions, Node } from "@tiptap/core";
 import { Link } from "@tiptap/extension-link";
 import { Table, TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
 import StarterKit from "@tiptap/starter-kit";
+import { createDocumentStepsNode } from "./document-steps.js";
 
-const PLACEHOLDER_HREF = /^\{\{[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*\}\}$/;
+const PLACEHOLDER_HREF = /^\{\{(.+)\}\}$/;
 const REFERENCE_NAME = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 const RESOURCE_KEY = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
 const ALLOWED_LINK_SCHEMES = ["https://", "http://", "mailto:", "tel:"] as const;
 
 export function isDocumentPlaceholderHref(href: string): boolean {
-  return PLACEHOLDER_HREF.test(href);
+  const name = PLACEHOLDER_HREF.exec(href)?.[1];
+  return name !== undefined && isDocumentReferenceName(name);
 }
 
 const UNSAFE_URL_CHARACTERS = new Set(["<", ">", '"']);
@@ -70,6 +72,7 @@ export const DOCUMENT_NODE_NAMES = [
   "button",
   "divider",
   "pageBreak",
+  "steps",
 ] as const;
 
 export const DocumentVariable = Node.create({
@@ -130,7 +133,8 @@ export const DocumentResource = Node.create({
 export const DocumentButton = Node.create({
   name: "button",
   group: "block",
-  content: "text*",
+  // A placeholder in the label ("View {{pageName}}") must survive the round trip.
+  content: "(text | variable)*",
   marks: "",
   defining: true,
   addAttributes() {
@@ -178,6 +182,8 @@ export const DocumentPageBreak = Node.create({
   },
 });
 
+export const DocumentSteps = createDocumentStepsNode(isDocumentReferenceName);
+
 // A repeat row is a table row carrying `each`: prosemirror-tables requires
 // the tableRow node type, so a separate node type is not an option.
 export const DocumentTableRow = TableRow.extend({
@@ -204,8 +210,6 @@ export const DocumentTableRow = TableRow.extend({
   },
 });
 
-export const DocumentRepeatRow = DocumentTableRow;
-
 export const DocumentTable = Table.extend({
   renderHTML() {
     return ["table", ["tbody", 0]];
@@ -288,6 +292,28 @@ export const DocumentTextAlign = Extension.create({
   },
 });
 
+// Only "small" exists: the sender line above an address block. Serialized as data-size for the
+// same reason as data-align.
+export const DocumentTextSize = Extension.create({
+  name: "documentTextSize",
+  addGlobalAttributes() {
+    return [
+      {
+        types: ["paragraph"],
+        attributes: {
+          textSize: {
+            default: null,
+            parseHTML: (element) =>
+              element.getAttribute("data-size") === "small" ? "small" : null,
+            renderHTML: (attributes) =>
+              attributes["textSize"] === "small" ? { "data-size": "small" } : {},
+          },
+        },
+      },
+    ];
+  },
+});
+
 export const documentExtensions: Extensions = [
   StarterKit.configure({
     blockquote: false,
@@ -319,5 +345,7 @@ export const documentExtensions: Extensions = [
   DocumentButton,
   DocumentDivider,
   DocumentPageBreak,
+  DocumentSteps,
   DocumentTextAlign,
+  DocumentTextSize,
 ];

package/packages/bundled-features/src/template-resolver/document-steps.ts

@@ -0,0 +1,114 @@
+// @runtime client
+// A progress row: fixed stages stored in the template, the reached stage read
+// from a variable at render time. Universal like document-schema.ts.
+import { Node } from "@tiptap/core";
+
+// Keys end up as Handlebars string literals in the compiled body, so they are
+// restricted to characters that cannot close or escape a literal.
+const STEP_KEY = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
+export const DOCUMENT_STEPS_MAX = 8;
+const STEP_LABEL_MAX_LENGTH = 40;
+
+export type DocumentStep = { readonly key: string; readonly label: string };
+
+export function isDocumentStepKey(value: string): boolean {
+  return STEP_KEY.test(value);
+}
+
+export function documentStepKeyOf(label: string): string {
+  return label
+    .normalize("NFKD")
+    .replace(/\p{M}/gu, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+}
+
+// Editor input: "value=Label" entries separated by commas; a bare label derives its value.
+export function parseDocumentStepsInput(text: string): readonly DocumentStep[] | null {
+  const steps = text
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== "")
+    .map((entry): DocumentStep => {
+      const separator = entry.indexOf("=");
+      const label = (separator < 0 ? entry : entry.slice(separator + 1)).trim();
+      const key = separator < 0 ? documentStepKeyOf(entry) : entry.slice(0, separator).trim();
+      return { key, label: label.slice(0, STEP_LABEL_MAX_LENGTH) };
+    });
+  return areValidSteps(steps) ? steps : null;
+}
+
+function areValidSteps(steps: readonly DocumentStep[]): boolean {
+  return (
+    steps.length > 0 &&
+    steps.length <= DOCUMENT_STEPS_MAX &&
+    new Set(steps.map((step) => step.key)).size === steps.length &&
+    steps.every((step) => isDocumentStepKey(step.key) && step.label !== "")
+  );
+}
+
+// Duplicate or invalid keys would make the reached stage ambiguous, so the whole
+// list is refused rather than repaired.
+export function readDocumentSteps(element: {
+  querySelectorAll(selector: string): ArrayLike<{
+    getAttribute(name: string): string | null;
+    textContent: string | null;
+  }>;
+}): readonly DocumentStep[] | null {
+  const steps = Array.from(element.querySelectorAll("span[data-step]")).map((span) => ({
+    key: span.getAttribute("data-step") ?? "",
+    label: (span.textContent ?? "").trim().slice(0, STEP_LABEL_MAX_LENGTH),
+  }));
+  return areValidSteps(steps) ? steps : null;
+}
+
+function isDocumentStep(step: unknown): step is DocumentStep {
+  return (
+    typeof step === "object" &&
+    step !== null &&
+    "key" in step &&
+    "label" in step &&
+    typeof step.key === "string" &&
+    typeof step.label === "string"
+  );
+}
+
+// Node attrs are untyped JSON; anything that is not a step entry is dropped.
+export function readDocumentStepsAttribute(value: unknown): readonly DocumentStep[] {
+  return Array.isArray(value) ? value.filter(isDocumentStep) : [];
+}
+
+export function createDocumentStepsNode(isReferenceName: (value: string) => boolean) {
+  return Node.create({
+    name: "steps",
+    group: "block",
+    atom: true,
+    addAttributes() {
+      return { variable: { default: null }, steps: { default: [] } };
+    },
+    parseHTML() {
+      return [
+        {
+          tag: "div[data-steps]",
+          getAttrs: (element) => {
+            const variable = element.getAttribute("data-steps");
+            const steps = readDocumentSteps(element);
+            if (variable === null || !isReferenceName(variable) || steps === null) return false;
+            return { variable, steps };
+          },
+        },
+      ];
+    },
+    renderHTML({ node }) {
+      return [
+        "div",
+        { "data-steps": node.attrs["variable"] },
+        ...readDocumentStepsAttribute(node.attrs["steps"]).map(
+          (step) => ["span", { "data-step": step.key }, step.label] as const,
+        ),
+      ];
+    },
+  });
+}

package/packages/bundled-features/src/template-resolver/feature.ts

@@ -3,6 +3,7 @@ import {
   createSystemConfig,
   defineFeature,
 } from "@cosmicdrift/kumiko-framework/engine";
+import { isCollectionRefusedKind } from "./constants.js";
 import { bySlugQuery } from "./handlers/by-slug.query.js";
 import { byTenantQuery } from "./handlers/by-tenant.query.js";
 import { makeCollectionItemQuery } from "./handlers/collection-item.query.js";
@@ -10,6 +11,7 @@ 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";
@@ -59,14 +61,25 @@ export type TemplateResolverOptions = {
   readonly collections?: readonly ContentCollectionDefinition[];
 };
 
+function assertCollectionKindsAllowed(collections: readonly ContentCollectionDefinition[]): void {
+  for (const collection of collections) {
+    if (isCollectionRefusedKind(collection.kind)) {
+      throw new Error(
+        `template-resolver: collection "${collection.id}" uses kind "${collection.kind}", which collections may not write`,
+      );
+    }
+  }
+}
+
 export function createTemplateResolverFeature(opts: TemplateResolverOptions = {}) {
   const collections = opts.collections ?? [];
+  assertCollectionKindsAllowed(collections);
   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`, `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`.",
+        "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.',
@@ -100,6 +113,8 @@ export function createTemplateResolverFeature(opts: TemplateResolverOptions = {}
       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),

package/packages/bundled-features/src/template-resolver/handlers/bundle-import.ts

@@ -1,5 +1,6 @@
 import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import type {
+  BeforeTransactionResult,
   HandlerContext,
   SessionUser,
   TenantId,
@@ -16,9 +17,13 @@ import type { LinkedResourceEntry } from "../linked-resources.js";
 import {
   attachmentLimitFailure,
   attachmentNeedsMailTemplate,
+  createPreparedBundleResourceEntry,
+  type PreparedTemplateFile,
+  prepareTemplateAttachmentBeforeTransaction,
+  prepareTemplateResourceBeforeTransaction,
+  type Release,
   readTemplateResourceMaxBytes,
-  storeBundleAttachment,
-  storeTemplateResource,
+  releaseAll,
 } from "../store-template-resource.js";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
 import type { TemplateBundle } from "../template-bundle.js";
@@ -92,64 +97,101 @@ async function collectBundleIssues(
   return issues;
 }
 
-async function storeBundleResources(
-  args: BundleImport,
-): Promise<WriteResult<Record<string, LinkedResourceEntry>>> {
-  const linked: Record<string, LinkedResourceEntry> = {};
-  const pdfLinks = Object.entries(args.bundle.pdfAttachments);
+export type PreparedBundleResources = ReadonlyMap<string, PreparedTemplateFile>;
+
+function checkBundleAttachments(bundle: TemplateBundle): WriteResult<null> {
   const attachmentCount =
-    Object.values(args.bundle.resources).filter((resource) => resource.purpose === "attachment")
-      .length + pdfLinks.length;
-  if (attachmentCount > 0 && args.bundle.kind !== "mail") return attachmentNeedsMailTemplate();
+    Object.values(bundle.resources).filter((resource) => resource.purpose === "attachment").length +
+    Object.keys(bundle.pdfAttachments).length;
+  if (attachmentCount > 0 && 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 };
+  return { isSuccess: true, data: null };
+}
+
+// beforeTransaction half: validates the bundle and uploads every resource file to the target
+// tenant's storage. A failed or throwing upload releases the ones before it.
+export async function prepareTemplateBundleBeforeTransaction(
+  args: BundleImport & { readonly status: BundleImportStatus },
+): Promise<BeforeTransactionResult<PreparedBundleResources>> {
+  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 attachmentCheck = checkBundleAttachments(args.bundle);
+  if (!attachmentCheck.isSuccess) return attachmentCheck;
+
   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({
+  const prepared = new Map<string, PreparedTemplateFile>();
+  const releases: Release[] = [];
+  try {
+    // 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"));
+      const common = {
         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 result =
+        resource.purpose === "attachment"
+          ? await prepareTemplateAttachmentBeforeTransaction({
+              ...common,
+              fileName: resource.fileName,
+            })
+          : await prepareTemplateResourceBeforeTransaction(common);
+      if (!result.isSuccess) {
+        await releaseAll(releases);
+        return result;
+      }
+      if (result.release) releases.push(result.release);
+      prepared.set(key, result.data);
     }
-    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;
+  } catch (cause) {
+    await releaseAll(releases);
+    throw cause;
+  }
+  return { isSuccess: true, data: prepared, release: () => releaseAll(releases) };
+}
+
+async function linkPreparedBundleResources(
+  args: BundleImport,
+  prepared: PreparedBundleResources,
+): Promise<WriteResult<Record<string, LinkedResourceEntry>>> {
+  const linked: Record<string, LinkedResourceEntry> = {};
+  // The document template is not looked up: a bundle may carry it later than the mail.
+  for (const [key, link] of Object.entries(args.bundle.pdfAttachments)) {
+    linked[key] = { kind: "rendered-pdf", ...link };
+  }
+  for (const [key, file] of prepared) {
+    const entry = await createPreparedBundleResourceEntry(
+      { ctx: args.ctx, user: args.user, tenantId: args.tenantId },
+      file,
+    );
+    if (!entry.isSuccess) return entry;
+    linked[key] = entry.data;
   }
   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.
+// Validates every locale first, so a bad locale is refused before anything is written.
+// The resource files are uploaded in the beforeTransaction phase; a rolled-back transaction
+// releases them there. A crash between the upload and the commit leaves the binaries unreferenced.
 export async function importTemplateBundle(
-  args: BundleImport & { readonly status: BundleImportStatus },
+  args: BundleImport & {
+    readonly status: BundleImportStatus;
+    readonly prepared: PreparedBundleResources;
+  },
 ): Promise<WriteResult<{ ids: Record<string, string> }>> {
   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);
+  const linked = await linkPreparedBundleResources(args, args.prepared);
   if (!linked.isSuccess) return linked;
 
   const variableSchema = args.bundle.variableSchema ?? {};

package/packages/bundled-features/src/template-resolver/handlers/collection-set.write.ts

@@ -7,7 +7,7 @@ import {
 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 { isCollectionRefusedKind } from "../constants.js";
 import { documentViolationsToFieldIssues, sanitizeTemplateBody } from "../document-sanitizer.js";
 import {
   type CollectionEntryRow,
@@ -43,12 +43,13 @@ export function makeCollectionSetWrite(collection: ContentCollectionDefinition)
         ? `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)) {
+      // Defense in depth: createTemplateResolverFeature already refuses these kinds at mount.
+      if (isCollectionRefusedKind(collection.kind)) {
         return writeFailure(
           new ValidationError({
             fields: [
               {
-                path: "kind",
+                path: "",
                 code: "kind_not_allowed",
                 i18nKey: "templateResolver.errors.collection.kindNotAllowed",
                 params: { detail: collection.kind },