Merge remote-tracking branch 'origin/main' into claude/issue-4556-recorded-by-nullable

Author: claude

.changeset/console-785b8a5d432c.md

@@ -0,0 +1,102 @@
+---
+"@objectstack/console": minor
+---
+
+Console (objectui) refreshed to `785b8a5d432c` — the 2026-08-02 objectui batch reaches v17 (#4665).
+
+Until this pin moves, a merged objectui fix exists only on objectui's `main`: the
+release pipeline clones objectui at `.objectui-sha`, so anything newer is simply not
+in the artifact the platform ships, and its frontend changeset never reaches the
+platform's release history (#3340). Four of the seven PRs merged that day changed
+published packages, and one of them is **breaking for authoring** — so that
+migration is written out here, in the layer the release notes are compiled from,
+rather than left implicit in a SHA.
+
+## Breaking for authoring — an action param's picker target is `reference`, and only `reference` (objectui#3203)
+
+`ActionParam` in `@object-ui/types` no longer declares the nine resolved-side picker
+keys: `referenceTo`, `displayField`, `idField`, `descriptionField`, `titleFormat`,
+`lookupColumns`, `lookupFilters`, `lookupPageSize`, `dependsOn`.
+
+Migration:
+
+- **Inline picker target** — rewrite to `reference`:
+  FROM `{ name: 'account_id', type: 'lookup', referenceTo: 'account' }`
+  TO   `{ name: 'account_id', type: 'lookup', reference: 'account' }`
+- **The other eight** — make the param **field-backed** and it inherits the whole
+  picker group from the object field: `{ field: 'account_id' }`.
+
+**This removes a compile-time illusion, not a capability.** Those keys were never
+storable: `@objectstack/spec`'s `ActionParamSchema` is `.strict()`, its authorable key
+list carries `reference` and not `referenceTo`, and its alias table names
+`referenceto → reference` by hand — so an authored `referenceTo` has always been a
+hard parse rejection on the server. Only `tsc` waved it through, against objectui's
+public type, which meant the mistake surfaced at publish time instead of at the
+authoring keystroke. `ActionParam` is now derived from the spec schema
+(`Omit< z.input< typeof ActionParamSchema >, 'type' >`), so the authoring type and
+the parser can no longer disagree about a spelling, and `resolveActionParams()`
+additionally names any resolved-only key it meets in a dev-mode warning with the
+prescription above — covering params authored in plain JS or JSON, which `tsc` never
+sees.
+
+## Also author-visible in this batch
+
+- **An unrecognised dashboard date-filter value is skipped and named, not compared**
+  (objectui#3196, `@object-ui/core` minor — the other half of #4475). A `date` /
+  `dateRange` value that is neither a known preset nor a parseable date used to fall
+  through to "bare string means equality on that day", so a typo
+  (`defaultValue: 'last_7_dayz'`) reached the backend as `WHERE created_at = $1` and
+  answered `200 OK` with zero rows — indistinguishable from "this range has no data".
+  Such a filter is now dropped with a `console.warn` naming the filter, the offending
+  value and the accepted spellings; the widget's numbers go from 0 to unfiltered.
+- **`record:activity` fetches a feed instead of rendering a permanently empty one**
+  (objectui#3204, `@object-ui/plugin-detail`). The block's eleven declared inputs were
+  filters over a hard-coded `items={[]}`; the feed now resolves from `items` → a
+  mounted `DiscussionContext` → a self-fetch of `sys_activity` scoped to the bound
+  record, and the read-side inputs actually filter. `showSubscriptionToggle` is
+  labelled `NOT IMPLEMENTED` in its own input description rather than left looking
+  configurable.
+- **A fetching activity feed says "loading", not "No activity recorded"**
+  (objectui#3210, `@object-ui/plugin-detail` patch). The declared `loading` prop was
+  destructured into `_loading` and never read, so the panel asserted the record had no
+  activity for the whole duration of every fetch.
+- **`managedBy: 'system'` → `'system-data'` follow-through** (objectui#3214): the
+  Console now speaks the vocabulary this platform's retirement left standing.
+
+Full frontend range below. `fix(ci)` / CI-only commits are omitted — they release
+nothing and are not in the shipped bundle.
+
+- fix(fields)!: FieldWidgetComponentProps stops claiming to have every key (#3221) (#3230)
+- fix(app-shell): inspectors read and write the expression envelope (#3218) (#3228)
+- fix(app-shell): flow simulator evaluates a `{ dialect, source }` edge guard (#3216) (#3217)
+- feat(types,core,app-shell)!: follow the `managedBy: 'system'` → `'system-data'` retirement (objectstack#3355) (#3214)
+- fix(app-shell): flow branch editor stamps an id on the edges it creates (#3202) (#3215)
+- fix(plugin-detail): a fetching activity feed says "loading", not "No activity recorded" (#3205) (#3210)
+- feat(plugin-detail): record:activity fetches a feed instead of rendering an empty one (#3165) (#3204)
+- fix(types,app-shell)!: `reference` 是 action param 唯一可作者化的 picker 目标 (#3174) (#3203)
+- fix(deps): #3184 可合并版 —— focus-scope 栈驱逐竞态补丁,解冲突 + 补丁存废说明 (#3200)
+- fix(core): 未知的 date filter 值改为跳过并警告,不再降级成永不命中的等值 (#3151) (#3196)
+- fix(types): retarget the objectstack#4171 inverted pins at their real trigger (#3177) (#3194)
+- fix(components,grid): a grid's search box searches the list, not the page you can see (#3118) (#3192)
+- feat(core): declare the 18 spec-owned action keys ActionDef absorbed silently (#3190)
+- fix(app-shell): actually compile `spec-symbol-parity.test.ts`'s type assertions (#3181) (#3187)
+- feat(app-shell): wire navigation action items to the console action runtime (framework#4509) (#3180)
+- feat(deps)!: upgrade to @objectstack/spec 17.0.0-rc.1 and retire the wait timeout fields (#3101) (#3178)
+- fix(studio,timeline,list): 表单设计器解析对象翻译；timeline 认它自己配置的日期字段 (#3134, #3129) (#3175)
+- feat(flow-designer)!: the script node authors a function call, and nothing else (framework#4343) (#3170)
+- fix(studio): stop offering the retired `action.shortcut` / `action.bulkEnabled` keys (#3154)
+- fix(dashboard): date 型 globalFilter 的预设名默认值应提升为区间 (objectstack#4475) (#3150)
+- fix(dashboard,report): honor the declared percent scale so a ratio of 1 renders as 100.0% (#3136) (#3140)
+- fix(charts): name the slices — pie/donut legends lost their labels to a `type` dimension (#3135) (#3138)
+- fix(approvals): record-header Reject fires after one dialog again (#3126) (#3128)
+- fix(console): binding-reach 探针少报了自己 6 个块的覆盖面，而且是静默的 (#3149) (#3153)
+- fix(flow-designer): the default path is the edge marker, not the branch (#3148)
+- fix(plugin-list,plugin-form): 在注册表路径上把 dataSource 接到 list-view / embeddable-form (#3144) (#3147)
+- fix(actions): one placement rule for `locations` — declare it or it renders nowhere (#3145)
+- fix(app-shell): datasource preview 不再报告读副本数量 (objectstack#4468) (#3143)
+- feat(grid): aggregate single-call mode for bulk actions — execution: 'aggregate' (#3141)
+- fix(form): `required` is presence, not truthiness — `false` and `0` are values (#3137)
+- fix(environment): localize the entitlement dialog + read cloud's nested error envelope (#3130)
+- fix(i18n): resolve qualified view ids (#3132)
+
+objectui range: `7d9734d5e321...785b8a5d432c`

.changeset/orderby-direction-vocabulary.md

@@ -0,0 +1,14 @@
+---
+"@objectstack/metadata-protocol": patch
+---
+
+fix(metadata-protocol): 元数据审计历史与全局搜索按 `order` 排序,不再按 `direction` (#4674)
+
+`protocol.ts` 里两处内部 `engine.find` 调用把排序写成 `{ field, direction: 'desc' }`。QueryAST 的排序形状是 `SortNodeSchema` = `{ field, order }`,两个真实驱动都只认 `.order` 且没有 `direction` 回退——`undefined === 'desc'` 为假,于是两个查询实际都在**升序**运行。`direction` 是 `IReportService` 的词汇,是另一份契约,这正是错误拼写看起来合理的原因。
+
+由于两个查询都带 `limit`,方向错误不只是把一页重排,而是**改变了哪些行会被返回**:
+
+- **元数据审计历史**取到的是最旧的 `limit` 条事件——一个对象生命的开头,而永远不是它最近的变更。在长期存在的对象上,编辑者要找的东西一条也看不到。
+- **全局搜索**取到的是最陈旧的 `perObject` 条匹配,最近编辑过的记录恰好被 `limit` 截断掉——而那正是搜索者最可能想要的。
+
+两处的 `as any` / `: any` 一并去掉:`EngineQueryOptions.orderBy` 是 `SortNodeSchema[]`,本来就会拒绝 `direction`,而类型擦除正是让它溜过去的原因。恢复类型是这次改动价值的大头,因为对内部调用方来说 `tsc` 就是那条被执行的渠道。

.objectui-sha

@@ -1 +1 @@
-7d9734d5e3212c565d824c717354a4a2fddbfce2
+785b8a5d432cf009389a1a9180fdac2a8297543f

packages/metadata-protocol/src/protocol.orderby-vocabulary.test.ts

@@ -0,0 +1,132 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+//
+// Two internal `engine.find` calls sorted by `direction`, a key nothing on that
+// path reads (#4674).
+//
+// The QueryAST sort shape is `SortNodeSchema` = `{ field, order }`
+// (`packages/spec/src/data/query.zod.ts`), and both real drivers normalize off
+// `.order` with no fallback — `sql-driver` maps `item.order === 'desc'`,
+// `mongodb-driver` the same. With `order` absent, `undefined === 'desc'` is
+// false and both land on ASCENDING. `direction` is `IReportService`'s
+// vocabulary; it is a genuinely different contract, which is how the wrong
+// spelling looked plausible.
+//
+// Because both queries carry a `limit`, the wrong direction did not merely
+// reorder a page — it changed WHICH ROWS CAME BACK. So these tests assert on
+// identity, not sequence: with a limit smaller than the fixture, sorting the
+// wrong way returns a disjoint set. An order-only assertion would have passed
+// against a fake that ignored `orderBy` entirely.
+//
+// Nothing caught this because both sites erased their types (`} as any)` and
+// `const opts: any`), the protocol's `INVALID_SORT` normalizer does not run on
+// calls the protocol makes to `this.engine.find` directly, and that normalizer
+// rejects bad VALUES rather than unknown KEYS — the schema is not `.strict()`,
+// so `direction` was dropped rather than flagged.
+
+import { describe, it, expect, vi } from 'vitest';
+import { ObjectStackProtocolImplementation } from './protocol.js';
+
+/**
+ * A `find` that honours the QueryAST contract for sort and limit, and nothing
+ * else. Filtering is deliberately not implemented: what is under test is which
+ * rows survive `orderBy` + `limit`, and a double that also filtered would let a
+ * sort bug hide behind a `where` that happened to select the right rows.
+ *
+ * It reads `order` — the shape the drivers read. A double that read `direction`
+ * would agree with the bug instead of catching it, which is exactly what the
+ * publish-rollback double did until this change.
+ */
+function makeFind(rowsByObject: Record<string, any[]>) {
+    return vi.fn(async (object: string, opts: any = {}) => {
+        const rows = [...(rowsByObject[object] ?? [])];
+        for (const { field, order } of [...(opts.orderBy ?? [])].reverse()) {
+            rows.sort((a, b) => {
+                const av = a[field], bv = b[field];
+                if (av === bv) return 0;
+                return (av < bv ? -1 : 1) * (order === 'desc' ? -1 : 1);
+            });
+        }
+        return typeof opts.limit === 'number' ? rows.slice(0, opts.limit) : rows;
+    });
+}
+
+/** The options the protocol handed to `engine.find` on its first call. */
+const optionsFrom = (find: any) => find.mock.calls[0][1];
+
+const AUDIT_ROWS = ['2024-01-01', '2024-02-01', '2024-03-01', '2024-04-01', '2024-05-01'].map(
+    (d, i) => ({
+        id: `a${i + 1}`,
+        occurred_at: `${d}T00:00:00.000Z`,
+        actor: 'someone',
+        operation: 'save',
+        outcome: 'allowed',
+        code: 'OK',
+    }),
+);
+
+describe('auditMetaItem sorts newest-first (#4674)', () => {
+    function makeProtocol() {
+        const find = makeFind({ sys_metadata_audit: AUDIT_ROWS });
+        const engine = { registry: { getObject: () => undefined }, find };
+        return { p: new ObjectStackProtocolImplementation(engine as any), find };
+    }
+
+    it('returns the NEWEST `limit` events, not the oldest', async () => {
+        const { p } = makeProtocol();
+        const { events } = await p.auditMetaItem({ type: 'objects', name: 'invoice', limit: 2 });
+
+        // The whole defect in one assertion: ascending returns a1/a2 here.
+        expect(events.map(e => e.id)).toEqual(['a5', 'a4']);
+    });
+
+    it('asks for `order`, never `direction`', async () => {
+        const { p, find } = makeProtocol();
+        await p.auditMetaItem({ type: 'objects', name: 'invoice', limit: 2 });
+
+        const sort = optionsFrom(find).orderBy;
+        expect(sort).toEqual([{ field: 'occurred_at', order: 'desc' }]);
+        // Named explicitly: `direction` reads as a well-formed "sort by
+        // occurred_at, direction unspecified" and passes every existing check.
+        expect(sort[0]).not.toHaveProperty('direction');
+    });
+});
+
+const SEARCH_ROWS = ['2024-01-01', '2024-02-01', '2024-03-01', '2024-04-01'].map((d, i) => ({
+    id: `c${i + 1}`,
+    name: `Acme ${i + 1}`,
+    updated_at: `${d}T00:00:00.000Z`,
+}));
+
+const CONTACT = {
+    name: 'contact',
+    fields: { name: { name: 'name', type: 'text', searchable: true } },
+};
+
+describe('searchAll sorts newest-first (#4674)', () => {
+    function makeProtocol() {
+        const find = makeFind({ contact: SEARCH_ROWS });
+        const engine = {
+            registry: { getObject: (n: string) => (n === 'contact' ? CONTACT : undefined), getAllObjects: () => [CONTACT] },
+            find,
+        };
+        return { p: new ObjectStackProtocolImplementation(engine as any), find };
+    }
+
+    it('returns the most recently updated matches, not the stalest', async () => {
+        const { p } = makeProtocol();
+        const { hits } = await p.searchAll({ q: 'Acme', perObject: 2 });
+
+        // Ascending returned c1/c2 — the stalest rows, with the recently-edited
+        // ones truncated away by `perObject`.
+        expect(hits.map(h => h.id)).toEqual(['c4', 'c3']);
+    });
+
+    it('asks for `order`, never `direction`', async () => {
+        const { p, find } = makeProtocol();
+        await p.searchAll({ q: 'Acme', perObject: 2 });
+
+        const sort = optionsFrom(find).orderBy;
+        expect(sort).toEqual([{ field: 'updated_at', order: 'desc' }]);
+        expect(sort[0]).not.toHaveProperty('direction');
+    });
+});

packages/metadata-protocol/src/protocol.ts

@@ -25,7 +25,7 @@ import {
     SEARCHABLE_TEXTUAL_TYPES, SEARCHABLE_ENUM_TYPES, SEARCH_AUTO_EXCLUDED_FIELDS,
     RPC_QUERY_ALIAS_SLOTS, foldQueryAliasSlots,
     type QueryAliasConflict, type QueryAliasSlot,
-    type DroppedFieldsEvent, type QueryAST,
+    type DroppedFieldsEvent, type QueryAST, type EngineQueryOptions,
 } from '@objectstack/spec/data';
 import { PLURAL_TO_SINGULAR, SINGULAR_TO_PLURAL } from '@objectstack/spec/shared';
 import { applyConversionsToStoredItem, type ConversionNotice } from '@objectstack/spec';
@@ -3377,11 +3377,20 @@ export class ObjectStackProtocolImplementation implements
                 type: singular,
                 name: request.name,
             };
+            // `order`, NOT `direction`: the QueryAST sort shape is
+            // `SortNodeSchema` = `{ field, order }`, and both drivers normalize
+            // off `.order` with no fallback. `direction` is `IReportService`'s
+            // vocabulary and is silently DROPPED here (the schema is not
+            // `.strict()`), which left this query running ascending — the
+            // OLDEST `limit` audit events, i.e. the beginning of an object's
+            // life and never its recent changes (#4674). The `as any` is gone
+            // for the same reason: `EngineQueryOptions` rejects the wrong key,
+            // and erasing the type is what let it through.
             const rows = await this.engine.find('sys_metadata_audit', {
                 where,
-                orderBy: [{ field: 'occurred_at', direction: 'desc' }],
+                orderBy: [{ field: 'occurred_at', order: 'desc' }],
                 limit,
-            } as any);
+            });
             const events = (Array.isArray(rows) ? rows : []).map((r: any) => ({
                 id: r.id,
                 occurredAt:
@@ -5164,10 +5173,15 @@ export class ObjectStackProtocolImplementation implements
             const where = andClauses.length === 1 ? andClauses[0] : { $and: andClauses };
 
             try {
-                const opts: any = {
+                // `order`, NOT `direction` — see the audit-history query above.
+                // Ascending here returned the STALEST `perObject` matches and
+                // truncated away the recently-edited records a searcher is most
+                // likely to want (#4674). Typed rather than `any` so the
+                // contract rejects the wrong key at the call site.
+                const opts: EngineQueryOptions = {
                     where,
                     limit: perObject,
-                    orderBy: [{ field: 'updated_at', direction: 'desc' }],
+                    orderBy: [{ field: 'updated_at', order: 'desc' }],
                 };
                 if (request.context !== undefined) opts.context = request.context;
 

packages/objectql/src/protocol-publish-rollback.test.ts

@@ -82,12 +82,21 @@ function makeStubEngine() {
         async find(table: string, opts: { where: Record<string, unknown> }) {
             if (table === 'sys_metadata_history') {
                 const out = historyRows.filter((h) => matchesHistory(h, opts.where));
-                if (opts && (opts as any).orderBy) {
-                    const { field, direction } = (opts as any).orderBy;
+                // QueryAST shape: `orderBy` is an ARRAY of `{ field, order }`
+                // (SortNodeSchema). This double used to destructure
+                // `{ field, direction }` off the array itself, so both names
+                // read `undefined` — it spoke the `direction` vocabulary the
+                // engine does not read (#4674) AND, because an array has no
+                // `.field`, sorted nothing at all. Either way a test built on
+                // it would have ratified the broken behaviour.
+                const orderBy = (opts as any).orderBy;
+                if (Array.isArray(orderBy) && orderBy.length > 0) {
                     out.sort((a: any, b: any) => {
-                        const av = a[field]; const bv = b[field];
-                        if (av < bv) return direction === 'desc' ? 1 : -1;
-                        if (av > bv) return direction === 'desc' ? -1 : 1;
+                        for (const { field, order } of orderBy) {
+                            const av = a[field]; const bv = b[field];
+                            if (av < bv) return order === 'desc' ? 1 : -1;
+                            if (av > bv) return order === 'desc' ? -1 : 1;
+                        }
                         return 0;
                     });
                 }