@stalfh233/omc-fake-platform 0.0.0-stage → 0.4.39

package/dist/workflow.js

@@ -0,0 +1,363 @@
+import { businessRefusal, malformedEnvelope, NOT_HANDLED } from "./state.js";
+const PENDING_STATES = new Set(["NOTSTARTED", "INPROGRESS"]);
+const ACTIVITY_TYPES = new Set(["START", "END", "CONNECTION", "PARTICIPANT", "SUB_INSTANCE", "CIRCULATE", "SYSTEM_ACTIVITY", "AGENT_ACTIVITY"]);
+const POINT = /^-?\d+(?:\.\d+)?,\s-?\d+(?:\.\d+)?$/;
+/**
+ * Live 8.6.26 fidelity (2026-09-17 probe): workflow/validate and /publish
+ * answer HTTP 200 + errcode 0 and put the truth in `data` as
+ * ValidateMessage[]. The originate (first PARTICIPANT) node's `participant`
+ * must be the platform keyword `"{Originator}"`; a plain value ("admin")
+ * answers `401035 <activityName> ERROR` and the flow never goes live.
+ * `"{Creator}"` on a non-originate participant node is a `401062` WARN that
+ * does not block.
+ */
+function validateWorkflowParticipants(activities) {
+    if (!Array.isArray(activities))
+        return [];
+    const rows = activities;
+    const participants = rows.filter((activity) => String(activity?.activityType ?? "") === "PARTICIPANT");
+    const messages = [];
+    const originate = participants[0];
+    if (originate && String(originate.participant ?? "") !== "{Originator}")
+        messages.push({ errCode: 401035, errContent: originate.activityName ?? originate.activityCode ?? "", errMsg: null, errorLevel: "ERROR" });
+    for (const activity of participants.slice(1)) {
+        if (String(activity.participant ?? "") === "{Creator}")
+            messages.push({ errCode: 401062, errContent: activity.activityName ?? activity.activityCode ?? "", errMsg: null, errorLevel: "WARN" });
+    }
+    return messages;
+}
+function invalidRenderShape(body) {
+    if (!Array.isArray(body.activities))
+        return "activities";
+    const codes = new Set();
+    for (const activity of body.activities) {
+        const record = activity;
+        const code = String(record?.activityCode ?? "").trim();
+        const type = String(record?.activityType ?? "").trim();
+        if (!code || codes.has(code) || !ACTIVITY_TYPES.has(type))
+            return "activities";
+        codes.add(code);
+    }
+    if (!Array.isArray(body.rules))
+        return "rules";
+    for (const rule of body.rules) {
+        const record = rule;
+        const pre = String(record?.preActivityCode ?? "");
+        const post = String(record?.postActivityCode ?? "");
+        const points = record?.points;
+        if (!codes.has(pre) || !codes.has(post) || !Array.isArray(points) || points.length === 0 || points.some((point) => typeof point !== "string" || !POINT.test(point)))
+            return "rules";
+    }
+    return null;
+}
+/**
+ * Spawn the two work items a workflow start produces: the originator fill item
+ * (already FINISHED — the start submit is the fill) and the pending approval
+ * item that `workitem.list` must surface for `data.submit`.
+ */
+export function startWorkflowInstance(state, input) {
+    const sequence = state.workItems.size + 1;
+    const instanceId = `wf-${sequence}`;
+    const fillId = `wi-${sequence}`;
+    const approveId = `wi-${sequence + 1}`;
+    state.workItems.set(fillId, {
+        id: fillId,
+        instanceId,
+        activityCode: "fill",
+        activityName: "填写申请单",
+        participant: "tester",
+        state: "FINISHED",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+    });
+    state.workItems.set(approveId, {
+        id: approveId,
+        instanceId,
+        activityCode: "approve",
+        activityName: "审批",
+        participant: "tester",
+        state: "INPROGRESS",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+    });
+    return { workflowInstanceId: instanceId, workItemId: approveId };
+}
+/** Complete a pending work item (approval submit). Returns false if unknown. */
+export function completeWorkItem(state, workItemId) {
+    const item = state.workItems.get(workItemId);
+    if (!item)
+        return false;
+    item.state = "FINISHED";
+    return true;
+}
+/**
+ * Portal draft-save shape (finishStart=FALSE): one instance in DRAFT with a
+ * single PENDING start work item. Submitting that item (startWorkflowDraft's
+ * workItemId) is what advances the instance — see startWorkflowInstance for
+ * the finishStart=TRUE twin.
+ */
+export function startWorkflowDraft(state, input) {
+    const sequence = state.workItems.size + 1;
+    const instanceId = `wf-${sequence}`;
+    const startId = `wi-${sequence}`;
+    state.workItems.set(startId, {
+        id: startId,
+        instanceId,
+        activityCode: "fill",
+        activityName: "填写申请单",
+        participant: "tester",
+        state: "INPROGRESS",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+        isStart: true,
+    });
+    return { workflowInstanceId: instanceId, workItemId: startId };
+}
+/** After the START work item is submitted, the next (approval) activity spawns a pending todo. */
+export function spawnApprovalWorkItem(state, input) {
+    const approveId = `wi-${state.workItems.size + 1}`;
+    state.workItems.set(approveId, {
+        id: approveId,
+        instanceId: input.instanceId,
+        activityCode: "approve",
+        activityName: "审批",
+        participant: "tester",
+        state: "INPROGRESS",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+    });
+    return approveId;
+}
+function toWorkItemVO(item) {
+    return {
+        id: item.id,
+        instanceId: item.instanceId,
+        activityCode: item.activityCode,
+        activityName: item.activityName,
+        state: item.state,
+        workflowCode: item.workflowCode,
+        schemaCode: item.schemaCode,
+        participant: item.participant,
+        participantName: item.participantName ?? item.participant,
+        originator: item.originator,
+        sequenceNo: item.sequenceNo,
+    };
+}
+/** W7-S29-greenfield lane: workflow template authoring + runtime work-item query. Twin of src/lanes/workflow.ts. */
+export const workflowRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/workflow/create": {
+            const code = String(body.workflowCode ?? body.code ?? "");
+            const name = String(body.workflowName ?? body.name ?? code);
+            const schemaCode = String(body.schemaCode ?? "");
+            // Ticket 76 live fidelity: creating a workflow when the SCHEMA already
+            // has one answers an envelope with NO numeric errcode (live:
+            // "envelope for /api/api/workflow/create has no numeric errcode") — the
+            // tool must decode it as a duplicate-create, not a malformed failure.
+            if ([...ctx.state.workflows.values()].some((wf) => wf.schemaCode === schemaCode) && !ctx.state.workflows.has(code))
+                return malformedEnvelope({ workflowCode: code, workflowName: name, schemaCode, exist: true });
+            if (!ctx.state.workflows.has(code)) {
+                // Ticket 112 platform fidelity: the real create auto-generates a
+                // full draft (START → PARTICIPANT 填写申请单 → END with canvas rules;
+                // WorkflowTemplateController update @ApiImplicitParam example) — the
+                // fake seeds the same platform-shaped template so the merge path has
+                // real activity boxes and rule shapes to echo.
+                ctx.state.workflows.set(code, {
+                    code,
+                    name,
+                    schemaCode,
+                    template: {
+                        workflowCode: code,
+                        name,
+                        workflowName: name,
+                        schemaCode,
+                        // Live create seeds templateType DRAFT ("SAVE" is not a
+                        // WorkflowTemplateStatus member — S29 contract).
+                        templateType: "DRAFT",
+                        activities: [
+                            { activityCode: "Activity1", activityType: "START", activityName: "开始", x: 327, y: 36, width: 158, height: 40 },
+                            { activityCode: "Activity2", activityType: "PARTICIPANT", activityName: "填写申请单", participant: "{Originator}", x: 327, y: 116, width: 158, height: 40 },
+                            { activityCode: "Activity3", activityType: "END", activityName: "结束", x: 327, y: 196, width: 158, height: 40 },
+                        ],
+                        rules: [
+                            { preActivityCode: "Activity1", postActivityCode: "Activity2", points: ["406, 76", "406, 116"] },
+                            { preActivityCode: "Activity2", postActivityCode: "Activity3", points: ["406, 156", "406, 196"] },
+                        ],
+                    },
+                    published: null,
+                });
+            }
+            return { code };
+        }
+        case "/api/api/workflow/isworkflow": {
+            // WorkflowTemplateController.isWorkFlow(schemaCode): any header for the
+            // schema answers true.
+            const schemaCode = String(q.schemaCode ?? "");
+            return [...ctx.state.workflows.values()].some((wf) => wf.schemaCode === schemaCode);
+        }
+        case "/api/api/workflow/getWorkflow": {
+            // WorkflowTemplateController.getWorkflow(schemaCode): the published
+            // template for the schema (carries workflowCode), or null when the model
+            // has none. Used to auto-start a workflow-backed data.submit.
+            const schemaCode = String(q.schemaCode ?? "");
+            const wf = [...ctx.state.workflows.values()].find((candidate) => candidate.schemaCode === schemaCode);
+            if (!wf)
+                return null;
+            const template = (wf.published ?? wf.template);
+            return { ...template, workflowCode: wf.code };
+        }
+        case "/api/api/workflow/get_header": {
+            const wf = ctx.state.workflows.get(String(q.workflowCode ?? ""));
+            // Round-2 live fidelity (BUG-05): these endpoints answer 401001
+            // 流程不存在！ for an ABSENT workflow rather than a null payload.
+            if (!wf)
+                return businessRefusal(401001, "流程不存在！");
+            return { code: wf.code, name: wf.name };
+        }
+        case "/api/api/workflow/get_draft": {
+            const wf = ctx.state.workflows.get(String(q.workflowCode ?? ""));
+            if (!wf)
+                return businessRefusal(401001, "流程不存在！");
+            return wf.template;
+        }
+        case "/api/api/workflow/get_published": {
+            const wf = ctx.state.workflows.get(String(q.workflowCode ?? ""));
+            // Live fidelity: like get_header/get_draft, an ABSENT workflow answers
+            // 401001 流程不存在！ rather than a null payload; the tool degrades that
+            // to exists:false. Ticket 77: an UNPUBLISHED workflow still answers the
+            // DRAFT shape here — data presence is not publish evidence. The
+            // published face carries the templateType PUBLISH marker.
+            if (!wf)
+                return businessRefusal(401001, "流程不存在！");
+            return wf.published ?? wf.template ?? null;
+        }
+        case "/api/api/workflow/update": {
+            const code = String(body.workflowCode ?? q.workflowCode ?? "");
+            const wf = ctx.state.workflows.get(code);
+            if (!wf)
+                return null;
+            // Ticket 112 platform fidelity (WorkflowTemplateUtil.java:90-171): an
+            // illegal templateType ("BusinessProcess" is not a
+            // WorkflowTemplateStatus member — valueOf at :136) or an activities
+            // element without a type makes the converter swallow the exception
+            // into a PARTIAL model; the save chain then fails with errcode 50000.
+            if (body.templateType === "BusinessProcess")
+                return businessRefusal(50000, "服务异常");
+            if (Array.isArray(body.activities) &&
+                body.activities.some((activity) => {
+                    const record = activity;
+                    const type = record != null && typeof record === "object" ? (record.type ?? record.activityType) : undefined;
+                    return type === undefined || type === null || String(type).trim() === "";
+                }))
+                return businessRefusal(50000, "服务异常");
+            if (body.activities !== undefined && invalidRenderShape(body))
+                return businessRefusal(50000, "服务异常");
+            // Platform fidelity (live 2026-09-23; bench12/13/15): an existing
+            // activityCode cannot be RENAMED or RETYPED — the stored name/type win.
+            // A caller that wants a different name/type must send it under a fresh
+            // code (the tool reconciles this before the wire); re-sending the same
+            // code with a changed name is a silent no-op on the platform, so the fake
+            // must reproduce it rather than store the body verbatim.
+            const stored = wf.template.activities;
+            const storedByCode = new Map((Array.isArray(stored) ? stored : []).map((activity) => [String(activity.activityCode ?? ""), activity]));
+            const pinned = Array.isArray(body.activities)
+                ? {
+                    ...body,
+                    activities: body.activities.map((activity) => {
+                        const prior = storedByCode.get(String(activity.activityCode ?? ""));
+                        return prior
+                            ? { ...activity, activityName: prior.activityName, i18nMessage: prior.i18nMessage, activityType: prior.activityType }
+                            : activity;
+                    }),
+                }
+                : body;
+            wf.template = { ...pinned };
+            return { code };
+        }
+        case "/api/api/workflow/validate":
+        case "/api/api/workflow/publish": {
+            const code = String(body.workflowCode ?? q.workflowCode ?? "");
+            const wf = ctx.state.workflows.get(code);
+            if (!wf)
+                return null;
+            if (body.activities !== undefined && invalidRenderShape(body))
+                return businessRefusal(50000, "服务异常");
+            // Live 8.6.26 fidelity (2026-09-17): validate/publish REFUSE with HTTP
+            // 200 + errcode 0 and the truth in `data` as ValidateMessage[]
+            // ({errCode, errContent, errorLevel}). The originate (first PARTICIPANT)
+            // node's participant must be the platform keyword "{Originator}" — a
+            // plain user/role value answers 401035 ERROR while errcode stays 0, and
+            // the flow never goes live. `{Creator}` on a non-originate node is a WARN
+            // (401062) that does not block.
+            const activities = Array.isArray(body.activities) ? body.activities : wf.template.activities;
+            const validation = validateWorkflowParticipants(activities);
+            if (input.path === "/api/api/workflow/validate")
+                return validation;
+            if (validation.some((message) => message.errorLevel === "ERROR"))
+                return validation;
+            // Ticket 77: the published face carries the PUBLISH marker (live readback
+            // evidence: publish state is identified by templateType:PUBLISH /
+            // version fields, never by data presence).
+            wf.published = { ...body, templateType: "PUBLISH", workflowVersion: (wf.published ? Number(wf.published.workflowVersion ?? 1) : 0) + 1 };
+            return { code, workflowVersion: wf.published.workflowVersion };
+        }
+        case "/api/api/workflow/delete":
+            ctx.state.workflows.delete(String(body.workflowCode ?? q.workflowCode ?? q.code ?? ""));
+            return null;
+        case "/api/api/runtime/workflow/search_workitems": {
+            // The real endpoint returns the caller's pending todos (biz_workitem only
+            // holds pending rows); finished items move to the finished store. The
+            // server's filterWorkflowInstanceId is a NOT-equal exclusion, so it is
+            // deliberately not honored here — exact instance matching is client-side.
+            let rows = [...ctx.state.workItems.values()].filter((item) => PENDING_STATES.has(item.state));
+            if (q.workflowCode)
+                rows = rows.filter((item) => item.workflowCode === q.workflowCode);
+            if (q.schemaCode)
+                rows = rows.filter((item) => item.schemaCode === q.schemaCode);
+            const page = Number(q.page ?? 0);
+            const size = Number(q.size ?? 20);
+            const start = page * size;
+            return {
+                totalElements: rows.length,
+                totalPages: size > 0 ? Math.ceil(rows.length / size) : 0,
+                content: rows.slice(start, start + size).map(toWorkItemVO),
+            };
+        }
+        case "/api/api/runtime/workflow/getBizObjectByWfInstanceId": {
+            const instanceId = String(q.workflowInstanceId ?? "");
+            const item = [...ctx.state.workItems.values()].find((candidate) => candidate.instanceId === instanceId);
+            if (!item)
+                return null;
+            return { id: item.bizObjectId, schemaCode: item.schemaCode };
+        }
+        case "/api/api/organization/role/list":
+            // Real shape: groups with `children` roles (see real-env observation).
+            return [
+                { id: "grp-1", name: "默认", code: "SYS_1000000", children: [{ id: "role-lead", name: "部门负责人", code: "SYS260630023816197", roleType: "SYS", corpId: "corp-1" }] },
+                { id: "role-finance", name: "财务负责人", code: "SYS260515031207258", roleType: "SYS", corpId: "corp-1" },
+            ];
+        case "/api/api/organization/department/tree":
+            return { departmentList: [{ id: "dept-1", name: "总所", code: "1", corpId: "corp-1", parentId: null }, { id: "dept-2", name: "业务部", code: "1_1", corpId: "corp-1", parentId: "dept-1" }] };
+        case "/api/api/organization/user/search": {
+            // UserController.search: @RequestBody {wd,page,size} → PageVO<UserVO>.
+            const wd = String(body.wd ?? "");
+            if (!wd)
+                return businessRefusal(10005, "关键字不能为空");
+            const users = [
+                { id: "user-1", username: "18900000001", name: "付文彬", departmentId: "dept-1", userId: "18900000001", status: "ENABLE", deleted: false, corpId: "corp-1" },
+                { id: "user-2", username: "18900000002", name: "李四", departmentId: "dept-2", userId: "18900000002", status: "ENABLE", deleted: false, corpId: "corp-1" },
+            ].filter((user) => user.name.includes(wd) || user.username.includes(wd));
+            const page = Number(body.page ?? 0);
+            const size = Number(body.size ?? 100);
+            return { totalElements: users.length, totalPages: size > 0 ? Math.ceil(users.length / size) : 0, content: users.slice(page * size, page * size + size) };
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@stalfh233/omc-fake-platform",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.39",
+  "description": "OMC 的内存假 CloudPivot 平台（wire 接缝的第二个适配器）+ HTTP 假服务器——@stalfh233/omc-cli 的测试与 bench 基准基座",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./state": "./dist/state.js",
+    "./http-server": "./dist/http-server.js"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json"
+  },
+  "dependencies": {
+    "omc-core": "0.4.39"
+  },
+  "engines": {
+    "node": ">=22.13"
+  }
+}