@mldong/jeeflow 1.1.0 → 1.2.0

package/dist/facade.d.ts

@@ -1,10 +1,13 @@
 import type { ProcessExtRepository, ProcessRepository } from './spi.js';
 import type { EngineImpl } from './engine.js';
+export type UserSearch = (query: Record<string, any>) => Promise<[Record<string, any>[], number]> | [Record<string, any>[], number];
 export declare class JeeflowFacade {
     private readonly engine;
     private readonly repo;
     private readonly extRepo?;
+    private userSearch?;
     constructor(engine: EngineImpl, repo: ProcessRepository, extRepo?: ProcessExtRepository | undefined);
+    setUserSearch(fn: UserSearch): this;
     flow(action: string, args?: Record<string, any>): Promise<Record<string, any>>;
     private dispatch;
     private startAndExecute;
@@ -18,5 +21,18 @@ export declare class JeeflowFacade {
     private designSave;
     private surrogatePage;
     private surrogateSave;
+    private getLastByName;
+    private highLight;
+    private collectPath;
+    private approvalRecord;
+    private getAssigneeTextData;
+    private createCCInstance;
+    private updateCCStatus;
+    private taskDetail;
+    private jumpAbleTaskNameList;
+    private candidatePage;
+    private nextTaskCandidates;
+    private taskAddActor;
+    private taskLatest;
     private ext;
 }

package/dist/facade.js

@@ -15,11 +15,17 @@ export class JeeflowFacade {
     engine;
     repo;
     extRepo;
+    userSearch;
     constructor(engine, repo, extRepo) {
         this.engine = engine;
         this.repo = repo;
         this.extRepo = extRepo;
     }
+    // 注入用户搜索钩子（candidatePage 无模型候选时的用户分页搜索）
+    setUserSearch(fn) {
+        this.userSearch = fn;
+        return this;
+    }
     async flow(action, args = {}) {
         try {
             const data = await this.dispatch(action, args);
@@ -61,6 +67,31 @@ export class JeeflowFacade {
                 return this.surrogateSave(args);
             case 'processSurrogate/remove':
                 return this.ext().removeSurrogate(toId(args.id));
+            case 'processDefine/getLastByName':
+                return this.getLastByName(args);
+            case 'processInstance/highLight':
+                return this.highLight(args);
+            case 'processInstance/approvalRecord':
+                return this.approvalRecord(args);
+            case 'processInstance/getAssigneeTextData':
+                return this.getAssigneeTextData(args);
+            case 'processInstance/createCCInstance':
+                return this.createCCInstance(args);
+            case 'processInstance/updateCCStatus':
+                return this.updateCCStatus(args);
+            case 'processInstance/ccList':
+                throw new Error('ccList 需要核心分页 SPI（pageCcInstances），当前语言 1.3.0 补齐');
+            case 'processTask/detail':
+                return this.taskDetail(args);
+            case 'processTask/jumpAbleTaskNameList':
+                return this.jumpAbleTaskNameList(args);
+            case 'processTask/candidatePage':
+                return this.candidatePage(args);
+            case 'processTask/surrogate':
+            case 'processTask/addCandidate':
+                return this.taskAddActor(args);
+            case 'processTask/latest':
+                return this.taskLatest(args);
             default:
                 throw new Error(`未知 action: ${action}`);
         }
@@ -299,6 +330,221 @@ export class JeeflowFacade {
         }
         return { id: surrogate.id };
     }
+    // ── 视图端点（v1.2.0） ──────────────────────────────────────────────────
+    async getLastByName(args) {
+        const def = await this.repo.findDefineByName(String(args.processDefineName ?? ''));
+        if (!def)
+            throw new Error(`流程定义不存在: ${args.processDefineName}`);
+        return { id: def.id, name: def.name, displayName: def.displayName, type: def.type, state: def.state, version: def.version };
+    }
+    async highLight(args) {
+        const instanceId = toId(args.id);
+        const inst = await this.repo.findInstanceById(instanceId);
+        if (!inst)
+            throw new Error('流程实例不存在');
+        const active = [];
+        const history = [];
+        const edges = [];
+        const doing = await this.repo.findDoingTasks(instanceId);
+        for (const t of doing)
+            if (!active.includes(t.taskName))
+                active.push(t.taskName);
+        const his = await this.repo.findHistoryTasks(instanceId);
+        for (const t of his)
+            if (!active.includes(t.taskName) && !history.includes(t.taskName))
+                history.push(t.taskName);
+        // 路径补全：start 沿边递归（遇活跃节点停止）
+        const def = await this.repo.findDefineById(inst.defineId);
+        if (def) {
+            try {
+                const flow = JSON.parse(toStr(def.content));
+                this.collectPath(flow, 'start', '', active, history, edges, new Set());
+            }
+            catch { /* ignore */ }
+        }
+        return { activeNodeNames: active, historyNodeNames: history, historyEdgeNames: edges };
+    }
+    collectPath(flow, nodeId, edgeName, active, history, edges, visited) {
+        if (visited.has(nodeId))
+            return;
+        visited.add(nodeId);
+        if (edgeName && !edges.includes(edgeName))
+            edges.push(edgeName);
+        for (const e of flow.edges ?? []) {
+            if (e.sourceNodeId !== nodeId)
+                continue;
+            const target = (flow.nodes ?? []).find((n) => n.id === e.targetNodeId);
+            if (!target)
+                continue;
+            const tid = target.id;
+            if (!active.includes(tid) && !history.includes(tid))
+                history.push(tid);
+            if (active.includes(tid))
+                continue;
+            this.collectPath(flow, tid, e.id, active, history, edges, visited);
+        }
+    }
+    async approvalRecord(args) {
+        const instanceId = toId(args.id);
+        const his = await this.repo.findHistoryTasks(instanceId);
+        return his.map(t => ({
+            taskName: t.taskName, displayName: t.displayName, taskType: t.taskType ?? null,
+            performType: t.performType ?? null, taskState: t.taskState, operator: t.actorId ?? '',
+            finishTime: t.finishTime ?? null, variable: t.variables ?? {},
+        }));
+    }
+    async getAssigneeTextData(args) {
+        const instanceId = toId(args.id);
+        const includeNodeName = args.includeNodeName !== false;
+        const rows = [];
+        const doing = await this.repo.findDoingTasks(instanceId);
+        for (const t of doing) {
+            const actors = await this.repo.findTaskActors(t.id);
+            for (const actor of actors) {
+                rows.push({ label: includeNodeName ? `${t.displayName}:${actor}` : actor, value: actor });
+            }
+        }
+        return rows;
+    }
+    async createCCInstance(args) {
+        const instanceId = toId(args.processInstanceId);
+        const operator = String(args.operator ?? 'user1');
+        const actors = toStringList2(args.actorIds);
+        if (actors.length === 0)
+            throw new Error('actorIds 缺失');
+        await this.repo.createCcInstance(instanceId, operator, ...actors);
+    }
+    async updateCCStatus(args) {
+        const instanceId = toId(args.processInstanceId);
+        const operator = String(args.operator ?? 'user1');
+        await this.repo.updateCcStatus(instanceId, operator);
+    }
+    async taskDetail(args) {
+        const taskId = toId(args.id);
+        const operator = String(args.operator ?? 'user1');
+        const task = await this.repo.findTaskById(taskId);
+        if (!task)
+            throw new Error('任务不存在');
+        const actors = await this.repo.findTaskActors(taskId);
+        const vo = {
+            id: task.id, processInstanceId: task.processInstanceId, taskName: task.taskName,
+            displayName: task.displayName, taskType: task.taskType ?? null,
+            performType: task.performType ?? null, taskState: task.taskState,
+            operator: task.actorId ?? '', formKey: task.formKey ?? '',
+            taskActorIdList: actors, executable: task.isAllowed(operator),
+        };
+        // taskModel：流程定义中对应节点
+        const inst = await this.repo.findInstanceById(task.processInstanceId);
+        if (inst) {
+            const def = await this.repo.findDefineById(inst.defineId);
+            if (def) {
+                try {
+                    const flow = JSON.parse(toStr(def.content));
+                    for (const n of flow.nodes ?? []) {
+                        if (n.id === task.taskName) {
+                            vo.taskModel = { name: n.id, displayName: n.text?.value ?? '', type: n.type };
+                            break;
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return vo;
+    }
+    async jumpAbleTaskNameList(args) {
+        const instanceId = toId(args.processInstanceId);
+        const done = await this.repo.findDoneTasks(instanceId);
+        const rows = [];
+        const seen = new Set();
+        for (const t of done) {
+            if ((t.performType ?? 0) === 1)
+                continue; // COUNTERSIGN
+            if (!seen.has(t.taskName)) {
+                seen.add(t.taskName);
+                rows.push({ label: t.displayName, value: t.taskName });
+            }
+        }
+        return rows;
+    }
+    async candidatePage(args) {
+        const taskId = toId(args.processTaskId ?? args.id);
+        const task = await this.repo.findTaskById(taskId);
+        if (!task)
+            throw new Error('任务不存在');
+        const inst = await this.repo.findInstanceById(task.processInstanceId);
+        if (!inst)
+            throw new Error('流程实例不存在');
+        // 模型候选解析：后继任务节点的 candidateUsers 配置
+        let candidates = [];
+        const def = await this.repo.findDefineById(inst.defineId);
+        if (def) {
+            try {
+                const flow = JSON.parse(toStr(def.content));
+                candidates = this.nextTaskCandidates(flow, task.taskName);
+            }
+            catch { /* ignore */ }
+        }
+        if (candidates.length > 0) {
+            const rows = candidates.map(c => ({ userId: c, realName: c }));
+            return { rows, recordCount: rows.length };
+        }
+        // 无模型候选 → 用户分页搜索（依赖 userSearch 钩子）
+        if (!this.userSearch)
+            throw new Error('未配置 userSearch（用户搜索钩子）');
+        const [rows, total] = await this.userSearch(args);
+        return { rows, recordCount: total };
+    }
+    nextTaskCandidates(flow, taskName) {
+        const result = [];
+        const visited = new Set();
+        const collect = (node) => {
+            const v = node.properties?.candidateUsers;
+            if (v) {
+                for (const s of String(v).split(',')) {
+                    const t = s.trim();
+                    if (t && !result.includes(t))
+                        result.push(t);
+                }
+            }
+        };
+        const walk = (nodeId) => {
+            if (visited.has(nodeId))
+                return;
+            visited.add(nodeId);
+            for (const e of flow.edges ?? []) {
+                if (e.sourceNodeId !== nodeId)
+                    continue;
+                const target = (flow.nodes ?? []).find((n) => n.id === e.targetNodeId);
+                if (!target)
+                    continue;
+                if (target.type === 'snaker:task' || target.type === 'snaker:custom') {
+                    collect(target);
+                    continue;
+                }
+                if (['snaker:fork', 'snaker:join', 'snaker:decision'].includes(target.type)) {
+                    walk(target.id);
+                }
+            }
+        };
+        walk(taskName);
+        return result;
+    }
+    async taskAddActor(args) {
+        const taskId = toId(args.processTaskId);
+        const actors = toStringList2(args.actorIds);
+        if (actors.length === 0)
+            throw new Error('actorIds 缺失');
+        await this.repo.addTaskActor(taskId, actors);
+    }
+    async taskLatest(args) {
+        const instanceId = toId(args.processInstanceId);
+        const doing = await this.repo.findDoingTasks(instanceId);
+        if (doing.length === 0)
+            return null;
+        const t = doing[0];
+        return { id: t.id, taskName: t.taskName, displayName: t.displayName, taskState: t.taskState, operator: t.actorId ?? '' };
+    }
     ext() {
         if (!this.extRepo)
             throw new Error('未配置 ProcessExtRepository（扩展仓储）');
@@ -321,6 +567,13 @@ function toId(v) {
         throw new Error('id 缺失或非法');
     return n;
 }
+function toStringList2(v) {
+    if (Array.isArray(v))
+        return v.map(String);
+    if (typeof v === 'string')
+        return v.split(',').map(s => s.trim()).filter(Boolean);
+    return [];
+}
 function toInt(v) {
     const n = Number(v);
     if (!Number.isFinite(n))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mldong/jeeflow",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "jeeflow workflow engine — Node.js / TypeScript implementation",
   "type": "module",
   "main": "./dist/index.js",