@cosmicdrift/kumiko-bundled-features 0.81.1 → 0.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-bundled-features",
-  "version": "0.81.1",
+  "version": "0.82.0",
   "description": "Built-in features — tenant, user, auth, delivery. The stuff you'd rewrite anyway, already typed.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -85,11 +85,11 @@
     "./step-dispatcher": "./src/step-dispatcher/index.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.81.1",
-    "@cosmicdrift/kumiko-framework": "0.81.1",
-    "@cosmicdrift/kumiko-headless": "0.81.1",
-    "@cosmicdrift/kumiko-renderer": "0.81.1",
-    "@cosmicdrift/kumiko-renderer-web": "0.81.1",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.82.0",
+    "@cosmicdrift/kumiko-framework": "0.82.0",
+    "@cosmicdrift/kumiko-headless": "0.82.0",
+    "@cosmicdrift/kumiko-renderer": "0.82.0",
+    "@cosmicdrift/kumiko-renderer-web": "0.82.0",
     "@mollie/api-client": "^4.5.0",
     "@node-rs/argon2": "^2.0.2",
     "@types/nodemailer": "^8.0.0",

package/src/tags/__tests__/feature.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import { DEFAULT_TAG_ROLES } from "../constants";
 import { createTagsFeature } from "../feature";
-import { assignTagPayloadSchema, createTagPayloadSchema, removeTagPayloadSchema } from "../schemas";
+import {
+  assignTagPayloadSchema,
+  createTagPayloadSchema,
+  removeTagPayloadSchema,
+  renameTagPayloadSchema,
+} from "../schemas";
 
 // Unit tests: feature-shape, role-options, schema-validation. The ES-loop
 // behaviour (idempotent assign/remove, projection, tenant-isolation, read
@@ -42,7 +47,7 @@ function rawQueryAccess(feature: ReturnType<typeof createTagsFeature>, nameMatch
 }
 
 describe("createTagsFeature shape", () => {
-  test("registers tag + tag-assignment entities, 3 write-handlers, 2 query-handlers", () => {
+  test("registers tag + tag-assignment entities, 4 write-handlers, 2 query-handlers", () => {
     const feature = createTagsFeature();
 
     expect(Object.keys(feature.entities ?? {})).toEqual(
@@ -52,11 +57,12 @@ describe("createTagsFeature shape", () => {
     expect(Object.keys(feature.writeHandlers)).toEqual(
       expect.arrayContaining([
         expect.stringMatching(/create-tag/),
+        expect.stringMatching(/rename-tag/),
         expect.stringMatching(/assign-tag/),
         expect.stringMatching(/remove-tag/),
       ]),
     );
-    expect(Object.keys(feature.writeHandlers)).toHaveLength(3);
+    expect(Object.keys(feature.writeHandlers)).toHaveLength(4);
 
     expect(Object.keys(feature.queryHandlers)).toEqual(
       expect.arrayContaining([
@@ -73,6 +79,7 @@ describe("createTagsFeature access-options", () => {
     const feature = createTagsFeature();
     expect(feature).toBe(createTagsFeature());
     expect(writeAccess(feature, "create-tag")).toEqual([...DEFAULT_TAG_ROLES]);
+    expect(writeAccess(feature, "rename-tag")).toEqual([...DEFAULT_TAG_ROLES]);
     expect(writeAccess(feature, "assign-tag")).toEqual([...DEFAULT_TAG_ROLES]);
     expect(writeAccess(feature, "remove-tag")).toEqual([...DEFAULT_TAG_ROLES]);
     expect(queryAccess(feature, "tag:list")).toEqual([...DEFAULT_TAG_ROLES]);
@@ -82,6 +89,7 @@ describe("createTagsFeature access-options", () => {
   test("roles option overrides every write- and query-path", () => {
     const feature = createTagsFeature({ roles: ["Admin", "Editor"] });
     expect(writeAccess(feature, "create-tag")).toEqual(["Admin", "Editor"]);
+    expect(writeAccess(feature, "rename-tag")).toEqual(["Admin", "Editor"]);
     expect(writeAccess(feature, "assign-tag")).toEqual(["Admin", "Editor"]);
     expect(writeAccess(feature, "remove-tag")).toEqual(["Admin", "Editor"]);
     expect(queryAccess(feature, "tag:list")).toEqual(["Admin", "Editor"]);
@@ -90,7 +98,7 @@ describe("createTagsFeature access-options", () => {
 
   test("access:{openToAll} applies to every write- and query-path", () => {
     const feature = createTagsFeature({ access: { openToAll: true } });
-    for (const path of ["create-tag", "assign-tag", "remove-tag"]) {
+    for (const path of ["create-tag", "rename-tag", "assign-tag", "remove-tag"]) {
       expect(rawWriteAccess(feature, path)).toEqual({ openToAll: true });
     }
     for (const query of ["tag:list", "tag-assignment:list"]) {
@@ -155,6 +163,28 @@ describe("createTagPayloadSchema", () => {
   });
 });
 
+describe("renameTagPayloadSchema", () => {
+  const valid = { id: "tag-1", version: 0, name: "Neu" };
+
+  test("accepts id + version + name", () => {
+    expect(renameTagPayloadSchema.safeParse(valid).success).toBe(true);
+  });
+
+  test("rejects a missing version (optimistic lock is mandatory)", () => {
+    expect(renameTagPayloadSchema.safeParse({ id: "tag-1", name: "Neu" }).success).toBe(false);
+  });
+
+  test("rejects an empty name", () => {
+    expect(renameTagPayloadSchema.safeParse({ ...valid, name: "" }).success).toBe(false);
+  });
+
+  test("rejects a name over 64 chars", () => {
+    expect(renameTagPayloadSchema.safeParse({ ...valid, name: "x".repeat(65) }).success).toBe(
+      false,
+    );
+  });
+});
+
 describe("assign/remove payload schemas", () => {
   const valid = { tagId: "tag-1", entityType: "credit", entityId: "c-1" };
 

package/src/tags/__tests__/tags.integration.test.ts

@@ -61,6 +61,10 @@ async function remove(tagId: string, entityType: string, entityId: string, user
   return stack.http.writeOk(TagsHandlers.removeTag, { tagId, entityType, entityId }, user);
 }
 
+async function tagById(id: string, user = admin): Promise<Record<string, unknown> | undefined> {
+  return (await listTags(user)).find((t) => t["id"] === id);
+}
+
 async function listTags(user = admin): Promise<Array<Record<string, unknown>>> {
   const res = await stack.http.queryOk<{ rows: Array<Record<string, unknown>> }>(
     TagsQueries.tagList,
@@ -129,6 +133,64 @@ describe("tags integration — catalog + assignment roundtrip", () => {
   });
 });
 
+describe("tags integration — rename", () => {
+  test("rename-tag updates name, preserves color, bumps version", async () => {
+    const { id } = await stack.http.writeOk<{ id: string }>(
+      TagsHandlers.createTag,
+      { name: "Mandant Alt", color: "#abc" },
+      admin,
+    );
+    const before = await tagById(id);
+    expect(before?.["name"]).toBe("Mandant Alt");
+    // The rename UI passes the list-row version as the optimistic-lock base —
+    // assert it's actually there (tags are CRUD-only, so it's authoritative).
+    expect(typeof before?.["version"]).toBe("number");
+    const version = before?.["version"] as number;
+
+    await stack.http.writeOk(TagsHandlers.renameTag, { id, version, name: "Mandant Neu" }, admin);
+
+    const after = await tagById(id);
+    expect(after?.["name"]).toBe("Mandant Neu");
+    expect(after?.["color"]).toBe("#abc"); // shallow merge keeps non-renamed fields
+    expect(after?.["version"]).toBe(version + 1);
+  });
+
+  test("rename-tag with a stale version is rejected (409), name unchanged", async () => {
+    const { id } = await stack.http.writeOk<{ id: string }>(
+      TagsHandlers.createTag,
+      { name: "Konflikt" },
+      admin,
+    );
+    const stale = (await tagById(id))?.["version"] as number;
+    await stack.http.writeOk(TagsHandlers.renameTag, { id, version: stale, name: "Erster" }, admin);
+
+    const err = await stack.http.writeErr(
+      TagsHandlers.renameTag,
+      { id, version: stale, name: "Zweiter" }, // stale: the row already moved to stale+1
+      admin,
+    );
+    expect(err.httpStatus).toBe(409);
+    expect((await tagById(id))?.["name"]).toBe("Erster");
+  });
+
+  test("tenant B cannot rename tenant A's tag (404, A untouched)", async () => {
+    const { id } = await stack.http.writeOk<{ id: string }>(
+      TagsHandlers.createTag,
+      { name: "A privat" },
+      admin,
+    );
+    const version = (await tagById(id, admin))?.["version"] as number;
+
+    const err = await stack.http.writeErr(
+      TagsHandlers.renameTag,
+      { id, version, name: "B-Übernahme" },
+      otherTenant,
+    );
+    expect(err.httpStatus).toBe(404);
+    expect((await tagById(id, admin))?.["name"]).toBe("A privat");
+  });
+});
+
 describe("tags integration — many-to-many composition", () => {
   test("one entity carries multiple tags", async () => {
     const a = await createTag("rot");

package/src/tags/constants.ts

@@ -18,6 +18,7 @@ export const TAGS_SECTION_EXTENSION_NAME = "TagSection";
 // object instead of magic strings (mirror custom-fields' Handlers/Queries).
 export const TagsHandlers = {
   createTag: "tags:write:create-tag",
+  renameTag: "tags:write:rename-tag",
   assignTag: "tags:write:assign-tag",
   removeTag: "tags:write:remove-tag",
 } as const;

package/src/tags/feature.ts

@@ -12,8 +12,8 @@
 // tag-assignments filtered on entityId (tags of an entity) or tagId (entities
 // with a tag). See entity.ts.
 //
-// v1 scope: create-tag, assign-tag, remove-tag, list tags, list assignments.
-// Deferred: rename/delete-tag, optional host-projection decoration
+// Scope: create-tag, rename-tag, assign-tag, remove-tag, list tags, list assignments.
+// Deferred: delete-tag, optional host-projection decoration
 // (`wireTagsFor`), search indexing, user-data-rights anonymization.
 
 import {
@@ -27,6 +27,7 @@ import { tagAssignmentEntity, tagEntity } from "./entity";
 import { createAssignTagHandler } from "./handlers/assign-tag.write";
 import { createCreateTagHandler } from "./handlers/create-tag.write";
 import { createRemoveTagHandler } from "./handlers/remove-tag.write";
+import { createRenameTagHandler } from "./handlers/rename-tag.write";
 
 // Opt-in tier-gating: when set, the feature declares itself r.toggleable so the
 // dispatcher gate + feature-toggles + tier-engine can switch the WHOLE feature
@@ -42,7 +43,7 @@ function registerTags(
   toggleable: TagsToggleable | undefined,
 ): void {
   r.describe(
-    "Generic, host-agnostic tagging for any entity. Owns two event-sourced entities — the per-tenant `tag` catalog (`read_tags`) and `tag-assignment` join rows keyed by (entityType, entityId) (`read_tag_assignments`) — so tagging adds NO column to the host entity and needs no relational pivot or JOIN. Provides write-handlers `create-tag`, `assign-tag` (idempotent), `remove-tag` (idempotent) and list queries for the catalog and the assignments. Read which tags an entity has, or which entities carry a tag, by listing `tag-assignment` filtered on `entityId` or `tagId` and composing in the read-layer. Every path uses one access rule — adopt the host's model with createTagsFeature({ access: { openToAll: true } }) or pin roles with createTagsFeature({ roles }). Pass { toggleable: { default: false } } to make the whole feature tier-gatable via the tier-engine (no host hook).",
+    "Generic, host-agnostic tagging for any entity. Owns two event-sourced entities — the per-tenant `tag` catalog (`read_tags`) and `tag-assignment` join rows keyed by (entityType, entityId) (`read_tag_assignments`) — so tagging adds NO column to the host entity and needs no relational pivot or JOIN. Provides write-handlers `create-tag`, `rename-tag` (optimistic-locked), `assign-tag` (idempotent), `remove-tag` (idempotent) and list queries for the catalog and the assignments. Read which tags an entity has, or which entities carry a tag, by listing `tag-assignment` filtered on `entityId` or `tagId` and composing in the read-layer. Every path uses one access rule — adopt the host's model with createTagsFeature({ access: { openToAll: true } }) or pin roles with createTagsFeature({ roles }). Pass { toggleable: { default: false } } to make the whole feature tier-gatable via the tier-engine (no host hook).",
   );
   r.uiHints({
     displayLabel: "Tags",
@@ -58,6 +59,7 @@ function registerTags(
   r.entity("tag-assignment", tagAssignmentEntity);
 
   r.writeHandler(createCreateTagHandler(access));
+  r.writeHandler(createRenameTagHandler(access));
   r.writeHandler(createAssignTagHandler(access));
   r.writeHandler(createRemoveTagHandler(access));
 

package/src/tags/handlers/create-tag.write.ts

@@ -6,8 +6,7 @@ import { type CreateTagPayload, createTagPayloadSchema } from "../schemas";
 // create-tag — adds a tag to the tenant's catalog. The framework mints a fresh
 // UUIDv7 id (no explicit id passed). Tag names are not unique by design: the
 // catalog is a free list and dedup is a UI concern (autocomplete from existing
-// tags). Rename/delete are deferred to a later iteration (v1 scope: create,
-// assign, remove, list).
+// tags). Rename is rename-tag.write.ts; delete is still deferred.
 export function createCreateTagHandler(access: AccessRule = DEFAULT_TAG_ACCESS): WriteHandlerDef {
   return {
     name: "create-tag",

package/src/tags/handlers/rename-tag.write.ts

@@ -0,0 +1,26 @@
+import type { AccessRule, WriteHandlerDef } from "@cosmicdrift/kumiko-framework/engine";
+import { DEFAULT_TAG_ACCESS } from "../constants";
+import { tagExecutor } from "../executor";
+import { type RenameTagPayload, renameTagPayloadSchema } from "../schemas";
+
+// rename-tag — renames a tag in the tenant's catalog. Optimistic-locked: the
+// client sends the `version` it read (mirrors tenant:update). The executor
+// merges shallowly so only `name` changes — `color` is preserved. A stale
+// version returns version_conflict; the UI refetches and retries.
+export function createRenameTagHandler(access: AccessRule = DEFAULT_TAG_ACCESS): WriteHandlerDef {
+  return {
+    name: "rename-tag",
+    schema: renameTagPayloadSchema,
+    access,
+    handler: async (event, ctx) => {
+      const payload = event.payload as RenameTagPayload; // @cast-boundary engine-payload
+      return tagExecutor.update(
+        { id: payload.id, version: payload.version, changes: { name: payload.name } },
+        event.user,
+        ctx.db,
+      );
+    },
+  };
+}
+
+export const renameTagHandler: WriteHandlerDef = createRenameTagHandler();

package/src/tags/index.ts

@@ -20,11 +20,17 @@ export {
   createRemoveTagHandler,
   removeTagHandler,
 } from "./handlers/remove-tag.write";
+export {
+  createRenameTagHandler,
+  renameTagHandler,
+} from "./handlers/rename-tag.write";
 export {
   type AssignTagPayload,
   assignTagPayloadSchema,
   type CreateTagPayload,
   createTagPayloadSchema,
   type RemoveTagPayload,
+  type RenameTagPayload,
   removeTagPayloadSchema,
+  renameTagPayloadSchema,
 } from "./schemas";

package/src/tags/schemas.ts

@@ -6,6 +6,15 @@ export const createTagPayloadSchema = z.object({
 });
 export type CreateTagPayload = z.infer<typeof createTagPayloadSchema>;
 
+// rename-tag — id + the version the client read (optimistic lock, mirrors
+// tenant:update) + the new name. The executor merges shallowly, so color stays.
+export const renameTagPayloadSchema = z.object({
+  id: z.string().min(1),
+  version: z.number().int().nonnegative(),
+  name: z.string().min(1).max(64),
+});
+export type RenameTagPayload = z.infer<typeof renameTagPayloadSchema>;
+
 // assign + remove share the (tag, entity) reference shape.
 const entityTagRef = {
   tagId: z.string().min(1).max(64),