@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/fake/form.js

@@ -0,0 +1,101 @@
+import { capabilityShapeError } from "../capability-shape.js";
+import { CAPABILITY_CONTROL_TYPES } from "../capability-shape.js";
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+/** form-publish-chain lane: default-form draft/publish. Twin of src/lanes/form.ts. */
+export const formRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/bizsheet/get": {
+            const sheet = ctx.state.sheets.get(q.sheetCode);
+            if (!sheet)
+                return null;
+            const name = q.sheetCode;
+            return {
+                id: `sheet-${q.sheetCode}`,
+                sheetCode: sheet.sheetCode,
+                code: sheet.sheetCode,
+                name,
+                sheetType: 0,
+                existDraft: sheet.existDraft,
+                published: sheet.published,
+                draftViewJson: sheet.draftViewJson ?? null,
+                draftAttributesJson: sheet.draftAttributesJson ?? null,
+                draftHtmlJson: sheet.draftHtmlJson ?? null,
+                // Ticket 100: real bizsheet columns (BizForm.java:95-100); the
+                // designer writes draftActionsJson on save and both faces on publish
+                // (frontend-dist/admin/js/4280.cfa75764.js offsets 193538/185347).
+                draftActionsJson: sheet.draftActionsJson ?? null,
+                publishedViewJson: sheet.publishedViewJson ?? null,
+                publishedAttributesJson: sheet.publishedAttributesJson ?? null,
+                publishedActionsJson: sheet.publishedActionsJson ?? null,
+                publishedHtmlJson: sheet.publishedHtmlJson ?? null,
+                binding: { fieldCodes: sheet.fieldCodes },
+            };
+        }
+        case "/api/api/app/bizsheet/create": {
+            const code = String(body.code ?? body.sheetCode);
+            if (!ctx.state.sheets.has(code))
+                ctx.state.sheets.set(code, { sheetCode: code, existDraft: false, published: false, draftHtmlJson: "[]", fieldCodes: [] });
+            return null;
+        }
+        case "/api/api/app/bizsheet/update": {
+            let attributes = {};
+            if (typeof body.draftAttributesJson === "string") {
+                try {
+                    attributes = JSON.parse(body.draftAttributesJson);
+                }
+                catch {
+                    return businessRefusal(50000, "draftAttributesJson 不是合法 JSON");
+                }
+            }
+            for (const [fieldCode, control] of Object.entries(attributes)) {
+                const controlType = Number(control.type);
+                const propertyType = Object.entries(CAPABILITY_CONTROL_TYPES).find(([, value]) => value === controlType)?.[0];
+                if (propertyType === undefined)
+                    continue;
+                const options = control.options && typeof control.options === "object" ? control.options : {};
+                const shapeError = capabilityShapeError(Number(propertyType), "control", options);
+                if (shapeError)
+                    return businessRefusal(50000, `${fieldCode}: ${shapeError}`);
+            }
+            const code = String(body.code ?? body.sheetCode);
+            const existing = ctx.state.sheets.get(code) ?? {
+                sheetCode: code,
+                existDraft: false,
+                published: false,
+                draftHtmlJson: "[]",
+                fieldCodes: [],
+            };
+            ctx.state.sheets.set(code, {
+                ...existing,
+                existDraft: true,
+                draftViewJson: body.draftViewJson ?? existing.draftViewJson ?? null,
+                draftAttributesJson: body.draftAttributesJson ?? existing.draftAttributesJson ?? null,
+                fieldCodes: typeof body.draftAttributesJson === "string" ? Object.keys(attributes) : existing.fieldCodes,
+                draftActionsJson: body.draftActionsJson ?? existing.draftActionsJson ?? null,
+                // draftHtmlJson holds the COMPLETE layout JSON array (including the
+                // customScript element when present). Default to "[]" on first
+                // draft so onlinejs.compose can parse it as an array.
+                draftHtmlJson: body.draftHtmlJson ?? existing.draftHtmlJson ?? "[]",
+            });
+            return null;
+        }
+        case "/api/api/app/bizsheet/publish": {
+            const code = String(body.code ?? body.sheetCode);
+            const sheet = ctx.state.sheets.get(code);
+            if (sheet) {
+                sheet.published = true;
+                sheet.existDraft = false;
+                sheet.publishedViewJson = sheet.draftViewJson ?? null;
+                sheet.publishedAttributesJson = sheet.draftAttributesJson ?? null;
+                sheet.publishedActionsJson = body.publishedActionsJson ?? "[]";
+                sheet.publishedHtmlJson = sheet.draftHtmlJson ?? "[]";
+            }
+            return null;
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=form.js.map

package/dist/fake/index.js

@@ -0,0 +1,121 @@
+import { dispatchFakeRoute } from "./routes.js";
+import { createFakeState, isBusinessRefusal, isMalformedEnvelope, isRawResponse } from "./state.js";
+export { FAKE_RSA_PUBLIC_KEY } from "./state.js";
+/**
+ * In-memory fake CloudPivot 8.6 for offline CLI tests: implements the auth
+ * flow and every live-proven endpoint the tool surface drives. Supports
+ * failure injection (transport outage, non-8.6 version, business errcode).
+ *
+ * The wire behavior is split into one route module per configuration lane
+ * under ./fake/, mirroring src/lanes/*; this class owns the shared store,
+ * the failure-injection flags, and the seed/readback test accessors.
+ */
+export class FakeCloudPivot {
+    options;
+    state;
+    transportDown = false;
+    businessFailure = null;
+    /** Round-2 T-06: inject a RAW (non-errcode) response body to exercise malformed-envelope diagnostics. */
+    malformedResponse = null;
+    /** When true, /api/api/runtime/form/submit returns no objectId for formType=2. */
+    forceSubmitMissingObjectId = false;
+    forceSubmitMismatchedObjectId = false;
+    omitDraftSaveWorkItem = false;
+    constructor(options = {}) {
+        this.options = options;
+        this.state = createFakeState(options);
+    }
+    /** Test accessor: the stored default-form draft for a schema (undefined if none). */
+    sheetDraft(schemaCode) {
+        return this.state.sheets.get(schemaCode);
+    }
+    /** Test accessor: the last request body for the given path (or undefined). */
+    lastBody(path) {
+        for (let i = this.state.callLog.length - 1; i >= 0; i -= 1) {
+            if (this.state.callLog[i].path === path)
+                return this.state.callLog[i].body;
+        }
+        return undefined;
+    }
+    /** Test accessor: every recorded request body for the given path (in order). */
+    bodiesFor(path) {
+        return this.state.callLog.filter((entry) => entry.path === path).map((entry) => entry.body);
+    }
+    queriesFor(path) {
+        return this.state.callLog.filter((entry) => entry.path === path).map((entry) => entry.query);
+    }
+    seedRule(rule) {
+        const id = rule.id ?? `rule-${this.state.rules.size + 1}`;
+        this.state.rules.set(`${rule.schemaCode}#${rule.code}`, {
+            ...rule,
+            id,
+            schemaCode: rule.schemaCode,
+            code: rule.code,
+            name: rule.name ?? rule.code,
+            enabled: rule.enabled ?? false,
+        });
+    }
+    seedDataRow(schemaCode, data, id = `row-${this.state.dataRows.size + 1}`) {
+        this.state.dataRows.set(id, { bizObjectId: id, schemaCode, ...data });
+    }
+    /**
+     * Reproduce ticket 07: mark a model's default list view as having no
+     * configured columns. Subsequent /runtime/query/list responses drop business
+     * columns from `data` (they read back null) though seedDataRow stored them.
+     */
+    markListViewUnconfigured(schemaCode) {
+        this.state.unconfiguredListViews.add(schemaCode);
+    }
+    seedApp(app) {
+        this.state.apps.set(app.code, {
+            id: app.id ?? `app-${this.state.apps.size + 1}`,
+            code: app.code,
+            name: app.name ?? app.code,
+            groupId: app.groupId ?? [...this.state.appGroups.keys()][0] ?? "group-1",
+            ...(app.published !== undefined ? { published: app.published } : {}),
+        });
+    }
+    seedField(schemaCode, code, propertyType, published = true) {
+        this.state.fields.set(`${schemaCode}#${code}`, { code, name: code, type: String(propertyType), published });
+    }
+    async request(input) {
+        this.state.callLog.push({
+            path: input.path,
+            method: input.method,
+            body: input.body,
+            query: input.query,
+            ...(input.multipart !== undefined ? { multipart: { filename: input.multipart.filename, contentType: input.multipart.contentType, bytes: input.multipart.content.length } } : {}),
+        });
+        if (this.transportDown)
+            throw new Error("simulated transport outage");
+        if (this.businessFailure && input.path.includes(this.businessFailure.pathFragment))
+            return { status: 200, body: { errcode: this.businessFailure.errcode, errmsg: "simulated business refusal", data: null } };
+        if (this.malformedResponse && input.path.includes(this.malformedResponse.pathFragment))
+            return { status: 200, body: this.malformedResponse.body };
+        const handler = this.route(input);
+        if (isBusinessRefusal(handler))
+            return { status: 200, body: { errcode: handler.errcode, errmsg: handler.errmsg, data: null } };
+        // Ticket 76: raw-envelope passthrough for platforms answers that carry no
+        // numeric errcode (workflow/create duplicate-schema live shape).
+        if (isMalformedEnvelope(handler))
+            return { status: 200, body: handler.payload };
+        // Ticket 106: non-envelope bodies (upload refId plain string, export ZIP
+        // bytes) pass through verbatim.
+        if (isRawResponse(handler))
+            return { status: 200, body: handler.payload };
+        if (handler === undefined)
+            return { status: 404, body: { errcode: 404, errmsg: "not found", data: null } };
+        return { status: 200, body: { errcode: 0, errmsg: "ok", data: handler } };
+    }
+    route(input) {
+        const ctx = {
+            state: this.state,
+            options: this.options,
+            forceSubmitMissingObjectId: this.forceSubmitMissingObjectId,
+            forceSubmitMismatchedObjectId: this.forceSubmitMismatchedObjectId,
+            omitDraftSaveWorkItem: this.omitDraftSaveWorkItem,
+        };
+        return dispatchFakeRoute(ctx, input);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/fake/list-view.js

@@ -0,0 +1,289 @@
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+import { QUERY_ACTION_RELATIVE, QUERY_ACTION_TYPE, validateButtonActionConfig } from "../lanes/list-view-shapes.js";
+/**
+ * BizQueryController.dealHistoryDataOfButton (8.6.26 :535-631) injects these
+ * default query actions on the query/get read face when the stored view lacks
+ * them, so readback from a view that was never configured with actions still
+ * carries the platform buttons. The tool filters/decodes them; the fake mirrors
+ * the injection so unit tests see the same shape as live. Enum numbers come
+ * from the shared list-view shape descriptors (ticket 53).
+ */
+const PLATFORM_DEFAULT_ACTIONS = [
+    { actionCode: "qr_code", name: "打印二维码", queryActionType: QUERY_ACTION_TYPE.index.QR_CODE, sortKey: 7, icon: "plus", associationType: QUERY_ACTION_RELATIVE.index.BIZSHEET, associationCode: "__schema__", clientType: null },
+    { actionCode: "batch_print", name: "批量打印", queryActionType: QUERY_ACTION_TYPE.index.BATCH_PRINT, sortKey: 6, icon: "plus", associationType: QUERY_ACTION_RELATIVE.index.BIZSHEET, associationCode: "__schema__", clientType: null },
+    { actionCode: "batch_update", name: "批量修改", queryActionType: QUERY_ACTION_TYPE.index.BATCH_UPDATE, sortKey: 3, icon: "plus", associationType: QUERY_ACTION_RELATIVE.index.BIZSHEET },
+    { actionCode: "import_attachment", name: "导入附件", queryActionType: QUERY_ACTION_TYPE.index.IMPORT_ATTACHMENT, sortKey: 10, icon: "upload" },
+    { actionCode: "export_attachment", name: "导出附件", queryActionType: QUERY_ACTION_TYPE.index.EXPORT_ATTACHMENT, sortKey: 11, icon: "download" },
+    { actionCode: "batch_submit", name: "批量提交", queryActionType: QUERY_ACTION_TYPE.index.BATCH_SUBMIT, sortKey: 3, icon: "plus" },
+];
+/**
+ * Live 2026-09-17: a freshly created PC LIST view is seeded with STORED
+ * actions (not merely injected on read): add/delete/import/export/editowner.
+ * Measured on two un-configured views (eq_repair_order, a fresh model's
+ * default view) whose read face carries the full 11 (these 5 stored + the 6
+ * injected below). Because `query/update` REPLACES actions, configuring one
+ * action used to delete these five — the list then rendered with NO Add
+ * button. The fake must seed them or a regression cannot be caught.
+ */
+const DEFAULT_STORED_ACTIONS = [
+    { actionCode: "add", name: "新增", queryActionType: QUERY_ACTION_TYPE.index.ADD, icon: "plus" },
+    { actionCode: "delete", name: "删除", queryActionType: QUERY_ACTION_TYPE.index.DELETE, icon: "delete" },
+    { actionCode: "import", name: "导入", queryActionType: QUERY_ACTION_TYPE.index.IMPORT, icon: "upload" },
+    { actionCode: "export", name: "导出", queryActionType: QUERY_ACTION_TYPE.index.EXPORT, icon: "download" },
+    { actionCode: "editowner", name: "修改拥有者", queryActionType: QUERY_ACTION_TYPE.index.EDITOWNER, icon: "plus" },
+];
+function seedStoredActions(view) {
+    if (view.queryActions !== undefined)
+        return;
+    view.queryActions = DEFAULT_STORED_ACTIONS.map((action) => ({ ...action, schemaCode: view.schemaCode, clientType: "PC", associationType: action.actionCode === "add" ? QUERY_ACTION_RELATIVE.index.BIZSHEET : undefined, associationCode: action.actionCode === "add" ? view.schemaCode : undefined }));
+}
+function injectDefaultActions(schemaCode, stored) {
+    const actions = stored.map((action) => ({ ...action }));
+    const hasType = (type) => actions.some((action) => action.queryActionType === type);
+    const hasImportExport = hasType(21) || hasType(22);
+    for (const template of PLATFORM_DEFAULT_ACTIONS) {
+        const type = Number(template.queryActionType);
+        if (type === 21 || type === 22) {
+            if (hasImportExport)
+                continue;
+        }
+        else if (hasType(type))
+            continue;
+        const row = { ...template, schemaCode };
+        if (row.associationCode === "__schema__")
+            row.associationCode = schemaCode;
+        if (row.clientType === undefined)
+            row.clientType = "PC";
+        actions.push(row);
+    }
+    return actions;
+}
+/**
+ * BizQueryController.executeReSetQueryActionsSortKey (:962-998) resets sortKey
+ * to i+1 and backfills queryId/schemaCode/clientType; ModelManagementFacadeImpl
+ * .updateBizQuery (:1977-1987) copies a PC `add` action with a relativeCode to
+ * an APP `add`. The fake mirrors both so readback matches live.
+ */
+function normalizeStoredActions(bodyActions, clientType, schemaCode) {
+    const actions = bodyActions.map((action, index) => ({
+        ...action,
+        sortKey: index + 1,
+        clientType,
+        schemaCode,
+        // Persisted BizQueryAction boolean columns default to false (observed live);
+        // platform-injected read-face actions are not persisted, so they stay null.
+        systemAction: action.systemAction ?? false,
+        customService: action.customService ?? false,
+    }));
+    for (const action of actions) {
+        if (action.actionCode === "add" && (action.associationCode === undefined || action.associationCode === null || action.associationCode === "")) {
+            action.associationType = QUERY_ACTION_RELATIVE.index.BIZSHEET;
+            action.associationCode = schemaCode;
+        }
+    }
+    if (clientType === "PC") {
+        const pcAdd = actions.find((action) => action.actionCode === "add" && action.clientType === "PC" && action.associationCode != null);
+        if (pcAdd) {
+            const existing = actions.findIndex((action) => action.clientType === "APP" && action.actionCode === "add");
+            if (existing >= 0)
+                actions.splice(existing, 1);
+            actions.push({ ...pcAdd, clientType: "APP", sortKey: actions.length + 1 });
+        }
+    }
+    return actions;
+}
+/**
+ * BizButtonFacadeImpl.addBizButtonList(String,String,ButtonTriggerType,String)
+ * (8.6.26 :112-137) returns early on a blank `customButtonJson`, so an omitted
+ * key leaves the stored buttons untouched; a JSON array fully replaces them
+ * (batchDeleteByTrigger then re-add), forcing schemaCode/triggerType QUERY/
+ * triggerCode view code and sortKey = array index. The fake mirrors that so the
+ * query/update round trip matches live.
+ */
+function replaceStoredButtons(customButtonJson, schemaCode, triggerCode) {
+    if (typeof customButtonJson !== "string" || customButtonJson.trim() === "")
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(customButtonJson);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed))
+        return undefined;
+    for (const button of parsed) {
+        if (!button || typeof button !== "object" || Array.isArray(button))
+            return undefined;
+        try {
+            validateButtonActionConfig(button);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return parsed.map((button, index) => ({
+        ...button,
+        schemaCode: button.schemaCode ?? schemaCode,
+        triggerType: "QUERY",
+        triggerCode,
+        sortKey: index,
+    }));
+}
+/** W1-list-view lane: design-time query views. Twin of src/lanes/list-view.ts. */
+export const listViewRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/query/create": {
+            const code = String(body.code ?? `view-${ctx.state.listViews.size + 1}`);
+            // Live fidelity (ticket 81): creating a view whose code already exists
+            // answers 303002 编码重复 — a post-timeout retry hits exactly this.
+            const existing = ctx.state.listViews.get(code);
+            if (existing && existing.schemaCode === String(body.schemaCode ?? ""))
+                return businessRefusal(303002, `编码重复：${code}`);
+            const created = { code, name: String(body.name), schemaCode: String(body.schemaCode ?? ""), queryColumns: [] };
+            seedStoredActions(created);
+            ctx.state.listViews.set(code, created);
+            return { code };
+        }
+        case "/api/api/app/query/get_header": {
+            const view = ctx.state.listViews.get(q.code);
+            return view
+                ? { id: `view-${view.code}`, code: view.code, name: view.name, schemaCode: view.schemaCode, type: "LIST", showOnPc: false, publish: view.publish === true, ...(view.queryPresentationType !== undefined ? { queryPresentationType: view.queryPresentationType } : {}) }
+                : null;
+        }
+        case "/api/api/app/query/update_header": {
+            // BizQueryController.updateHeader → updateBizQuery(BizQueryHeaderModel):
+            // a PLAIN header update with NO publish gate (unlike /query/update, whose
+            // body-driven queryPresentationType assignment is skipped once the view
+            // is published — the BUG-11 live root cause).
+            const code = String(body.code ?? "");
+            const view = ctx.state.listViews.get(code);
+            if (!view)
+                return null;
+            if (body.queryPresentationType !== undefined)
+                view.queryPresentationType = body.queryPresentationType;
+            if (typeof body.name === "string")
+                view.name = body.name;
+            if (typeof body.publish === "boolean")
+                view.publish = body.publish;
+            return { code, queryPresentationType: view.queryPresentationType ?? null };
+        }
+        case "/api/api/app/query/get": {
+            // Live shape: every model owns a default list view (code = schemaCode)
+            // that starts without business columns. Lazy-create on first fetch.
+            // BizQueryFacadeImpl.getBizQuery sets model.clientType from the request
+            // (query/get requires it; query/update refuses a null clientType), so the
+            // fake echoes it too.
+            const schemaCode = String(q.schemaCode ?? "");
+            const code = String(q.code ?? schemaCode);
+            let view = ctx.state.listViews.get(code);
+            if (!view && code === schemaCode) {
+                // Live: a model's default view is created PUBLISHED (h_biz_query.publish=1).
+                view = { code, name: code, schemaCode, queryColumns: [], publish: true };
+                seedStoredActions(view);
+                ctx.state.listViews.set(code, view);
+            }
+            if (!view)
+                return null;
+            // BizQueryFacadeImpl.getBizQuery overwrites a condition's stored options
+            // with the field's own options before readback, so the read face is
+            // field-derived rather than the persisted condition value.
+            const queryConditions = view.queryConditions?.map((condition) => {
+                const propertyCode = String(condition.propertyCode ?? "");
+                const field = propertyCode.includes(".") ? undefined : ctx.state.fields.get(`${view.schemaCode || schemaCode}#${propertyCode}`);
+                return { ...condition, options: field?.options ?? null };
+            });
+            const clientType = String(q.clientType ?? "PC");
+            const queryActions = clientType === "PC" ? injectDefaultActions(view.schemaCode || schemaCode, view.queryActions ?? []) : view.queryActions;
+            return {
+                id: `view-${code}`,
+                code: view.code,
+                name: view.name,
+                schemaCode: view.schemaCode || schemaCode,
+                clientType,
+                queryColumns: view.queryColumns,
+                ...(view.options !== undefined ? { options: view.options } : {}),
+                ...(view.queryPresentationType !== undefined ? { queryPresentationType: view.queryPresentationType } : {}),
+                ...(view.queryGanttModel !== undefined ? { queryGanttModel: view.queryGanttModel } : {}),
+                ...(view.queryLayer !== undefined ? { queryLayer: view.queryLayer } : {}),
+                ...(view.multiTableHeaderConfig !== undefined ? { multiTableHeaderConfig: view.multiTableHeaderConfig } : {}),
+                ...(view.querySorts ? { querySorts: view.querySorts } : {}),
+                ...(queryConditions ? { queryConditions } : {}),
+                ...(queryActions && queryActions.length > 0 ? { queryActions } : {}),
+                ...(view.queryPresentation ? { queryPresentation: view.queryPresentation } : {}),
+                ...(view.customButtons ? { customButtons: view.customButtons } : {}),
+            };
+        }
+        case "/api/api/app/query/update": {
+            const code = String(body.code ?? "");
+            const view = ctx.state.listViews.get(code);
+            if (!view)
+                return null;
+            // BizQueryController.update calls validateNotEmptyGantt (:1121-1136) before
+            // updateBizQuery: a GANTT view requires queryGanttModel with non-null
+            // startTime/endTime/title codes.
+            if (body.queryPresentationType === "GANTT") {
+                const gantt = body.queryGanttModel;
+                if (!gantt || typeof gantt !== "object")
+                    return businessRefusal(10005, "甘特图参数不能为空");
+                if (gantt.startTimePropertyCode == null)
+                    return businessRefusal(10005, "甘特图开始时间映射参数不能为空！");
+                if (gantt.endTimePropertyCode == null)
+                    return businessRefusal(10005, "甘特图结束时间映射参数不能为空！");
+                if (gantt.titlePropertyCode == null)
+                    return businessRefusal(10005, "甘特图标题映射参数不能为空！");
+            }
+            if (Array.isArray(body.queryColumns))
+                view.queryColumns = body.queryColumns;
+            // BizQueryModel.options (String) is replaced whenever the update body
+            // carries the key; an omitted key leaves it untouched (updateBizQuery's
+            // name/options diff branch, ModelManagementFacadeImpl:1966-1973).
+            if (body.options !== undefined)
+                view.options = body.options;
+            // BizQueryHeaderModel.queryPresentationType is assigned by updateBizQuery
+            // (:1955) but the entity update block is SKIPPED when the stored view is
+            // published (ModelManagementFacadeImpl:1998-2010) — a live-verified
+            // silent drop (BUG-11). The tool must therefore drive /update_header for
+            // an already-published view.
+            if (body.queryPresentationType !== undefined && view.publish !== true)
+                view.queryPresentationType = body.queryPresentationType;
+            // saveBizQueryDetail only swaps queryGantt when the submitted model is
+            // non-null (:178-183), so an omitted key leaves the stored gantt.
+            if (body.queryGanttModel && typeof body.queryGanttModel === "object")
+                view.queryGanttModel = body.queryGanttModel;
+            // saveBizQueryDetail assigns queryLayer/multiTableHeaderConfig
+            // unconditionally (:184-186); the tool only sends them when configured.
+            if (Array.isArray(body.queryLayer))
+                view.queryLayer = body.queryLayer;
+            if (body.multiTableHeaderConfig !== undefined)
+                view.multiTableHeaderConfig = body.multiTableHeaderConfig;
+            if (Array.isArray(body.querySorts))
+                view.querySorts = body.querySorts;
+            if (Array.isArray(body.queryConditions))
+                view.queryConditions = body.queryConditions;
+            if (Array.isArray(body.queryActions)) {
+                view.queryActions = normalizeStoredActions(body.queryActions, String(body.clientType ?? "PC"), String(body.schemaCode ?? view.schemaCode ?? ""));
+            }
+            // BizQueryDetailServiceImpl.saveBizQueryDetail removes every presentation
+            // whose clientType matches and re-adds the submitted one; an omitted
+            // presentation (absent body key) leaves the stored one untouched.
+            if (body.queryPresentation && typeof body.queryPresentation === "object") {
+                view.queryPresentation = body.queryPresentation;
+            }
+            const buttons = replaceStoredButtons(body.customButtonJson, String(body.schemaCode ?? view.schemaCode ?? ""), code);
+            if (buttons !== undefined)
+                view.customButtons = buttons;
+            return { code: view.code };
+        }
+        case "/api/api/app/query/list":
+            return [...ctx.state.listViews.values()].map((view) => ({ code: view.code, name: view.name }));
+        case "/api/api/app/query/delete":
+            ctx.state.listViews.delete(q.code);
+            return null;
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=list-view.js.map

package/dist/fake/model.js

@@ -0,0 +1,136 @@
+import { relationTargetOf } from "../field-families.js";
+import { MODEL_REFERENCED_DELETE_ERRCODE } from "../lanes/model-contract.js";
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+/** model-management lane: app tree, model CRUD, physical delete. Twin of src/lanes/model.ts. */
+export const modelRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/app/apppackage/trees": {
+            // Live fidelity (ticket 68): the tree row id is the AppFunction id, not
+            // the biz-model record id; appCode filters the tree, treeHidden models
+            // keep a record but no tree node. Ticket 83: rows carry parentId (live
+            // AppFunctionModel shape; bizmodels/update requires it) and the node
+            // display name comes from nodeName (the menu node is renamed
+            // independently of the schema record).
+            const appCode = q.appCode === undefined ? undefined : String(q.appCode);
+            // Live 8.6.26 fidelity (2026-09-17): the tree is NESTED — a Folder row
+            // carrying its BizModel children — not a flat list. The environment lane
+            // used a top-level map and silently dropped every model, so a live
+            // discover_environment with applicationCode returned no models. Consumers
+            // must flattenTreeRows (as resolveModelTreeNode already does); the fake
+            // must nest so a regression cannot pass.
+            const children = [...ctx.state.models.values()]
+                .filter((model) => !model.treeHidden && (appCode === undefined || (model.appCode ?? "test") === appCode))
+                .map((model) => ({ id: model.id, type: "BizModel", code: model.code, name: model.nodeName ?? model.name, parentId: "folder-1" }));
+            return [{ id: "folder-1", type: "FOLDER", code: "general", name: "General", children }];
+        }
+        case "/api/api/app/bizmodels/list_schema":
+            return [...ctx.state.models.values()].map((model) => ({ id: model.recordId, schemaCode: model.code, name: model.name }));
+        case "/api/api/app/bizmodels/create": {
+            const code = String(body.bizSchemaCode ?? body.code);
+            const n = ctx.state.models.size + 1;
+            ctx.state.models.set(code, {
+                id: `model-${n}-fn`,
+                recordId: `model-${n}-rec`,
+                code,
+                name: String(body.name ?? code),
+                appCode: String(body.applicationCode ?? body.appCode ?? "test"),
+            });
+            // Live fidelity (ticket 42): bizmodels/create seeds NO form — the model
+            // has no h_biz_sheet row until the form is created (bizsheet/create, or
+            // form.draft's scaffold-on-absent path). Do not pre-seed a sheet here.
+            return { schemaCode: code };
+        }
+        case "/api/api/app/apppackage/physically_delete": {
+            const rows = Array.isArray(input.body) ? input.body : [];
+            for (const row of rows) {
+                if (row.type === undefined || row.type === null || row.type === "") {
+                    ctx.state.apps.delete(String(row.code));
+                    continue;
+                }
+                const code = String(row.code);
+                // deleteFunctions semantics (ticket 23): a model referenced by
+                // another model's relation field cannot be deleted. Live: the sync
+                // face answers errcode 0 and the async dispatcher fails with
+                // ServiceException "xxx被模型 yyy 引用,不能删除"
+                // (AppIntegrationFacadeImpl.deleteFunctions:2201); the fake surfaces
+                // the check synchronously (MODEL_REFERENCED_DELETE_ERRCODE stands for
+                // the ServiceException envelope family) so the blocker and the
+                // referencing list are visible even when a caller bypasses the tool
+                // precheck. The live per-column async cascade (3-4s/column) is not
+                // simulated — the fake removes the model synchronously.
+                const referencers = [
+                    ...new Set([...ctx.state.fields.entries()]
+                        .filter(([key, field]) => !key.startsWith(`${code}#`) && relationTargetOf(field) === code)
+                        .map(([key]) => key.split("#")[0])),
+                ];
+                if (referencers.length > 0)
+                    return businessRefusal(MODEL_REFERENCED_DELETE_ERRCODE, `${code}被模型 ${referencers.join(",")} 引用,不能删除`);
+                // Ticket 68 live fidelity: physically_delete resolves each row id as an
+                // AppFunction id (removeBizModel → getAppFunction(id)); a biz-model
+                // record id is refused with 601003 业务模型不存在.
+                const model = ctx.state.models.get(code);
+                if (model && row.id !== model.id)
+                    return businessRefusal(601003, "业务模型不存在");
+                ctx.state.models.delete(code);
+                ctx.state.sheets.delete(code);
+                // The cascade drops the model's own bizproperty rows too — without
+                // this cleanup a deleted referencing model would keep blocking the
+                // referenced model's delete (dependency-inverted chains must pass).
+                for (const key of [...ctx.state.fields.keys()])
+                    if (key.startsWith(`${code}#`))
+                        ctx.state.fields.delete(key);
+            }
+            return null;
+        }
+        case "/api/api/app/bizmodels/exits_bizschema":
+            return ctx.state.models.has(q.schemaCode);
+        case "/api/api/app/bizmodels/get_summary":
+            // BizSchemaController.get_summary: an absent schema answers "" (ok), an
+            // existing one returns its summary string.
+            return ctx.state.models.get(q.schemaCode)?.summary ?? "";
+        case "/api/api/app/bizmodels/update_summary": {
+            // BizSchemaController.updateSummary: non-empty summary required
+            // (validateNotEmpty) and a missing schema answers the
+            // BIZ_SCHEMA_NOT_PUBLISHED errcode (ErrorCode.java:194 → 300014).
+            const schemaCode = String(body.schemaCode ?? "");
+            if (!ctx.state.models.has(schemaCode))
+                return businessRefusal(300014, "数据模型未发布");
+            const model = ctx.state.models.get(schemaCode);
+            model.summary = String(body.summary ?? "");
+            return null;
+        }
+        case "/api/api/app/bizmodels/get_all": {
+            const model = ctx.state.models.get(q.schemaCode);
+            return model ? { id: model.recordId, name: model.name, modelType: "LIST" } : null;
+        }
+        case "/api/api/app/bizmodels/update": {
+            // Ticket 83 (source-pinned BizSchemaController.update :266-305): the
+            // endpoint patches the AppFunction MENU NODE — bizSchemaCode, id, name,
+            // parentId are all validateNotEmpty-required; the schema RECORD is not
+            // migrated (get_all keeps the original name/type per probe evidence),
+            // so the rename lands on nodeName only.
+            const schemaCode = String(body.bizSchemaCode ?? body.schemaCode ?? "");
+            const model = ctx.state.models.get(schemaCode);
+            if (!model)
+                return businessRefusal(300014, "数据模型未发布");
+            const nodeId = String(body.id ?? "");
+            const name = String(body.name ?? "");
+            const parentId = String(body.parentId ?? "");
+            if (!nodeId)
+                return businessRefusal(10005, "id不能为空");
+            if (!name)
+                return businessRefusal(10005, "名称不能为空");
+            if (!parentId)
+                return businessRefusal(10005, "父id不可为空");
+            if (nodeId !== model.id)
+                return businessRefusal(10005, `id不是模型 ${schemaCode} 的应用树节点`);
+            model.nodeName = name;
+            return null;
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=model.js.map