@cosmicdrift/kumiko-bundled-features 0.64.0 → 0.66.0

package/src/tags/web/__tests__/tag-section.test.tsx

@@ -9,7 +9,7 @@ import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import type { ReactNode } from "react";
 import { TagsHandlers, TagsQueries } from "../../constants";
 import { defaultTranslations } from "../i18n";
-import { TagSection } from "../tag-section";
+import { TagSection, tagSelectionDelta } from "../tag-section";
 
 type TagRow = { id: string; name: string };
 type AssignmentRow = { tagId: string; entityType: string; entityId: string };
@@ -17,14 +17,12 @@ type AssignmentRow = { tagId: string; entityType: string; entityId: string };
 let catalogRows: readonly TagRow[] = [];
 let assignmentRows: readonly AssignmentRow[] = [];
 
-// createTag returns the new id; assign/remove return data-less success.
 const dispatchSpy = mock(async (type: string) =>
   type === TagsHandlers.createTag
     ? { isSuccess: true, data: { id: "tag-new" } }
     : { isSuccess: true, data: undefined },
 );
 
-// useQuery is called twice (catalog + assignments) — branch on the QN.
 const useQuerySpy = mock((type: string) => ({
   data: type === TagsQueries.tagList ? { rows: catalogRows } : { rows: assignmentRows },
   loading: false,
@@ -47,14 +45,33 @@ function Wrapper({ children }: { readonly children: ReactNode }): ReactNode {
   );
 }
 
+// The combobox's assign/remove toggle drives onChange with the full new
+// selection; the component diffs it against the current tags via this helper.
+// Popover interaction itself (cmdk + Radix in jsdom) is covered by the
+// combobox primitive's own tests + e2e — here we pin the diff that turns a
+// selection into assign/remove calls.
+describe("tagSelectionDelta", () => {
+  test("addition only", () => {
+    expect(tagSelectionDelta(["a"], ["a", "b"])).toEqual({ added: ["b"], removed: [] });
+  });
+  test("removal only", () => {
+    expect(tagSelectionDelta(["a", "b"], ["a"])).toEqual({ added: [], removed: ["b"] });
+  });
+  test("simultaneous add + remove", () => {
+    expect(tagSelectionDelta(["a"], ["b"])).toEqual({ added: ["b"], removed: ["a"] });
+  });
+  test("no change", () => {
+    expect(tagSelectionDelta(["a", "b"], ["b", "a"])).toEqual({ added: [], removed: [] });
+  });
+});
+
 describe("TagSection", () => {
-  test("shows assigned + available tags and dispatches assign/remove with the right QN + payload", async () => {
+  test("renders assigned tags as combobox chips", () => {
     catalogRows = [
       { id: "t1", name: "important" },
       { id: "t2", name: "project-x" },
     ];
     assignmentRows = [{ tagId: "t1", entityType: "note", entityId: "note-1" }];
-    dispatchSpy.mockClear();
 
     render(
       <Wrapper>
@@ -62,28 +79,10 @@ describe("TagSection", () => {
       </Wrapper>,
     );
 
-    // Assigned tag → remove button; unassigned catalog tag → assign button.
-    expect(screen.getByTestId("tags-section-remove-t1")).toBeTruthy();
-    expect(screen.getByTestId("tags-section-assign-t2")).toBeTruthy();
-    expect(screen.queryByTestId("tags-section-assign-t1")).toBeNull();
-
-    fireEvent.click(screen.getByTestId("tags-section-assign-t2"));
-    await waitFor(() =>
-      expect(dispatchSpy).toHaveBeenCalledWith(TagsHandlers.assignTag, {
-        tagId: "t2",
-        entityType: "note",
-        entityId: "note-1",
-      }),
-    );
-
-    fireEvent.click(screen.getByTestId("tags-section-remove-t1"));
-    await waitFor(() =>
-      expect(dispatchSpy).toHaveBeenCalledWith(TagsHandlers.removeTag, {
-        tagId: "t1",
-        entityType: "note",
-        entityId: "note-1",
-      }),
-    );
+    expect(screen.getByTestId("combobox-tags-section-select")).toBeTruthy();
+    // assigned → chip shown in the trigger; unassigned t2 lives in the (closed) dropdown
+    expect(screen.getByText("important")).toBeTruthy();
+    expect(screen.queryByText("project-x")).toBeNull();
   });
 
   test("create-and-attach dispatches create-tag, then assign-tag with the new id", async () => {

package/src/tags/web/i18n.ts

@@ -9,7 +9,9 @@ export const defaultTranslations: TranslationsByLocale = {
   de: {
     "tags.section.createMode": "Speichere zuerst den Eintrag, um Tags zu setzen.",
     "tags.section.loading": "Lädt…",
-    "tags.section.none": "Keine Tags.",
+    "tags.section.label": "Tags",
+    "tags.section.placeholder": "Tags auswählen…",
+    "tags.section.empty": "Keine Tags gefunden.",
     "tags.section.newLabel": "Neuer Tag",
     "tags.section.create": "Tag anlegen & zuweisen",
     "tags.section.working": "Speichert…",
@@ -17,7 +19,9 @@ export const defaultTranslations: TranslationsByLocale = {
   en: {
     "tags.section.createMode": "Save the entity first to add tags.",
     "tags.section.loading": "Loading…",
-    "tags.section.none": "No tags.",
+    "tags.section.label": "Tags",
+    "tags.section.placeholder": "Select tags…",
+    "tags.section.empty": "No tags found.",
     "tags.section.newLabel": "New tag",
     "tags.section.create": "Create & attach tag",
     "tags.section.working": "Saving…",

package/src/tags/web/tag-section.tsx

@@ -1,9 +1,9 @@
 // @runtime client
-// TagSection — drop-in tag manager for ANY entity. Given an entityName +
-// entityId it shows the entity's current tags and lets the user attach an
-// existing tag, create-and-attach a new one, or detach a tag. Tag writes are
-// immediate (assign/remove are idempotent), so the section owns its own state
-// and refetches after each action — it is NOT part of a host form's save.
+// TagSection — drop-in tag manager for ANY entity, GitLab-labels style: one
+// searchable multi-combobox showing the entity's tags as chips, with a compact
+// row below to create-and-attach a brand-new tag. Tag writes are immediate
+// (assign/remove are idempotent), so the section owns its state and refetches
+// after each action — it is NOT part of a host form's save.
 //
 // Two ways to mount (both need tagsClient() registered once, for i18n):
 //   - standalone:   <TagSection entityName="note" entityId={noteId} />
@@ -29,12 +29,20 @@ type AssignmentRow = {
 type TagListResponse = { readonly rows: readonly TagRow[] };
 type AssignmentListResponse = { readonly rows: readonly AssignmentRow[] };
 
-// Structural shape of a dispatcher write result for the generic action wrapper.
-// The real WriteResult (a discriminated union) is assignable to this; narrowing
-// on `isSuccess` reaches `error.i18nKey` without importing server-side types.
-type ActionResult =
-  | { readonly isSuccess: true }
-  | { readonly isSuccess: false; readonly error: { readonly i18nKey: string } };
+// What changed between the entity's current tags and the combobox's new
+// selection. A single combobox toggle yields one add or one remove; the diff
+// stays correct for a batch selection too.
+export function tagSelectionDelta(
+  prev: readonly string[],
+  next: readonly string[],
+): { readonly added: readonly string[]; readonly removed: readonly string[] } {
+  const prevSet = new Set(prev);
+  const nextSet = new Set(next);
+  return {
+    added: next.filter((id) => !prevSet.has(id)),
+    removed: prev.filter((id) => !nextSet.has(id)),
+  };
+}
 
 export function TagSection({
   entityName,
@@ -84,98 +92,101 @@ export function TagSection({
   }
 
   const catalogTags = catalog.data?.rows ?? [];
-  const byId = new Map(catalogTags.map((tg) => [tg.id, tg]));
-  const assignedRows = (assignments.data?.rows ?? []).filter((r) => r.entityType === entityName);
-  const assignedIds = new Set(assignedRows.map((r) => r.tagId));
-  const assignedTags = assignedRows.map((r) => byId.get(r.tagId) ?? { id: r.tagId, name: r.tagId });
-  const available = catalogTags.filter((tg) => !assignedIds.has(tg.id));
+  const assignedIds = (assignments.data?.rows ?? [])
+    .filter((r) => r.entityType === entityName)
+    .map((r) => r.tagId);
+  // Catalog drives the options; an assigned tag missing from the catalog (none
+  // in v1 — no delete-tag yet) is appended so it stays removable.
+  const nameById = new Map(catalogTags.map((tg) => [tg.id, tg.name]));
+  const options = [...new Set([...catalogTags.map((tg) => tg.id), ...assignedIds])].map((id) => ({
+    value: id,
+    label: nameById.get(id) ?? id,
+  }));
 
   const refetch = async (): Promise<void> => {
     await Promise.all([catalog.refetch(), assignments.refetch()]);
   };
 
-  const run = async (action: () => Promise<ActionResult>): Promise<void> => {
+  // Runs a write-sequence (each step returns false + sets errorKey on failure,
+  // stopping the sequence) and refetches to server-truth when it completes.
+  const apply = async (writes: () => Promise<boolean>): Promise<void> => {
     setBusy(true);
     setErrorKey(null);
     try {
-      const result = await action();
-      if (!result.isSuccess) {
-        setErrorKey(result.error.i18nKey);
-        return;
-      }
-      await refetch();
+      if (await writes()) await refetch();
     } finally {
       setBusy(false);
     }
   };
 
-  const assign = (tagId: string): Promise<void> =>
-    run(() =>
-      dispatcher.write(TagsHandlers.assignTag, { tagId, entityType: entityName, entityId }),
-    );
+  const writeOk = async (type: string, payload: Record<string, unknown>): Promise<boolean> => {
+    const result = await dispatcher.write(type, payload);
+    if (!result.isSuccess) {
+      setErrorKey(result.error.i18nKey);
+      return false;
+    }
+    return true;
+  };
 
-  const detach = (tagId: string): Promise<void> =>
-    run(() =>
-      dispatcher.write(TagsHandlers.removeTag, { tagId, entityType: entityName, entityId }),
-    );
+  const onSelectionChange = (next: readonly string[]): void => {
+    const { added, removed } = tagSelectionDelta(assignedIds, next);
+    if (added.length === 0 && removed.length === 0) return;
+    void apply(async () => {
+      for (const tagId of added) {
+        if (!(await writeOk(TagsHandlers.assignTag, { tagId, entityType: entityName, entityId })))
+          return false;
+      }
+      for (const tagId of removed) {
+        if (!(await writeOk(TagsHandlers.removeTag, { tagId, entityType: entityName, entityId })))
+          return false;
+      }
+      return true;
+    });
+  };
 
-  const createAndAssign = async (): Promise<void> => {
+  const createAndAssign = (): void => {
     const name = newName.trim();
     if (name === "") return;
-    setBusy(true);
-    setErrorKey(null);
-    try {
+    void apply(async () => {
       const created = await dispatcher.write<{ id: string }>(TagsHandlers.createTag, { name });
       if (!created.isSuccess) {
         setErrorKey(created.error.i18nKey);
-        return;
+        return false;
       }
-      const assigned = await dispatcher.write(TagsHandlers.assignTag, {
-        tagId: created.data.id,
-        entityType: entityName,
-        entityId,
-      });
-      if (!assigned.isSuccess) {
-        setErrorKey(assigned.error.i18nKey);
-        return;
+      if (
+        !(await writeOk(TagsHandlers.assignTag, {
+          tagId: created.data.id,
+          entityType: entityName,
+          entityId,
+        }))
+      ) {
+        return false;
       }
       setNewName("");
-      await refetch();
-    } finally {
-      setBusy(false);
-    }
+      return true;
+    });
   };
 
   return (
     <div data-testid="tags-section">
-      {assignedTags.length === 0 ? (
-        <Text>{t("tags.section.none")}</Text>
-      ) : (
-        assignedTags.map((tg) => (
-          <Button
-            key={tg.id}
-            variant="secondary"
-            disabled={busy}
-            onClick={() => void detach(tg.id)}
-            testId={`tags-section-remove-${tg.id}`}
-          >
-            {`${tg.name} ✕`}
-          </Button>
-        ))
-      )}
-
-      {available.map((tg) => (
-        <Button
-          key={tg.id}
-          variant="secondary"
+      <Field id="tags-section-select" label={t("tags.section.label")}>
+        <Input
+          kind="combobox"
+          multiple
+          id="tags-section-select"
+          name="tags"
+          options={options}
+          value={assignedIds}
+          onChange={onSelectionChange}
           disabled={busy}
-          onClick={() => void assign(tg.id)}
-          testId={`tags-section-assign-${tg.id}`}
-        >
-          {`+ ${tg.name}`}
-        </Button>
-      ))}
+          placeholder={t("tags.section.placeholder")}
+          emptyText={t("tags.section.empty")}
+        />
+      </Field>
 
+      {/* ponytail: separate create row — the shared combobox has no create-on-type
+          affordance. Fold create into the dropdown's Command.Empty if/when the
+          renderer-web combobox grows a freeSolo/onCreate prop. */}
       <Field id="tags-section-new" label={t("tags.section.newLabel")}>
         <Input
           kind="text"
@@ -186,9 +197,9 @@ export function TagSection({
         />
       </Field>
       <Button
-        variant="primary"
+        variant="secondary"
         disabled={busy || newName.trim() === ""}
-        onClick={() => void createAndAssign()}
+        onClick={() => createAndAssign()}
         testId="tags-section-create"
       >
         {busy ? t("tags.section.working") : t("tags.section.create")}

package/src/text-content/web/__tests__/client-plugin.test.tsx

@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import type { TreeNode } from "@cosmicdrift/kumiko-framework/engine";
+import { textContentClient } from "../client-plugin";
+
+// Deckt die drei neuen Migrations-Pfade (advisor-Gap): navId-Attach + SSE-
+// Entities, no-leak ohne navId (conditional-spread), und der Unwrap (Provider
+// emittiert die Folder/Leaves direkt, NICHT unter dem "Content"-Wrapper).
+// Der Provider fetcht → fetch wird gemockt.
+
+describe("textContentClient — shape", () => {
+  test("ohne navId: kein navProvider/navEntities (no-leak), aber Resolver bleibt", () => {
+    const def = textContentClient();
+    expect(def.name).toBe("text-content");
+    expect(def.navProviders).toBeUndefined();
+    expect(def.navEntities).toBeUndefined();
+    expect(def.resolvers?.["text-content:edit"]).toBeDefined();
+  });
+
+  test("mit navId: Provider + SSE-Entities unter exakt dieser QN", () => {
+    const navId = "publicstatus:nav:content";
+    const def = textContentClient({ navId });
+    expect(Object.keys(def.navProviders ?? {})).toEqual([navId]);
+    expect(def.navEntities?.[navId]).toEqual(["text-block"]);
+  });
+});
+
+describe("textContentClient — Provider unwrappt den Content-Container", () => {
+  const origFetch = globalThis.fetch;
+  afterEach(() => {
+    globalThis.fetch = origFetch;
+  });
+
+  test("emittiert Folder/Leaves direkt, kein 'Content'-Wrapper-Knoten", async () => {
+    const blocks = [
+      { slug: "imprint", lang: "de", title: "Imprint", body: "x", folder: null, updatedAt: "" },
+      { slug: "hero", lang: "de", title: "Hero", body: null, folder: "page", updatedAt: "" },
+    ];
+    // Test-Mock-Grenze: bun-Mock deckt nicht die volle fetch-Signatur
+    // (preconnect etc.) — Double-Cast bewusst, nur dieser Test ruft fetch.
+    globalThis.fetch = mock(
+      async () =>
+        new Response(JSON.stringify({ data: { blocks } }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        }),
+    ) as unknown as typeof fetch;
+
+    const navId = "x:nav:content";
+    const provider = textContentClient({ navId }).navProviders?.[navId];
+    if (provider === undefined) throw new Error("provider missing");
+
+    let emitted: readonly TreeNode[] | undefined;
+    provider()((nodes) => {
+      emitted = nodes;
+    });
+    // fetch().then(...) ist async → eine Makrotask abwarten bis emit lief.
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(emitted).toBeDefined();
+    const labels = (emitted ?? []).map((n) => n.label).sort();
+    // Kein "Content"-Wrapper — root-leaf "Imprint" + folder "page" direkt.
+    expect(labels).not.toContain("Content");
+    expect(labels).toEqual(["Imprint", "page"]);
+  });
+});

package/src/text-content/web/client-plugin.tsx

@@ -157,8 +157,10 @@ const treeProvider: TreeChildrenSubscribe = () => (emit, emitError) => {
       return r.json();
     })
     .then((data: ByTenantResponse) => {
-      const nodes = groupBlocksByFolder(data.data.blocks);
-      emit(nodes);
+      // Der App-seitige r.nav-Knoten IST der "Content"-Container → die
+      // Provider-Kinder sind die Folder/Leaves darunter, nicht der Wrapper.
+      const content = groupBlocksByFolder(data.data.blocks)[0];
+      emit(content !== undefined && Array.isArray(content.children) ? content.children : []);
     })
     .catch((e) => {
       // V.1.4: explicit error-Signal via emitError. ProviderBranch zeigt
@@ -346,19 +348,20 @@ function TextContentEditor({
   );
 }
 
-export function textContentClient(): ClientFeatureDefinition {
+// `navId` = die QN des r.nav({ provider: true })-Knotens, den die App für den
+// Content-Tree registriert (z.B. "publicstatus:nav:content"). Die App besitzt
+// Label/Icon/Access des Knotens (managed-pages-Konvention) — das Feature
+// liefert nur die Kinder + den Editor. Ohne navId: nur der Resolver, kein
+// Sidebar-Knoten (server-only-Consumer wie money-horse leaken nichts).
+export function textContentClient(opts?: { readonly navId?: string }): ClientFeatureDefinition {
+  const navId = opts?.navId;
   return {
     name: "text-content",
-    treeProvider,
-    // V.1.5b: SSE-driven Tree-Refresh. Bei jedem text-block-Event
-    // (created/updated/deleted) ruft ProviderBranch den treeProvider
-    // neu auf → Tree-State spiegelt save sofort wider (Stale-Tree-Fix).
-    treeEntities: ["text-block"],
-    treeActions: {
-      edit: { args: { slug: "" as string, lang: "" as string } },
-      list: {},
-      create: { args: { folder: "" as string } },
-    },
+    ...(navId !== undefined && {
+      navProviders: { [navId]: treeProvider },
+      // SSE-Refresh: jedes text-block-Event re-fired den Provider → Tree live.
+      navEntities: { [navId]: ["text-block"] },
+    }),
     resolvers: {
       "text-content:edit": TextContentEditor,
     },

package/src/tier-engine/__tests__/resolver.integration.test.ts

@@ -71,6 +71,20 @@ const features = composeFeatures(
   { includeBundled: true },
 );
 
+// Zweite Komposition MIT Trial-Option: jeder Tenant bekommt 30 Tage ab
+// inserted_at die "pro"-Features (feat-pro), unabhängig vom gespeicherten Tier.
+const TRIAL_HOURS = 30 * 24;
+const featuresWithTrial = composeFeatures(
+  [
+    createTierEngineFeature({
+      tierMap: TEST_TIER_MAP,
+      trial: { tier: "pro", durationHours: TRIAL_HOURS },
+    }),
+    featProFeature,
+  ],
+  { includeBundled: true },
+);
+
 let stack: TestStack;
 const tenantA = "00000000-0000-4000-8000-0000000000a1" as TenantId;
 const tenantB = "00000000-0000-4000-8000-0000000000b2" as TenantId;
@@ -212,3 +226,56 @@ describe("createTierEngineFeature — per-tenant resolver", () => {
     expect(systemSet.size).toBeGreaterThanOrEqual(2);
   });
 });
+
+describe("createTierEngineFeature — Trial-Phase (zeit-abgeleitet)", () => {
+  function sysUser(tenantId: TenantId, id: string) {
+    return createTestUser({ id, tenantId, roles: ["SystemAdmin", "TenantAdmin"] });
+  }
+
+  test("neuer 'free'-Tenant sieht im Fenster die Trial-Features (feat-pro)", async () => {
+    const usage = findTierResolverUsage(featuresWithTrial);
+    if (!usage) throw new Error("setup failure: no trial resolver");
+    const plugin = usage.options as TierResolverPlugin;
+
+    // Gespeicherter Tier ist free (keine feat-pro), inserted_at = jetzt → Trial aktiv.
+    await stack.http.writeOk(
+      "tier-engine:write:tier-assignment:create",
+      { tier: "free" },
+      sysUser(tenantA, "trial-sys-1"),
+    );
+    const resolver = await plugin.build({ db: stack.db, registry: stack.registry });
+    expect(resolver(tenantA).has("feat-pro")).toBe(true);
+  });
+
+  test("Tenant außerhalb des Fensters (inserted_at > 30 Tage) fällt auf free zurück", async () => {
+    const usage = findTierResolverUsage(featuresWithTrial);
+    if (!usage) throw new Error("setup failure: no trial resolver");
+    const plugin = usage.options as TierResolverPlugin;
+
+    await stack.http.writeOk(
+      "tier-engine:write:tier-assignment:create",
+      { tier: "free" },
+      sysUser(tenantB, "trial-sys-2"),
+    );
+    // Anlage-Datum künstlich 31 Tage zurückdrehen → Trial abgelaufen. tenantB ist
+    // eine fixe Test-UUID (kein User-Input) → inline-Interpolation unkritisch.
+    await asRawClient(stack.db).unsafe(
+      `UPDATE read_tier_assignments SET inserted_at = now() - interval '31 days' WHERE tenant_id = '${tenantB}'::uuid`,
+    );
+    const resolver = await plugin.build({ db: stack.db, registry: stack.registry });
+    expect(resolver(tenantB).has("feat-pro")).toBe(false);
+  });
+
+  test("ohne Trial-Option ist der Resolver unverändert (free = keine feat-pro)", async () => {
+    const usage = findTierResolverUsage(features);
+    if (!usage) throw new Error("setup failure");
+    const plugin = usage.options as TierResolverPlugin;
+    await stack.http.writeOk(
+      "tier-engine:write:tier-assignment:create",
+      { tier: "free" },
+      sysUser(tenantA, "no-trial-sys"),
+    );
+    const resolver = await plugin.build({ db: stack.db, registry: stack.registry });
+    expect(resolver(tenantA).has("feat-pro")).toBe(false);
+  });
+});

package/src/tier-engine/__tests__/trial.test.ts

@@ -0,0 +1,27 @@
+// Trial-Fenster: reine epochMs-Arithmetik, Rand inklusive.
+
+import { describe, expect, test } from "bun:test";
+import { isTrialActive } from "../trial";
+
+const HOUR_MS = 3_600_000;
+const start = 1_700_000_000_000;
+
+describe("isTrialActive", () => {
+  test("innerhalb des Fensters → aktiv", () => {
+    expect(isTrialActive(start, start + 10 * 24 * HOUR_MS, 720)).toBe(true);
+    expect(isTrialActive(start, start, 720)).toBe(true);
+  });
+
+  test("exakt am Fenster-Ende → nicht mehr aktiv (halb-offen)", () => {
+    expect(isTrialActive(start, start + 720 * HOUR_MS, 720)).toBe(false);
+  });
+
+  test("nach dem Fenster → inaktiv", () => {
+    expect(isTrialActive(start, start + 721 * HOUR_MS, 720)).toBe(false);
+    expect(isTrialActive(start, start + 31 * 24 * HOUR_MS, 720)).toBe(false);
+  });
+
+  test("Dauer 0 → nie aktiv", () => {
+    expect(isTrialActive(start, start, 0)).toBe(false);
+  });
+});

package/src/tier-engine/entity.ts

@@ -33,3 +33,11 @@ export const tierAssignmentEntity = createEntity({
     source: createTextField({ required: false, maxLength: 20 }),
   },
 });
+
+export type TierAssignmentRow = {
+  readonly id: string;
+  readonly version: number;
+  readonly tier: string;
+  readonly source: string | null;
+  readonly tenantId: string;
+};