@cosmicdrift/kumiko-samples 0.388.0 → 0.390.0

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

@@ -107,7 +107,12 @@ export async function seedSystemTemplate(
 ): Promise<{ id: string }> {
   const tenantId = SYSTEM_TENANT_ID;
   const by = opts.by ?? createSystemUser(tenantId);
-  const tdb = createTenantDb({ db, tenantId, mode: "system" });
+  const tdb = createTenantDb({
+    db,
+    tenantId,
+    mode: "system",
+    reason: "system templates live in the system tenant",
+  });
 
   const label = `seedSystemTemplate ${opts.slug}/${opts.kind}/${opts.locale}`;
   const slug = templateSlugSchema.safeParse(opts.slug);
@@ -408,7 +413,12 @@ export async function seedTextBlock(
   opts: SeedTextBlockOptions,
 ): Promise<{ id: string }> {
   const by = opts.by ?? createSystemUser(opts.tenantId);
-  const tdb = createTenantDb({ db, tenantId: opts.tenantId, mode: "system" });
+  const tdb = createTenantDb({
+    db,
+    tenantId: opts.tenantId,
+    mode: "system",
+    reason: "seeding writes text blocks into an explicitly named tenant",
+  });
 
   const existingRow = await fetchOne<TemplateResourceRow>(db, templateResourcesTable, {
     tenantId: opts.tenantId,
@@ -442,12 +452,14 @@ export async function seedTextBlock(
     row: { id: string; version: number },
     current: TemplateResourceRow | null | undefined,
   ): Promise<{ id: string }> => {
+    // No folder option keeps the row's folder, so a re-seed cannot drop it from the content tree.
+    const folder = opts.folder === undefined ? (current?.folder ?? null) : fields.folder;
     // Skip no-op updates so a legal re-seed on every pod boot does not bump
     // version/modifiedAt (ETag, "last changed", event-store growth).
     if (
       current?.title === fields.title &&
       current?.content === fields.content &&
-      current?.folder === fields.folder
+      current?.folder === folder
     ) {
       return { id: String(row.id) };
     }
@@ -458,7 +470,7 @@ export async function seedTextBlock(
         changes: {
           title: fields.title,
           content: fields.content,
-          folder: fields.folder,
+          folder,
           // A re-seed must not revive an archived block; only a served one gets a new served version.
           ...(current?.status === "active" && servedStampChanges(row)),
         },
@@ -533,7 +545,11 @@ export type LegalContentBlock = {
 export async function seedLegalContentFromJson(
   db: DbConnection,
   blocks: readonly LegalContentBlock[],
-  opts: { readonly tenantId?: TenantId; readonly by?: SessionUser } = {},
+  opts: {
+    readonly tenantId?: TenantId;
+    readonly by?: SessionUser;
+    readonly folder?: string;
+  } = {},
 ): Promise<void> {
   const tenantId = opts.tenantId ?? SYSTEM_TENANT_ID;
   const by = opts.by ?? createSystemUser(tenantId);
@@ -544,6 +560,7 @@ export async function seedLegalContentFromJson(
       locale: block.locale,
       title: block.title,
       content: block.content,
+      ...(opts.folder !== undefined && { folder: opts.folder }),
       ifExists: "update",
       by,
     });

package/packages/bundled-features/src/template-resolver/store-template-resource.ts

@@ -1,5 +1,6 @@
 import { fetchOne, selectMany } from "@cosmicdrift/kumiko-framework/db";
 import type {
+  BeforeTransactionContext,
   BeforeTransactionResult,
   ConfigAccessor,
   HandlerContext,
@@ -19,7 +20,7 @@ import {
   type UploadedFileBytes,
   uploadFileBytesBeforeTransaction,
 } from "@cosmicdrift/kumiko-framework/files";
-import { fileContextForTenant } from "../file-foundation/index.ts";
+import { fileContextForTenant, readFileRefContent } from "../file-foundation/index.ts";
 import { extensionForResourceContentType, requireForTenant } from "../shared/index.ts";
 import {
   DEFAULT_RESOURCE_MAX_BYTES,
@@ -29,13 +30,13 @@ import {
 import { executor } from "./handlers/shared.ts";
 import {
   attachmentEntriesOf,
+  isFileAttachmentEntry,
   type LinkedResourceEntry,
   parseLinkedResourceEntries,
   templatePdfAttachmentLinkSchema,
 } from "./linked-resources.ts";
 import { normalizeResourceImage } from "./resource-image.ts";
 import { type TemplateResourceRow, templateResourcesTable } from "./table.ts";
-import { readTemplateResource } from "./template-resources.ts";
 import { ACTIVE_TEMPLATE_STATUS, SYSTEM_TENANT_ID } from "./web/constants.ts";
 import { TemplateResolverErrors } from "./web/qualified-names.ts";
 
@@ -100,7 +101,7 @@ function isAttachmentKey(links: Readonly<Record<string, LinkedResourceEntry>>, k
 // so both receive the target tenant's db and identity.
 function uploadToTenant(
   args: {
-    readonly ctx: HandlerContext;
+    readonly ctx: PrepareContext;
     readonly user: SessionUser;
     readonly tenantId: TenantId;
   },
@@ -110,7 +111,7 @@ function uploadToTenant(
   return uploadFileBytesBeforeTransaction(
     {
       db: requireForTenant(ctx, tenantId).db,
-      files: fileContextForTenant(ctx, ctx.user.tenantId, tenantId),
+      services: { files: fileContextForTenant(ctx, ctx.user.tenantId, tenantId) },
       registry: ctx.registry,
       user: { ...user, tenantId },
     },
@@ -119,7 +120,7 @@ function uploadToTenant(
 }
 
 type TenantScope = {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly user: SessionUser;
   readonly tenantId: TenantId;
 };
@@ -133,7 +134,7 @@ function createFileRefFromPrepared(scope: TenantScope, upload: UploadedFileBytes
 }
 
 async function linkImage(args: {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly user: SessionUser;
   readonly tenantId: TenantId;
   readonly row: TemplateResourceRow;
@@ -197,7 +198,7 @@ type ImageTarget = {
 
 // Runs before the upload (reject early, store nothing) and again in the transaction on the fresh row.
 async function checkImageTarget(args: {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly tenantId: TenantId;
   readonly templateId?: string | undefined;
   readonly key?: string | undefined;
@@ -220,7 +221,7 @@ async function checkImageTarget(args: {
 // beforeTransaction half: normalizes the image and uploads it to the target tenant's storage.
 // The caller is responsible for authorization; the function trusts tenantId.
 export async function prepareTemplateResourceBeforeTransaction(args: {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly user: SessionUser;
   readonly tenantId: TenantId;
   readonly bytes: Uint8Array;
@@ -260,6 +261,10 @@ export async function prepareTemplateResourceBeforeTransaction(args: {
   };
 }
 
+// The prepare phase runs before the transaction, so it must not rely on anything the in-transaction
+// context adds (events, dispatch.write).
+export type PrepareContext = HandlerContext | BeforeTransactionContext;
+
 export type Release = () => Promise<void>;
 
 // Tries every release, so one failing delete does not strand the other uploads; the first rejection is rethrown.
@@ -271,13 +276,13 @@ export async function releaseAll(releases: readonly Release[]): Promise<void> {
 
 // Failure paths: a failing release must not replace the upload error the caller needs to see.
 export async function releaseAfterFailure(
-  ctx: HandlerContext,
+  ctx: PrepareContext,
   releases: readonly Release[],
 ): Promise<void> {
   try {
     await releaseAll(releases);
   } catch (releaseError) {
-    ctx.log?.warn("template upload rollback: releasing stored files failed", {
+    ctx.obs.log?.warn("template upload rollback: releasing stored files failed", {
       error: releaseError instanceof Error ? releaseError.message : String(releaseError),
     });
   }
@@ -290,12 +295,50 @@ export type PreparedLinkedResourceCopy = {
   readonly upload?: UploadedFileBytes;
 };
 
+// The source row's own fileName is personal data and may be ciphertext, so the copy is named from
+// the link entry or the key.
+function copiedFileName(key: string, entry: LinkedResourceEntry, contentType: string): string {
+  if (typeof entry !== "string" && isFileAttachmentEntry(entry)) return entry.fileName;
+  return `${key}.${extensionForResourceContentType(contentType) ?? "bin"}`;
+}
+
+function sourceUnreadable(): WriteResult<never> {
+  return writeFailure(
+    new UnprocessableError(TemplateResolverErrors.resourceSourceUnreadable, {
+      i18nKey: "templateResolver.errors.resource.sourceUnreadable",
+    }),
+  );
+}
+
+// Undefined: the fileRef row exists but its bytes cannot be read, which must not look like a
+// deleted file. The provider is chosen by the tenant of the fileRef, not by the caller's.
+async function readCopySource(
+  ctx: PrepareContext,
+  fileRefId: string,
+): Promise<{ contentType: string; bytes: Uint8Array } | null | undefined> {
+  try {
+    const found = await readFileRefContent({
+      db: ctx.db,
+      filesForTenant: (tid) => fileContextForTenant(ctx, ctx.user.tenantId, tid),
+      fileRefId,
+      allowedTenantIds: [SYSTEM_TENANT_ID, ctx.user.tenantId],
+    });
+    return found === null ? null : { contentType: found.contentType, bytes: found.content };
+  } catch (cause) {
+    ctx.obs.log?.warn("template copy: source file could not be read", {
+      fileRefId,
+      errorClass: cause instanceof Error ? cause.name : typeof cause,
+    });
+    return undefined;
+  }
+}
+
 // beforeTransaction half: copies the file behind every entry into the target tenant's storage, so a
 // template copied from the system default keeps working once the tenant exports it or measures its
 // attachments. An entry whose source file is gone is left out: it could not be resolved at render
 // time either. A failed or throwing upload releases the ones before it.
 export async function prepareLinkedResourceCopiesBeforeTransaction(args: {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly user: SessionUser;
   readonly tenantId: TenantId;
   readonly resources: Readonly<Record<string, LinkedResourceEntry>>;
@@ -309,14 +352,20 @@ export async function prepareLinkedResourceCopiesBeforeTransaction(args: {
         copies.push({ key, entry });
         continue;
       }
-      const file = await readTemplateResource(
-        ctx,
-        typeof entry === "string" ? entry : entry.fileRefId,
-      );
-      if (file === null) continue;
+      const source = await readCopySource(ctx, typeof entry === "string" ? entry : entry.fileRefId);
+      if (source === undefined) {
+        await releaseAfterFailure(ctx, releases);
+        return sourceUnreadable();
+      }
+      // skip: the source fileRef is deleted or unknown, so there is nothing to copy
+      if (source === null) continue;
       const uploaded = await uploadToTenant(
         { ctx, user, tenantId },
-        { fileName: file.fileName, mimeType: file.contentType, data: file.bytes },
+        {
+          fileName: copiedFileName(key, entry, source.contentType),
+          mimeType: source.contentType,
+          data: source.bytes,
+        },
       );
       if (!uploaded.isSuccess) {
         await releaseAfterFailure(ctx, releases);
@@ -481,7 +530,7 @@ type AttachmentTarget = {
 
 // Runs before the upload (reject early, store nothing) and again in the transaction on the fresh row.
 async function checkAttachmentTarget(args: {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly tenantId: TenantId;
   readonly templateId: string;
   readonly key: string;
@@ -506,7 +555,7 @@ async function checkAttachmentTarget(args: {
 // beforeTransaction half: validates a PDF/PNG/JPEG and uploads it unchanged to the target tenant's
 // storage. With templateId the template is checked first; a bundle import has none yet.
 export async function prepareTemplateAttachmentBeforeTransaction(args: {
-  readonly ctx: HandlerContext;
+  readonly ctx: PrepareContext;
   readonly user: SessionUser;
   readonly tenantId: TenantId;
   readonly bytes: Uint8Array;

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

@@ -27,16 +27,16 @@ type FileRefRow = {
 // Reads the file behind a template resource. Null when the fileRef is unknown
 // to the caller's tenant or has no bytes.
 export async function readTemplateResource(
-  ctx: Pick<HandlerContext, "db" | "files" | "user">,
+  ctx: Pick<HandlerContext, "db" | "services" | "user">,
   fileRefId: string,
 ): Promise<TemplateResourceFile | null> {
-  if (!ctx.files) return null;
+  if (!ctx.services.files) return null;
   const row = await fetchOne<FileRefRow>(ctx.db, fileRefsTable, {
     id: fileRefId,
     isDeleted: false,
   });
   if (!row) return null;
-  const handle = ctx.files.refFromFileRef(row);
+  const handle = ctx.services.files.refFromFileRef(row);
   if (!(await handle.exists())) return null;
   return { fileName: row.fileName, contentType: row.mimeType, bytes: await handle.read() };
 }
@@ -44,7 +44,7 @@ export async function readTemplateResource(
 // Replaces the whole key map of one row with files that are already stored (bundle import,
 // copy-locale). Single keys go through storePreparedTemplateResource and resource-remove.
 export async function attachTemplateResources(
-  ctx: Pick<HandlerContext, "forTenant">,
+  ctx: Pick<HandlerContext, "tenants">,
   args: {
     readonly user: SessionUser;
     readonly tenantId: TenantId;

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

@@ -3,7 +3,7 @@
 // No bun:test here — callers register cases with their own test runner.
 
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import { seedRow } from "@cosmicdrift/kumiko-testing/helpers";
+import { seedRowViaEventStore } from "@cosmicdrift/kumiko-testing/helpers";
 import type { ResolveRequest, TemplateResource } from "./api.ts";
 import { TemplateNotFoundError } from "./api.ts";
 import { templateResourcesTable } from "./table.ts";
@@ -50,7 +50,7 @@ type SeedTemplateArgs = {
 };
 
 async function seedTemplate(db: DbConnection, args: SeedTemplateArgs): Promise<void> {
-  await seedRow(db, templateResourcesTable, {
+  await seedRowViaEventStore(db, templateResourcesTable, {
     tenantId: args.tenantId,
     slug: args.slug,
     kind: args.kind,

package/packages/bundled-features/src/template-resolver/web/document-insert-fields.tsx

@@ -0,0 +1,222 @@
+import { usePrimitives, VariableChips } from "@cosmicdrift/kumiko-renderer";
+import { AlignCenter, AlignJustify, AlignLeft, AlignRight } from "lucide-react";
+import type { ReactNode } from "react";
+import { insertAndCloseOf, type PanelModel } from "./document-insert-model.ts";
+import { DOCUMENT_TEXT_ALIGNMENTS, type DocumentTextAlignment } from "./document-schema.ts";
+import { type PanelKind, variableLabelOf } from "./document-tiptap-helpers.ts";
+
+const ALIGNMENT_ICONS: Record<DocumentTextAlignment, ReactNode> = {
+  left: <AlignLeft size={16} />,
+  center: <AlignCenter size={16} />,
+  right: <AlignRight size={16} />,
+  justify: <AlignJustify size={16} />,
+};
+
+const ALIGNMENT_LABEL_KEYS: Record<DocumentTextAlignment, string> = {
+  left: "template-resolver.documentEditor.alignLeft",
+  center: "template-resolver.documentEditor.alignCenter",
+  right: "template-resolver.documentEditor.alignRight",
+  justify: "template-resolver.documentEditor.alignJustify",
+};
+
+type OptionSelectProps = {
+  readonly id: string;
+  readonly label: string;
+  readonly names: readonly string[];
+  readonly labels: Readonly<Record<string, string>>;
+  readonly value: string;
+  readonly onChange: (name: string) => void;
+};
+
+function NameSelect({ id, label, names, labels, value, onChange }: OptionSelectProps): ReactNode {
+  const { Field, Input } = usePrimitives();
+  return (
+    <Field id={id} label={label}>
+      <Input
+        kind="select"
+        id={id}
+        name={id}
+        value={value}
+        onChange={onChange}
+        display="dropdown"
+        options={names.map((name) => ({ value: name, label: variableLabelOf(name, labels) }))}
+      />
+    </Field>
+  );
+}
+
+function renderLinkFields(m: PanelModel): ReactNode {
+  const { t, Field, Input } = m;
+  return (
+    <Field id={`${m.idPrefix}-href`} label={t("template-resolver.documentEditor.linkHref")}>
+      <Input
+        kind="text"
+        id={`${m.idPrefix}-href`}
+        name="href"
+        value={m.href}
+        onChange={m.setHref}
+        placeholder={t("template-resolver.documentEditor.linkHrefPlaceholder")}
+      />
+    </Field>
+  );
+}
+
+function renderPlaceholderFields(m: PanelModel): ReactNode {
+  return (
+    !m.noVariables && (
+      <div className="flex flex-wrap gap-1">
+        <VariableChips
+          variables={m.selectable}
+          labels={m.variableLabels}
+          onInsert={(name) => insertAndCloseOf(m)({ type: "variable", attrs: { name } })}
+        />
+      </div>
+    )
+  );
+}
+
+function renderAlignFields(m: PanelModel): ReactNode {
+  const { t, Button, editor } = m;
+  return (
+    <div className="flex flex-wrap gap-1">
+      {DOCUMENT_TEXT_ALIGNMENTS.map((alignment) => (
+        <Button
+          key={alignment}
+          type="button"
+          variant="secondary"
+          size="sm"
+          onClick={() => {
+            editor
+              .chain()
+              .focus()
+              .updateAttributes("paragraph", { textAlign: alignment })
+              .updateAttributes("heading", { textAlign: alignment })
+              .run();
+            m.onClose();
+          }}
+        >
+          {ALIGNMENT_ICONS[alignment]}
+          {t(ALIGNMENT_LABEL_KEYS[alignment])}
+        </Button>
+      ))}
+    </div>
+  );
+}
+
+function renderImageFields(m: PanelModel): ReactNode {
+  const { t, Field, Input, idPrefix } = m;
+  return (
+    <>
+      <Field id={`${idPrefix}-resource`} label={t("template-resolver.documentEditor.resourceKey")}>
+        <Input
+          kind="text"
+          id={`${idPrefix}-resource`}
+          name="resource"
+          value={m.resource}
+          onChange={m.setResource}
+        />
+      </Field>
+      <Field id={`${idPrefix}-alt`} label={t("template-resolver.documentEditor.imageAlt")}>
+        <Input kind="text" id={`${idPrefix}-alt`} name="alt" value={m.alt} onChange={m.setAlt} />
+      </Field>
+    </>
+  );
+}
+
+function renderButtonFields(m: PanelModel): ReactNode {
+  const { t, Field, Input, idPrefix } = m;
+  return (
+    !m.noVariables && (
+      <>
+        <NameSelect
+          id={`${idPrefix}-target`}
+          label={t("template-resolver.documentEditor.buttonTarget")}
+          names={m.selectable}
+          labels={m.variableLabels}
+          value={m.selectedName}
+          onChange={m.setChosenName}
+        />
+        <Field id={`${idPrefix}-text`} label={t("template-resolver.documentEditor.buttonText")}>
+          <Input
+            kind="text"
+            id={`${idPrefix}-text`}
+            name="text"
+            value={m.buttonText}
+            onChange={m.setButtonText}
+          />
+        </Field>
+      </>
+    )
+  );
+}
+
+function renderRepeatFields(m: PanelModel): ReactNode {
+  return (
+    !m.noVariables && (
+      <NameSelect
+        id={`${m.idPrefix}-list`}
+        label={m.t("template-resolver.documentEditor.repeatList")}
+        names={m.selectable}
+        labels={m.variableLabels}
+        value={m.selectedName}
+        onChange={m.setChosenName}
+      />
+    )
+  );
+}
+
+function renderImagesFields(m: PanelModel): ReactNode {
+  return (
+    !m.noVariables && (
+      <NameSelect
+        id={`${m.idPrefix}-images-variable`}
+        label={m.t("template-resolver.documentEditor.imagesVariable")}
+        names={m.selectable}
+        labels={m.variableLabels}
+        value={m.selectedName}
+        onChange={m.setChosenName}
+      />
+    )
+  );
+}
+
+function renderStepsFields(m: PanelModel): ReactNode {
+  const { t, Field, Input, idPrefix } = m;
+  return (
+    !m.noVariables && (
+      <>
+        <NameSelect
+          id={`${idPrefix}-steps-variable`}
+          label={t("template-resolver.documentEditor.stepsVariable")}
+          names={m.selectable}
+          labels={m.variableLabels}
+          value={m.selectedName}
+          onChange={m.setChosenName}
+        />
+        <Field
+          id={`${idPrefix}-steps-list`}
+          label={t("template-resolver.documentEditor.stepsList")}
+        >
+          <Input
+            kind="text"
+            id={`${idPrefix}-steps-list`}
+            name="steps"
+            value={m.stepsText}
+            onChange={m.setStepsText}
+          />
+        </Field>
+      </>
+    )
+  );
+}
+
+export const PANEL_FIELDS: Readonly<Record<PanelKind, (m: PanelModel) => ReactNode>> = {
+  link: renderLinkFields,
+  placeholder: renderPlaceholderFields,
+  align: renderAlignFields,
+  image: renderImageFields,
+  button: renderButtonFields,
+  repeat: renderRepeatFields,
+  images: renderImagesFields,
+  steps: renderStepsFields,
+};