@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/fake/runtime-data.js

@@ -0,0 +1,367 @@
+import { ENGINE_OWNED_KEYS, RUNTIME_DATA_WIRE, RUNTIME_QUERY_OPERATORS, SUBMIT_STATUS_TRANSITIONS } from "../lanes/runtime-data-contract.js";
+import { applyBusinessRules } from "./businessrule.js";
+import { businessRefusal, NOT_HANDLED } from "./state.js";
+import { completeWorkItem, spawnApprovalWorkItem, startWorkflowDraft, startWorkflowInstance } from "./workflow.js";
+/**
+ * verifyReplay (ticket 22 source evidence): the platform registers tokens in
+ * Redis via getReplayToken->disposeReplay and consumes them single-use —
+ * blank or unknown token -> SYS_REPLAY_ERROR 100005 "频繁重复提交！" (ErrorCode.java:68,
+ * RedisCacheService.verifyFormId deletes on success). Only the two start
+ * branches run this gate (AbstractFormRuntimeController.handleSubmit workflowCode
+ * branch; FormRuntimeController.saveWorkflow isStartWf) — formType=2 and
+ * workItemId approval submits never check it.
+ */
+function verifyReplayToken(state, body) {
+    const token = typeof body.replayToken === "string" ? body.replayToken : "";
+    if (!token || !state.replayTokens.has(token)) {
+        return businessRefusal(RUNTIME_DATA_WIRE.replayTokenErrcode, "频繁重复提交！");
+    }
+    state.replayTokens.delete(token);
+    return null;
+}
+/** M2-runtime-data lane: query/save/load/submit. Twin of src/lanes/runtime-data.ts. */
+/**
+ * Ticket 78 live fidelity: a runtime write against a model whose application
+ * is UNPUBLISHED answers a stable 50000 (the same call succeeds on a
+ * published app's model).
+ */
+function unpublishedAppRefusal(ctx, schemaCode) {
+    const code = typeof schemaCode === "string" ? schemaCode : "";
+    const model = code ? ctx.state.models.get(code) : undefined;
+    const appCode = model?.appCode ?? "test";
+    const app = ctx.state.apps.get(appCode);
+    return app?.published === false ? businessRefusal(50000, "系统异常：应用未发布") : null;
+}
+export const runtimeDataRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/runtime/query/list": {
+            // QueryRuntimeController face: queryCondition is a 3-level
+            // and>or>and>leaf array (level1 AND across groups, level2 OR across
+            // and-groups, level3 AND across leaves), PageVO response.
+            const schemaCode = String(body.schemaCode ?? "");
+            const rows = [...ctx.state.dataRows.values()].filter((row) => row.schemaCode === schemaCode);
+            const groups = Array.isArray(body.queryCondition) ? body.queryCondition : [];
+            const filtered = groups.length > 0
+                ? rows.filter((row) => groups.every((group) => (Array.isArray(group) ? group : [group]).some((andGroup) => (Array.isArray(andGroup) ? andGroup : [andGroup]).every((leaf) => matchesCondition(leaf, row)))))
+                : rows;
+            const page = typeof body.page === "number" ? body.page : 0;
+            const size = typeof body.size === "number" ? body.size : 20;
+            const start = page * size;
+            // An unconfigured default list view omits business columns from the
+            // projection: the stored value exists but the wire row does not carry
+            // it, so explicit display columns read back null (ticket 07).
+            const unconfigured = ctx.state.unconfiguredListViews.has(schemaCode);
+            const project = (row) => unconfigured
+                ? Object.fromEntries(Object.entries(row).filter(([key]) => !ctx.state.fields.has(`${schemaCode}#${key}`)))
+                : { ...row };
+            return {
+                totalElements: filtered.length,
+                totalPages: size > 0 ? Math.ceil(filtered.length / size) : 0,
+                page,
+                size,
+                content: filtered.slice(start, start + size).map((row) => ({
+                    bizObjectId: row.bizObjectId,
+                    schemaCode,
+                    data: project(row),
+                })),
+            };
+        }
+        case "/api/api/runtime/form/save": {
+            const bizObject = (body.bizObject ?? {});
+            const data = bizObject.data ?? {};
+            // Ticket 78: unpublished-app models answer a stable 50000 on runtime saves.
+            const unpublished = unpublishedAppRefusal(ctx, bizObject.schemaCode);
+            if (unpublished)
+                return unpublished;
+            // Live 2026-09-24 (bench31): a SINGLE relation (propertyType 9) given an
+            // ARRAY answers a stable 50000 (object/{id}/id work; multi 11 and staff
+            // 50/51 legitimately take arrays).
+            for (const [key, field] of ctx.state.fields) {
+                if (!key.startsWith(`${bizObject.schemaCode}#`) || !field.published)
+                    continue;
+                if (Number(field.type) !== 9)
+                    continue;
+                const value = data[field.code];
+                if (Array.isArray(value) && value.length > 0)
+                    return businessRefusal(50000, "服务异常");
+            }
+            // Portal draft-save shape (ticket 13): workflowCode + no workItemId +
+            // no workflowInstanceId -> FormRuntimeController.saveWorkflow with
+            // finishStart=FALSE. The row is created DRAFT (only because data carries
+            // sequenceStatus DRAFT; the tool injects it) together with a DRAFT
+            // instance and a pending START work item. FormSaveVO returns the triple
+            // { objectId, workflowInstanceId, workItem:{id} }.
+            if (typeof body.workflowCode === "string" && body.workflowCode && !body.workItemId && !body.workflowInstanceId) {
+                // saveWorkflow isStartWf branch runs verifyReplay before creating
+                // anything (FormRuntimeController:996) — no token, no draft.
+                const replayRefusal = verifyReplayToken(ctx.state, body);
+                if (replayRefusal)
+                    return replayRefusal;
+                // The portal carries a client-chosen id in data.id (form SDK echo);
+                // the tool generates one when the caller omits it. The fake honors
+                // both, exactly like createAndGetBizObject keeping a supplied id.
+                const id = typeof data.id === "string" && data.id ? data.id : `wfdraft-${ctx.state.dataRows.size + 1}`;
+                const sequenceStatus = data.sequenceStatus === "DRAFT" ? "DRAFT" : "PROCESSING";
+                const created = { bizObjectId: id, schemaCode: bizObject.schemaCode, sequenceStatus, ...data, id };
+                ctx.state.dataRows.set(id, created);
+                applyBusinessRules(ctx.state, "Create", created);
+                const started = startWorkflowDraft(ctx.state, {
+                    workflowCode: body.workflowCode,
+                    schemaCode: String(bizObject.schemaCode ?? ""),
+                    bizObjectId: id,
+                });
+                return {
+                    objectId: id,
+                    bizObjectId: id,
+                    workflowInstanceId: started.workflowInstanceId,
+                    // Live shape (TID 88a47a7c): getWorkItem reads inside the
+                    // still-uncommitted request TX, so FormSaveVO carries NO workItem;
+                    // the todo is only visible to a committed follow-up read.
+                    ...(ctx.omitDraftSaveWorkItem
+                        ? {}
+                        : {
+                            workItem: {
+                                id: started.workItemId,
+                                instanceId: started.workflowInstanceId,
+                                activityCode: "fill",
+                                activityName: "填写申请单",
+                                state: "INPROGRESS",
+                                workflowCode: body.workflowCode,
+                                schemaCode: String(bizObject.schemaCode ?? ""),
+                                bizObjectId: id,
+                            },
+                        }),
+                };
+            }
+            // Live shape: the platform reads the target id from data["id"]; a
+            // top-level bizObject.id is ignored (kept here as a fallback only).
+            const suppliedId = [data.id, bizObject.id].find((value) => typeof value === "string" && value);
+            const existing = suppliedId ? ctx.state.dataRows.get(suppliedId) : undefined;
+            if (existing) {
+                const merged = { ...existing, ...data, bizObjectId: existing.bizObjectId, schemaCode: existing.schemaCode };
+                ctx.state.dataRows.set(String(existing.bizObjectId), merged);
+                applyBusinessRules(ctx.state, "Update", merged);
+                return { objectId: existing.bizObjectId, bizObjectId: existing.bizObjectId };
+            }
+            // Live quirk: a non-empty id absent from the store does NOT update — the
+            // facade silently creates under that id. The tool guards against this.
+            const id = suppliedId ?? `row-${ctx.state.dataRows.size + 1}`;
+            const created = { bizObjectId: id, schemaCode: bizObject.schemaCode, ...data };
+            ctx.state.dataRows.set(id, created);
+            applyBusinessRules(ctx.state, "Create", created);
+            return { bizObjectId: id, objectId: id };
+        }
+        case "/api/api/runtime/form/load": {
+            const row = ctx.state.dataRows.get(q.bizObjectId ?? q.objectId);
+            if (!row)
+                return null;
+            // The live face nests bizObject alongside the flat map; keep both so
+            // flat-field consumers and the submit chain's bizObject.data reader
+            // both work.
+            return {
+                ...row,
+                bizObject: {
+                    schemaCode: row.schemaCode,
+                    sheetCode: row.schemaCode,
+                    id: row.bizObjectId,
+                    data: { ...row },
+                },
+            };
+        }
+        case "/api/api/runtime/form/delete": {
+            // Ticket 22 source evidence (FormRuntimeController:1233): @RequestParam
+            // schemaCode + objectId; validateNotEmpty(schemaCode) -> PortalException
+            // 10005 非法的参数 (ResultEnum.ILLEGAL_PARAMETER_ERR, BaseController:887);
+            // getBizObject miss -> BIZ_OBJECT_NOT_EXIST 304001 业务对象不存在; success
+            // -> ResponseResult<Boolean> data true. The old fake deleted
+            // q.bizObjectId (a key the tool never sends) unconditionally.
+            const deleteSchemaCode = String(q.schemaCode ?? "");
+            const deleteObjectId = String(q.objectId ?? "");
+            if (!deleteSchemaCode)
+                return businessRefusal(10005, "非法的参数");
+            if (!ctx.state.dataRows.has(deleteObjectId))
+                return businessRefusal(RUNTIME_DATA_WIRE.absenceErrcode, "业务对象不存在");
+            ctx.state.dataRows.delete(deleteObjectId);
+            return true;
+        }
+        case "/api/api/runtime/form/getReplayToken": {
+            // disposeReplay registers the token before it is returned
+            // (AbstractFormRuntimeController.replayToken -> putFormId).
+            const token = `REPLAY${Math.random().toString(36).slice(2).padEnd(32, "0")}`;
+            ctx.state.replayTokens.add(token);
+            return token;
+        }
+        case "/api/api/runtime/form/submit": {
+            // Ticket 78: unpublished-app models answer a stable 50000 on runtime submits.
+            const unpublished = unpublishedAppRefusal(ctx, body.bizObject?.schemaCode);
+            if (unpublished)
+                return unpublished;
+            // Pin the WorkItemSubmitVO contract documented in the issue 13 evidence:
+            // - formType="2" -> submitBizSheet: sets sequenceStatus=COMPLETED,
+            //   returns { objectId, schemaCode, formCode }. When the payload's
+            //   bizObject carries an id (the proven save->load->submit chain),
+            //   the existing draft row is completed in place.
+            // - formType="1" + workflowCode -> startWorkflow: returns
+            //   { workflowInstanceId }
+            if (body.formType === RUNTIME_DATA_WIRE.formTypeWorkflow) {
+                const approvalWorkItemId = typeof body.workItemId === "string" && body.workItemId ? body.workItemId : "";
+                if (approvalWorkItemId) {
+                    // Ticket 22 source evidence: WorkItemSubmitVO has NO top-level
+                    // bizObjectId — the engine reads bizObject.id only
+                    // (initSubmitBizObject never backfills it from the work item). When
+                    // it is empty, loadBizObject returns null (BizObjectManagerImpl:206)
+                    // and changeBizObject/saveBizObject NPEs on objectExisted.getData()
+                    // (DataChangeHandlerImpl:104 / SubmitDataChangeHandlerImpl:214) ->
+                    // errcode 50000. This gate covers BOTH workItemId faces (the START
+                    // draft item and the approval todo) and fires before any mutation:
+                    // the platform NPE aborts the request transaction.
+                    const approvalBizObject = (body.bizObject ?? {});
+                    const approvalBizObjectId = typeof approvalBizObject.id === "string" && approvalBizObject.id ? approvalBizObject.id : "";
+                    if (!approvalBizObjectId) {
+                        return businessRefusal(RUNTIME_DATA_WIRE.approvalNpeErrcode, "engine NPE: workItem submit without bizObject.id (DataChangeHandlerImpl.objectExisted is null)");
+                    }
+                    // Submitting the instance's START work item (the portal draft shape):
+                    // the start item finishes, the approval activity spawns a pending
+                    // todo, and the SAME row id moves DRAFT -> PROCESSING. Platform
+                    // response shape: { result, objectId } (no workflowInstanceId).
+                    const startItem = ctx.state.workItems.get(approvalWorkItemId);
+                    if (startItem?.isStart) {
+                        const completed = completeWorkItem(ctx.state, approvalWorkItemId);
+                        spawnApprovalWorkItem(ctx.state, {
+                            instanceId: startItem.instanceId,
+                            workflowCode: startItem.workflowCode,
+                            schemaCode: startItem.schemaCode,
+                            bizObjectId: startItem.bizObjectId,
+                        });
+                        const row = ctx.state.dataRows.get(startItem.bizObjectId);
+                        if (row) {
+                            mergeSubmittedData(row, body);
+                            row.sequenceStatus = SUBMIT_STATUS_TRANSITIONS.workflowStart;
+                        }
+                        return { result: completed, objectId: startItem.bizObjectId };
+                    }
+                    // Approval submit: the addressed pending work item is completed and
+                    // leaves the pending store (search_workitems no longer returns it).
+                    const completed = completeWorkItem(ctx.state, approvalWorkItemId);
+                    if (completed) {
+                        const row = ctx.state.dataRows.get(approvalBizObjectId);
+                        if (row) {
+                            mergeSubmittedData(row, body);
+                            row.sequenceStatus = body.agree === false ? SUBMIT_STATUS_TRANSITIONS.approvalReject : SUBMIT_STATUS_TRANSITIONS.approvalAgree;
+                        }
+                    }
+                    return {
+                        workflowInstanceId: typeof body.workflowInstanceId === "string" ? body.workflowInstanceId : null,
+                        objectId: approvalBizObjectId || undefined,
+                        workItemId: approvalWorkItemId,
+                        agree: body.agree !== false,
+                        completed,
+                    };
+                }
+                // Start submit: the platform creates the in-flight bizObject and spawns
+                // the fill (finished) + approval (pending) work items.
+                // handleSubmit verifies the replay token BEFORE dispatching
+                // submitWorkflowByWorkflowCode (AbstractFormRuntimeController:156) —
+                // the gate precedes every side effect below.
+                const replayRefusal = verifyReplayToken(ctx.state, body);
+                if (replayRefusal)
+                    return replayRefusal;
+                const bizObject = (body.bizObject ?? {});
+                // WorkItemSubmitVO carries no top-level bizObjectId (ticket 22): the
+                // created id comes from bizObject.id only — a top-level key is an
+                // unknown JSON property the platform silently ignores.
+                const explicitId = typeof bizObject.id === "string" && bizObject.id ? bizObject.id : "";
+                // Ticket 22 source evidence: submitWorkflowByWorkflowCode ->
+                // startWorkflowInstance(create) -> BizObjectFacadeImpl.createAndGetBizObject
+                // is a pure INSERT (BizObjectInsertModel, no existence check) — an
+                // existing id dies on the duplicate primary key (40000, live TID
+                // 771f64ee). The old fake silently mutated the row in place.
+                if (explicitId && ctx.state.dataRows.has(explicitId)) {
+                    return businessRefusal(RUNTIME_DATA_WIRE.workflowStartDuplicateErrcode, `Duplicate entry '${explicitId}' for key 'PRIMARY' (create-only workflow start)`);
+                }
+                const bizObjectId = explicitId || `wfrow-${ctx.state.dataRows.size + 1}`;
+                const submittedData = typeof bizObject.data === "object" && bizObject.data ? bizObject.data : {};
+                ctx.state.dataRows.set(bizObjectId, {
+                    bizObjectId,
+                    sequenceStatus: SUBMIT_STATUS_TRANSITIONS.workflowStart,
+                    schemaCode: String(bizObject.schemaCode ?? ""),
+                    formCode: String(bizObject.sheetCode ?? bizObject.schemaCode ?? ""),
+                    ...submittedData,
+                });
+                const started = startWorkflowInstance(ctx.state, {
+                    workflowCode: String(body.workflowCode ?? ""),
+                    schemaCode: String(bizObject.schemaCode ?? ""),
+                    bizObjectId,
+                });
+                return { workflowInstanceId: started.workflowInstanceId, objectId: bizObjectId, workItemId: started.workItemId };
+            }
+            if (ctx.forceSubmitMissingObjectId) {
+                // Simulate a transport / protocol deviation: submitBizSheet
+                // returns no objectId. The tool must surface this rather than
+                // fabricate sequenceStatus:COMPLETED.
+                const noIdBizObject = (body.bizObject ?? {});
+                return { schemaCode: String(noIdBizObject.schemaCode ?? "") };
+            }
+            const bizObject = (body.bizObject ?? {});
+            const existing = typeof bizObject.id === "string" ? ctx.state.dataRows.get(bizObject.id) : undefined;
+            if (existing) {
+                // submitBizSheet -> saveBizObject: the submitted data persists
+                // (updateBizObject mergeObject patch) and the status moves COMPLETED.
+                mergeSubmittedData(existing, body);
+                existing.sequenceStatus = SUBMIT_STATUS_TRANSITIONS.inPlaceSubmit;
+                return { objectId: ctx.forceSubmitMismatchedObjectId ? "unexpected-submit-id" : bizObject.id, schemaCode: String(bizObject.schemaCode ?? ""), formCode: String(bizObject.sheetCode ?? bizObject.schemaCode ?? "") };
+            }
+            const id = `sub-${ctx.state.dataRows.size + 1}`;
+            ctx.state.dataRows.set(id, {
+                bizObjectId: id,
+                sequenceStatus: SUBMIT_STATUS_TRANSITIONS.inPlaceSubmit,
+                schemaCode: String(bizObject.schemaCode ?? ""),
+                formCode: String(bizObject.sheetCode ?? bizObject.schemaCode ?? ""),
+                ...(typeof bizObject.data === "object" && bizObject.data ? bizObject.data : {}),
+            });
+            return { objectId: id, schemaCode: String(bizObject.schemaCode ?? ""), formCode: String(bizObject.sheetCode ?? bizObject.schemaCode ?? "") };
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+/**
+ * The submit face persists bizObject.data itself (submitBizSheet ->
+ * saveBizObject; SubmitDataChangeHandlerImpl.updateBizObject): the submitted
+ * fields merge patch-style onto the stored row. Engine-owned keys the tool
+ * strips are the contract constant (ticket 20): a raw caller echoing them
+ * must not pin the row's status.
+ */
+function mergeSubmittedData(row, body) {
+    const bizObject = (body.bizObject ?? {});
+    if (!bizObject.data || typeof bizObject.data !== "object")
+        return;
+    for (const [key, value] of Object.entries(bizObject.data)) {
+        if (ENGINE_OWNED_KEYS.includes(key))
+            continue;
+        row[key] = value;
+    }
+}
+/**
+ * Leaf evaluation goes through the contract operator table (ticket 20) —
+ * the same table the DSL compiler encodes through, so every queryFilterType
+ * the compiler can emit is evaluated here (before, Gte/Lte/NotBetween fell
+ * through to an unconditional true).
+ */
+function matchesCondition(condition, row) {
+    if (!condition || typeof condition !== "object")
+        return true;
+    const value = condition;
+    if (value.op === "and" || value.op === "or") {
+        const items = Array.isArray(value.items) ? value.items : [];
+        const results = items.map((item) => matchesCondition(item, row));
+        return value.op === "and" ? results.every(Boolean) : results.some(Boolean);
+    }
+    const operator = RUNTIME_QUERY_OPERATORS[String(value.queryFilterType ?? "")];
+    if (!operator)
+        return true;
+    return operator.matches(row[String(value.propertyCode ?? "")], String(value.propertyValue ?? ""));
+}
+//# sourceMappingURL=runtime-data.js.map

package/dist/fake/state.js

@@ -0,0 +1,67 @@
+/**
+ * Shared in-memory store for the fake CloudPivot 8.6. The per-lane route
+ * modules read and mutate this one store; `FakeCloudPivot` owns an instance
+ * and exposes it as `state` for tests. This mirrors the single shared
+ * governance spine that the `src/lanes/*` adapters stand on.
+ */
+export const FAKE_RSA_PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4qB3KApdqvS/Civj0U5oX6nLgRLlLEvsUJpbNZAhT3Jq9+OGDv+th8TzUVSUzb68lKs4L6mDz1sZEJVTw6OKHjhf8pPvMuSPmEb3s6oEwh5kKRbG0qwE5xdaPgkIPSOOYYcPD6WLS9wQfhwh3kWfWttM6DKAOJB65RLfEdufYI52vJ5tbWqLumj/GDeOIub4e7PVD/6pGCJJNLjdg+vzYPZrSuSc+3/W23PqVIpnINjw+QNASi9U8KHDNvXapQa1vSEzaIrBhdDpdqnDiIrnYbVB6tQ3MotCAL9lse8VAEKoxaPwmgD6k8CdwjgZDNfnHD+xC+9qPUpmXpfLvRUHIwIDAQAB";
+/** Sentinel returned by a lane route when the path is outside its lane. */
+export const NOT_HANDLED = Symbol("omc-fake-not-handled");
+export function businessRefusal(errcode, errmsg) {
+    return { fakeBusinessRefusal: true, errcode, errmsg };
+}
+export function isBusinessRefusal(value) {
+    return typeof value === "object" && value !== null && value.fakeBusinessRefusal === true;
+}
+export function malformedEnvelope(payload) {
+    return { fakeMalformedEnvelope: true, payload };
+}
+export function isMalformedEnvelope(value) {
+    return typeof value === "object" && value !== null && value.fakeMalformedEnvelope === true;
+}
+export function rawResponse(payload) {
+    return { fakeRawResponse: true, payload };
+}
+export function isRawResponse(value) {
+    return typeof value === "object" && value !== null && value.fakeRawResponse === true;
+}
+export function createFakeState(options = {}) {
+    const defaultAppCode = options.applicationCode ?? "test";
+    return {
+        fields: new Map(),
+        dictionaries: new Map(),
+        dictionaryClasses: new Map(),
+        sheets: new Map(),
+        rules: new Map(),
+        ruleHistory: [],
+        ruleSeq: 0,
+        dataRules: new Map(),
+        dataRuleSeq: 0,
+        services: new Map(),
+        ieUploads: new Map(),
+        ieUploadSeq: 0,
+        categories: [{ id: "fakecat_seed", name: "插件集成服务" }],
+        dbConnPools: new Map([
+            // Pre-existing environment pool (ticket 92+ fixtures reference it as
+            // their DATA_SQL/DATA_TABLE binding target).
+            ["bpm", { id: "fakepool_bpm", code: "bpm", name: "bpm", databaseType: "MySQL", datasourceType: "DATABASE", jdbcUrl: "jdbc:mysql://127.0.0.1:3306/bpm?useSSL=false", username: "bpm", password: "fake-ciphertext" }],
+        ]),
+        onlineJs: new Map(),
+        listViews: new Map(),
+        reportPages: new Map(),
+        biDashboards: new Map(),
+        workflows: new Map(),
+        workItems: new Map(),
+        dataRows: new Map(),
+        replayTokens: new Set(),
+        unconfiguredListViews: new Set(),
+        /** Ticket 79 live-fidelity: remaining transient 不存在列 publish refusals per schema (self-healing column-sync failure). */
+        transientPublishFailures: new Map(),
+        fieldDetailDrift: new Map(),
+        models: new Map(),
+        apps: new Map([[defaultAppCode, { id: "app-1", code: defaultAppCode, name: "Test App", groupId: "group-1" }]]),
+        appGroups: new Map([["group-1", { id: "group-1", code: "default", name: "默认分组" }]]),
+        callLog: [],
+    };
+}
+//# sourceMappingURL=state.js.map