@cosmicdrift/kumiko-samples 0.338.0

package/samples/recipes/pipeline-basics/src/feature.ts

@@ -0,0 +1,424 @@
+// Pipeline Basics — Inventory-Management Showcase
+//
+// Production-pattern sample that exercises every Tier-1 step from
+// the M.1 step-vocabulary in a single feature. The handlers below
+// are the canonical reference for "what the pipeline form looks
+// like in real code"; the M.3 codemod (later) will translate the
+// free-form `custom-handlers` sample into roughly this shape.
+//
+// Steps covered:
+//   - r.step.aggregate.create / aggregate.update / aggregate.appendEvent
+//   - r.step.read.findOne / read.findMany
+//   - r.step.compute / branch / forEach / return
+//   - r.step.unsafeProjectionUpsert / unsafeProjectionDelete
+//
+// Domain: products with a current-stock counter. Stock-adjustments
+// are tracked as domain events on the product stream (in addition
+// to the auto-CRUD updated-event). A custom non-aggregate
+// projection (`low_stock_alerts`) gets upserted/deleted inline
+// whenever stock crosses a threshold — exactly the use-case the
+// `unsafe`-prefix is designed for: framework-author opting into
+// raw projection-writes after seeing the prefix at every call site.
+
+import type { EntityTableMeta } from "@cosmicdrift/kumiko-framework/db";
+import {
+  buildEntityTable,
+  createEventStoreExecutor,
+  integer,
+  selectMany,
+  table,
+  text,
+  updateMany,
+  uuid,
+} from "@cosmicdrift/kumiko-framework/db";
+import type { PipelineCtx } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  createEntity,
+  createNumberField,
+  createTextField,
+  defineFeature,
+  defineWriteHandler,
+  stepsPipeline,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { z } from "zod";
+
+const LOW_STOCK_THRESHOLD = 10;
+
+export const productEntity = createEntity({
+  table: "read_inventory_products",
+  fields: {
+    sku: createTextField({ personal: false, reason: "is_business_data", required: true }),
+    name: createTextField({ personal: false, reason: "is_business_data", required: true }),
+    currentStock: createNumberField({ default: 0 }),
+  },
+});
+
+// Custom non-aggregate projection. The boot-validator allows direct
+// upsert/delete only because `r.requires.projection(...)` is declared
+// inside the feature below — without that line, boot fails fast.
+export const lowStockAlertsTable: EntityTableMeta = table("read_inventory_low_stock_alerts", {
+  productId: uuid("product_id").primaryKey(),
+  sku: text("sku").notNull(),
+  currentStock: integer("current_stock").notNull(),
+  threshold: integer("threshold").notNull(),
+});
+
+// Module-level drizzle-table + executor — the steps below capture
+// `productExecutor` from this scope, and the integration test
+// imports `productTable` for raw selects.
+export const productTable = buildEntityTable("product", productEntity);
+const productExecutor = createEventStoreExecutor(productTable, productEntity, {
+  entityName: "product",
+});
+
+export const inventoryFeature = defineFeature("inventory", (r) => {
+  r.entity("product", productEntity);
+  r.requires.projection("read_inventory_low_stock_alerts");
+
+  // Domain-events on the product stream (alongside the auto-CRUD
+  // events). r.defineEvent registers them globally — the `type`
+  // field of aggregate.appendEvent is a plain string, but using
+  // `<eventDef>.name` here gives type-safe aliasing if the event
+  // is later renamed.
+  const stockAdjusted = r.defineEvent(
+    "product-stock-adjusted",
+    z.object({
+      delta: z.number().int(),
+      reason: z.string(),
+      newStock: z.number().int(),
+    }),
+    { piiFields: "none" },
+  );
+
+  const archived = r.defineEvent("product-archived", z.object({ reason: z.string() }), {
+    piiFields: "none",
+  });
+
+  // Inline projection that maintains `currentStock` from the
+  // stock-adjusted domain event. Pure event-sourcing pattern: the
+  // adjust-stock handler does NOT call aggregate.update — it only
+  // appends the domain event, and this projection (running in the
+  // same TX) replays its effect onto the product row.
+  //
+  // Why pure-ES (rather than aggregate.update + appendEvent in one
+  // handler): combining the two inflates the stream-version mid-
+  // handler, which would trip optimistic-locking on a back-to-back
+  // adjust-stock call. The split-here is the canonical Marten/CQRS
+  // shape — domain events are the source of truth, projections are
+  // the queryable view.
+  r.projection({
+    name: "product-stock-counter",
+    source: "product",
+    table: productTable,
+    apply: {
+      [stockAdjusted.name]: async (event, tx, table) => {
+        const p = event.payload as { newStock: number };
+        await updateMany(tx, table, { currentStock: p.newStock }, { id: event.aggregateId });
+      },
+    },
+  });
+
+  // -------------------------------------------------------------
+  // 1. inventory:product:create — straight aggregate.create.
+  //    Simplest pipeline form: one mutating step + return.
+  // -------------------------------------------------------------
+  r.writeHandler(
+    defineWriteHandler({
+      name: "product:create",
+      schema: z.object({
+        sku: z.string().min(1),
+        name: z.string().min(1),
+        initialStock: z.number().int().min(0).default(0),
+      }),
+      access: { roles: ["Admin"] },
+      perform: stepsPipeline<{ sku: string; name: string; initialStock: number }, { id: string }>(
+        ({ event, r }) => [
+          r.step.aggregate.create("product", {
+            executor: productExecutor,
+            data: () => ({
+              sku: event.payload.sku,
+              name: event.payload.name,
+              currentStock: event.payload.initialStock,
+            }),
+          }),
+          r.step.return(({ steps }) => ({
+            isSuccess: true as const,
+            data: { id: (steps["product"] as { id: string }).id },
+          })),
+        ],
+      ),
+    }),
+  );
+
+  // -------------------------------------------------------------
+  // 2. inventory:product:rename — read + branch (skip-if-noop).
+  //    Demonstrates the read-then-conditional-write pattern.
+  //    The aggregate.update inside `onTrue` only runs when the
+  //    name actually changed — saves an event + a projection
+  //    write per redundant rename.
+  // -------------------------------------------------------------
+  r.writeHandler(
+    defineWriteHandler({
+      name: "product:rename",
+      schema: z.object({ id: z.uuid(), name: z.string().min(1) }),
+      access: { roles: ["Admin"] },
+      perform: stepsPipeline<{ id: string; name: string }, { id: string; renamed: boolean }>(
+        ({ event, r }) => [
+          r.step.read.findOne("current", {
+            table: productTable,
+            where: () => ({ id: event.payload.id }),
+          }),
+          r.step.branch({
+            if: ({ steps }) => {
+              const cur = steps["current"] as { name: string } | null;
+              return cur !== null && cur.name !== event.payload.name;
+            },
+            onTrue: [
+              r.step.aggregate.update("product", {
+                executor: productExecutor,
+                id: () => event.payload.id,
+                version: ({ steps }) => (steps["current"] as { version?: number } | null)?.version,
+                changes: () => ({ name: event.payload.name }),
+              }),
+            ],
+          }),
+          r.step.return(({ steps }) => ({
+            isSuccess: true as const,
+            data: {
+              id: event.payload.id,
+              // Truthy iff the aggregate.update step actually ran —
+              // the executor lands its SaveContext under steps.product.
+              renamed: steps["product"] !== undefined,
+            },
+          })),
+        ],
+      ),
+    }),
+  );
+
+  // -------------------------------------------------------------
+  // 3. inventory:product:adjust-stock — every Tier-1 step in one
+  //    handler. Production-realistic: read aggregate, compute new
+  //    stock, persist update, append a domain-event for the
+  //    audit-trail, then upsert OR delete the low-stock-alert
+  //    based on whether the new stock crosses the threshold.
+  // -------------------------------------------------------------
+  r.writeHandler(
+    defineWriteHandler({
+      name: "product:adjust-stock",
+      schema: z.object({
+        id: z.uuid(),
+        delta: z.number().int(),
+        reason: z.string().min(1),
+      }),
+      access: { roles: ["Admin", "User"] },
+      perform: stepsPipeline<
+        { id: string; delta: number; reason: string },
+        { id: string; newStock: number }
+      >(({ event, r }) => [
+        r.step.read.findOne("current", {
+          table: productTable,
+          where: () => ({ id: event.payload.id }),
+        }),
+        r.step.compute("newStock", ({ steps }) => {
+          const cur = steps["current"] as { currentStock: number } | null;
+          if (!cur) {
+            throw new Error(`product not found: ${event.payload.id}`);
+          }
+          return cur.currentStock + event.payload.delta;
+        }),
+        // Pure-ES: emit the domain event; the inline `product-stock-counter`
+        // projection above replays it onto the product row in the same TX.
+        // No aggregate.update here — see the projection's comment for why
+        // the split is intentional.
+        r.step.aggregate.appendEvent({
+          aggregateId: () => event.payload.id,
+          aggregateType: "product",
+          type: stockAdjusted.name,
+          // Explicit ctx-type: payload's resolver is StepResolver<unknown>,
+          // which prevents TS from inferring `ctx.steps` shape via the
+          // destructure. Followup #4 (TData-Inference) tracks the DX-fix.
+          payload: ({ steps }: PipelineCtx) => ({
+            delta: event.payload.delta,
+            reason: event.payload.reason,
+            newStock: steps["newStock"] as number,
+          }),
+        }),
+        // Inline projection-maintenance: cross the threshold in
+        // either direction in the same TX as the aggregate write.
+        // Async multi-stream projections would lag here — this is
+        // the use-case for inline unsafeProjection.*.
+        r.step.branch({
+          if: ({ steps }) => (steps["newStock"] as number) < LOW_STOCK_THRESHOLD,
+          onTrue: [
+            r.step.unsafeProjectionUpsert({
+              table: lowStockAlertsTable,
+              on: ["productId"],
+              row: ({ steps }) => {
+                const cur = steps["current"] as { sku: string };
+                return {
+                  productId: event.payload.id,
+                  sku: cur.sku,
+                  currentStock: steps["newStock"] as number,
+                  threshold: LOW_STOCK_THRESHOLD,
+                };
+              },
+            }),
+          ],
+          onFalse: [
+            r.step.unsafeProjectionDelete({
+              table: lowStockAlertsTable,
+              where: () => ({ productId: event.payload.id }),
+            }),
+          ],
+        }),
+        r.step.return(({ steps }) => ({
+          isSuccess: true as const,
+          data: {
+            id: event.payload.id,
+            newStock: steps["newStock"] as number,
+          },
+        })),
+      ]),
+    }),
+  );
+
+  // -------------------------------------------------------------
+  // 4. inventory:product:bulk-adjust — forEach over a list of
+  //    adjustments. Each iteration is its own read+update mini-
+  //    pipeline; `scope.adj` is the per-iteration item.
+  //    Sequential by design (concurrency=1 in M.1.6).
+  // -------------------------------------------------------------
+  r.writeHandler(
+    defineWriteHandler({
+      name: "product:bulk-adjust",
+      schema: z.object({
+        adjustments: z.array(z.object({ id: z.uuid(), delta: z.number().int() })).min(1),
+      }),
+      access: { roles: ["Admin"] },
+      perform: stepsPipeline<
+        { adjustments: ReadonlyArray<{ id: string; delta: number }> },
+        { processed: number }
+      >(({ event, r }) => [
+        r.step.forEach({
+          over: () => event.payload.adjustments,
+          as: "adj",
+          do: [
+            r.step.read.findOne("current", {
+              table: productTable,
+              where: ({ scope }) => ({ id: (scope["adj"] as { id: string }).id }),
+            }),
+            r.step.compute("newStock", ({ steps, scope }) => {
+              const cur = steps["current"] as { currentStock: number } | null;
+              const adj = scope["adj"] as { delta: number };
+              if (!cur) throw new Error("product not found in bulk-adjust");
+              return cur.currentStock + adj.delta;
+            }),
+            r.step.aggregate.update("product", {
+              executor: productExecutor,
+              id: ({ scope }) => (scope["adj"] as { id: string }).id,
+              version: ({ steps }) => (steps["current"] as { version?: number } | null)?.version,
+              changes: ({ steps }) => ({ currentStock: steps["newStock"] as number }),
+              // Pure update path inside forEach — no appendEvent
+              // alongside, so optimistic-locking stays meaningful.
+            }),
+          ],
+        }),
+        r.step.return(() => ({
+          isSuccess: true as const,
+          data: { processed: event.payload.adjustments.length },
+        })),
+      ]),
+    }),
+  );
+
+  // -------------------------------------------------------------
+  // 5. inventory:product:archive — domain-event + projection
+  //    cleanup. The aggregate is preserved (event-sourced!), the
+  //    side-projection row gets purged in the same TX. Reads
+  //    against archived products still work via loadAggregate;
+  //    list-views skip them by filtering on the archived event.
+  // -------------------------------------------------------------
+  r.writeHandler(
+    defineWriteHandler({
+      name: "product:archive",
+      schema: z.object({ id: z.uuid(), reason: z.string().min(1) }),
+      access: { roles: ["Admin"] },
+      perform: stepsPipeline<{ id: string; reason: string }, { id: string }>(({ event, r }) => [
+        r.step.aggregate.appendEvent({
+          aggregateId: () => event.payload.id,
+          aggregateType: "product",
+          type: archived.name,
+          payload: () => ({ reason: event.payload.reason }),
+        }),
+        r.step.unsafeProjectionDelete({
+          table: lowStockAlertsTable,
+          where: () => ({ productId: event.payload.id }),
+        }),
+        r.step.return(() => ({
+          isSuccess: true as const,
+          data: { id: event.payload.id },
+        })),
+      ]),
+    }),
+  );
+
+  // -------------------------------------------------------------
+  // 6. inventory:report:bulk-archive-stale — forEach + read.findMany.
+  //    Demonstrates the read-list-then-loop pattern: pull a slice
+  //    of low-stock alerts via read.findMany, archive each. Used
+  //    by the integration test to prove findMany lands rows under
+  //    steps.<name> as an array.
+  // -------------------------------------------------------------
+  r.writeHandler(
+    defineWriteHandler({
+      name: "report:archive-low-stock-products",
+      schema: z.object({ reason: z.string().min(1) }),
+      access: { roles: ["Admin"] },
+      perform: stepsPipeline<{ reason: string }, { archivedCount: number }>(({ event, r }) => [
+        r.step.read.findMany("alerts", {
+          table: lowStockAlertsTable,
+        }),
+        r.step.forEach<{ productId: string }>({
+          over: ({ steps }) => (steps["alerts"] as ReadonlyArray<{ productId: string }>) ?? [],
+          as: "alert",
+          do: [
+            r.step.aggregate.appendEvent({
+              aggregateId: ({ scope }) => (scope["alert"] as { productId: string }).productId,
+              aggregateType: "product",
+              type: archived.name,
+              payload: () => ({ reason: event.payload.reason }),
+            }),
+            r.step.unsafeProjectionDelete({
+              table: lowStockAlertsTable,
+              where: ({ scope }) => ({
+                productId: (scope["alert"] as { productId: string }).productId,
+              }),
+            }),
+          ],
+        }),
+        r.step.return(({ steps }) => ({
+          isSuccess: true as const,
+          data: {
+            archivedCount: (steps["alerts"] as ReadonlyArray<unknown>).length,
+          },
+        })),
+      ]),
+    }),
+  );
+
+  // -------------------------------------------------------------
+  // Query handlers — free-form. M.1's pipeline-engine is write-
+  // only; queries get the existing handler signature. The list
+  // below is what the integration test reads against.
+  // -------------------------------------------------------------
+  r.queryHandler(
+    "low-stock-alerts:list",
+    z.object({}),
+    async (_query, ctx) => {
+      const rows = await selectMany(ctx.db, lowStockAlertsTable);
+      return { rows };
+    },
+    { access: { roles: ["Admin"] } },
+  );
+});

package/samples/recipes/pipeline-basics/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@cosmicdrift/kumiko-framework/*": [
+        "../../../packages/framework/src/*/index.ts"
+      ]
+    },
+    "noEmit": true,
+    "rootDir": "../../..",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": ["bun-types"]
+  },
+  "include": ["src"]
+}

package/samples/recipes/public-share-token/README.md

@@ -0,0 +1,37 @@
+# Public share token
+
+Minimal pattern for **tokenized anonymous read surfaces**: authenticated users
+mint a link; visitors resolve it without login.
+
+Domain-agnostic — no credit/folder logic. Full consumer:
+[Cashcolt money-horse](https://github.com/CosmicDriftGameStudio/money-horse)
+(`share-by-token` + 5 layout templates).
+
+## What it shows
+
+- **`createEntity` + event-sourced CRUD** — `tokenHash` unique, plain token show-once
+- **`defineWriteHandler` / `defineQueryHandler`** — create, revoke, read-by-token
+- **Anonymous query** — `roles: ["anonymous", …]` + `rateLimit: { per: "ip+handler" }`
+- **404 ohne Leak** — invalid / expired / revoked → same `NotFoundError` shape
+- **`anonymousAccess`** on test stack (see integration test)
+
+Client wiring: [`recipes/apex-surface-auth`](../apex-surface-auth/) or a gate
+before `createKumikoApp` (money-horse uses `public-share-gate.tsx` like the public
+calculator).
+
+## Handlers
+
+| QN | Access |
+|---|---|
+| `public-share:write:share-link:create` | authenticated (`openToAll`) |
+| `public-share:write:share-link:revoke` | owner |
+| `public-share:query:share-by-token` | anonymous + authenticated |
+
+## Run tests
+
+From repo root (needs `TEST_DATABASE_URL` + `REDIS_URL`):
+
+```bash
+cd kumiko-framework/samples/recipes/public-share-token
+bun test src/__tests__/feature.integration.test.ts
+```

package/samples/recipes/public-share-token/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@cosmicdrift/kumiko-sample-public-share-token",
+  "description": "Generic share-token entity: mint hash-stored token, anonymous read-by-token with IP rate-limit.",
+  "private": true,
+  "dependencies": {
+    "@cosmicdrift/kumiko-framework": "workspace:*"
+  }
+}

package/samples/recipes/public-share-token/src/feature.ts

@@ -0,0 +1,197 @@
+// Public share token — generic recipe (no domain payload).
+//
+// Pattern: authenticated create → plain token show-once → anonymous
+// read-by-token with SHA-256 lookup. Revoke sets revokedAt via executor.
+//
+// See money-horse for credit/folder snapshots, layouts, tier gates.
+
+import { generateToken } from "@cosmicdrift/kumiko-framework/api";
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import {
+  createEntity,
+  createEntityExecutor,
+  createJsonbField,
+  createTextField,
+  createTimestampField,
+  defineFeature,
+  defineQueryHandler,
+  defineWriteHandler,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import { getTemporal } from "@cosmicdrift/kumiko-framework/time";
+import { z } from "zod";
+
+const TOKEN_PREFIX = "sh_";
+
+const SHARE_BY_TOKEN_REASON =
+  "resolves the share link by token hash for callers whose dispatch tenant is not the link owner's";
+
+export const shareLinkEntity = createEntity({
+  table: "read_public_share_links",
+  idType: "uuid",
+  fields: {
+    tokenHash: createTextField({
+      personal: false,
+      reason: "is_token_hash",
+      required: true,
+      maxLength: 64,
+    }),
+    label: createTextField({
+      personal: false,
+      reason: "is_business_data",
+      required: true,
+      maxLength: 200,
+    }),
+    payload: createJsonbField(),
+    expiresAt: createTimestampField({ required: true }),
+    revokedAt: createTimestampField({}),
+  },
+  indexes: [
+    {
+      unique: true,
+      columns: ["tokenHash"],
+      name: "read_public_share_links_hash_unique",
+    },
+  ],
+});
+
+const { executor, table } = createEntityExecutor("share-link", shareLinkEntity);
+
+async function hashToken(plain: string): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(plain));
+  let hex = "";
+  for (const byte of new Uint8Array(digest)) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+async function mintToken(): Promise<{ plain: string; hash: string }> {
+  const plain = `${TOKEN_PREFIX}${generateToken()}`;
+  return { plain, hash: await hashToken(plain) };
+}
+
+const createSchema = z.object({
+  label: z.string().min(1).max(200),
+  payload: z.record(z.string(), z.unknown()).optional(),
+  expiresInDays: z.number().int().min(1).max(90).default(30),
+});
+
+export const shareLinkCreateWrite = defineWriteHandler({
+  name: "share-link:create",
+  schema: createSchema,
+  access: {
+    openToAll: {
+      reason:
+        "any signed-in user may create a share link for their own tenant; the link " +
+        "itself is only reachable via its unguessable token",
+    },
+  },
+  rateLimit: { per: "ip+handler", limit: 30, windowSeconds: 60 },
+  handler: async (event, ctx) => {
+    const { plain, hash } = await mintToken();
+    const now = getTemporal().Now.instant();
+    const expiresAt = now.add({ hours: 24 * event.payload.expiresInDays });
+
+    const result = await executor.create(
+      {
+        tokenHash: hash,
+        label: event.payload.label,
+        payload: event.payload.payload ?? {},
+        expiresAt,
+        revokedAt: null,
+        tenantId: event.user.tenantId,
+      },
+      event.user,
+      ctx.db,
+    );
+    if (!result.isSuccess) return result;
+
+    const id = String((result.data as { id: unknown }).id);
+    return {
+      isSuccess: true as const,
+      data: { id, plainToken: plain, expiresAt: expiresAt.toString() },
+    };
+  },
+});
+
+export const shareLinkRevokeWrite = defineWriteHandler({
+  name: "share-link:revoke",
+  schema: z.object({ id: z.uuid() }),
+  access: {
+    openToAll: {
+      reason:
+        "any signed-in user may attempt to revoke a share link, but only the link's " +
+        "own creator succeeds; the handler checks ownerId against the caller and " +
+        "returns not-found otherwise",
+    },
+  },
+  handler: async (event, ctx) => {
+    const rows = await ctx.db.selectMany(
+      table,
+      { id: event.payload.id, tenantId: event.user.tenantId },
+      { limit: 1 },
+    );
+    const row = rows[0];
+    const ownerId = String(row?.["insertedById"] ?? row?.["inserted_by_id"] ?? "");
+    if (!row || ownerId !== event.user.id) {
+      throw new NotFoundError("share-link");
+    }
+
+    return executor.update(
+      {
+        id: event.payload.id,
+        version: Number(row["version"]),
+        changes: { revokedAt: getTemporal().Now.instant() },
+      },
+      event.user,
+      ctx.db,
+    );
+  },
+});
+
+interface ShareLinkRow {
+  readonly id: string;
+  readonly label: string;
+  readonly payload: unknown;
+  readonly expiresAt: Temporal.Instant;
+  readonly revokedAt: Temporal.Instant | null;
+}
+
+export const shareByTokenQuery = defineQueryHandler({
+  name: "share-by-token",
+  schema: z.object({ token: z.string().min(1) }),
+  access: { roles: ["anonymous", "Member", "User", "TenantAdmin", "SystemAdmin"] },
+  rateLimit: { per: "ip+handler", limit: 30, windowSeconds: 60 },
+  escapeHatch: {
+    grants: ["unsafeRaw"],
+    reason: SHARE_BY_TOKEN_REASON,
+  },
+  handler: async (query, ctx) => {
+    const hash = await hashToken(query.payload.token);
+    const row = await fetchOne<ShareLinkRow>(ctx.db.unsafeRaw(SHARE_BY_TOKEN_REASON), table, {
+      tokenHash: hash,
+    });
+
+    if (!row) {
+      throw new NotFoundError("share-link");
+    }
+
+    const now = getTemporal().Now.instant();
+    if (row.revokedAt != null || row.expiresAt.epochMilliseconds <= now.epochMilliseconds) {
+      throw new NotFoundError("share-link");
+    }
+
+    return {
+      label: row.label,
+      payload: row.payload,
+    };
+  },
+});
+
+export const publicShareTokenFeature = defineFeature("public-share", (r) => {
+  r.entity("share-link", shareLinkEntity);
+  r.writeHandler(shareLinkCreateWrite);
+  r.writeHandler(shareLinkRevokeWrite);
+  r.queryHandler(shareByTokenQuery);
+});