@aiao/rxdb-plugin-history 0.0.0-stage → 0.0.26

package/src/redo-stack.ts

@@ -0,0 +1,79 @@
+import type { HistoryItem } from '@aiao/rxdb';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+/**
+ * Redo 栈容量上限（会话内）
+ *
+ * 超过则丢弃最旧的项（尾部），避免长会话下无界增长。
+ */
+export const MAX_REDO_STACK_SIZE = 1000;
+
+/**
+ * 会话级 Redo 栈
+ *
+ * 从 HistoryManager 抽离的 redo 栈管理子模块：
+ * - 持有内存 `BehaviorSubject<HistoryItem[]>`（不持久化）
+ * - 新项总在头部（push 后第一个）
+ * - 容量上限 `MAX_REDO_STACK_SIZE`
+ *
+ * 设计理由：
+ * - HistoryManager 原本 1120 行，redo 栈状态 + 操作占 60+ 行且与 history 查询/undo 流程正交
+ * - 独立后可单测，并避免泄漏 BehaviorSubject 引用
+ *
+ * @internal 由 HistoryManager 持有；外部通过 HistoryManager 公共 API 访问
+ */
+export class RedoStack {
+  readonly #subject = new BehaviorSubject<HistoryItem[]>([]);
+
+  /**
+   * 当前 redo 栈的可观察流（新项在前）
+   */
+  get items$(): Observable<HistoryItem[]> {
+    return this.#subject.asObservable();
+  }
+
+  /**
+   * 当前栈快照
+   */
+  get value(): HistoryItem[] {
+    return this.#subject.value;
+  }
+
+  /**
+   * 将一组历史项压入栈顶（items 在前）
+   *
+   * 超过 MAX_REDO_STACK_SIZE 时丢弃尾部最旧项。
+   */
+  push(items: HistoryItem[]): void {
+    const merged = [...items, ...this.#subject.value];
+    const capped = merged.length > MAX_REDO_STACK_SIZE ? merged.slice(0, MAX_REDO_STACK_SIZE) : merged;
+    this.#subject.next(capped);
+  }
+
+  /**
+   * 按稳定身份（`fingerprint`）移除已应用的项。
+   *
+   * @param items - 已经 redo 完成、需要出栈的项
+   * @returns 实际被移除的项（按栈中原顺序）；不在栈中的项被忽略
+   *
+   * @remarks
+   * **不能用「移除 N 项」代替身份匹配**：作用域 redo 会先按 scope 筛出本作用域的项再应用，
+   * 这些项未必位于栈顶。按数量截栈顶会删掉栈头那些**未被 redo** 的项（它们从此丢失），
+   * 而真正已 redo 的项仍留在栈里可以被重复执行。
+   */
+  remove(items: HistoryItem[]): HistoryItem[] {
+    const targets = new Set(items.map(item => item.fingerprint));
+    const current = this.#subject.value;
+    const removed = current.filter(item => targets.has(item.fingerprint));
+    if (removed.length === 0) return removed;
+    this.#subject.next(current.filter(item => !targets.has(item.fingerprint)));
+    return removed;
+  }
+
+  /**
+   * 清空栈
+   */
+  clear(): void {
+    this.#subject.next([]);
+  }
+}

package/src/remove-branch.ts

@@ -0,0 +1,89 @@
+import {
+  type LocalRxDBBranchRepository,
+  type LocalRxDBChangeRepository,
+  RxDBBranch,
+  RxDBChange,
+  RxDBError
+} from '@aiao/rxdb';
+import { VersionManager } from './VersionManager.js';
+
+/**
+ * 移除一个分支
+ * @param version
+ * @param branchId
+ *
+ * @remarks
+ * 「查子分支 → 查 change → 删」整段必须在一个事务窗口内完成。
+ * 拆开之后，检查与删除之间新建的子分支会漏判，留下 `parentId` 指向不存在分支的孤儿，
+ * 而孤儿又会被切分支时的「父节点缺失即当作到根」静默吞掉，损坏无声。
+ *
+ * 事务体内一律用 `executor.getRepository(...)`：绑在适配器上的仓库会重新入队，
+ * 排在自己这个事务后面（队列并发度 1），永久挂起。
+ */
+export const remove_branch = async (version: VersionManager, branchId: string) => {
+  const { adapter } = await version.getLocalRepositories();
+  // 检查是否为主分支
+  if (branchId === 'main') {
+    throw new RxDBError(`Cannot remove main branch`);
+  }
+
+  // 校验失败**返回**而不是就地抛出：抛出会被适配器的事务包装层裹成适配器错误类型
+  // （`RxDBAdapterSqliteError` 等），调用方拿到的异常身份就跟着实现细节变了。
+  // 校验失败时本事务一行都没写，回不回滚无所谓，留到事务外抛更稳。
+  const rejection = await adapter.transaction(async executor => {
+    const branchRepository = executor.getRepository(RxDBBranch) as unknown as LocalRxDBBranchRepository;
+    const changeRepository = executor.getRepository(RxDBChange) as unknown as LocalRxDBChangeRepository;
+
+    // 检查分支是否存在
+    const branch = (
+      await branchRepository.find({
+        where: {
+          combinator: 'and',
+          rules: [{ field: 'id', operator: '=', value: branchId }]
+        },
+        limit: 1
+      })
+    )[0];
+
+    if (!branch) {
+      return `Branch '${branchId}' not found`;
+    }
+
+    // 检查分支是否为激活状态
+    if (branch.activated) {
+      return `Cannot remove active branch '${branchId}'. Switch to another branch first.`;
+    }
+
+    // 检查是否有子分支依赖于该分支
+    //
+    // 必须直接查 `parentId`：拿「父分支有哪些 change、子分支的 fromChangeId 是否落在其中」
+    // 反推拓扑有两个漏洞 —— 父分支一条 change 都没有时整段检查被跳过；子分支的 fromChangeId
+    // 指向的 change 若已被清理也会漏判。两者都留下 `parentId` 指向不存在分支的孤儿。
+    const childBranches = await branchRepository.find({
+      where: {
+        combinator: 'and',
+        rules: [
+          { field: 'parentId', operator: '=', value: branchId },
+          { field: 'id', operator: '!=', value: branchId }
+        ]
+      },
+      limit: 1
+    });
+    if (childBranches?.length) {
+      return `Cannot remove branch '${branchId}' because it has child branches`;
+    }
+
+    const branchChanges = await changeRepository.find({
+      where: {
+        combinator: 'and',
+        rules: [{ field: 'branchId', operator: '=', value: branchId }]
+      }
+    });
+    await executor.removeMany([...branchChanges, branch]);
+    return undefined;
+  });
+
+  if (rejection) {
+    throw new RxDBError(rejection);
+  }
+};

package/src/restore-entity.ts

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview 恢复被删除实体的纯逻辑
+ *
+ * 从 {@link VersionManager.restoreEntity} 抽出的独立实现，遵循
+ * `create_branch` / `merge_branch` 的「接收 VersionManager 实例」模式。
+ */
+
+import { EntityType, getEntityMetadata, RestoreEntityOptions, RxDBError } from '@aiao/rxdb';
+import { get_switch_version_actions } from './switch-branch-actions.js';
+import type { VersionManager } from './VersionManager.js';
+
+/**
+ * 恢复被删除的实体。
+ *
+ * 根据 RxDBChange 记录中的 inversePatch 重新插入实体，
+ * 恢复操作本身会生成新的 RxDBChange 记录（可被 push 到远程）。
+ *
+ * @param vm - 版本管理器实例
+ * @param entity - 被删除的实体实例（需要包含 metadata 信息）
+ * @param options - 恢复选项，包含 changeId（DELETE 类型的 RxDBChange 记录 ID）
+ * @returns 恢复后的实体实例
+ */
+export async function restore_entity<T extends EntityType>(
+  vm: VersionManager,
+  entity: InstanceType<T>,
+  options: RestoreEntityOptions
+): Promise<InstanceType<T>> {
+  const { changeRepository, adapter } = await vm.getLocalRepositories();
+
+  const changes = await changeRepository.find({
+    where: {
+      combinator: 'and',
+      rules: [{ field: 'id', operator: '=', value: Number(options.changeId) }]
+    },
+    limit: 1
+  });
+
+  if (changes.length === 0) {
+    throw new RxDBError(`RxDBChange not found: ${options.changeId}`);
+  }
+
+  const change = changes[0];
+
+  if (change.type !== 'DELETE') {
+    throw new RxDBError(`Cannot restore from non-DELETE change (type=${change.type})`);
+  }
+
+  if (!change.inversePatch) {
+    throw new RxDBError(`RxDBChange ${options.changeId} has no inversePatch`);
+  }
+
+  const EntityType = entity.constructor as T;
+  const metadata = getEntityMetadata(EntityType);
+  const currentBranch = await vm.getCurrentBranch();
+
+  // 身份校验必须在写入之前：只校验 changeId/type/inversePatch 时，传 A 的实体配 B 的 changeId
+  // 会真的把 B 恢复出来，再用 A 的 constructor 去查 —— 返回 undefined，而返回类型声明是非空的
+  // InstanceType<T>。分支同理：别的分支的 change 不能应用到当前分支。
+  if (change.namespace !== metadata.namespace || change.entity !== metadata.name) {
+    throw new RxDBError(
+      `RxDBChange ${options.changeId} belongs to ${change.namespace}:${change.entity}, ` +
+        `not ${metadata.namespace}:${metadata.name}`
+    );
+  }
+  if (change.branchId != null && change.branchId !== currentBranch.id) {
+    throw new RxDBError(
+      `RxDBChange ${options.changeId} belongs to branch '${change.branchId}', current branch is '${currentBranch.id}'`
+    );
+  }
+
+  const actions = get_switch_version_actions([change], false);
+  // 不能走 switchBranch：各适配器的 switch_branch 第一步就是 remove_all_triggers_sql
+  // （见 sqlite-core / pglite 的 version/switch_branch.ts），恢复出来的行不会产生任何 change 行——
+  // 本函数的 TSDoc 说「恢复操作本身会生成新的 RxDBChange 记录（可被 push 到远程）」直接落空，
+  // 远端永远停在「已删除」，本地与远端静默分叉。
+  // 改走 mergeChanges(actions, undefined, false)：与 merge_branch 的 squash 出口同路，
+  // disableTriggers=false 让数据库触发器照常记账。
+  await adapter.mergeChanges(actions, undefined, false);
+
+  const repo = adapter.getRepository(EntityType);
+  const restored = await repo.find({
+    where: {
+      combinator: 'and',
+      rules: [{ field: 'id', operator: '=', value: change.entityId }]
+    },
+    limit: 1
+  });
+
+  // 返回类型是非空的 InstanceType<T>，恢复不出行时必须抛错而不是让 undefined 冒充实体
+  if (!restored[0]) {
+    throw new RxDBError(
+      `Restore produced no row for ${metadata.namespace}:${metadata.name} id=${String(change.entityId)}`
+    );
+  }
+
+  return restored[0] as InstanceType<T>;
+}

package/src/scope-selection.ts

@@ -0,0 +1,132 @@
+/**
+ * 作用域历史选择（纯函数）
+ *
+ * @packageDocumentation
+ *
+ * `history(scope).undo()` 的选择口径与展示口径**不是同一件事**：
+ *
+ * - 展示（`filterHistoriesByScope`）可以把一个事务裁成「与你有关的那几条」，
+ *   用户在 User 的历史面板上看到的就该是 User 的部分；
+ * - 执行**不能**这么裁。事务是原子的，只回滚它的一半会留下一个从未存在过的中间态
+ *   （订单被撤销、订单行还在）。
+ *
+ * 因此这里把「选哪几条」和「能不能整条应用」分开：`selectScopedHistories` 只返回
+ * **完整未裁剪**的历史项，凡是触及作用域但同时改了作用域外数据的事务，一律进
+ * `crossScope` 由调用方拒绝（{@link RxDBCrossScopeTransactionError}）。
+ *
+ * 为什么是「拒绝」而不是「连带撤销作用域外的部分」：作用域的契约是**只影响这个作用域**。
+ * 悄悄扩大影响面，调用方无从知道自己刚刚还回滚了别的仓库；而静默跳过则是点了撤销
+ * 什么都没发生。报错是唯一一个既不越权、又不骗人的选项，且可恢复——调用方改用
+ * `history()`（database 作用域）就能完整撤销这个事务。
+ */
+
+import { HistoryItem, HistoryScope, RxDBChange, RxDBError } from '@aiao/rxdb';
+/** 判定作用域归属只需要这三个字段 */
+type ScopedChange = Pick<RxDBChange, 'entity' | 'entityId' | 'namespace'>;
+
+/**
+ * 单条变更是否落在作用域内
+ *
+ * @remarks
+ * entity 作用域用 `===` 比较 id，`0` / `''` 这类假值同样是合法 id——
+ * 判空必须用 `undefined` 而不是真值判断，否则 `entityId = 0` 会退化成 repository 作用域。
+ */
+export function isChangeInScope(change: ScopedChange, scope: HistoryScope): boolean {
+  if (scope.type === 'database') return true;
+  if (change.namespace !== scope.namespace || change.entity !== scope.entity) return false;
+  return scope.type === 'repository' || change.entityId === scope.entityId;
+}
+
+/** 历史项是否**至少有一条**变更落在作用域内（决定它是否出现在该作用域的历史里） */
+export function historyTouchesScope(history: HistoryItem, scope: HistoryScope): boolean {
+  return history.changes.some(change => isChangeInScope(change, scope));
+}
+
+/** 历史项是否**全部**变更都落在作用域内（决定它能否被该作用域整条应用） */
+export function isHistoryWithinScope(history: HistoryItem, scope: HistoryScope): boolean {
+  return history.changes.every(change => isChangeInScope(change, scope));
+}
+
+/** {@link selectScopedHistories} 的结果 */
+export interface ScopedHistorySelection {
+  /** 触及作用域、但同时改了作用域外数据的事务：不可部分应用 */
+  crossScope: HistoryItem[];
+  /** 完全落在作用域内、可以整条应用的历史项（未被裁剪） */
+  selected: HistoryItem[];
+}
+
+/**
+ * 在作用域内挑出接下来 `step` 条要 undo / redo 的历史项
+ *
+ * @param histories - 候选历史（已按可撤销 / 可重做过滤，最新在前）
+ * @param scope - 作用域
+ * @param step - 取几条；非正数取 0 条
+ *
+ * @remarks
+ * `step` 数的是「触及作用域的历史项」，越界事务同样占一个名额而不是被跳过——
+ * undo 必须后进先出，跳过它去撤更早的那条会把顺序弄乱。
+ */
+export function selectScopedHistories(
+  histories: HistoryItem[],
+  scope: HistoryScope,
+  step: number
+): ScopedHistorySelection {
+  const window = histories.filter(history => historyTouchesScope(history, scope)).slice(0, Math.max(0, step));
+  const crossScope: HistoryItem[] = [];
+  const selected: HistoryItem[] = [];
+
+  for (const history of window) {
+    if (isHistoryWithinScope(history, scope)) {
+      selected.push(history);
+    } else {
+      crossScope.push(history);
+    }
+  }
+
+  return { crossScope, selected };
+}
+
+const describeScope = (scope: HistoryScope): string => {
+  if (scope.type === 'database') return 'database';
+  if (scope.type === 'repository') return `${scope.namespace}:${scope.entity}`;
+  return `${scope.namespace}:${scope.entity}#${String(scope.entityId)}`;
+};
+
+const describeOutsiders = (histories: readonly HistoryItem[], scope: HistoryScope): string => {
+  const outsiders = new Set<string>();
+  for (const history of histories) {
+    for (const change of history.changes) {
+      if (isChangeInScope(change, scope)) continue;
+      outsiders.add(
+        scope.type === 'entity' ?
+          `${change.namespace}:${change.entity}#${String(change.entityId)}`
+        : `${change.namespace}:${change.entity}`
+      );
+    }
+  }
+  return [...outsiders].join(', ');
+};
+
+/**
+ * 作用域 undo / redo 撞上跨作用域事务
+ *
+ * @remarks
+ * 拿到本错误说明选中的历史项里有事务同时改了作用域内外的数据。作用域**不会**替你决定
+ * 是牺牲原子性还是越权撤销，改用不带参数的 `rxdb.versionManager.history()`
+ * （database 作用域）可以完整撤销这个事务。`historyManager` 是私有字段，够不到。
+ */
+export class RxDBCrossScopeTransactionError extends RxDBError {
+  constructor(
+    /** 发起 undo / redo 的作用域 */
+    readonly scope: HistoryScope,
+    /** 越界的历史项（完整未裁剪） */
+    readonly histories: readonly HistoryItem[]
+  ) {
+    super(
+      `Scoped history operation would split a transaction: scope ${describeScope(scope)} also changes ` +
+        `${describeOutsiders(histories, scope)}. Use the database scope to apply the whole transaction.`
+    );
+    this.name = 'RxDBCrossScopeTransactionError';
+    Object.setPrototypeOf(this, RxDBCrossScopeTransactionError.prototype);
+  }
+}

package/src/switch-branch-actions.ts

@@ -0,0 +1,238 @@
+import {
+  EntityStaticType,
+  getRxDBChangeKey,
+  LocalRxDBChangeRepository,
+  RxDBChange,
+  RxDBError,
+  SwitchVersionActions
+} from '@aiao/rxdb';
+import { find_switch_branch_step } from './find-switch-branch-step.js';
+import { VersionManager } from './VersionManager.js';
+/**
+ * 计算切换分支所需的操作
+ * @param version
+ * @param branchId 要切换到的分支ID
+ * @returns 返回切换分支所需的操作序列
+ */
+export const switch_branch_actions = async (version: VersionManager, branchId: string) => {
+  const { branchRepository, changeRepository } = await version.getLocalRepositories();
+  const current_branch = (
+    await branchRepository.find({
+      where: {
+        combinator: 'and',
+        rules: [{ field: 'activated', operator: '=', value: true }]
+      },
+      limit: 1
+    })
+  )[0];
+  if (!current_branch) throw new RxDBError('Current branch not found');
+  const all_branches = await branchRepository.find({
+    where: {
+      combinator: 'and',
+      rules: []
+    }
+  });
+  const next_branch = all_branches.find(b => b.id === branchId);
+  if (!next_branch) throw new RxDBError(`Branch (${branchId}) not found`);
+  if (current_branch.id === next_branch.id) {
+    throw new RxDBError('Cannot switch to the same branch');
+  }
+
+  const currentChange = await get_branch_max_change(changeRepository, current_branch.id);
+  const nextChange = await get_branch_max_change(changeRepository, next_branch.id);
+
+  const steps = find_switch_branch_step({
+    branches: all_branches,
+    currentBranch: current_branch,
+    currentChangeId: currentChange ? currentChange.id : null,
+    nextBranch: next_branch,
+    nextChangeId: nextChange ? nextChange.id : null
+  });
+
+  const actions: SwitchVersionActions = {
+    deletes: new Map(),
+    updates: new Map(),
+    inserts: new Map()
+  };
+
+  for (let i = 0; i < steps.length; i++) {
+    const { branch, fromChangeId, toChangeId } = steps[i];
+    const is_patch = fromChangeId < toChangeId;
+    const is_inverse_patch = fromChangeId > toChangeId;
+
+    // 构建查询条件：查询 fromChangeId 和 toChangeId 之间的变更
+    // 注意：区间是开区间 (min, max]，不包含起点但包含终点
+    // 因为起点代表的状态已经存在，只需要应用之后的变更
+    const minId = Math.min(fromChangeId, toChangeId);
+    const maxId = Math.max(fromChangeId, toChangeId);
+
+    const options: EntityStaticType<typeof RxDBChange, 'findAllOptions'> = {
+      where: {
+        combinator: 'and',
+        rules: [
+          { field: 'branchId', operator: '=', value: branch.id },
+          { field: 'id', operator: '>', value: minId },
+          { field: 'id', operator: '<=', value: maxId },
+          { field: 'revertChangeId', operator: '=', value: null }
+        ]
+      }
+    };
+
+    // 对于子分支，需要额外限制：不处理 branch.fromChangeId 及之前的变更
+    // 因为这些变更属于父分支的历史，不属于当前子分支的变更范围
+    // 注意：这个限制对 is_patch 和 is_inverse_patch 都适用
+    if (branch.fromChangeId) {
+      // 已经通过 minId > branch.fromChangeId 限制过了
+      // 所以这里不需要额外处理，minId 已经确保大于 branch.fromChangeId
+      // 但为了代码清晰，明确检查一下
+      if (minId < branch.fromChangeId) {
+        options.where.rules.push({ field: 'id', operator: '>', value: branch.fromChangeId });
+      }
+    }
+    const changes = await changeRepository.find(options);
+    if (is_inverse_patch) {
+      inverse_patch_all(changes, actions);
+    } else if (is_patch) {
+      patch_all(changes, actions);
+    }
+  }
+  return actions;
+};
+
+/**
+ * 应用所有补丁
+ * @param changes 需要计算的 changes
+ * @param actions 现有的操作结果
+ */
+const patch_all = (changes: RxDBChange[], actions?: SwitchVersionActions) =>
+  get_switch_version_actions(changes, true, actions);
+
+/**
+ * 反向应用所有补丁
+ * @param changes 需要计算的 changes
+ * @param actions 现有的操作结果
+ */
+const inverse_patch_all = (changes: RxDBChange[], actions?: SwitchVersionActions) =>
+  get_switch_version_actions(changes, false, actions);
+
+/**
+ * 计算切换版本所需的操作
+ * @param changes 需要计算的 changes
+ * @param options
+ */
+export const get_switch_version_actions = (
+  changes: RxDBChange[],
+  isPatch: boolean,
+  actions: SwitchVersionActions = {
+    deletes: new Map(),
+    updates: new Map(),
+    inserts: new Map()
+  }
+): SwitchVersionActions => {
+  if (isPatch) {
+    const need_changes = [...changes].sort((a, b) => a.id - b.id);
+    for (const change of need_changes) {
+      const changeKey = getRxDBChangeKey(change);
+      switch (change.type) {
+        case 'INSERT':
+          // 浅拷贝：actions 不得持有 change.patch 的引用，否则后续 Object.assign 合并会原地
+          // 改写源 change（可能是 EntityManager 缓存实例），污染缓存
+          actions.inserts.set(changeKey, {
+            patch: { ...change.patch! },
+            inversePatch: null
+          });
+          break;
+        case 'UPDATE':
+          {
+            const existing = actions.inserts.get(changeKey) || actions.updates.get(changeKey);
+            if (existing) {
+              // 合并补丁：正向补丁累加，反向补丁保持最早的
+              if (existing.patch && change.patch) {
+                Object.assign(existing.patch, change.patch);
+              }
+              if (existing.inversePatch === null && change.inversePatch) {
+                existing.inversePatch = { ...change.inversePatch };
+              } else if (existing.inversePatch && change.inversePatch) {
+                Object.assign(existing.inversePatch, change.inversePatch);
+              }
+            } else {
+              actions.updates.set(changeKey, {
+                patch: { ...change.patch! },
+                inversePatch: { ...change.inversePatch! }
+              });
+            }
+          }
+          break;
+        case 'DELETE':
+          actions.deletes.set(changeKey, {
+            patch: null,
+            inversePatch: { ...change.inversePatch! }
+          });
+          actions.inserts.delete(changeKey);
+          actions.updates.delete(changeKey);
+          break;
+      }
+    }
+  } else {
+    const need_changes = [...changes].sort((a, b) => b.id - a.id);
+    for (const change of need_changes) {
+      const changeKey = getRxDBChangeKey(change);
+      switch (change.type) {
+        case 'INSERT':
+          // 浅拷贝的理由同正向分支：actions 不得持有 change 的补丁引用，
+          // 否则后续 Object.assign 合并会原地改写源 change（可能是 EntityManager 缓存实例）
+          actions.deletes.set(changeKey, {
+            patch: null,
+            inversePatch: { ...change.patch! }
+          });
+          actions.inserts.delete(changeKey);
+          actions.updates.delete(changeKey);
+          break;
+        case 'UPDATE':
+          {
+            // 同时查 inserts：逆向按 id 降序处理，撤销 DELETE 会先落一条 inserts，
+            // 紧接着更早的 UPDATE 必须并进那条 inserts。只查 updates 会让同一实体
+            // 同时出现在 inserts 与 updates 两张表里。
+            const existing = actions.inserts.get(changeKey) || actions.updates.get(changeKey);
+            if (existing) {
+              // 反向合并：正向补丁用 inversePatch，反向补丁用 patch
+              if (existing.patch && change.inversePatch) {
+                Object.assign(existing.patch, change.inversePatch);
+              }
+              if (existing.inversePatch && change.patch) {
+                Object.assign(existing.inversePatch, change.patch);
+              }
+            } else {
+              actions.updates.set(changeKey, {
+                patch: { ...change.inversePatch! },
+                inversePatch: { ...change.patch! }
+              });
+            }
+          }
+          break;
+        case 'DELETE':
+          actions.inserts.set(changeKey, {
+            patch: { ...change.inversePatch! },
+            inversePatch: null
+          });
+          break;
+      }
+    }
+  }
+  return actions;
+};
+
+const get_branch_max_change = async (changeRepository: LocalRxDBChangeRepository, branchId: string) => {
+  const changes = await changeRepository.find({
+    where: {
+      combinator: 'and',
+      rules: [
+        { field: 'branchId', operator: '=', value: branchId },
+        { field: 'revertChangeId', operator: '=', value: null }
+      ]
+    },
+    orderBy: [{ field: 'id', sort: 'desc' }],
+    limit: 1
+  });
+  return changes[0];
+};