@cosmicdrift/kumiko-samples 0.365.1 → 0.367.0

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(

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

@@ -52,41 +52,37 @@ export const productTable = buildEntityTable("product", productEntity);
 export const guestOrderTable = buildEntityTable("guest-order", guestOrderEntity);
 
 export const anonymousAccessFeature = defineFeature("shop", (r) => {
-  r.entity("product", productEntity);
-  r.entity("guest-order", guestOrderEntity);
+  r.entity({ name: "product", ...productEntity });
+  r.entity({ name: "guest-order", ...guestOrderEntity });
 
   // Public listing: anonymous + authenticated customers see it. Combining
   // the roles in one handler is preferred over duplicating the read path —
   // the handler body can branch on `event.user.id === "anonymous"` if it
   // needs to personalise (e.g. show a sign-in CTA, hide a wishlist button).
-  r.queryHandler(
-    "product:list",
-    z.object({}),
-    async (_event, ctx) => ctx.db.selectMany(productTable),
-    {
-      access: { roles: [...access.anonymous, "User", "Admin"] },
-      rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
-    },
-  );
+  r.queryHandler({
+    name: "product:list",
+    schema: z.object({}),
+    handler: async (_event, ctx) => ctx.db.selectMany(productTable),
+    access: { roles: [...access.anonymous, "User", "Admin"] },
+    rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
+  });
 
   // Authenticated-only listing — same data, different access rule. The
   // openToAll declaration here is the regression-guard: even with
   // anonymousAccess enabled on the server, this endpoint stays gated to
   // logged-in users.
-  r.queryHandler(
-    "product:authenticated-only",
-    z.object({}),
-    async (_event, ctx) => ctx.db.selectMany(productTable),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in (non-anonymous) user may list products here; this handler is " +
-            "the regression-guard proving anonymousAccess never silently exposes an authenticated-only endpoint",
-        },
+  r.queryHandler({
+    name: "product:authenticated-only",
+    schema: z.object({}),
+    handler: async (_event, ctx) => ctx.db.selectMany(productTable),
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in (non-anonymous) user may list products here; this handler is " +
+          "the regression-guard proving anonymousAccess never silently exposes an authenticated-only endpoint",
       },
     },
-  );
+  });
 
   // Anonymous + authenticated guest checkout. Stores the synthesised user-id
   // ("anonymous") in `placedBy` so audit-trail / support queries can tell
@@ -97,36 +93,33 @@ export const anonymousAccessFeature = defineFeature("shop", (r) => {
   const guestOrderExecutor = createEventStoreExecutor(guestOrderTable, guestOrderEntity, {
     entityName: "guest-order",
   });
-  r.writeHandler(
-    "guest-order:place",
-    z.object({
+  r.writeHandler({
+    name: "guest-order:place",
+    schema: z.object({
       productId: z.uuid(),
       email: z.string().email(),
     }),
-    async (event, ctx) =>
-      guestOrderExecutor.create({ ...event.payload, placedBy: event.user.id }, event.user, ctx.db),
-    {
-      // `email` is recordOwned PII (personal: { of: "id" }) written by an
-      // anonymous root handler — the runtime personal-data gate
-      // (write-origin.ts) requires this explicit opt-in, the same way the
-      // boot validator would reject an openToAll declaration missing it.
-      access: { roles: [...access.anonymous, "User"], personalData: "public-intake" },
-      rateLimit: { per: "ip+handler", limit: 30, windowSeconds: 60 },
-    },
-  );
+    handler: async (event, ctx) =>
+      guestOrderExecutor.create({ ...event.payload, placedBy: event.user.id }, event.user, ctx.db), // `email` is recordOwned PII (personal: { of: "id" }) written by an
+    // anonymous root handler — the runtime personal-data gate
+    // (write-origin.ts) requires this explicit opt-in, the same way the
+    // boot validator would reject an openToAll declaration missing it.
+    access: { roles: [...access.anonymous, "User"], personalData: "public-intake" },
+    rateLimit: { per: "ip+handler", limit: 30, windowSeconds: 60 },
+  });
 
   // Admin-only product CRUD — proves role-gated handlers still reject
   // anonymous callers. Same shape as any other handler in the framework:
   // anonymous is just a regular role, not a special case.
-  r.writeHandler(
-    "product:create",
-    z.object({ name: z.string().min(1), priceCents: z.string() }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "product:create",
+    schema: z.object({ name: z.string().min(1), priceCents: z.string() }),
+    handler: async (event, ctx) => {
       const exec = createEventStoreExecutor(productTable, productEntity, {
         entityName: "product",
       });
       return exec.create(event.payload, event.user, ctx.db);
     },
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 });

package/samples/recipes/anonymous-access-multitenant/src/feature.ts

@@ -34,32 +34,30 @@ export const productEntity = createEntity({
 export const productTable = buildEntityTable("product", productEntity);
 
 export const multiTenantShopFeature = defineFeature("mtshop", (r) => {
-  r.entity("product", productEntity);
+  r.entity({ name: "product", ...productEntity });
 
   // Public listing — every tenant has its own products, scoped by tenantId
   // automatically via the framework's tenant-isolation. Anonymous visitors
   // see only the tenant they landed on.
-  r.queryHandler(
-    "product:list",
-    z.object({}),
-    async (_event, ctx) => ctx.db.selectMany(productTable),
-    {
-      access: { roles: [...access.anonymous, "User", "Admin"] },
-      rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
-    },
-  );
+  r.queryHandler({
+    name: "product:list",
+    schema: z.object({}),
+    handler: async (_event, ctx) => ctx.db.selectMany(productTable),
+    access: { roles: [...access.anonymous, "User", "Admin"] },
+    rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
+  });
 
   // Admin-only — proves role-gating still works on top of the multi-tenant
   // anonymous resolution.
-  r.writeHandler(
-    "product:create",
-    z.object({ name: z.string().min(1) }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "product:create",
+    schema: z.object({ name: z.string().min(1) }),
+    handler: async (event, ctx) => {
       const exec = createEventStoreExecutor(productTable, productEntity, {
         entityName: "product",
       });
       return exec.create(event.payload, event.user, ctx.db);
     },
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 });

package/samples/recipes/auth-foundation-providers/src/feature.ts

@@ -47,7 +47,7 @@ export function createSubdomainTenantRoutingFeature(
   const reserved = new Set(opts.reservedSubdomains ?? ["www", "app", "api", "admin"]);
 
   return defineFeature("sample-subdomain-tenant-routing", (r) => {
-    r.requires("auth-foundation");
+    r.requires({ features: ["auth-foundation"] });
 
     const resolverPlugin: TenantResolverProvider = {
       trust,

package/samples/recipes/basic-entity/README.md

@@ -28,7 +28,7 @@ task-management → single feature, single `task` entity, six CRUD handlers
 ```
 
 No bundled features required — this is the baseline before you add
-`r.requires("tenant")`, auth, or cross-feature extensions.
+`r.requires({ features: ["tenant"] })`, auth, or cross-feature extensions.
 
 ## Flow
 

package/samples/recipes/boot-check/README.md

@@ -13,7 +13,7 @@ never mounted, and nothing caught it — until now.
   feature-prefixed message.
 - **Conditional invariants `r.requires` can't express** — the check only
   fails when *this* feature's own shape demands it (has a PII field), not
-  unconditionally. A plain `r.requires("user-data-hook")` would fail even
+  unconditionally. A plain `r.requires({ features: ["user-data-hook"] })` would fail even
   for a prompt-store variant with no PII fields at all.
 - **`validateBoot`** — the framework's boot-time validator, run directly
   against a feature list. `bootCheck` has no DB dependency, so this is the

package/samples/recipes/boot-check/src/feature.ts

@@ -6,7 +6,7 @@ import { createEntity, createTextField, defineFeature } from "@cosmicdrift/kumik
 
 // A prompt-store integration trap: a feature with a PII field was mounted
 // without its required companion feature, and nothing caught it at boot.
-// r.requires("user-data-hook") can't express this — it would
+// r.requires({ features: ["user-data-hook"] }) can't express this — it would
 // fail even for a prompt-store variant with no PII fields at all.
 const promptFields = {
   text: createTextField({
@@ -16,7 +16,7 @@ const promptFields = {
 };
 
 export const promptStoreFeature = defineFeature("prompt-store", (r) => {
-  r.entity("prompt", createEntity({ fields: promptFields }));
+  r.entity({ name: "prompt", ...createEntity({ fields: promptFields }) });
   r.bootCheck(({ features }) => {
     const hasPiiField = Object.values(promptFields).some((field) => field.pii);
     const hasUserDataHook = features.some((f) => f.name === "user-data-hook");

package/samples/recipes/chat-channels/src/feature.ts

@@ -16,7 +16,7 @@ import * as z from "zod";
 export const OPS_ANNOUNCEMENT_TYPE = qn("ops", "notify", "announcement");
 
 export const opsFeature = defineFeature("ops", (r) => {
-  r.requires("delivery");
+  r.requires({ features: ["delivery"] });
 
   r.writeHandler(
     defineWriteHandler({

package/samples/recipes/cross-feature-events/src/feature.ts

@@ -64,7 +64,7 @@ export const capturedEvents: CapturedEvent[] = [];
 // --- Feature ---
 
 export const pubsubOrderFeature = defineFeature("pubsubOrders", (r) => {
-  r.entity("pubsub-order", orderEntity);
+  r.entity({ name: "pubsub-order", ...orderEntity });
 
   // Define the event shape once. The returned `.name` is the qualified
   // name ("pubsub-orders:event:order-placed") — pass it to ctx.appendEvent.
@@ -76,10 +76,10 @@ export const pubsubOrderFeature = defineFeature("pubsubOrders", (r) => {
 
   const { executor: orderExecutor } = createEntityExecutor("pubsub-order", orderEntity);
 
-  r.writeHandler(
-    "order:place",
-    z.object({ customer: z.string().min(1), product: z.string().min(1) }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "order:place",
+    schema: z.object({ customer: z.string().min(1), product: z.string().min(1) }),
+    handler: async (event, ctx) => {
       const result = await orderExecutor.create(event.payload, event.user, ctx.db);
       if (result.isSuccess) {
         // emitEvent runs inside the executor's TX and is typed against
@@ -100,8 +100,8 @@ export const pubsubOrderFeature = defineFeature("pubsubOrders", (r) => {
       }
       return result;
     },
-    { access: { roles: ["Admin", "Customer"] } },
-  );
+    access: { roles: ["Admin", "Customer"] },
+  });
 
   // Async consumer — Marten-style. Fires after commit, via the event-
   // dispatcher. No `table` means this MSP is pure side-effect (no state

package/samples/recipes/currencies-global/src/feature.ts

@@ -49,9 +49,9 @@ const CURRENCY_CATALOG = [
 ] as const;
 
 export const currenciesGlobalFeature = defineFeature("currenciesGlobal", (r) => {
-  const currency = r.entity("currency", currencyEntity);
-  r.entity("tenant-currency", tenantCurrencyEntity);
-  r.entity("invoice", invoiceEntity);
+  const currency = r.entity({ name: "currency", ...currencyEntity });
+  r.entity({ name: "tenant-currency", ...tenantCurrencyEntity });
+  r.entity({ name: "invoice", ...invoiceEntity });
 
   // Seed global currency table — available for all tenants to pick from
   r.referenceData(currency, [...CURRENCY_CATALOG], { upsertKey: "code" });

package/samples/recipes/currencies-per-tenant/src/feature.ts

@@ -19,8 +19,8 @@ export { currencyEntity } from "./entities/currency";
 export { invoiceEntity } from "./entities/invoice";
 
 export const currenciesPerTenantFeature = defineFeature("currenciesPerTenant", (r) => {
-  r.entity("currency", currencyEntity);
-  r.entity("invoice", invoiceEntity);
+  r.entity({ name: "currency", ...currencyEntity });
+  r.entity({ name: "invoice", ...invoiceEntity });
 
   // No r.referenceData() — tenants create currencies themselves
   r.writeHandler(currencyCreate);

package/samples/recipes/custom-fields-basic/README.md

@@ -36,7 +36,7 @@ property-management    → our feature: opts the `property` entity into
                          custom-fields via wireCustomFieldsFor
 ```
 
-The `property-management` feature `r.requires("custom-fields")` — the
+The `property-management` feature `r.requires({ features: ["custom-fields"] })` — the
 bundle is non-optional for this recipe because the wired entity would
 otherwise have an empty jsonb column and no way to write into it.
 

package/samples/recipes/custom-fields-basic/src/feature.ts

@@ -53,9 +53,10 @@ function propertyExecutor() {
 // --- Feature ---
 
 export const propertyFeature = defineFeature("property-management", (r) => {
-  r.requires("custom-fields");
+  r.requires({ features: ["custom-fields"] });
 
-  r.entity("property", {
+  r.entity({
+    name: "property",
     table: "read_sample_cf_properties",
     fields: {
       name: { type: "text", required: true, maxLength: 200 },

package/samples/recipes/custom-handlers/README.md

@@ -13,9 +13,9 @@ logic is yours.
 
 ## What it shows
 
-- **`r.writeHandler(name, schema, handler, options)`** — the positional
-  inline form, useful when the handler body is short and stays close to
-  its registration.
+- **`r.writeHandler({ name, schema, handler, access })`** — the inline
+  form, useful when the handler body is short and stays close to its
+  registration.
 - **Read-modify-write with optimistic locking** — `increment` reads the
   current count, computes the new one, and updates with the version it
   read. Two concurrent increments cannot both succeed.

package/samples/recipes/custom-handlers/src/feature.ts

@@ -25,7 +25,7 @@ export const counterEntity = createEntity({
 });
 
 export const counterFeature = defineFeature("counters", (r) => {
-  r.entity("counter", counterEntity);
+  r.entity({ name: "counter", ...counterEntity });
 
   // createEntityExecutor bundles buildEntityTable + createEventStoreExecutor —
   // the same pair every custom write-handler opens with. Collapses 3 lines
@@ -33,19 +33,19 @@ export const counterFeature = defineFeature("counters", (r) => {
   const { executor: counterExecutor } = createEntityExecutor("counter", counterEntity);
 
   // Standard create
-  r.writeHandler(
-    "counter:create",
-    z.object({ name: z.string().min(1) }),
-    async (event, ctx) =>
+  r.writeHandler({
+    name: "counter:create",
+    schema: z.object({ name: z.string().min(1) }),
+    handler: async (event, ctx) =>
       counterExecutor.create({ ...event.payload, count: 0 }, event.user, ctx.db),
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 
   // Custom handler: increment with business logic
-  r.writeHandler(
-    "counter:increment",
-    z.object({ id: z.uuid(), amount: z.number().min(1).max(100) }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "counter:increment",
+    schema: z.object({ id: z.uuid(), amount: z.number().min(1).max(100) }),
+    handler: async (event, ctx) => {
       const current = await counterExecutor.detail({ id: event.payload.id }, event.user, ctx.db);
       if (!current) {
         return failNotFound("counter", event.payload.id);
@@ -65,14 +65,14 @@ export const counterFeature = defineFeature("counters", (r) => {
         ctx.db,
       );
     },
-    { access: { roles: ["Admin", "User"] } },
-  );
+    access: { roles: ["Admin", "User"] },
+  });
 
   // Custom handler: reset to zero
-  r.writeHandler(
-    "counter:reset",
-    z.object({ id: z.uuid() }),
-    async (event, ctx) =>
+  r.writeHandler({
+    name: "counter:reset",
+    schema: z.object({ id: z.uuid() }),
+    handler: async (event, ctx) =>
       // Admin reset: last-writer-wins is intentional — there's no useful
       // concurrent-reset race to guard against.
       counterExecutor.update(
@@ -81,16 +81,16 @@ export const counterFeature = defineFeature("counters", (r) => {
         ctx.db,
         { skipOptimisticLock: true },
       ),
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 
   // Custom query: only counters above a threshold. list() returns one page
   // (default 50, max 200, MAX_LIST_LIMIT), so a JS filter would miss rows after
   // page 1; filter in the query instead. totalCount counts over the whole WHERE.
-  r.queryHandler(
-    "counter:active",
-    z.object({ minCount: z.number().int().default(1), cursor: z.string().optional() }),
-    async (query, ctx) =>
+  r.queryHandler({
+    name: "counter:active",
+    schema: z.object({ minCount: z.number().int().default(1), cursor: z.string().optional() }),
+    handler: async (query, ctx) =>
       counterExecutor.list(
         {
           filter: { field: "count", op: "gte", value: query.payload.minCount },
@@ -100,28 +100,24 @@ export const counterFeature = defineFeature("counters", (r) => {
         query.user,
         ctx.db,
       ),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in user may list active counters; the sample has no per-user counter ownership",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in user may list active counters; the sample has no per-user counter ownership",
       },
     },
-  );
+  });
 
   // Standard detail
-  r.queryHandler(
-    "counter:detail",
-    z.object({ id: z.uuid() }),
-    async (query, ctx) => counterExecutor.detail(query.payload, query.user, ctx.db),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in user may read a counter by id; the sample has no per-user counter ownership",
-        },
+  r.queryHandler({
+    name: "counter:detail",
+    schema: z.object({ id: z.uuid() }),
+    handler: async (query, ctx) => counterExecutor.detail(query.payload, query.user, ctx.db),
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in user may read a counter by id; the sample has no per-user counter ownership",
       },
     },
-  );
+  });
 });

package/samples/recipes/dashboard-stats/src/feature.ts

@@ -36,10 +36,10 @@ export const ticketFeature = defineFeature("tickets", (r) => {
   // Flat result: each dashboard stat reads one field via its valueField.
   // limit: 1 keeps the page tiny; totalCount counts over the whole WHERE in
   // the database, so no rows are loaded just to be counted.
-  r.queryHandler(
-    "ticket:stats",
-    z.object({}),
-    async (query, ctx) => {
+  r.queryHandler({
+    name: "ticket:stats",
+    schema: z.object({}),
+    handler: async (query, ctx) => {
       const countWithStatus = async (status: (typeof TICKET_STATUSES)[number]): Promise<number> => {
         const page = await ticketExecutor.list(
           { filter: { field: "status", op: "eq", value: status }, limit: 1, totalCount: true },
@@ -54,8 +54,8 @@ export const ticketFeature = defineFeature("tickets", (r) => {
       ]);
       return { open, closed, total: open + closed };
     },
-    { access: readerRoles },
-  );
+    access: readerRoles,
+  });
 
   r.translations({
     keys: {

package/samples/recipes/delivery-notifications/README.md

@@ -28,7 +28,7 @@ channel-inApp / channel-email / channel-push
 support           → our business logic (tickets + the notification declaration)
 ```
 
-The `support` feature `r.requires("delivery")`: channels are features that attach to delivery, but `support` doesn't need to know them.
+The `support` feature `r.requires({ features: ["delivery"] })`: channels are features that attach to delivery, but `support` doesn't need to know them.
 
 ## Flow
 

package/samples/recipes/delivery-notifications/src/feature.ts

@@ -47,9 +47,9 @@ function ticketExecutor() {
 export const TICKET_ASSIGNED = qn("support", QnTypes.notify, "ticket-assigned");
 
 export const supportFeature = defineFeature("support", (r) => {
-  r.requires("delivery");
+  r.requires({ features: ["delivery"] });
 
-  r.entity("ticket", ticketEntity);
+  r.entity({ name: "ticket", ...ticketEntity });
 
   r.notification("ticket-assigned", {
     variables: {
@@ -79,16 +79,16 @@ export const supportFeature = defineFeature("support", (r) => {
     },
   });
 
-  r.writeHandler(
-    "ticket:create",
-    z.object({
+  r.writeHandler({
+    name: "ticket:create",
+    schema: z.object({
       title: z.string().min(1),
       description: z.string().optional(),
       assigneeId: z.uuid().optional(),
       priority: z.enum(["low", "normal", "critical"]),
       status: z.string().default("open"),
     }),
-    async (event, ctx) => {
+    handler: async (event, ctx) => {
       const created = await ticketExecutor().create(event.payload, event.user, ctx.db);
       const assigneeId = event.payload.assigneeId;
       // No assignee, no notification.
@@ -109,6 +109,6 @@ export const supportFeature = defineFeature("support", (r) => {
       });
       return created;
     },
-    { access: { roles: ["Admin", "Support"] } },
-  );
+    access: { roles: ["Admin", "Support"] },
+  });
 });

package/samples/recipes/designer-demo/src/feature.ts

@@ -12,7 +12,8 @@ import { z } from "zod";
 defineFeature("designerDemo", (r) => {
   r.optionalRequires("analytics");
 
-  r.entity("task", {
+  r.entity({
+    name: "task",
     fields: {
       title: { type: "text", required: true },
       done: { type: "boolean", default: false },