@mldong/jeeflow 1.0.0

package/dist/jdbc/shared.js

@@ -0,0 +1,317 @@
+// 共享 JDBC 仓储核心——SQL 逻辑与数据库无关。
+//
+// 设计（多数据库维护策略）：
+// - 本文件是**唯一维护点**：15 个仓储方法的 SQL 逻辑、行映射、ID 生成
+// - SQL 占位符统一使用 `?`，由各数据库适配器（SqlAdapter）转换为自家风格
+//   （MySQL `?` 原生 / PostgreSQL `$n`）
+// - 事务（spec §7.4）：withTx 用 AsyncLocalStorage 绑定当前异步上下文的事务连接
+//
+// 新增数据库 = 写一个适配器（约 80 行）：实现 SqlAdapter + 连接包装
+// （execute/fetchOne/fetchAll/begin/commit/rollback）。参考 mysql.ts / postgres.ts。
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ProcessInstance, ProcessTask } from '../model.js';
+import { TaskState } from '../model.js';
+// 当前异步上下文绑定的事务连接
+const txStore = new AsyncLocalStorage();
+/** 默认 ID 生成器：时间戳毫秒 + 同毫秒递增序号（对齐 Java nextId 默认实现） */
+export class TsIDGenerator {
+    last = 0;
+    seq = 0;
+    nextId() {
+        const now = Date.now();
+        if (now === this.last) {
+            this.seq++;
+        }
+        else {
+            this.last = now;
+            this.seq = 0;
+        }
+        return now * 1000 + this.seq;
+    }
+}
+/** 把核心 SQL 的统一 `?` 占位符转换为适配器风格 */
+export function convertPlaceholder(sql, style) {
+    if (style === '$n') {
+        let i = 0;
+        return sql.replace(/\?/g, () => `$${++i}`);
+    }
+    return sql; // '?' 原生
+}
+/** 生成 n 个 `?` 占位符（用于 IN 列表） */
+export function repeatPh(n) {
+    return Array.from({ length: n }, () => '?').join(',');
+}
+export class JdbcRepository {
+    adapter;
+    idGen;
+    constructor(adapter, idGen = new TsIDGenerator()) {
+        this.adapter = adapter;
+        this.idGen = idGen;
+    }
+    sql(s) {
+        return convertPlaceholder(s, this.adapter.placeholder);
+    }
+    // ── 事务（spec §7.4：AsyncLocalStorage 绑定连接）─────────────────────────
+    async withTx(fn) {
+        const conn = await this.adapter.acquire();
+        try {
+            await conn.begin();
+            try {
+                const result = await txStore.run(conn, fn);
+                await conn.commit();
+                return result;
+            }
+            catch (err) {
+                await conn.rollback();
+                throw err;
+            }
+        }
+        finally {
+            await this.adapter.release(conn);
+        }
+    }
+    /** 返回当前连接：有事务绑定用事务连接，否则从适配器获取 */
+    async c() {
+        return txStore.getStore() ?? (await this.adapter.acquire());
+    }
+    /** 归还非事务连接（事务连接由 withTx 统一释放） */
+    async done(conn) {
+        if (!txStore.getStore())
+            await this.adapter.release(conn);
+    }
+    // ── ProcessDefine ─────────────────────────────────────────────────────────
+    async findDefineById(id) {
+        const conn = await this.c();
+        try {
+            const row = await conn.fetchOne(this.sql('SELECT id, name, display_name, type, state, content, version, ' +
+                'create_time, create_user, update_time, update_user FROM wf_process_define WHERE id = ?'), [id]);
+            if (!row)
+                return null;
+            return {
+                id: row.id, name: row.name, displayName: row.display_name, type: row.type,
+                state: row.state,
+                content: row.content ? Buffer.from(row.content).toString('utf8') : '',
+                version: row.version, createTime: row.create_time, createUser: row.create_user,
+                updateTime: row.update_time, updateUser: row.update_user,
+            };
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    // ── ProcessInstance ───────────────────────────────────────────────────────
+    static INSTANCE_COLS = 'id, parent_id, process_define_id, state, parent_node_name, business_no, ' +
+        'operator, expire_time, variable, create_time, create_user, update_time, update_user';
+    async findInstanceById(id) {
+        const conn = await this.c();
+        try {
+            const row = await conn.fetchOne(this.sql(`SELECT ${JdbcRepository.INSTANCE_COLS} FROM wf_process_instance WHERE id = ?`), [id]);
+            if (!row)
+                return null;
+            const inst = new ProcessInstance({
+                id: row.id, parentId: row.parent_id, defineId: row.process_define_id,
+                state: row.state, parentNodeName: row.parent_node_name, businessNo: row.business_no,
+                operator: row.operator, expireTime: row.expire_time,
+                createTime: row.create_time, createUser: row.create_user,
+                updateTime: row.update_time, updateUser: row.update_user,
+                tasks: [],
+            });
+            inst.variables = row.variable ? JSON.parse(row.variable) : {};
+            return inst;
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async saveInstance(inst) {
+        const conn = await this.c();
+        try {
+            await conn.execute(this.sql('INSERT INTO wf_process_instance (id, parent_id, process_define_id, state, ' +
+                'parent_node_name, business_no, operator, expire_time, variable, ' +
+                'create_time, create_user, update_time, update_user) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)'), [inst.id, inst.parentId ?? null, inst.defineId, inst.state, inst.parentNodeName ?? '',
+                inst.businessNo ?? '', inst.operator, inst.expireTime ?? null,
+                JSON.stringify(inst.variables ?? {}), inst.createTime, inst.createUser,
+                inst.updateTime, inst.updateUser]);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async updateInstance(inst) {
+        const conn = await this.c();
+        try {
+            await conn.execute(this.sql('UPDATE wf_process_instance SET state=?, parent_node_name=?, business_no=?, ' +
+                'operator=?, expire_time=?, variable=?, update_time=?, update_user=? WHERE id=?'), [inst.state, inst.parentNodeName ?? '', inst.businessNo ?? '', inst.operator,
+                inst.expireTime ?? null, JSON.stringify(inst.variables ?? {}),
+                inst.updateTime, inst.updateUser, inst.id]);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    // ── ProcessTask ───────────────────────────────────────────────────────────
+    static TASK_COLS = 'id, process_instance_id, task_name, display_name, task_type, perform_type, ' +
+        'task_state, operator, finish_time, expire_time, form_key, task_parent_id, ' +
+        'variable, create_time, create_user, update_time, update_user';
+    async findTaskById(taskId) {
+        const conn = await this.c();
+        try {
+            const row = await conn.fetchOne(this.sql(`SELECT ${JdbcRepository.TASK_COLS} FROM wf_process_task WHERE id = ?`), [taskId]);
+            if (!row)
+                return null;
+            const task = this.mapTask(row);
+            task.actorIds = await this.findTaskActors(taskId);
+            return task;
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async saveTask(task) {
+        const conn = await this.c();
+        try {
+            await conn.execute(this.sql('INSERT INTO wf_process_task (id, process_instance_id, task_name, display_name, ' +
+                'task_type, perform_type, task_state, operator, finish_time, expire_time, form_key, ' +
+                'task_parent_id, variable, create_time, create_user, update_time, update_user) ' +
+                'VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)'), [task.id, task.processInstanceId, task.taskName, task.displayName, task.taskType ?? 0,
+                task.performType ?? 0, task.taskState, task.actorId ?? '', task.finishTime ?? null,
+                task.expireTime ?? null, task.formKey ?? '', task.parentTaskId ?? null,
+                JSON.stringify(task.variables ?? {}), task.createTime, task.createUser,
+                task.updateTime, task.updateUser]);
+            await this.replaceTaskActors(conn, task.id, task.actorIds ?? []);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async updateTask(task) {
+        const conn = await this.c();
+        try {
+            await conn.execute(this.sql('UPDATE wf_process_task SET task_state=?, operator=?, finish_time=?, expire_time=?, ' +
+                'variable=?, update_time=?, update_user=? WHERE id=?'), [task.taskState, task.actorId ?? '', task.finishTime ?? null, task.expireTime ?? null,
+                JSON.stringify(task.variables ?? {}), task.updateTime, task.updateUser, task.id]);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async findTasksByState(instanceId, state, taskNames) {
+        let sql = `SELECT ${JdbcRepository.TASK_COLS} FROM wf_process_task WHERE process_instance_id = ?`;
+        const args = [instanceId];
+        if (state !== null) {
+            sql += ' AND task_state = ?';
+            args.push(state);
+        }
+        if (taskNames && taskNames.length > 0) {
+            sql += ` AND task_name IN (${repeatPh(taskNames.length)})`;
+            args.push(...taskNames);
+        }
+        sql += ' ORDER BY id ASC';
+        const conn = await this.c();
+        try {
+            const rows = await conn.fetchAll(this.sql(sql), args);
+            const tasks = rows.map(r => this.mapTask(r));
+            if (tasks.length > 0) {
+                const ids = tasks.map(t => t.id);
+                const actorRows = await conn.fetchAll(this.sql(`SELECT process_task_id, actor_id FROM wf_process_task_actor WHERE process_task_id IN (${repeatPh(ids.length)}) ORDER BY id ASC`), ids);
+                for (const t of tasks)
+                    t.actorIds = [];
+                for (const r of actorRows) {
+                    const t = tasks.find(x => x.id === r.process_task_id);
+                    if (t)
+                        t.actorIds.push(r.actor_id);
+                }
+            }
+            return tasks;
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async findDoingTasks(instanceId, taskNames) {
+        return this.findTasksByState(instanceId, TaskState.Doing, taskNames);
+    }
+    async findDoneTasks(instanceId, taskNames) {
+        return this.findTasksByState(instanceId, TaskState.Done, taskNames);
+    }
+    async findHistoryTasks(instanceId) {
+        return this.findTasksByState(instanceId, null);
+    }
+    mapTask(row) {
+        const task = new ProcessTask({
+            id: row.id, processInstanceId: row.process_instance_id, taskName: row.task_name,
+            displayName: row.display_name, taskType: row.task_type, performType: row.perform_type,
+            taskState: row.task_state, actorId: row.operator, finishTime: row.finish_time,
+            expireTime: row.expire_time, formKey: row.form_key, parentTaskId: row.task_parent_id,
+            createTime: row.create_time, createUser: row.create_user,
+            updateTime: row.update_time, updateUser: row.update_user,
+        });
+        task.variables = row.variable ? JSON.parse(row.variable) : {};
+        task.actorIds = [];
+        return task;
+    }
+    // ── TaskActor ─────────────────────────────────────────────────────────────
+    async replaceTaskActors(conn, taskId, actors) {
+        await conn.execute(this.sql('DELETE FROM wf_process_task_actor WHERE process_task_id = ?'), [taskId]);
+        await this.insertTaskActors(conn, taskId, actors);
+    }
+    async insertTaskActors(conn, taskId, actors) {
+        const now = new Date();
+        for (const a of actors) {
+            await conn.execute(this.sql('INSERT INTO wf_process_task_actor (id, process_task_id, actor_id, create_time, create_user) VALUES (?,?,?,?,?)'), [this.idGen.nextId(), taskId, a, now, 'jeeflow']);
+        }
+    }
+    async findTaskActors(taskId) {
+        const conn = await this.c();
+        try {
+            const rows = await conn.fetchAll(this.sql('SELECT actor_id FROM wf_process_task_actor WHERE process_task_id = ? ORDER BY id ASC'), [taskId]);
+            return rows.map(r => r.actor_id);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async addTaskActor(taskId, actors) {
+        const conn = await this.c();
+        try {
+            await this.insertTaskActors(conn, taskId, actors);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async removeTaskActor(taskId, actors) {
+        if (actors.length === 0)
+            return;
+        const conn = await this.c();
+        try {
+            await conn.execute(this.sql(`DELETE FROM wf_process_task_actor WHERE process_task_id = ? AND actor_id IN (${repeatPh(actors.length)})`), [taskId, ...actors]);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    // ── CcInstance（抄送）─────────────────────────────────────────────────────
+    async createCcInstance(instanceId, creator, ...actorIds) {
+        const conn = await this.c();
+        try {
+            const now = new Date();
+            for (const actorId of actorIds) {
+                await conn.execute(this.sql('INSERT INTO wf_process_cc_instance (id, process_instance_id, actor_id, state, ' +
+                    'create_time, create_user, update_time, update_user) VALUES (?,?,?,0,?,?,?,?)'), [this.idGen.nextId(), instanceId, actorId, now, creator, now, creator]);
+            }
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+    async updateCcStatus(instanceId, actorId) {
+        const conn = await this.c();
+        try {
+            await conn.execute(this.sql('UPDATE wf_process_cc_instance SET state=1, update_time=? WHERE process_instance_id=? AND actor_id=?'), [new Date(), instanceId, actorId]);
+        }
+        finally {
+            await this.done(conn);
+        }
+    }
+}

package/dist/memory.d.ts

@@ -0,0 +1,29 @@
+import type { ProcessDefine } from './model.js';
+import { type ProcessInstance, type ProcessTask } from './model.js';
+import type { ProcessRepository } from './spi.js';
+export declare class MemoryRepository implements ProcessRepository {
+    private defines;
+    private instances;
+    private tasks;
+    private actors;
+    private seq;
+    addDefine(def: ProcessDefine): void;
+    findDefineById(id: number): Promise<ProcessDefine | null>;
+    saveInstance(inst: ProcessInstance): Promise<void>;
+    updateInstance(inst: ProcessInstance): Promise<void>;
+    findInstanceById(id: number): Promise<ProcessInstance | null>;
+    findTaskById(id: number): Promise<ProcessTask | null>;
+    saveTask(task: ProcessTask): Promise<void>;
+    updateTask(task: ProcessTask): Promise<void>;
+    findDoingTasks(instanceId: number, taskNames?: string[]): Promise<ProcessTask[]>;
+    findDoneTasks(instanceId: number, _taskNames?: string[]): Promise<ProcessTask[]>;
+    findHistoryTasks(instanceId: number): Promise<ProcessTask[]>;
+    findTaskActors(taskId: number): Promise<string[]>;
+    addTaskActor(taskId: number, actors: string[]): Promise<void>;
+    removeTaskActor(taskId: number, actors: string[]): Promise<void>;
+    createCcInstance(..._args: any[]): Promise<void>;
+    updateCcStatus(..._args: any[]): Promise<void>;
+    allDefines(): ProcessDefine[];
+    allInstances(): ProcessInstance[];
+    allTasks(): ProcessTask[];
+}

package/dist/memory.js

@@ -0,0 +1,127 @@
+import { cloneInstance, cloneTask } from './model.js';
+export class MemoryRepository {
+    defines = new Map();
+    instances = new Map();
+    tasks = new Map();
+    actors = new Map();
+    seq = 1;
+    addDefine(def) {
+        if (!def.id)
+            def.id = this.seq++;
+        this.defines.set(def.id, def);
+    }
+    async findDefineById(id) { return this.defines.get(id) ?? null; }
+    async saveInstance(inst) {
+        if (!inst.id)
+            inst.id = this.seq++;
+        const cp = cloneInstance(inst);
+        cp.tasks = [];
+        this.instances.set(inst.id, cp);
+    }
+    async updateInstance(inst) {
+        const cp = cloneInstance(inst);
+        cp.tasks = [];
+        this.instances.set(inst.id, cp);
+    }
+    async findInstanceById(id) {
+        const inst = this.instances.get(id);
+        if (!inst)
+            return null;
+        const cp = cloneInstance(inst);
+        cp.tasks = [];
+        for (const t of this.tasks.values()) {
+            if (t.processInstanceId === id) {
+                const tc = cloneTask(t);
+                tc.actorIds = this.actors.get(t.id) ?? t.actorIds;
+                cp.tasks.push(tc);
+            }
+        }
+        return cp;
+    }
+    async findTaskById(id) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return null;
+        const cp = cloneTask(t);
+        cp.actorIds = this.actors.get(id) ?? t.actorIds;
+        return cp;
+    }
+    async saveTask(task) {
+        if (!task.id)
+            task.id = this.seq++;
+        const cp = cloneTask(task);
+        cp.actorIds = [];
+        this.tasks.set(task.id, cp);
+        if (task.actorIds.length)
+            this.actors.set(task.id, [...task.actorIds]);
+    }
+    async updateTask(task) {
+        const cp = cloneTask(task);
+        cp.actorIds = [];
+        this.tasks.set(task.id, cp);
+        if (task.actorIds.length)
+            this.actors.set(task.id, [...task.actorIds]);
+    }
+    async findDoingTasks(instanceId, taskNames) {
+        const result = [];
+        for (const t of this.tasks.values()) {
+            if (t.processInstanceId === instanceId && t.taskState === 10) {
+                if (taskNames?.length && !taskNames.includes(t.taskName))
+                    continue;
+                const cp = cloneTask(t);
+                cp.actorIds = this.actors.get(t.id) ?? t.actorIds;
+                result.push(cp);
+            }
+        }
+        return result;
+    }
+    async findDoneTasks(instanceId, _taskNames) {
+        const result = [];
+        for (const t of this.tasks.values()) {
+            if (t.processInstanceId === instanceId && t.taskState === 20) {
+                const cp = cloneTask(t);
+                cp.actorIds = this.actors.get(t.id) ?? t.actorIds;
+                result.push(cp);
+            }
+        }
+        return result;
+    }
+    async findHistoryTasks(instanceId) {
+        const result = [];
+        for (const t of this.tasks.values()) {
+            if (t.processInstanceId === instanceId) {
+                const cp = cloneTask(t);
+                cp.actorIds = this.actors.get(t.id) ?? t.actorIds;
+                result.push(cp);
+            }
+        }
+        return result;
+    }
+    async findTaskActors(taskId) { return this.actors.get(taskId) ?? []; }
+    async addTaskActor(taskId, actors) {
+        const existing = this.actors.get(taskId) ?? [];
+        const seen = new Set(existing);
+        for (const a of actors) {
+            if (!seen.has(a)) {
+                existing.push(a);
+                seen.add(a);
+            }
+        }
+        this.actors.set(taskId, existing);
+    }
+    async removeTaskActor(taskId, actors) {
+        const remove = new Set(actors);
+        this.actors.set(taskId, (this.actors.get(taskId) ?? []).filter(a => !remove.has(a)));
+    }
+    async createCcInstance(..._args) { }
+    async updateCcStatus(..._args) { }
+    allDefines() { return [...this.defines.values()]; }
+    allInstances() { return [...this.instances.values()]; }
+    allTasks() {
+        return [...this.tasks.values()].map(t => {
+            const cp = cloneTask(t);
+            cp.actorIds = this.actors.get(t.id) ?? t.actorIds;
+            return cp;
+        });
+    }
+}

package/dist/model.d.ts

@@ -0,0 +1,137 @@
+export interface FlowModel {
+    name: string;
+    displayName: string;
+    type: string;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+}
+export interface FlowNode {
+    id: string;
+    type: string;
+    x: number;
+    y: number;
+    properties: Record<string, any>;
+    text: {
+        value: string;
+    };
+}
+export interface FlowEdge {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    properties: Record<string, any>;
+    text?: {
+        value: string;
+    };
+}
+export declare const TypeStart = "snaker:start";
+export declare const TypeEnd = "snaker:end";
+export declare const TypeTask = "snaker:task";
+export declare const TypeDecision = "snaker:decision";
+export declare const TypeFork = "snaker:fork";
+export declare const TypeJoin = "snaker:join";
+export declare const TypeCustom = "snaker:custom";
+export interface ProcessDefine {
+    id: number;
+    name: string;
+    displayName: string;
+    type: string;
+    state: number;
+    content: Uint8Array | string;
+    version: number;
+    createTime: Date;
+    createUser: string;
+    updateTime: Date;
+    updateUser: string;
+}
+export declare enum InstanceState {
+    Doing = 10,
+    Done = 20,
+    Reject = 45
+}
+export declare enum TaskState {
+    Doing = 10,
+    Done = 20,
+    Abandoned = 99
+}
+export declare const BusinessNoKey = "BUSINESS_NO";
+export declare class ProcessInstance {
+    id: number;
+    parentId?: number;
+    defineId: number;
+    state: InstanceState;
+    parentNodeName: string;
+    businessNo: string;
+    operator: string;
+    expireTime?: Date;
+    variables: Record<string, any>;
+    tasks: ProcessTask[];
+    createTime: Date;
+    createUser: string;
+    updateTime: Date;
+    updateUser: string;
+    constructor(data: any);
+    /** 工厂——创建流程实例 */
+    static create(id: number, defineId: number, operator: string, vars: Record<string, any>, now: Date): ProcessInstance;
+    /** 完成任务（子实体状态转换 + 实例变量合并） */
+    completeTask(task: ProcessTask, operator: string, vars: Record<string, any>, now: Date): void;
+    /** 废弃单个任务 */
+    abandonTask(task: ProcessTask, now: Date): void;
+    /** 废弃所有进行中任务，返回被废弃列表（供调用方持久化） */
+    abandonAllDoing(now: Date): ProcessTask[];
+    /** 流程完成 */
+    finish(now: Date): void;
+    /** 驳回流程 */
+    reject(now: Date): void;
+    /** 追加变量 */
+    addVariable(vars: Record<string, any>): void;
+    /** 获取进行中任务 */
+    getDoingTasks(): ProcessTask[];
+    /** 获取已完成任务 */
+    getDoneTasks(): ProcessTask[];
+    /** 所有任务是否都已完成（join 合并判断） */
+    isAllTasksFinished(): boolean;
+    /** 创建任务（子实体工厂） */
+    createTask(id: number, taskName: string, displayName: string, actor: string, operator: string, formKey: string, now: Date): ProcessTask;
+}
+export declare class ProcessTask {
+    id: number;
+    processInstanceId: number;
+    taskName: string;
+    displayName: string;
+    taskType: number;
+    performType: number;
+    taskState: TaskState;
+    actorId: string;
+    actorIds: string[];
+    finishTime?: Date;
+    expireTime?: Date;
+    formKey: string;
+    parentTaskId?: number;
+    variables: Record<string, any>;
+    createTime: Date;
+    createUser: string;
+    updateTime: Date;
+    updateUser: string;
+    constructor(data: any);
+    /** 完成任务 */
+    finish(operator: string, vars: Record<string, any>, now: Date): void;
+    /** 废弃任务 */
+    abandon(now: Date): void;
+    /** 是否进行中 */
+    isDoing(): boolean;
+    /** 是否已完成 */
+    isFinished(): boolean;
+    /** 操作人是否有权限处理 */
+    isAllowed(operator: string): boolean;
+}
+export declare function cloneInstance(inst: ProcessInstance): ProcessInstance;
+export declare function cloneTask(task: ProcessTask): ProcessTask;
+export interface UserInfo {
+    userId: string;
+    realName: string;
+    deptId?: string;
+    deptName?: string;
+    postId?: string;
+    postName?: string;
+}