@mldong/jeeflow 1.0.0

package/dist/engine.js

@@ -0,0 +1,400 @@
+import { TypeStart, TypeEnd, TypeTask, TypeDecision, TypeFork, TypeJoin, TypeCustom, ProcessInstance, TaskState, } from './model.js';
+import { EventType } from './extensions.js';
+export const KeySubmitType = 'submitType';
+export const KeyBusinessNo = 'BUSINESS_NO';
+export const KeyUserID = 'u_userId';
+export const KeyRealName = 'u_realName';
+export const KeyDeptID = 'u_deptId';
+export const KeyDeptName = 'u_deptName';
+export const KeyPostID = 'u_postId';
+export const KeyPostName = 'u_postName';
+export class EngineImpl {
+    repo;
+    userProv;
+    idGen;
+    exprEval;
+    ext;
+    registry;
+    constructor(repo, userProv, idGen, exprEval) {
+        this.repo = repo;
+        this.userProv = userProv;
+        this.idGen = idGen;
+        this.exprEval = exprEval;
+    }
+    setExtensions(ext) { this.ext = ext; }
+    setRegistry(reg) { this.registry = reg; }
+    async firePre(node, inst) {
+        if (!this.ext?.interceptors)
+            return true;
+        for (const ic of this.ext.interceptors.sort((a, b) => a.order - b.order))
+            if (!(await ic.preHandle(node, inst)))
+                return false;
+        return true;
+    }
+    async firePost(node, inst) {
+        if (!this.ext?.interceptors)
+            return;
+        for (const ic of this.ext.interceptors)
+            await ic.postHandle(node, inst);
+    }
+    async fireEvent(evt) {
+        if (!this.ext?.listeners)
+            return;
+        for (const l of this.ext.listeners)
+            await l(evt);
+    }
+    // ─── Start ─────────────────────────────────────────────────────────────────
+    async startProcessInstanceById(defineId, operator, args = {}) {
+        const def = await this.repo.findDefineById(defineId);
+        if (!def)
+            throw new Error(`define not found: ${defineId}`);
+        const content = typeof def.content === 'string' ? def.content : new TextDecoder().decode(def.content);
+        const flow = JSON.parse(content);
+        const vars = { ...args };
+        await this.addUserInfo(operator, vars);
+        const now = new Date();
+        // 聚合根工厂创建实例
+        const inst = ProcessInstance.create(this.nextId(), defineId, operator, vars, now);
+        await this.repo.saveInstance(inst);
+        await this.fireEvent({ type: EventType.ProcessStart, instanceId: inst.id, operator });
+        const startNode = findNodeByType(flow, TypeStart);
+        if (!startNode)
+            throw new Error('no start node');
+        for (const node of followEdges(flow, startNode.id)) {
+            await this.executeNode(flow, inst, node, operator, vars);
+        }
+        return (await this.repo.findInstanceById(inst.id));
+    }
+    // ─── Execute ───────────────────────────────────────────────────────────────
+    async executeProcessTask(taskId, operator, args = {}) {
+        const { task, inst } = await this.loadAndCheck(taskId, operator);
+        const vars = { ...inst.variables, ...task.variables, ...args };
+        await this.addUserInfo(operator, vars);
+        const now = new Date();
+        // 聚合根：完成任务（子实体状态转换 + 实例变量合并）
+        inst.completeTask(task, operator, vars, now);
+        await this.repo.updateTask(task);
+        await this.fireEvent({ type: EventType.TaskComplete, instanceId: inst.id, taskId: task.id, nodeId: task.taskName, operator });
+        const def = await this.repo.findDefineById(inst.defineId);
+        const flow = JSON.parse(typeof def.content === 'string' ? def.content : new TextDecoder().decode(def.content));
+        inst.variables = vars;
+        await this.repo.updateInstance(inst);
+        const curNode = findNode(flow, task.taskName);
+        if (curNode) {
+            const ct = curNode.properties?.countersignType;
+            if (ct === 'SEQUENTIAL') {
+                const doing = await this.repo.findDoingTasks(inst.id);
+                if (doing.length === 0) {
+                    const [actors, lc] = getCsState(vars, curNode.id);
+                    if (actors && lc + 1 < actors.length) {
+                        // 聚合根：创建串行会签下一步任务
+                        const nt = inst.createTask(this.nextId(), curNode.id, curNode.text.value, actors[lc + 1], operator, curNode.properties?.form ?? '', now);
+                        nt.variables = {
+                            [`nrOfInstances_${curNode.id}`]: actors.length,
+                            [`loopCounter_${curNode.id}`]: lc + 1,
+                            [`operatorList_${curNode.id}`]: actors,
+                        };
+                        await this.repo.saveTask(nt);
+                        return (await this.repo.findInstanceById(inst.id));
+                    }
+                }
+                else {
+                    return (await this.repo.findInstanceById(inst.id));
+                }
+            }
+            if (ct === 'PARALLEL' || ct?.startsWith('RATIO')) {
+                const doing = await this.repo.findDoingTasks(inst.id);
+                if (doing.length > 0)
+                    return (await this.repo.findInstanceById(inst.id));
+            }
+            for (const node of followEdges(flow, curNode.id)) {
+                if (node.type === TypeEnd) {
+                    // 聚合根：流程完成
+                    inst.finish(new Date());
+                    inst.variables = vars;
+                    await this.repo.updateInstance(inst);
+                    await this.fireEvent({ type: EventType.ProcessFinish, instanceId: inst.id, operator });
+                }
+                else {
+                    await this.executeNode(flow, inst, node, operator, vars);
+                }
+            }
+        }
+        return (await this.repo.findInstanceById(inst.id));
+    }
+    // ─── Reject ────────────────────────────────────────────────────────────────
+    async executeAndJumpToEnd(taskId, operator, args = {}) {
+        const { task, inst } = await this.loadAndCheck(taskId, operator);
+        const now = new Date();
+        // 聚合根：废弃所有进行中任务
+        for (const t of inst.abandonAllDoing(now))
+            await this.repo.updateTask(t);
+        // 子实体：完成任务
+        task.finish(operator, task.variables, now);
+        await this.repo.updateTask(task);
+        // 聚合根：驳回
+        inst.reject(now);
+        await this.repo.updateInstance(inst);
+        await this.fireEvent({ type: EventType.ProcessReject, instanceId: inst.id, taskId, operator });
+        return inst;
+    }
+    // ─── Jump ──────────────────────────────────────────────────────────────────
+    async executeAndJumpTask(taskId, operator, args = {}, targetTaskName) {
+        const { task, inst } = await this.loadAndCheck(taskId, operator);
+        const now = new Date();
+        // 聚合根：废弃所有进行中任务
+        for (const t of inst.abandonAllDoing(now))
+            await this.repo.updateTask(t);
+        // 子实体：完成任务
+        task.finish(operator, task.variables, now);
+        await this.repo.updateTask(task);
+        if (targetTaskName) {
+            const def = await this.repo.findDefineById(inst.defineId);
+            const flow = JSON.parse(typeof def.content === 'string' ? def.content : new TextDecoder().decode(def.content));
+            const target = findNode(flow, targetTaskName);
+            if (target)
+                await this.executeNode(flow, inst, target, operator, inst.variables);
+        }
+        return inst;
+    }
+    // ─── Jump To First Task（退回发起人，boot2 ROLLBACK_TO_OPERATOR=6）────────────
+    async executeAndJumpToFirstTaskNode(taskId, operator, args = {}) {
+        const { task, inst } = await this.loadAndCheck(taskId, operator);
+        const now = new Date();
+        // 聚合根：废弃所有进行中任务
+        for (const t of inst.abandonAllDoing(now))
+            await this.repo.updateTask(t);
+        // 子实体：完成任务
+        task.finish(operator, task.variables, now);
+        await this.repo.updateTask(task);
+        // 找到第一个任务节点，强制参与者为发起人，重新执行
+        const def = await this.repo.findDefineById(inst.defineId);
+        const flow = JSON.parse(typeof def.content === 'string' ? def.content : new TextDecoder().decode(def.content));
+        const startNode = findNodeByType(flow, TypeStart);
+        if (startNode) {
+            for (const node of followEdges(flow, startNode.id)) {
+                if (node.type === TypeTask || node.type === TypeCustom) {
+                    node.properties = node.properties ?? {};
+                    node.properties.assignee = inst.operator;
+                    await this.executeNode(flow, inst, node, operator, inst.variables);
+                    break;
+                }
+            }
+        }
+        return inst;
+    }
+    // ─── Helpers ───────────────────────────────────────────────────────────────
+    async loadAndCheck(taskId, operator) {
+        const task = await this.repo.findTaskById(taskId);
+        if (!task)
+            throw new Error(`task not found: ${taskId}`);
+        if (task.taskState !== TaskState.Doing)
+            throw new Error(`task not doing`);
+        if (!this.isAllowed(task, operator))
+            throw new Error(`operator ${operator} not allowed`);
+        const inst = await this.repo.findInstanceById(task.processInstanceId);
+        if (!inst)
+            throw new Error(`instance not found`);
+        return { task, inst };
+    }
+    async executeNode(flow, inst, node, operator, vars) {
+        if (!(await this.firePre(node, inst)))
+            return;
+        try {
+            switch (node.type) {
+                case TypeTask:
+                case TypeCustom:
+                    return this.createTask(node, inst, operator, vars);
+                case TypeDecision:
+                    return this.evaluateDecision(flow, inst, node, operator, vars);
+                case TypeFork:
+                    for (const n of followEdges(flow, node.id))
+                        await this.executeNode(flow, inst, n, operator, vars);
+                    return;
+                case TypeJoin: {
+                    const doing = await this.repo.findDoingTasks(inst.id);
+                    if (doing.length === 0)
+                        for (const n of followEdges(flow, node.id))
+                            await this.executeNode(flow, inst, n, operator, vars);
+                    return;
+                }
+                case TypeEnd:
+                    inst.finish(new Date());
+                    inst.variables = vars;
+                    await this.repo.updateInstance(inst);
+                    await this.fireEvent({ type: EventType.ProcessFinish, instanceId: inst.id, operator });
+                    return;
+            }
+        }
+        finally {
+            await this.firePost(node, inst);
+        }
+    }
+    async evaluateDecision(flow, inst, node, operator, vars) {
+        // 自定义决策（Registry 优先）
+        if (this.registry) {
+            const handlerName = node.properties?.decisionHandler ?? '';
+            if (handlerName) {
+                const h = this.registry.resolveDecision(handlerName);
+                if (h) {
+                    const branchId = await h.decide(node, inst, vars);
+                    if (branchId) {
+                        for (const edge of flow.edges) {
+                            if (edge.id === branchId) {
+                                const target = findNode(flow, edge.targetNodeId);
+                                if (target)
+                                    return this.executeNode(flow, inst, target, operator, vars);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // 自定义决策（Extensions 兼容）
+        if (this.ext?.decisionHandler) {
+            const handlerName = node.properties?.decisionHandler ?? '';
+            const branchId = await this.ext.decisionHandler(handlerName, node, inst, vars);
+            if (branchId) {
+                for (const edge of flow.edges) {
+                    if (edge.id === branchId) {
+                        const target = findNode(flow, edge.targetNodeId);
+                        if (target)
+                            return this.executeNode(flow, inst, target, operator, vars);
+                    }
+                }
+            }
+        }
+        // 表达式决策
+        for (const edge of flow.edges) {
+            if (edge.sourceNodeId !== node.id)
+                continue;
+            const expr = edge.properties?.expr;
+            if (!expr) {
+                const target = findNode(flow, edge.targetNodeId);
+                if (target)
+                    return this.executeNode(flow, inst, target, operator, vars);
+                return;
+            }
+            if (this.exprEval) {
+                const result = await this.exprEval.eval(expr, vars);
+                if (isTruthy(result)) {
+                    const target = findNode(flow, edge.targetNodeId);
+                    if (target)
+                        return this.executeNode(flow, inst, target, operator, vars);
+                    return;
+                }
+            }
+        }
+    }
+    async createTask(node, inst, operator, _vars) {
+        const actors = await this.resolveActors(node, inst);
+        if (!actors.length)
+            return;
+        const performType = parseInt(String(node.properties?.performType ?? '0'));
+        const ct = node.properties?.countersignType;
+        const now = new Date();
+        const form = node.properties?.form ?? '';
+        if (performType === 1 && ct) {
+            switch (ct) {
+                case 'PARALLEL':
+                    for (const actor of actors)
+                        await this.repo.saveTask(inst.createTask(this.nextId(), node.id, node.text.value, actor, operator, form, now));
+                    return;
+                case 'SEQUENTIAL': {
+                    const nt = inst.createTask(this.nextId(), node.id, node.text.value, actors[0], operator, form, now);
+                    nt.variables = {
+                        [`nrOfInstances_${node.id}`]: actors.length,
+                        [`loopCounter_${node.id}`]: 0,
+                        [`operatorList_${node.id}`]: actors,
+                    };
+                    await this.repo.saveTask(nt);
+                    return;
+                }
+                default:
+                    for (const actor of actors)
+                        await this.repo.saveTask(inst.createTask(this.nextId(), node.id, node.text.value, actor, operator, form, now));
+                    return;
+            }
+        }
+        await this.repo.saveTask(inst.createTask(this.nextId(), node.id, node.text.value, actors[0], operator, form, now));
+    }
+    async resolveActors(node, inst) {
+        // 1a. Registry 按名称解析（推荐）
+        if (this.registry) {
+            const handlerName = node.properties?.assignmentHandler ?? '';
+            if (handlerName) {
+                const h = this.registry.resolveAssignment(handlerName);
+                if (h)
+                    return await h.assign(node, inst);
+            }
+        }
+        // 1b. Extensions 兼容
+        if (this.ext?.assignmentHandler) {
+            const handlerName = node.properties?.assignmentHandler ?? '';
+            const result = await this.ext.assignmentHandler(handlerName, node, inst);
+            if (Array.isArray(result) && result.length > 0)
+                return result;
+        }
+        // 2. 固定指派 assignee（boot2 约定："applicant" → 解析为流程发起人）
+        const assignee = node.properties?.assignee;
+        if (assignee) {
+            const actors = assignee.split(',').map(s => s.trim()).filter(Boolean);
+            return actors.map(a => (a === 'applicant' ? inst.operator : a));
+        }
+        return [];
+    }
+    isAllowed(task, operator) {
+        // 子实体：actorIds 权限判断
+        return task.isAllowed(operator);
+    }
+    async addUserInfo(operator, vars) {
+        if (!this.userProv)
+            return;
+        const u = await this.userProv.getUser(operator);
+        if (!u)
+            return;
+        vars[KeyUserID] = u.userId;
+        if (u.realName)
+            vars[KeyRealName] = u.realName;
+        if (u.deptId)
+            vars[KeyDeptID] = u.deptId;
+        if (u.deptName)
+            vars[KeyDeptName] = u.deptName;
+        if (u.postId)
+            vars[KeyPostID] = u.postId;
+        if (u.postName)
+            vars[KeyPostName] = u.postName;
+    }
+    nextId() {
+        if (this.idGen)
+            return this.idGen.nextId();
+        return Date.now() * 1000 + Math.floor(Math.random() * 1000);
+    }
+}
+// ─── Pure Functions ──────────────────────────────────────────────────────────
+function findNode(flow, id) {
+    return flow.nodes.find(n => n.id === id);
+}
+function findNodeByType(flow, type) {
+    return flow.nodes.find(n => n.type === type);
+}
+function followEdges(flow, sourceId) {
+    return flow.edges
+        .filter(e => e.sourceNodeId === sourceId)
+        .map(e => findNode(flow, e.targetNodeId))
+        .filter(Boolean);
+}
+function getCsState(vars, nodeId) {
+    const actors = vars[`operatorList_${nodeId}`] ?? null;
+    const lc = parseInt(String(vars[`loopCounter_${nodeId}`] ?? '0'));
+    return [actors, lc];
+}
+function isTruthy(v) {
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'string')
+        return v !== '' && v !== 'false';
+    if (typeof v === 'number')
+        return v !== 0;
+    return v != null;
+}

package/dist/extensions.d.ts

@@ -0,0 +1,40 @@
+import type { FlowNode, ProcessInstance } from './model.js';
+/** 流程拦截器——对标 Java FlowInterceptor */
+export interface FlowInterceptor {
+    preHandle(node: FlowNode, inst: ProcessInstance): boolean | Promise<boolean>;
+    postHandle(node: FlowNode, inst: ProcessInstance): void | Promise<void>;
+    order: number;
+}
+/**
+ * 动态参与者指派——对标 Java AssignmentHandler.assign
+ * @param handlerName 节点配置的 assignmentHandler 名（如 "com.xxx.MyHandler"）
+ * @returns 参与者 ID 列表（空数组表示不处理）
+ */
+export type AssignmentHandler = (handlerName: string, node: FlowNode, inst: ProcessInstance) => string[] | Promise<string[]>;
+/**
+ * 自定义决策处理器——对标 Java DecisionHandler
+ * @param handlerName 节点配置的 decisionHandler 名
+ * @returns 选中的分支边 ID（空字符串表示不处理）
+ */
+export type DecisionHandler = (handlerName: string, node: FlowNode, inst: ProcessInstance, vars: Record<string, any>) => string | Promise<string>;
+export declare enum EventType {
+    ProcessStart = 0,
+    ProcessFinish = 1,
+    ProcessReject = 2,
+    TaskCreate = 3,
+    TaskComplete = 4
+}
+export interface ProcessEvent {
+    type: EventType;
+    instanceId: number;
+    taskId?: number;
+    nodeId?: string;
+    operator: string;
+}
+export type ProcessEventListener = (event: ProcessEvent) => void | Promise<void>;
+export interface EngineExtensions {
+    interceptors?: FlowInterceptor[];
+    assignmentHandler?: AssignmentHandler;
+    decisionHandler?: DecisionHandler;
+    listeners?: ProcessEventListener[];
+}

package/dist/extensions.js

@@ -0,0 +1,8 @@
+export var EventType;
+(function (EventType) {
+    EventType[EventType["ProcessStart"] = 0] = "ProcessStart";
+    EventType[EventType["ProcessFinish"] = 1] = "ProcessFinish";
+    EventType[EventType["ProcessReject"] = 2] = "ProcessReject";
+    EventType[EventType["TaskCreate"] = 3] = "TaskCreate";
+    EventType[EventType["TaskComplete"] = 4] = "TaskComplete";
+})(EventType || (EventType = {}));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { EngineImpl, type Engine } from './engine.js';
+export { MemoryRepository } from './memory.js';
+export { HandlerRegistry, type IAssignmentHandler, type IDecisionHandler } from './registry.js';
+export * from './model.js';
+export type { ProcessRepository, UserProvider, IDGenerator, ExpressionEvaluator } from './spi.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { EngineImpl } from './engine.js';
+export { MemoryRepository } from './memory.js';
+export { HandlerRegistry } from './registry.js';
+export * from './model.js';

package/dist/jdbc/index.d.ts

@@ -0,0 +1,3 @@
+export { JdbcRepository, TsIDGenerator, convertPlaceholder, repeatPh, type SqlAdapter, type SqlConnection, } from './shared.js';
+export { MysqlAdapter, MysqlConnection } from './mysql.js';
+export { PostgresAdapter, PostgresConnection } from './postgres.js';

package/dist/jdbc/index.js

@@ -0,0 +1,7 @@
+// JDBC 仓储（多数据库）——共享核心 + 数据库适配器
+//
+// - JdbcRepository / TsIDGenerator / SqlAdapter（共享核心，见 shared.ts）
+// - MysqlAdapter（mysql2，`?` 原生）/ PostgresAdapter（pg，`$n`）
+export { JdbcRepository, TsIDGenerator, convertPlaceholder, repeatPh, } from './shared.js';
+export { MysqlAdapter, MysqlConnection } from './mysql.js';
+export { PostgresAdapter, PostgresConnection } from './postgres.js';

package/dist/jdbc/mysql.d.ts

@@ -0,0 +1,19 @@
+import type { Pool, PoolConnection } from 'mysql2/promise';
+import type { SqlAdapter, SqlConnection } from './shared.js';
+export declare class MysqlConnection implements SqlConnection {
+    readonly raw: PoolConnection;
+    constructor(raw: PoolConnection);
+    execute(sql: string, args: any[]): Promise<void>;
+    fetchOne(sql: string, args: any[]): Promise<any | null>;
+    fetchAll(sql: string, args: any[]): Promise<any[]>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export declare class MysqlAdapter implements SqlAdapter {
+    private readonly pool;
+    placeholder: "?";
+    constructor(pool: Pool);
+    acquire(): Promise<MysqlConnection>;
+    release(conn: SqlConnection): Promise<void>;
+}

package/dist/jdbc/mysql.js

@@ -0,0 +1,41 @@
+// MySQL 适配器（mysql2）——连接池 + `?` 占位符（与核心一致，无需转换）。
+export class MysqlConnection {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async execute(sql, args) {
+        await this.raw.execute(sql, args);
+    }
+    async fetchOne(sql, args) {
+        const [rows] = await this.raw.execute(sql, args);
+        return rows[0] ?? null;
+    }
+    async fetchAll(sql, args) {
+        const [rows] = await this.raw.execute(sql, args);
+        return rows;
+    }
+    async begin() {
+        await this.raw.beginTransaction();
+    }
+    async commit() {
+        await this.raw.commit();
+    }
+    async rollback() {
+        await this.raw.rollback();
+    }
+}
+export class MysqlAdapter {
+    pool;
+    placeholder = '?';
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async acquire() {
+        return new MysqlConnection(await this.pool.getConnection());
+    }
+    async release(conn) {
+        ;
+        conn.raw.release();
+    }
+}

package/dist/jdbc/postgres.d.ts

@@ -0,0 +1,19 @@
+import type { Pool, PoolClient } from 'pg';
+import type { SqlAdapter, SqlConnection } from './shared.js';
+export declare class PostgresConnection implements SqlConnection {
+    readonly raw: PoolClient;
+    constructor(raw: PoolClient);
+    execute(sql: string, args: any[]): Promise<void>;
+    fetchOne(sql: string, args: any[]): Promise<any | null>;
+    fetchAll(sql: string, args: any[]): Promise<any[]>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export declare class PostgresAdapter implements SqlAdapter {
+    private readonly pool;
+    placeholder: "$n";
+    constructor(pool: Pool);
+    acquire(): Promise<PostgresConnection>;
+    release(conn: SqlConnection): Promise<void>;
+}

package/dist/jdbc/postgres.js

@@ -0,0 +1,45 @@
+// PostgreSQL 适配器（pg）——连接池 + `$n` 占位符。
+//
+// > 已在开发服务器实测（PostgreSQL 16，Docker mldong-pg）。
+// > pg 无 beginTransaction API，直接执行 BEGIN/COMMIT/ROLLBACK；
+// > 其余接口与 mysql.ts 对齐——核心 SQL 由 shared.convertPlaceholder 统一转换。
+export class PostgresConnection {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async execute(sql, args) {
+        await this.raw.query(sql, args);
+    }
+    async fetchOne(sql, args) {
+        const r = await this.raw.query(sql, args);
+        return r.rows[0] ?? null;
+    }
+    async fetchAll(sql, args) {
+        const r = await this.raw.query(sql, args);
+        return r.rows;
+    }
+    async begin() {
+        await this.raw.query('BEGIN');
+    }
+    async commit() {
+        await this.raw.query('COMMIT');
+    }
+    async rollback() {
+        await this.raw.query('ROLLBACK');
+    }
+}
+export class PostgresAdapter {
+    pool;
+    placeholder = '$n';
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async acquire() {
+        return new PostgresConnection(await this.pool.connect());
+    }
+    async release(conn) {
+        ;
+        conn.raw.release();
+    }
+}

package/dist/jdbc/shared.d.ts

@@ -0,0 +1,59 @@
+import { ProcessInstance, ProcessTask, type ProcessDefine } from '../model.js';
+import type { IDGenerator, ProcessRepository } from '../spi.js';
+/** 默认 ID 生成器：时间戳毫秒 + 同毫秒递增序号（对齐 Java nextId 默认实现） */
+export declare class TsIDGenerator implements IDGenerator {
+    private last;
+    private seq;
+    nextId(): number;
+}
+/** 适配器返回的连接包装——最小接口 */
+export interface SqlConnection {
+    execute(sql: string, args: any[]): Promise<void>;
+    fetchOne(sql: string, args: any[]): Promise<any | null>;
+    fetchAll(sql: string, args: any[]): Promise<any[]>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+/** 数据库适配器——连接生命周期 + 占位符风格 */
+export interface SqlAdapter {
+    placeholder: '?' | '$n';
+    acquire(): Promise<SqlConnection>;
+    release(conn: SqlConnection): Promise<void>;
+}
+/** 把核心 SQL 的统一 `?` 占位符转换为适配器风格 */
+export declare function convertPlaceholder(sql: string, style: string): string;
+/** 生成 n 个 `?` 占位符（用于 IN 列表） */
+export declare function repeatPh(n: number): string;
+export declare class JdbcRepository implements ProcessRepository {
+    private readonly adapter;
+    private readonly idGen;
+    constructor(adapter: SqlAdapter, idGen?: IDGenerator);
+    private sql;
+    withTx<T>(fn: () => Promise<T>): Promise<T>;
+    /** 返回当前连接：有事务绑定用事务连接，否则从适配器获取 */
+    private c;
+    /** 归还非事务连接（事务连接由 withTx 统一释放） */
+    private done;
+    findDefineById(id: number): Promise<ProcessDefine | null>;
+    private static INSTANCE_COLS;
+    findInstanceById(id: number): Promise<ProcessInstance | null>;
+    saveInstance(inst: ProcessInstance): Promise<void>;
+    updateInstance(inst: ProcessInstance): Promise<void>;
+    private static TASK_COLS;
+    findTaskById(taskId: number): Promise<ProcessTask | null>;
+    saveTask(task: ProcessTask): Promise<void>;
+    updateTask(task: ProcessTask): Promise<void>;
+    private findTasksByState;
+    findDoingTasks(instanceId: number, taskNames?: string[]): Promise<ProcessTask[]>;
+    findDoneTasks(instanceId: number, taskNames?: string[]): Promise<ProcessTask[]>;
+    findHistoryTasks(instanceId: number): Promise<ProcessTask[]>;
+    private mapTask;
+    private replaceTaskActors;
+    private insertTaskActors;
+    findTaskActors(taskId: number): Promise<string[]>;
+    addTaskActor(taskId: number, actors: string[]): Promise<void>;
+    removeTaskActor(taskId: number, actors: string[]): Promise<void>;
+    createCcInstance(instanceId: number, creator: string, ...actorIds: string[]): Promise<void>;
+    updateCcStatus(instanceId: number, actorId: string): Promise<void>;
+}