Function commitMemoryBundle

packages/storage/src/memory-bundle-io.ts:127–179

(
  root: string,
  input: CommitMemoryBundleInput,
)

}

export async function commitMemoryBundle(
  root: string,
  input: CommitMemoryBundleInput,
): Promise<MemoryBundleMutationResult> {
  const memoryBytes = validateDocumentBytes('memory', input.memory);
  const pendingBytes =
    input.pending === null ? null : validateDocumentBytes('pending', input.pending);
  const current = await readMemoryBundle(root);
  if (current.revision !== input.expectedRevision) {
    throw new MemoryBundleRevisionConflictError(input.expectedRevision, current);
  }

  const target = bundleTarget(memoryBytes, pendingBytes);
  if (target.snapshot.revision === current.revision) {
    if (!input.backup) return { changed: false, snapshot: current };
    const directory = await prepareMemoryDirectory(root);
    const currentBeforeBackup = await readMemoryBundle(root);
    if (currentBeforeBackup.revision !== input.expectedRevision) {
      throw new MemoryBundleRevisionConflictError(input.expectedRevision, currentBeforeBackup);
    }
    await writeMemoryBackup(directory, input.backup);
    const currentAfterBackup = await readMemoryBundle(root);
    if (currentAfterBackup.revision !== input.expectedRevision) {
      throw new MemoryBundleRevisionConflictError(input.expectedRevision, currentAfterBackup);
    }
    return { changed: false, snapshot: currentAfterBackup };
  }

  const directory = await prepareMemoryDirectory(root);
  await assertDirectoryBinding(directory);
  const currentBeforePublication = await readMemoryBundle(root);
  if (currentBeforePublication.revision !== input.expectedRevision) {
    throw new MemoryBundleRevisionConflictError(input.expectedRevision, currentBeforePublication);
  }
  if (input.backup) {
    await writeMemoryBackup(directory, input.backup);
    const currentAfterBackup = await readMemoryBundle(root);
    if (currentAfterBackup.revision !== input.expectedRevision) {
      throw new MemoryBundleRevisionConflictError(input.expectedRevision, currentAfterBackup);
    }
  }

  await publishTransaction(directory, target, input.expectedRevision);
  const committed = await readMemoryBundle(root);
  if (committed.revision !== target.snapshot.revision) {
    throw commitOutcomeUnknown(
      'Memory bundle publication could not be verified',
      target.snapshot.revision,
      new Error(`Expected ${target.snapshot.revision}, read ${committed.revision}`),
    );
  }
  return { changed: true, snapshot: committed };
}

export async function restoreMemoryBackup(
  root: string,