create-substrat 0.7.1 → 0.7.2

package/index.js

@@ -35,10 +35,10 @@ const TEMPLATE = join(HERE, 'template');
 // The runtime packages release together off one version line (the changesets `fixed`
 // group), so one constant is right for all of them. Engines do NOT share a line —
 // each versions on its own, so one pin per engine, deliberately.
-const SUBSTRAT = '^0.84.0';
-const ENGINE_WORKORDER = '^0.8.0';
-const ENGINE_INVOICING = '^0.9.0';
-const BOUNDARY_LINT = '^0.1.0';
+const SUBSTRAT = '^0.85.0';
+const ENGINE_WORKORDER = '^0.8.1';
+const ENGINE_INVOICING = '^0.9.1';
+const BOUNDARY_LINT = '^0.1.1';
 
 const DOCS = 'https://substrat.net';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-substrat",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Scaffold a Substrat vertical — `npm create substrat <dir>`.",
   "license": "Apache-2.0",
   "repository": {

package/template/src/module.ts

@@ -3,15 +3,18 @@ import {
   compareDecimal,
   moneyOf,
   mulMoney,
+  pageVisible,
   z,
   type EntityRef,
   type Money,
+  type Page,
 } from '@substrat-run/contracts';
 import {
   assertAllowed,
   ulid,
   type ModuleRegistration,
   type OperationHandler,
+  type PageParams,
 } from '@substrat-run/kernel';
 import {
   closeWorkOrder,
@@ -244,15 +247,25 @@ const closeRepairOp: OperationHandler<{ orderId: string }, WorkOrder> = async (c
  * PER-ENTITY check per repair. A portal customer holds an entity-narrowed grant
  * on their own customer record, so the walk workorder → bike → customer lets
  * them through for their own repairs and no one else's.
+ *
+ * Paged by OVER-FETCHING, which is what a permission-filtered walk needs: a page
+ * of 20 rows read from the table can leave 3 standing after the proof walk, so the
+ * fetch size and the page size are not the same number and cannot be made the same
+ * number. `pageVisible` does the over-fetch and advances the cursor by the last row
+ * EXAMINED — advancing by the last row RETURNED would re-examine every rejected row
+ * on the next request, and a page the walk rejects entirely would never advance at
+ * all. So a SHORT page does not end this walk; only a null `nextCursor` does.
  */
-const portalRepairsOp: OperationHandler<undefined, WorkOrder[]> = async (ctx) => {
-  const visible: WorkOrder[] = [];
-  for (const order of listOrders(ctx)) {
-    const decision = await ctx.check(WO.read, { entityType: 'workorder', entityId: order.id });
-    if (decision.allowed) visible.push(order);
-  }
-  return visible;
-};
+const portalRepairsOp: OperationHandler<PageParams | undefined, Page<WorkOrder>> = async (
+  ctx,
+  input,
+) =>
+  pageVisible(
+    (p) => listOrders(ctx, { ...input, ...p }),
+    input,
+    async (order) =>
+      (await ctx.check(WO.read, { entityType: 'workorder', entityId: order.id })).allowed,
+  );
 
 const timelineInput = z.object({
   entityType: z.string().min(1),

package/template/test/scenario.test.ts

@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import Database from 'better-sqlite3';
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { addMoney, moneyOf, mulMoney } from '@substrat-run/contracts';
+import { addMoney, moneyOf, mulMoney, type Page } from '@substrat-run/contracts';
 import type { ScopeStub } from '@substrat-run/kernel';
 import type { SqliteScopeHost } from '@substrat-run/adapter-sqlite';
 import type { WorkOrder, BillableLine } from '@substrat-run/engine-workorder';
@@ -105,7 +105,8 @@ describe('bike-shop scenario', () => {
       lisbeth.invoke('workorder/report-time', { orderId: repairId, hours: '1' }),
     ).rejects.toThrow(/permission denied/);
     // …but she CAN see her own repair through the portal walk.
-    await expect(lisbeth.invoke<WorkOrder[]>('shop/portal-repairs')).resolves.toHaveLength(1);
+    const lisbethSees = await lisbeth.invoke<Page<WorkOrder>>('shop/portal-repairs');
+    expect(lisbethSees.entries).toHaveLength(1);
 
     // The cross-tenant attacker: claiming t1's scope under his OWN tenant fails
     // the (tenant, scope) pair check…
@@ -120,7 +121,8 @@ describe('bike-shop scenario', () => {
     await expect(rutger.invoke('invoicing/list')).rejects.toThrow(/permission denied/);
     // …the control: the per-entity portal walk resolves for him too, and returns
     // exactly nothing — an open door onto an empty room, not a denial.
-    await expect(rutger.invoke<WorkOrder[]>('shop/portal-repairs')).resolves.toEqual([]);
+    const rutgerSees = await rutger.invoke<Page<WorkOrder>>('shop/portal-repairs');
+    expect(rutgerSees.entries).toEqual([]);
   });
 
   it('5. priced completion: the half-hour minimum bills, internal dropped, math exact', async () => {
@@ -153,9 +155,9 @@ describe('bike-shop scenario', () => {
   });
 
   it('6. star topology: the invoicing engine consumed workorder.completed', async () => {
-    const underlag = await greta.invoke<{ id: string; status: string; total: string }[]>(
-      'invoicing/list',
-    );
+    const { entries: underlag } = await greta.invoke<
+      Page<{ id: string; status: string; total: string }>
+    >('invoicing/list');
     expect(underlag).toHaveLength(1);
     expect(underlag[0]!.status).toBe('open');
     expect(underlag[0]!.total).toBe('336.5');
@@ -178,9 +180,10 @@ describe('bike-shop scenario', () => {
     const lisbeth = await host.getScope(w.lisbeth, w.t1, w.s1);
     const otto = await host.getScope(w.otto, w.t1, w.s1);
 
-    const hers = await lisbeth.invoke<WorkOrder[]>('shop/portal-repairs');
-    expect(hers.map((o) => o.id)).toEqual([repairId]);
-    await expect(otto.invoke<WorkOrder[]>('shop/portal-repairs')).resolves.toEqual([]);
+    const hers = await lisbeth.invoke<Page<WorkOrder>>('shop/portal-repairs');
+    expect(hers.entries.map((o) => o.id)).toEqual([repairId]);
+    const ottos = await otto.invoke<Page<WorkOrder>>('shop/portal-repairs');
+    expect(ottos.entries).toEqual([]);
 
     // Lisbeth reads her repair's timeline via the same entity walk…
     await expect(
@@ -194,7 +197,9 @@ describe('bike-shop scenario', () => {
   });
 
   it('8. export makes the underlag immutable; the next completion opens a new one', async () => {
-    const [underlag] = await greta.invoke<{ id: string }[]>('invoicing/list');
+    const {
+      entries: [underlag],
+    } = await greta.invoke<Page<{ id: string }>>('invoicing/list');
     await greta.invoke('invoicing/export', { underlagId: underlag!.id });
     await expect(greta.invoke('invoicing/export', { underlagId: underlag!.id })).rejects.toThrow(
       /immutable/,
@@ -214,7 +219,9 @@ describe('bike-shop scenario', () => {
     });
     await greta.invoke('shop/complete-repair', { orderId: repair2.id });
 
-    const all = await greta.invoke<{ status: string; total: string }[]>('invoicing/list');
+    const { entries: all } = await greta.invoke<Page<{ status: string; total: string }>>(
+      'invoicing/list',
+    );
     expect(all).toHaveLength(2);
     expect(all.filter((u) => u.status === 'open')).toHaveLength(1);
     expect(all.filter((u) => u.status === 'exported')).toHaveLength(1);