@cosmicdrift/kumiko-samples 0.363.0 → 0.365.0

package/packages/bundled-features/src/template-resolver/handlers/copy-locale.write.ts

@@ -2,7 +2,10 @@ import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import {
   defineWriteHandler,
   type HandlerContext,
+  type SessionUser,
   SYSTEM_TENANT_ID,
+  type TenantId,
+  type WriteResult,
 } from "@cosmicdrift/kumiko-framework/engine";
 import {
   AccessDeniedError,
@@ -13,10 +16,15 @@ import {
 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 { CONTENT_FORMATS, type ContentFormat } from "../constants.js";
+import { type LinkedResourceEntry, parseLinkedResourceEntries } from "../linked-resources.js";
 import { TemplateResolverErrors } from "../qualified-names.js";
+import {
+  createLinkedResourceCopies,
+  prepareLinkedResourceCopiesBeforeTransaction,
+} from "../store-template-resource.js";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
+import { toWorkingRow, type WorkingRow } from "../template-draft.js";
 import { attachTemplateResources } from "../template-resources.js";
 import { resolveTemplateVariables } from "../template-validation.js";
 import { targetExistsIssue } from "./bundle-import.js";
@@ -50,7 +58,8 @@ async function findCopySource(
     kind,
     locale,
   });
-  if (own || scope === "system") return own;
+  // 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<TemplateResourceRow>(readDb, templateResourcesTable, {
     tenantId: SYSTEM_TENANT_ID,
     slug,
@@ -60,51 +69,109 @@ async function findCopySource(
   });
 }
 
+const copyLocaleSchema = 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"),
+});
+
+type CopyRequest = {
+  readonly scope: CopyScope;
+  readonly tenantId: TenantId;
+  readonly source: WorkingRow;
+  readonly contentFormat: ContentFormat;
+  readonly sourceResources: Readonly<Record<string, LinkedResourceEntry>>;
+  // 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.
+  readonly sourceIsForeign: boolean;
+};
+
+// Runs before the upload (reject early, store nothing) and again in the transaction on the fresh rows.
+async function checkCopyRequest(
+  ctx: WriteCtx,
+  event: {
+    readonly user: SessionUser;
+    readonly payload: z.infer<typeof copyLocaleSchema>;
+  },
+): Promise<WriteResult<CopyRequest>> {
+  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);
+  const contentFormat = source?.contentFormat;
+  if (!source || !isOneOf(CONTENT_FORMATS, contentFormat)) {
+    return writeFailure(new NotFoundError("template-resource", `${slug}/${fromLocale}`));
+  }
+
+  if (!overwrite) {
+    const target = await fetchOne<TemplateResourceRow>(readDb, templateResourcesTable, {
+      tenantId,
+      slug,
+      kind,
+      locale: toLocale,
+    });
+    if (target) {
+      return writeFailure(new ValidationError({ fields: [targetExistsIssue(toLocale)] }));
+    }
+  }
+  return {
+    isSuccess: true,
+    data: {
+      scope,
+      tenantId,
+      source,
+      contentFormat,
+      sourceResources: parseLinkedResourceEntries(source.linkedResources),
+      sourceIsForeign: source.tenantId !== tenantId,
+    },
+  };
+}
+
 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"),
-  }),
+  schema: copyLocaleSchema,
   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.",
+  beforeTransaction: async (event, ctx) => {
+    const request = await checkCopyRequest(ctx, event);
+    if (!request.isSuccess) return request;
+    if (!request.data.sourceIsForeign) return { isSuccess: true, data: [] };
+    return prepareLinkedResourceCopiesBeforeTransaction({
+      ctx,
+      user: event.user,
+      tenantId: request.data.tenantId,
+      resources: request.data.sourceResources,
+    });
+  },
   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 source = await findCopySource(ctx, { scope, tenantId, slug, kind, locale: fromLocale });
-    if (!source || !isOneOf(CONTENT_FORMATS, source.contentFormat)) {
-      return writeFailure(new NotFoundError("template-resource", `${slug}/${fromLocale}`));
-    }
-
-    if (!overwrite) {
-      const target = await fetchOne<TemplateResourceRow>(readDb, templateResourcesTable, {
-        tenantId,
-        slug,
-        kind,
-        locale: toLocale,
-      });
-      if (target) {
-        return writeFailure(new ValidationError({ fields: [targetExistsIssue(toLocale)] }));
-      }
-    }
+    const { slug, kind, toLocale } = event.payload;
+    const request = await checkCopyRequest(ctx, event);
+    if (!request.isSuccess) return request;
+    const { scope, tenantId, source, contentFormat, sourceResources, sourceIsForeign } =
+      request.data;
 
     const variableSchema = storedRecord(source.variableSchema);
     const written = await writeTemplateRow({
@@ -119,7 +186,7 @@ export const copyLocaleWrite = defineWriteHandler({
         kind,
         locale: toLocale,
         content: source.content,
-        contentFormat: source.contentFormat,
+        contentFormat,
         variableSchema,
         meta: parseStoredJson(source.meta),
         title: source.title,
@@ -127,16 +194,17 @@ export const copyLocaleWrite = defineWriteHandler({
       },
     });
     if (!written.isSuccess) return written;
-    // A system source carries no files of its own: its resource keys are known to the tenant row anyway.
-    if (source.tenantId === tenantId) {
-      const attached = await attachTemplateResources(ctx, {
-        user: event.user,
-        tenantId,
-        templateId: written.data.id,
-        resources: parseLinkedResourceEntries(source.linkedResources),
-      });
-      if (!attached.isSuccess) return attached;
-    }
+    const resources = sourceIsForeign
+      ? await createLinkedResourceCopies({ ctx, user: event.user, tenantId }, event.prepared)
+      : { isSuccess: true as const, data: 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/packages/bundled-features/src/template-resolver/handlers/diff-to-system.query.ts

@@ -3,29 +3,8 @@ import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framew
 import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
-import { diffTemplateBlocks, splitTemplateBlocks } from "../template-diff.js";
-
-function parseStoredMeta(raw: string | null): Readonly<Record<string, unknown>> {
-  if (raw === null) return {};
-  try {
-    const parsed: unknown = JSON.parse(raw);
-    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-      ? Object.fromEntries(Object.entries(parsed))
-      : {};
-  } catch {
-    return {};
-  }
-}
-
-function diffMeta(
-  system: Readonly<Record<string, unknown>>,
-  tenant: Readonly<Record<string, unknown>>,
-) {
-  const keys = [...new Set([...Object.keys(system), ...Object.keys(tenant)])].sort();
-  return keys
-    .filter((key) => JSON.stringify(system[key]) !== JSON.stringify(tenant[key]))
-    .map((key) => ({ key, tenant: tenant[key], system: system[key] }));
-}
+import { isHiddenSystemDraft } from "../template-draft.js";
+import { buildOverrideDiff } from "./override-diff.js";
 
 export const diffToSystemQuery = defineQueryHandler({
   name: "diff-to-system",
@@ -45,28 +24,11 @@ export const diffToSystemQuery = defineQueryHandler({
       slug: tenantRow.slug,
       kind: tenantRow.kind,
       locale: tenantRow.locale,
+      status: "active",
     });
-    if (!systemRow) throw new NotFoundError("template-resource", tenantRow.slug);
+    if (!systemRow || isHiddenSystemDraft(query.user, systemRow))
+      throw new NotFoundError("template-resource", tenantRow.slug);
 
-    const blocks = diffTemplateBlocks(
-      splitTemplateBlocks(systemRow.content ?? "", systemRow.contentFormat),
-      splitTemplateBlocks(tenantRow.content ?? "", tenantRow.contentFormat),
-    );
-    const meta = diffMeta(parseStoredMeta(systemRow.meta), parseStoredMeta(tenantRow.meta));
-    return {
-      tenant: {
-        templateId: String(tenantRow.id),
-        templateVersion: tenantRow.version,
-        contentFormat: tenantRow.contentFormat,
-      },
-      system: {
-        templateId: String(systemRow.id),
-        templateVersion: systemRow.version,
-        contentFormat: systemRow.contentFormat,
-      },
-      identical: meta.length === 0 && blocks.every((block) => block.change === "same"),
-      blocks,
-      meta,
-    };
+    return buildOverrideDiff(tenantRow, systemRow);
   },
 });

package/packages/bundled-features/src/template-resolver/handlers/discard-draft.write.ts

@@ -0,0 +1,52 @@
+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, type StatusTarget, writeAccessFor } from "./toggle-status.write.js";
+
+function createDiscardDraftHandler(name: string, target: StatusTarget, description: string) {
+  return defineWriteHandler({
+    name,
+    schema: z.object({ id: z.string().min(1) }),
+    access: writeAccessFor(target),
+    ...(target === "system" ? { agent: { risk: "high" as const } } : {}),
+    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 as const, 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.",
+);

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

@@ -1,6 +1,7 @@
+import { isDeepStrictEqual } from "node:util";
 import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
-import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import { NotFoundError, ValidationError } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import {
   isFileAttachmentEntry,
@@ -8,12 +9,63 @@ import {
   type LinkedResourceEntry,
   parseLinkedResourceEntries,
 } from "../linked-resources.js";
+import { TemplateResolverErrors } from "../qualified-names.js";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
 import type { TemplateBundle } from "../template-bundle.js";
 import { readTemplateResource } from "../template-resources.js";
 import { kindSchema, templateSlugSchema } from "./shared.js";
 import { parseStoredJson, storedRecord } from "./template-gates.js";
 
+// The files live in the system tenant's key space; readTemplateResource only
+// serves the caller's own tenant, so anyone else would end in a misleading NotFound.
+function assertSystemFilesReadable(
+  scope: "tenant" | "system",
+  entries: Iterable<LinkedResourceEntry>,
+  callerTenantId: string,
+): void {
+  // skip: tenant exports read the caller's own files.
+  if (scope === "tenant") return;
+  // skip: the system tenant reads its own key space.
+  if (callerTenantId === SYSTEM_TENANT_ID) return;
+  const hasFileResources = [...entries].some((entry) => !isPdfAttachmentLink(entry));
+  // skip: PDF attachment links carry no file to read.
+  if (!hasFileResources) return;
+  throw new ValidationError({
+    fields: [
+      {
+        path: "scope",
+        code: "system_resources_need_system_tenant",
+        i18nKey: "templateResolver.errors.template.systemResourcesNeedSystemTenant",
+      },
+    ],
+  });
+}
+
+// A bundle carries one contentFormat and one variableSchema for all locales; importing it would
+// relabel the rows that differ from the first.
+function assertLocalesShareFormat(rows: readonly TemplateResourceRow[]): void {
+  const [first, ...rest] = rows;
+  // skip: a bundle without rows has nothing to compare
+  if (first === undefined) return;
+  const firstSchema = storedRecord(first.variableSchema);
+  const differing = rest.find(
+    (row) =>
+      row.contentFormat !== first.contentFormat ||
+      !isDeepStrictEqual(storedRecord(row.variableSchema), firstSchema),
+  );
+  // skip: all locales agree
+  if (differing === undefined) return;
+  throw new ValidationError({
+    fields: [
+      {
+        path: "slug",
+        code: TemplateResolverErrors.bundleLocalesDiffer,
+        i18nKey: "templateResolver.errors.template.bundleLocalesDiffer",
+      },
+    ],
+  });
+}
+
 export const exportBundleQuery = defineQueryHandler({
   name: "export-bundle",
   schema: z.object({
@@ -38,6 +90,7 @@ export const exportBundleQuery = defineQueryHandler({
       .sort((a, b) => a.locale.localeCompare(b.locale));
     const first = rows[0];
     if (!first) throw new NotFoundError("template-resource", slug);
+    assertLocalesShareFormat(rows);
 
     const locales: Record<string, { body: string; meta?: unknown }> = {};
     const entryByKey = new Map<string, LinkedResourceEntry>();
@@ -49,6 +102,8 @@ export const exportBundleQuery = defineQueryHandler({
       }
     }
 
+    assertSystemFilesReadable(scope, entryByKey.values(), query.user.tenantId);
+
     const resources: TemplateBundle["resources"] = {};
     const pdfAttachments: TemplateBundle["pdfAttachments"] = {};
     for (const [key, entry] of entryByKey) {

package/packages/bundled-features/src/template-resolver/handlers/find-by-id.query.ts

@@ -2,6 +2,7 @@ import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
+import { draftViewerTenantId, isHiddenSystemDraft, toWorkingRow } from "../template-draft.js";
 
 // Admin-Lookup für UI-Edit-Flow. Returnt das raw Template inkl. draft/
 // archived Status. Tenant-Isolation: User sieht nur Templates des
@@ -13,12 +14,13 @@ export const findByIdQuery = defineQueryHandler({
   schema: z.object({ id: z.string().min(1) }),
   access: { roles: ["TenantAdmin", "SystemAdmin", "User"] },
   description:
-    "Reads one template resource by row id with its content, variable schema, scope and draft/archived status, but only when it belongs to the caller's tenant or is a system default; use it to load a template into the admin editor.",
+    "Reads the version of one template resource an editor works on, by row id: the open draft if there is one (status draft), else the stored version, with content, variable schema and scope, but only when it belongs to the caller's tenant or is a served system default (a never-served system draft is visible to a SystemAdmin only); `active` is the version number and since-time the resolver serves, null when none is served. Use it to load a template into the admin editor.",
   handler: async (query, ctx) => {
-    const row = await fetchOne<TemplateResourceRow>(ctx.db, templateResourcesTable, {
+    const stored = await fetchOne<TemplateResourceRow>(ctx.db, templateResourcesTable, {
       id: query.payload.id,
     });
-    if (!row) return null;
+    if (!stored || isHiddenSystemDraft(query.user, stored)) return null;
+    const row = toWorkingRow(stored, draftViewerTenantId(query.user, stored));
     const isOwnTenant = row.tenantId === query.user.tenantId;
     const isSystemTemplate = row.scope === "system";
     if (!isOwnTenant && !isSystemTemplate) return null;
@@ -39,6 +41,7 @@ export const findByIdQuery = defineQueryHandler({
       parentTemplateId: row.parentTemplateId,
       status: row.status,
       modifiedAt: row.modifiedAt,
+      active: row.active,
     };
   },
 });

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

@@ -2,7 +2,7 @@ import { defineWriteHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framew
 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";
+import { importTemplateBundle, prepareTemplateBundleBeforeTransaction } from "./bundle-import.js";
 
 export const importBundleSystemWrite = defineWriteHandler({
   name: "import-bundle-system",
@@ -12,24 +12,23 @@ export const importBundleSystemWrite = defineWriteHandler({
   agent: { risk: "high" as const },
   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) => {
+  beforeTransaction: async (event, ctx) => {
     const { bundle } = event.payload;
+    // Must run before any upload.
     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 writeFailure(
+        new ValidationError({
+          fields: [
+            {
+              path: "bundle.resources",
+              code: "system_resources_need_system_tenant",
+              i18nKey: "templateResolver.errors.template.systemResourcesNeedSystemTenant",
+            },
+          ],
+        }),
       );
     }
-    return importTemplateBundle({
+    return prepareTemplateBundleBeforeTransaction({
       ctx,
       user: event.user,
       tenantId: SYSTEM_TENANT_ID,
@@ -39,4 +38,15 @@ export const importBundleSystemWrite = defineWriteHandler({
       overwrite: true,
     });
   },
+  handler: (event, ctx) =>
+    importTemplateBundle({
+      ctx,
+      user: event.user,
+      tenantId: SYSTEM_TENANT_ID,
+      scope: "system",
+      status: "active",
+      bundle: event.payload.bundle,
+      overwrite: true,
+      prepared: event.prepared,
+    }),
 });

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

@@ -1,7 +1,7 @@
 import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { templateBundleSchema } from "../template-bundle.js";
-import { importTemplateBundle } from "./bundle-import.js";
+import { importTemplateBundle, prepareTemplateBundleBeforeTransaction } from "./bundle-import.js";
 
 export const importBundleWrite = defineWriteHandler({
   name: "import-bundle",
@@ -9,6 +9,16 @@ export const importBundleWrite = defineWriteHandler({
   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.",
+  beforeTransaction: (event, ctx) =>
+    prepareTemplateBundleBeforeTransaction({
+      ctx,
+      user: event.user,
+      tenantId: event.user.tenantId,
+      scope: "tenant",
+      status: "draft",
+      bundle: event.payload.bundle,
+      overwrite: event.payload.overwrite,
+    }),
   handler: (event, ctx) =>
     importTemplateBundle({
       ctx,
@@ -18,5 +28,6 @@ export const importBundleWrite = defineWriteHandler({
       status: "draft",
       bundle: event.payload.bundle,
       overwrite: event.payload.overwrite,
+      prepared: event.prepared,
     }),
 });