@cosmicdrift/kumiko-samples 0.365.1 → 0.366.0

package/samples/apps/styleguide/src/features/widgets/feature.ts

@@ -198,10 +198,10 @@ export const widgetsFeature = defineFeature("widgets", (r) => {
     ],
   });
 
-  r.queryHandler(
-    "metrics:portfolio-stat",
-    z.object({ region: z.string().optional() }),
-    async ({ payload: { region } }, ctx) => ({
+  r.queryHandler({
+    name: "metrics:portfolio-stat",
+    schema: z.object({ region: z.string().optional() }),
+    handler: async ({ payload: { region } }, ctx) => ({
       value:
         region === "us"
           ? demoMoney(38120, "USD", ctx.locale)
@@ -212,86 +212,76 @@ export const widgetsFeature = defineFeature("widgets", (r) => {
       deltaDirection: "up",
       deltaTone: "positive",
     }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:net-worth-assets",
-    z.object({ region: z.string().optional() }),
-    async (_query, ctx) => ({ value: demoMoney(120000, "EUR", ctx.locale) }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+  });
+  r.queryHandler({
+    name: "metrics:net-worth-assets",
+    schema: z.object({ region: z.string().optional() }),
+    handler: async (_query, ctx) => ({ value: demoMoney(120000, "EUR", ctx.locale) }),
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:net-worth-debts",
-    z.object({ region: z.string().optional() }),
-    async (_query, ctx) => ({ value: demoMoney(65370, "EUR", ctx.locale) }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+  });
+  r.queryHandler({
+    name: "metrics:net-worth-debts",
+    schema: z.object({ region: z.string().optional() }),
+    handler: async (_query, ctx) => ({ value: demoMoney(65370, "EUR", ctx.locale) }),
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:response-times",
-    z.object({}),
-    async () => ({
+  });
+  r.queryHandler({
+    name: "metrics:response-times",
+    schema: z.object({}),
+    handler: async () => ({
       points: RESPONSE_POINTS,
       windowStartMs: 0,
       windowEndMs: 24 * 60 * 60 * 1000,
     }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:loan",
-    z.object({}),
-    async () => ({
+  });
+  r.queryHandler({
+    name: "metrics:loan",
+    schema: z.object({}),
+    handler: async () => ({
       series: LOAN_SERIES,
       markers: LOAN_MARKERS,
       windowStartMs: LOAN_START_MS,
       windowEndMs: loanMonthMs(LOAN_MONTHS),
       todayMs: LOAN_TODAY_MS,
     }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:latest-items",
-    z.object({}),
-    async (_query, ctx) => ({
+  });
+  r.queryHandler({
+    name: "metrics:latest-items",
+    schema: z.object({}),
+    handler: async (_query, ctx) => ({
       rows: [
         {
           id: "i1",
@@ -306,25 +296,23 @@ export const widgetsFeature = defineFeature("widgets", (r) => {
       ],
       nextCursor: null,
     }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:inbox-messages",
-    z.object({
+  });
+  r.queryHandler({
+    name: "metrics:inbox-messages",
+    schema: z.object({
       cursor: z.coerce.number().int().min(0).optional(),
       limit: z.number().int().min(1).max(100).optional(),
       unreadOnly: z.boolean().optional(),
       search: z.string().optional(),
     }),
-    async ({ payload: { cursor, limit, unreadOnly, search } }) => {
+    handler: async ({ payload: { cursor, limit, unreadOnly, search } }) => {
       const term = search?.trim().toLowerCase() ?? "";
       const filtered = INBOX_MESSAGES.filter(
         (m) =>
@@ -339,20 +327,18 @@ export const widgetsFeature = defineFeature("widgets", (r) => {
       const nextCursor = start + pageSize < filtered.length ? String(start + pageSize) : null;
       return { rows, nextCursor };
     },
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:upcoming-events",
-    z.object({}),
-    async (_query, ctx) => ({
+  });
+  r.queryHandler({
+    name: "metrics:upcoming-events",
+    schema: z.object({}),
+    handler: async (_query, ctx) => ({
       rows: [
         {
           primary: demoText("widgets:dashboard:demo-event-rate-adjustment", ctx.locale),
@@ -364,20 +350,18 @@ export const widgetsFeature = defineFeature("widgets", (r) => {
         },
       ],
     }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
-  r.queryHandler(
-    "metrics:goal-progress",
-    z.object({}),
-    async (_query, ctx) => ({
+  });
+  r.queryHandler({
+    name: "metrics:goal-progress",
+    schema: z.object({}),
+    handler: async (_query, ctx) => ({
       rows: [
         {
           label: demoText("widgets:dashboard:demo-goal-mortgage", ctx.locale),
@@ -391,16 +375,14 @@ export const widgetsFeature = defineFeature("widgets", (r) => {
         },
       ],
     }),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "demo dashboard widget: returns static canned data with no per-user or " +
-            "tenant scoping; any signed-in user may query it",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "demo dashboard widget: returns static canned data with no per-user or " +
+          "tenant scoping; any signed-in user may query it",
       },
     },
-  );
+  });
 
   r.translations({ keys: WIDGETS_I18N });
 

package/samples/apps/ui-walkthrough/src/features/rental/feature.ts

@@ -71,10 +71,10 @@ export const rentalFeature = defineFeature("rental", (r) => {
   r.crud("leasePosition", leasePositionEntity, { write: open, read: open });
   r.crud("leaseParty", leasePartyEntity, { write: open, read: open });
 
-  r.queryHandler(
-    "lease:akte",
-    idPayloadSchema,
-    async (query, ctx) => {
+  r.queryHandler({
+    name: "lease:akte",
+    schema: idPayloadSchema,
+    handler: async (query, ctx) => {
       const row = await leaseExecutor.detail({ id: query.payload.id }, query.user, ctx.db);
       if (!row) return failNotFound("lease", query.payload.id);
       const lease = parseLeaseRow(row);
@@ -104,13 +104,13 @@ export const rentalFeature = defineFeature("rental", (r) => {
         positionCount: await countChildren(positionExecutor),
       };
     },
-    open,
-  );
+    ...open,
+  });
 
-  r.queryHandler(
-    "lease:positions",
-    idPayloadSchema,
-    async (query, ctx) => {
+  r.queryHandler({
+    name: "lease:positions",
+    schema: idPayloadSchema,
+    handler: async (query, ctx) => {
       const page = await positionExecutor.list(
         { filter: { field: "lease", op: "eq", value: query.payload.id }, limit: 100 },
         query.user,
@@ -132,13 +132,13 @@ export const rentalFeature = defineFeature("rental", (r) => {
         }),
       };
     },
-    open,
-  );
+    ...open,
+  });
 
-  r.queryHandler(
-    "lease:kennzahlen",
-    z.object({}),
-    async () => ({
+  r.queryHandler({
+    name: "lease:kennzahlen",
+    schema: z.object({}),
+    handler: async () => ({
       debt: "123.456 €",
       debtSub: "nach 10 Jahren",
       debtDelta: "15 %",
@@ -146,13 +146,13 @@ export const rentalFeature = defineFeature("rental", (r) => {
       rent: "48.200 €",
       rentSub: "319 Verträge",
     }),
-    open,
-  );
+    ...open,
+  });
 
-  r.writeHandler(
-    "lease:terminate",
-    idPayloadSchema,
-    async (event, ctx) =>
+  r.writeHandler({
+    name: "lease:terminate",
+    schema: idPayloadSchema,
+    handler: async (event, ctx) =>
       leaseExecutor.update(
         {
           id: event.payload.id,
@@ -165,13 +165,13 @@ export const rentalFeature = defineFeature("rental", (r) => {
         ctx.db,
         { skipOptimisticLock: true },
       ),
-    open,
-  );
+    ...open,
+  });
 
-  r.writeHandler(
-    "lease:record-positions",
-    recordPositionsPayloadSchema,
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "lease:record-positions",
+    schema: recordPositionsPayloadSchema,
+    handler: async (event, ctx) => {
       let created: Awaited<ReturnType<typeof positionExecutor.create>> | undefined;
       const unitLabels = new Map<string, string | null | undefined>();
       for (const unitId of new Set(event.payload.items.map((item) => item.unit))) {
@@ -189,13 +189,13 @@ export const rentalFeature = defineFeature("rental", (r) => {
       }
       return created ?? failNotFound("leasePosition", event.payload.lease);
     },
-    open,
-  );
+    ...open,
+  });
 
-  r.writeHandler(
-    "rent:adjust",
-    rentAdjustPayloadSchema,
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "rent:adjust",
+    schema: rentAdjustPayloadSchema,
+    handler: async (event, ctx) => {
       const { positionId, wirksamAb, neuerBetrag } = event.payload;
       const current = await positionExecutor.detail({ id: positionId }, event.user, ctx.db);
       if (!current) return failNotFound("leasePosition", positionId);
@@ -229,8 +229,8 @@ export const rentalFeature = defineFeature("rental", (r) => {
         { skipOptimisticLock: true },
       );
     },
-    open,
-  );
+    ...open,
+  });
 
   r.screen(leaseListScreen);
   r.screen(leaseListShortScreen);

package/samples/apps/ui-walkthrough/src/features/vehicles/feature.ts

@@ -32,10 +32,10 @@ export const vehiclesFeature = defineFeature("vehicles", (r) => {
   r.crud("campaign", campaignEntity, { write: open, read: open });
   r.crud("campaignPost", campaignPostEntity, { write: open, read: open });
 
-  r.writeHandler(
-    "campaign-post:mark-posted",
-    markPostedPayloadSchema,
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "campaign-post:mark-posted",
+    schema: markPostedPayloadSchema,
+    handler: async (event, ctx) => {
       const current = await campaignPostExecutor.detail(
         { id: event.payload.id },
         event.user,
@@ -62,8 +62,8 @@ export const vehiclesFeature = defineFeature("vehicles", (r) => {
         { skipOptimisticLock: true },
       );
     },
-    open,
-  );
+    ...open,
+  });
 
   r.screen(vehicleListScreen);
   r.screen(vehicleEditScreen);

package/samples/apps/use-all-bundled/e2e-billing-gallery/gallery-features.ts

@@ -117,14 +117,14 @@ export const galleryProviderFeature: FeatureDefinition = defineFeature(
   "gallery-mock-provider",
   (r) => {
     r.describe("E2E-only mock subscription provider for the consent/termination gallery.");
-    r.requires("billing-foundation");
+    r.requires({ features: ["billing-foundation"] });
     r.useExtension("subscriptionProvider", GALLERY_PROVIDER, galleryProviderPlugin);
   },
 );
 
 export const galleryScreensFeature: FeatureDefinition = defineFeature("gallery-screens", (r) => {
   r.describe("E2E-only nav entry for the billing plans screen plus plan labels.");
-  r.requires("billing-foundation", "admin-shell");
+  r.requires({ features: ["billing-foundation", "admin-shell"] });
   r.nav({
     id: "billing",
     label: "gallery:nav.billing",

package/samples/apps/use-all-bundled/scripts/gen-sample-index.ts

@@ -89,13 +89,13 @@ export function extractFeaturesFromText(rawText: string): Set<string> {
     const name = m[1];
     if (name) feats.add(name);
   }
-  for (const m of text.matchAll(/r\.requires\(\s*["']([a-z0-9-]+)["']/g)) {
-    const name = m[1];
-    if (name) feats.add(name);
-  }
-  for (const m of text.matchAll(/r\.optionalRequires\(\s*["']([a-z0-9-]+)["']/g)) {
-    const name = m[1];
-    if (name) feats.add(name);
+  for (const m of text.matchAll(
+    /r\.(?:requires|optionalRequires)\(\s*\{\s*features:\s*\[([^\]]*)\]/g,
+  )) {
+    for (const quoted of (m[1] ?? "").matchAll(/["']([a-z0-9-]+)["']/g)) {
+      const name = quoted[1];
+      if (name) feats.add(name);
+    }
   }
   return feats;
 }

package/samples/apps/use-all-bundled/src/app/notes-feature.ts

@@ -120,9 +120,9 @@ export const notesFeature: FeatureDefinition = defineFeature("notes-demo", (r) =
   r.describe(
     "Dev-only host entity demonstrating tags, custom-fields, and folders on a real entityEdit screen.",
   );
-  r.requires("tags");
-  r.requires("custom-fields");
-  r.requires("folders");
+  r.requires({ features: ["tags"] });
+  r.requires({ features: ["custom-fields"] });
+  r.requires({ features: ["folders"] });
 
   wireCustomFieldsFor(r, "note", noteTable);
 

package/samples/apps/use-all-bundled/src/app/screens-feature.ts

@@ -9,7 +9,7 @@ import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-frame
 
 export const appScreensFeature: FeatureDefinition = defineFeature("app-screens", (r) => {
   r.describe("App-side nav placement for the user-profile self-service page.");
-  r.requires("user-profile");
+  r.requires({ features: ["user-profile"] });
   r.nav({
     id: "profile",
     label: "screen:profile.title",

package/samples/apps/user-data-rights-demo/src/feature.ts

@@ -6,10 +6,10 @@
 // DSGVO-Endpoints kommen vollstaendig aus user-data-rights.
 //
 // Dieses Feature zeigt:
-//   - r.entity("todo", todoEntity)            → Drizzle-Tabelle wird gebaut
-//   - r.writeHandler("create")                → User legt Todo an
-//   - r.queryHandler("list")                  → User sieht seine Todos
-//   - r.useExtension(EXT_USER_DATA, "todo")   → Forget + Export integration
+//   - r.entity({ name: "todo", ...todoEntity })  → Drizzle-Tabelle wird gebaut
+//   - r.writeHandler({ name: "create", … })      → User legt Todo an
+//   - r.queryHandler({ name: "list", … })        → User sieht seine Todos
+//   - r.useExtension(EXT_USER_DATA, "todo")      → Forget + Export integration
 //
 // Was passiert wenn der User dann request-export aufruft:
 //   1. user-data-rights.request-export.write triggert einen Job
@@ -122,7 +122,7 @@ const listTodosHandler = defineQueryHandler({
 });
 
 export const todosFeature = defineFeature(FEATURE_NAME, (r) => {
-  r.requires("user-data-rights");
+  r.requires({ features: ["user-data-rights"] });
 
   // store_todos is a direct-write store: the create handler `insertOne`s and
   // the forget hook `updateMany`/`deleteMany`s rows WITHOUT emitting lifecycle

package/samples/recipes/access-control/src/feature.ts

@@ -64,8 +64,8 @@ export const taskTable = buildEntityTable("task", taskEntity, {
 });
 
 export const accessControlFeature = defineFeature("access-control", (r) => {
-  r.entity("project", projectEntity);
-  r.entity("task", taskEntity);
+  r.entity({ name: "project", ...projectEntity });
+  r.entity({ name: "task", ...taskEntity });
   r.relation("task", "project", taskRelations.project);
 
   // Admin-only: standard create — no business logic, helper handles schema +
@@ -80,14 +80,14 @@ export const accessControlFeature = defineFeature("access-control", (r) => {
   // hand-write this handler instead of using the helper. The framework helpers
   // are deliberately scope-limited — opt out the moment you need defaults.
   const taskExecutor = createEventStoreExecutor(taskTable, taskEntity, { entityName: "task" });
-  r.writeHandler(
-    "task:create",
-    z.object({
+  r.writeHandler({
+    name: "task:create",
+    schema: z.object({
       title: z.string().min(1),
       projectId: z.uuid(),
       assigneeId: z.uuid().optional(),
     }),
-    async (event, ctx) =>
+    handler: async (event, ctx) =>
       taskExecutor.create(
         {
           ...event.payload,
@@ -96,22 +96,20 @@ export const accessControlFeature = defineFeature("access-control", (r) => {
         event.user,
         ctx.db,
       ),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in tenant user may create a task; assigneeId defaults to the caller when omitted",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in tenant user may create a task; assigneeId defaults to the caller when omitted",
       },
     },
-  );
+  });
 
   // Update requires version — optimistic locking is the default and this
   // narrowed schema (only title + assigneeId mutable) is stricter than the
   // helper's generic update schema, so we keep it hand-written.
-  r.writeHandler(
-    "task:update",
-    z.object({
+  r.writeHandler({
+    name: "task:update",
+    schema: z.object({
       id: z.uuid(),
       version: z.number(),
       changes: z.object({
@@ -119,17 +117,15 @@ export const accessControlFeature = defineFeature("access-control", (r) => {
         assigneeId: z.uuid().optional(),
       }),
     }),
-    async (event, ctx) => taskExecutor.update(event.payload, event.user, ctx.db),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in tenant user may update a task; optimistic locking (version) " +
-            "guards against concurrent overwrites, not caller identity",
-        },
+    handler: async (event, ctx) => taskExecutor.update(event.payload, event.user, ctx.db),
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in tenant user may update a task; optimistic locking (version) " +
+          "guards against concurrent overwrites, not caller identity",
       },
     },
-  );
+  });
 
   // Self-service list — no custom logic.
   r.queryHandler(