@cosmicdrift/kumiko-framework 0.65.0 → 0.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.65.0",
+  "version": "0.66.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",

package/src/db/__tests__/event-store-executor-list.integration.test.ts

@@ -256,6 +256,71 @@ describe("event-store-executor.list — filter (Tier 2.7c)", () => {
     expect(res.rows).toHaveLength(4);
     expect(res.total).toBe(4);
   });
+
+  test("filters[] AND: zwei dynamische Filter werden mit AND verknüpft", async () => {
+    await seed(10);
+    const res = await exec.list(
+      {
+        limit: 50,
+        sort: "rank",
+        sortDirection: "asc",
+        filters: [
+          { field: "rank", op: "gt", value: 2 },
+          { field: "rank", op: "lt", value: 6 },
+        ],
+      },
+      admin,
+      tdb,
+    );
+    expect(res.rows.map((r) => r["rank"])).toEqual([3, 4, 5]);
+  });
+
+  test("filters[] in: Faceted-Multi-Select rank in [2,4,8]", async () => {
+    await seed(10);
+    const res = await exec.list(
+      {
+        limit: 50,
+        sort: "rank",
+        sortDirection: "asc",
+        filters: [{ field: "rank", op: "in", value: [2, 4, 8] }],
+      },
+      admin,
+      tdb,
+    );
+    expect(res.rows.map((r) => r["rank"])).toEqual([2, 4, 8]);
+  });
+
+  test("statischer filter + dynamische filters[] kombinieren mit AND", async () => {
+    await seed(10);
+    const res = await exec.list(
+      {
+        limit: 50,
+        sort: "rank",
+        sortDirection: "asc",
+        filter: { field: "rank", op: "gt", value: 2 },
+        filters: [{ field: "rank", op: "in", value: [1, 3, 5, 9] }],
+      },
+      admin,
+      tdb,
+    );
+    // gt:2 AND in[1,3,5,9] → 3,5,9 (1 fällt durch gt:2 raus)
+    expect(res.rows.map((r) => r["rank"])).toEqual([3, 5, 9]);
+  });
+
+  test("filters[] mit leerem in-Array: leeres Resultat (kein Match-All)", async () => {
+    await seed(5);
+    const res = await exec.list(
+      {
+        limit: 50,
+        sort: "rank",
+        sortDirection: "asc",
+        filters: [{ field: "rank", op: "in", value: [] }],
+      },
+      admin,
+      tdb,
+    );
+    expect(res.rows).toHaveLength(0);
+  });
 });
 
 describe("event-store-executor.list — runtime SearchAdapter (Tier 2.7e Audit-Fix #1)", () => {

package/src/db/event-store-executor.ts

@@ -200,6 +200,15 @@ export type EventStoreExecutor = {
             readonly value: unknown;
           }
         | undefined;
+      // User-gewählte Faceted-Filter (dynamisch, additiv zum statischen
+      // `filter`). Alle werden mit AND verknüpft.
+      filters?:
+        | ReadonlyArray<{
+            readonly field: string;
+            readonly op: "eq" | "ne" | "lt" | "gt" | "in";
+            readonly value: unknown;
+          }>
+        | undefined;
     },
     user: SessionUser,
     db: TenantDb,
@@ -875,45 +884,49 @@ export function createEventStoreExecutor(
         whereSql.push(shifted.sqlText);
         for (const p of shifted.params) params.push(p);
       }
-      if (payload.filter !== undefined) {
-        const col = table[payload.filter.field];
-        if (col !== undefined) {
-          const screen = buildFilterWhere(
-            payload.filter.field,
-            payload.filter.op,
-            payload.filter.value,
-          );
-          if (screen === null) {
-            whereSql.push("FALSE");
-          } else {
-            for (const [field, value] of Object.entries(screen)) {
-              if (Array.isArray(value)) {
-                const placeholders = value.map((v) => {
-                  params.push(v);
-                  return `$${params.length}`;
-                });
-                whereSql.push(`${colSql(field)} IN (${placeholders.join(", ")})`);
-              } else if (typeof value === "object" && value !== null) {
-                const opMap: Record<string, string> = {
-                  gt: ">",
-                  gte: ">=",
-                  lt: "<",
-                  lte: "<=",
-                  ne: "<>",
-                };
-                for (const [opKey, opSym] of Object.entries(opMap)) {
-                  if (!(opKey in value)) continue;
-                  params.push((value as Record<string, unknown>)[opKey]);
-                  whereSql.push(`${colSql(field)} ${opSym} $${params.length}`);
-                }
-              } else {
-                params.push(value);
-                whereSql.push(`${colSql(field)} = $${params.length}`);
-              }
+      const applyFilter = (f: {
+        readonly field: string;
+        readonly op: "eq" | "ne" | "lt" | "gt" | "in";
+        readonly value: unknown;
+      }): void => {
+        if (table[f.field] === undefined) {
+          // skip: unknown field — not a real column, drop the filter (injection guard)
+          return;
+        }
+        const screen = buildFilterWhere(f.field, f.op, f.value);
+        if (screen === null) {
+          whereSql.push("FALSE");
+          // skip: filter is unsatisfiable → emit FALSE, no params to bind
+          return;
+        }
+        for (const [field, value] of Object.entries(screen)) {
+          if (Array.isArray(value)) {
+            const placeholders = value.map((v) => {
+              params.push(v);
+              return `$${params.length}`;
+            });
+            whereSql.push(`${colSql(field)} IN (${placeholders.join(", ")})`);
+          } else if (typeof value === "object" && value !== null) {
+            const opMap: Record<string, string> = {
+              gt: ">",
+              gte: ">=",
+              lt: "<",
+              lte: "<=",
+              ne: "<>",
+            };
+            for (const [opKey, opSym] of Object.entries(opMap)) {
+              if (!(opKey in value)) continue;
+              params.push((value as Record<string, unknown>)[opKey]);
+              whereSql.push(`${colSql(field)} ${opSym} $${params.length}`);
             }
+          } else {
+            params.push(value);
+            whereSql.push(`${colSql(field)} = $${params.length}`);
           }
         }
-      }
+      };
+      if (payload.filter !== undefined) applyFilter(payload.filter);
+      if (payload.filters !== undefined) for (const f of payload.filters) applyFilter(f);
 
       const orderByClause =
         payload.sort && table[payload.sort]

package/src/engine/__tests__/build-app-schema.test.ts

@@ -134,6 +134,27 @@ describe("buildAppSchema", () => {
     expect(fields["label"]?.["default"]).toBe("");
   });
 
+  test("filterable kommt ins Client-Schema (steuert die Faceted-Filter)", () => {
+    const entity = {
+      fields: {
+        status: { type: "select", options: ["draft", "published"], filterable: true },
+        name: { type: "text" },
+      },
+    } as unknown as EntityDefinition;
+    const f = defineFeature("ent", (r) => {
+      r.entity("thing", entity);
+    });
+    const app = buildAppSchema(createRegistry([f]));
+    const fields = (
+      app.features[0]?.entities["thing"] as unknown as {
+        fields: Record<string, Record<string, unknown>>;
+      }
+    ).fields;
+    expect(fields["status"]?.["filterable"]).toBe(true);
+    // Felder ohne filterable tragen den Key nicht (kein false-Müll).
+    expect(fields["name"]?.["filterable"]).toBeUndefined();
+  });
+
   test("AppSchema ist via JSON.stringify roundtrip-sicher", () => {
     // Echter Smoke-Test des Vertrags — wenn jemand in den project-
     // Helper eine Function reinschmuggelt, würde das hier brennen.

package/src/engine/build-app-schema.ts

@@ -311,6 +311,9 @@ function projectField(fieldDef: FieldDefinition): FieldDefinition {
   if (typeof def["type"] === "string") out["type"] = def["type"];
   if (typeof def["required"] === "boolean") out["required"] = def["required"];
   if (typeof def["sortable"] === "boolean") out["sortable"] = def["sortable"];
+  // filterable steuert die Faceted-Filter-Dropdowns im Renderer (select/
+  // boolean) — muss daher ins Client-Schema.
+  if (typeof def["filterable"] === "boolean") out["filterable"] = def["filterable"];
   if (isLiteral(def["default"])) out["default"] = def["default"];
   // Select: options-Liste ist plain JSON, durchschicken.
   if (Array.isArray(def["options"])) out["options"] = def["options"];

package/src/engine/entity-handlers.ts

@@ -95,6 +95,17 @@ const listSchema = z.object({
       value: z.unknown(),
     })
     .optional(),
+  // User-gewählte Faceted-Filter (dynamisch). Additiv zum statischen
+  // `filter` — executor.list verknüpft alle mit AND.
+  filters: z
+    .array(
+      z.object({
+        field: z.string(),
+        op: z.enum(["eq", "ne", "lt", "gt", "in"]),
+        value: z.unknown(),
+      }),
+    )
+    .optional(),
 });
 
 function parseHandlerName<TVerb extends string>(

package/src/engine/types/nav.ts

@@ -1,4 +1,6 @@
 import type { AccessRule } from "./handlers";
+import type { TargetRef } from "./target-ref";
+import type { TreeAction } from "./tree-node";
 
 // Nav entry declaration. Every feature that wants to appear in the app's
 // navigation tree registers one or more entries via r.nav(). The engine
@@ -34,6 +36,21 @@ export type NavDefinition = {
   // ("<feature>:screen:<id>"). Omit for pure grouping entries (a parent-only
   // nav node that renders a sub-tree but has no target screen itself).
   readonly screen?: string;
+  // Polymorphes Klick-Ziel (öffnet die EditorPanel-Maske via Target-
+  // Resolver) — Alternative zu `screen`. Ein Knoten trägt screen XOR
+  // target; der Renderer dispatcht das target statt einen Route-Link zu
+  // rendern. Gespiegelt aus dem alten Visual-Tree (TreeNode.target).
+  readonly target?: TargetRef;
+  // Hover-Actions rechts in der Zeile (VS-Code-Pattern) — erst bei Hover
+  // sichtbar. Reihenfolge wie deklariert.
+  readonly actions?: readonly TreeAction[];
+  // „+"-Affordance am Knoten. Klick dispatcht createAction.target; der
+  // Provider weiß was „leer befüllen" für ihn heißt (neuer Page-Slug etc.).
+  readonly createAction?: TreeAction;
+  // Children kommen zur Laufzeit aus einem registrierten nav-provider
+  // (lazy beim Ausklappen, SSE-live via treeEntities), keyed auf diese
+  // Nav-QN. Macht den Knoten expandable auch ohne statische children.
+  readonly provider?: boolean;
   // Role / openToAll gate. The nav resolver hides entries the user can't
   // reach; leave unset to always show (engine stays un-opinionated about
   // who sees what — apps that need default-deny can set { roles: [] }).

package/src/engine/types/screen.ts

@@ -309,7 +309,10 @@ export type EditSectionSpec = EditFieldsSection | EditExtensionSection;
 
 export type EditFieldsSection = {
   readonly kind?: "fields";
-  readonly title: string;
+  /** Optional. Ohne Titel rendert die Section nur ihre Felder (keine h3-
+   *  Überschrift) — für flache Forms (Card-Titel + Felder direkt, ein
+   *  einzelner Abschnitt) wie bei den meisten shadcn-Form-Mustern. */
+  readonly title?: string;
   readonly columns?: number;
   readonly fields: readonly EditFieldSpec[];
 };
@@ -333,6 +336,10 @@ export type EntityEditScreenDefinition = {
   readonly type: "entityEdit";
   readonly entity: string;
   readonly layout: EditLayout;
+  /** Optionaler i18n-Key (oder Roh-String) für den Submit-Button. Default
+   *  `kumiko.actions.save`. Lässt den Auto-Edit-Screen domain-spezifische
+   *  CTAs zeigen ("Save Address", "Create item") statt generisch "Speichern". */
+  readonly submitLabel?: string;
   /** Default true. `false` für Entities deren Create über einen eigenen
    *  Lifecycle-Write läuft (z.B. incident:open mit Event-Stream + Joins)
    *  statt über `<entity>:create`: unterdrückt den automatischen

package/src/ui-types/index.ts

@@ -74,5 +74,7 @@ export {
   normalizeEditField,
   normalizeListColumn,
 } from "../engine/types/screen";
+export type { TargetRef } from "../engine/types/target-ref";
+export type { TreeAction, TreeNode, TreeNodeState } from "../engine/types/tree-node";
 export type { WorkspaceDefinition } from "../engine/types/workspace";
 export type { AppSchema, FeatureSchema, WorkspaceSchema } from "./app-schema";