alinea 2.0.0-preview.1 → 2.0.0-preview.11

package/dist/core/db/EntryTransaction.js

@@ -1,941 +0,0 @@
-import "../../chunks/chunk-CQ52GEHY.js";
-
-// src/core/db/EntryTransaction.ts
-import { Config } from "alinea/core/Config";
-import { createRecord } from "alinea/core/EntryRecord";
-import { Field } from "alinea/core/Field";
-import { createId } from "alinea/core/Id";
-import { getRoot } from "alinea/core/Internal";
-import { ListRow } from "alinea/core/ListRow";
-import { Type } from "alinea/core/Type";
-import { ListEditor } from "alinea/core/field/ListField";
-import { MediaLocation } from "alinea/core/media/MediaLocation";
-import { entryUrl, pathSuffix } from "alinea/core/util/EntryFilenames";
-import {
-  generateKeyBetween,
-  generateNKeysBetween,
-  isValidOrderKey
-} from "alinea/core/util/FractionalIndexing";
-import { entries, fromEntries, isRecord, keys } from "alinea/core/util/Objects";
-import * as paths from "alinea/core/util/Paths";
-import { slugify } from "alinea/core/util/Slugs";
-import { unreachable } from "alinea/core/util/Types";
-import { Permission, Policy } from "../Role.js";
-import { ShaMismatchError } from "../source/ShaMismatchError.js";
-import { SourceTransaction } from "../source/Source.js";
-import { assert } from "../util/Assert.js";
-import { commitChanges } from "./CommitRequest.js";
-import { aliasesFromData, aliasUrl } from "./EntryAliases.js";
-import { EntryUrlConflictError } from "./EntryUrlConflictError.js";
-var EntryTransaction = class {
-  #checks = [];
-  #messages = [];
-  #config;
-  #index;
-  #tx;
-  #fileChanges = [];
-  #policy;
-  #urlClaims;
-  constructor(config, index, source, from, policy = Policy.ALLOW_ALL) {
-    if (index.sha !== from.sha) throw new ShaMismatchError(index.sha, from.sha);
-    this.#config = config;
-    this.#index = index;
-    this.#tx = new SourceTransaction(source, from);
-    this.#policy = policy;
-  }
-  get empty() {
-    return this.#messages.length === 0;
-  }
-  create({
-    locale,
-    type,
-    data,
-    root,
-    workspace,
-    fromSeed,
-    parentId = null,
-    id = createId(),
-    insertOrder = "last",
-    status = "published",
-    overwrite = false
-  }) {
-    const config = this.#config;
-    const index = this.#index;
-    const existing = index.byId(id);
-    if (existing) {
-      parentId = existing.parentId;
-      if (!workspace) workspace = existing.workspace;
-      if (!root) root = existing.root;
-      assert(
-        existing.workspace === workspace,
-        `Cannot create entry with id ${id} in workspace ${workspace}, already exists in ${existing.workspace}`
-      );
-      assert(
-        existing.root === root,
-        `Cannot create entry with id ${id} in root ${root}, already exists in ${existing.root}`
-      );
-    }
-    const workspaces = keys(config.workspaces);
-    if (!workspace) workspace = workspaces[0];
-    assert(
-      workspace in config.workspaces,
-      `Workspace "${workspace}" not found in config`
-    );
-    const roots = keys(config.workspaces[workspace]);
-    if (!root) root = roots[0];
-    assert(
-      root in config.workspaces[workspace],
-      `Root "${root}" not found in workspace "${workspace}"`
-    );
-    const rootConfig = this.#config.workspaces[workspace][root];
-    assert(rootConfig, "Invalid root");
-    this.#policy.assert(Permission.Create, {
-      workspace,
-      root,
-      type
-    });
-    const i18n = getRoot(rootConfig).i18n;
-    if (i18n) assert(i18n.locales.includes(locale), "Invalid locale");
-    else assert(locale === null, "Invalid locale");
-    let parent;
-    if (parentId) {
-      parent = index.findFirst((entry) => {
-        return entry.id === parentId && entry.locale === locale && entry.main;
-      });
-      assert(parent, `Parent not found: ${parentId}`);
-      this.#checks.push([parent.filePath, parent.fileHash]);
-      this.#policy.assert(Permission.Create, parent);
-    }
-    const siblings = Array.from(
-      index.findMany((entry) => {
-        return entry.root === root && entry.workspace === workspace && entry.parentId === parentId;
-      })
-    );
-    assert(typeof data === "object", "Invalid data");
-    const title = data.title ?? data.path;
-    assert(typeof title === "string", "Missing title");
-    let path = slugify(typeof data.path === "string" ? data.path : title);
-    assert(path.length > 0, "Invalid path");
-    const existingPath = existing?.get(locale)?.path;
-    const hasSamePath = existingPath === path;
-    if (!hasSamePath)
-      path = this.#getAvailablePath({
-        id,
-        path,
-        parentId,
-        root,
-        workspace,
-        locale
-      });
-    if (status !== "published" && existingPath) path = existingPath;
-    if (existingPath && !hasSamePath && status === "published") {
-      this.#rename(existing.id, locale, path);
-    }
-    if (overwrite && existing?.type === "MediaFile") {
-      const prev = existing.get(null)?.main;
-      assert(prev, "Previous entry not found");
-      const prevLocation = prev.data.location;
-      if (prevLocation !== data.location)
-        this.removeFile({
-          location: MediaLocation.storagePath(
-            this.#config,
-            prev.workspace,
-            prev.data.location
-          )
-        });
-    }
-    const parentDir = parent ? parent.childrenDir : Config.filePath(this.#config, workspace, root, locale);
-    const filePath = paths.join(
-      parentDir,
-      `${path}${status === "published" ? "" : `.${status}`}.json`
-    );
-    const hasSameVersion = existing?.get(locale)?.has(status);
-    const warnDuplicate = !overwrite && hasSameVersion;
-    assert(!warnDuplicate, `Cannot create duplicate entry with id ${id}`);
-    let newIndex;
-    if (existing) {
-      newIndex = existing.index;
-      if (status === "published") {
-        const versions = index.byId(id)?.get(locale);
-        if (versions)
-          for (const [status2, version] of versions) {
-            this.#tx.remove(version.filePath);
-          }
-      }
-    } else {
-      const previous = insertOrder === "first" ? null : siblings.at(-1) ?? null;
-      const next = insertOrder === "last" ? null : siblings.at(0) ?? null;
-      newIndex = generateKeyBetween(
-        previous?.index ?? null,
-        next?.index ?? null
-      );
-    }
-    if (locale !== null && status === "published") {
-      const from = index.findFirst((entry) => {
-        return entry.id === id && entry.locale !== locale && entry.status === "published";
-      });
-      if (from) {
-        const typeInstance = this.#config.schema[type];
-        assert(typeInstance, `Type not found: ${type}`);
-        const shared = Type.sharedData(typeInstance, from.data);
-        data = { ...shared, ...data };
-      }
-    }
-    if (status === "published") {
-      const urlCandidate = {
-        id,
-        type,
-        path,
-        parentId,
-        workspace,
-        root,
-        locale,
-        data
-      };
-      data = this.#dataWithPreviousUrlAlias(
-        urlCandidate,
-        this.#publishedEntry(id, locale)
-      );
-      if (locale !== null) this.#persistSharedFields(id, locale, type, data);
-      this.#assertUniqueUrls({ ...urlCandidate, data });
-    }
-    const seeds = existing?.get(locale);
-    const seeded = fromSeed ?? seeds?.seeded ?? null;
-    const record = createRecord(
-      { id, type, index: newIndex, path, seeded, data, title },
-      status
-    );
-    const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
-    this.#tx.add(filePath, contents);
-    this.#messages.push(this.#reportOp("create", title));
-    return this;
-  }
-  #rename(entryId, locale, path) {
-    const index = this.#index;
-    const versions = index.findMany((entry) => {
-      return entry.id === entryId && entry.locale === locale;
-    });
-    for (const version of versions) {
-      const name = version.status === "published" ? path : `${path}.${version.status}`;
-      const filePath = paths.join(version.parentDir, `${name}.json`);
-      this.#tx.rename(version.filePath, filePath);
-      const childrenDir = paths.join(version.parentDir, path);
-      this.#tx.rename(version.childrenDir, childrenDir);
-    }
-  }
-  update({ id, locale, status, set }) {
-    const index = this.#index;
-    const entry = index.findFirst((entry2) => {
-      return entry2.id === id && entry2.locale === locale && entry2.status === status;
-    });
-    assert(entry, `Entry not found: ${id}`);
-    this.#policy.assert(Permission.Update, entry);
-    for (const key of keys(set)) {
-      this.#policy.assert(Permission.Update, {
-        workspace: entry.workspace,
-        root: entry.root,
-        type: entry.type,
-        id: entry.id,
-        parents: entry.parents,
-        locale: entry.locale,
-        field: key
-      });
-    }
-    const fieldUpdates = fromEntries(
-      entries(set).map(([key, value]) => {
-        return [key, value ?? null];
-      })
-    );
-    let data = { ...entry.data, ...fieldUpdates };
-    const desiredPath = slugify(
-      data.path ?? entry.data.path ?? entry.path
-    );
-    const lockPath = entry.status !== "published" && !entry.main;
-    const path = lockPath ? entry.path : this.#getAvailablePath({
-      id,
-      path: desiredPath,
-      parentId: entry.parentId,
-      root: entry.root,
-      workspace: entry.workspace,
-      locale
-    });
-    this.#checks.push([entry.filePath, entry.fileHash]);
-    const childrenDir = paths.join(entry.parentDir, path);
-    const filePath = `${childrenDir}${entry.status === "published" ? "" : `.${entry.status}`}.json`;
-    if (entry.status === "published") {
-      this.#policy.assert(Permission.Publish, entry);
-      if (filePath !== entry.filePath) this.#rename(id, locale, path);
-      const urlCandidate = {
-        id,
-        type: entry.type,
-        path,
-        parentId: entry.parentId,
-        root: entry.root,
-        workspace: entry.workspace,
-        locale,
-        data
-      };
-      data = this.#dataWithPreviousUrlAlias(urlCandidate, entry);
-      if (locale !== null)
-        this.#persistSharedFields(id, locale, entry.type, data);
-      this.#assertUniqueUrls({ ...urlCandidate, data });
-    }
-    const record = createRecord(
-      {
-        id,
-        type: entry.type,
-        index: entry.index,
-        path: entry.path,
-        seeded: entry.seeded,
-        data
-      },
-      status
-    );
-    if (entry.status !== "published" && path !== entry.path) record.path = path;
-    const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
-    this.#tx.add(filePath, contents);
-    this.#messages.push(this.#reportOp("update", entry.title));
-    return this;
-  }
-  #getAvailablePath(target) {
-    const conflictingPaths = Array.from(
-      this.#index.findMany((entry) => {
-        return entry.id !== target.id && entry.parentId === target.parentId && entry.workspace === target.workspace && entry.root === target.root && entry.locale === target.locale && (entry.path === target.path || entry.path.startsWith(`${target.path}-`));
-      })
-    ).map((entry) => entry.path);
-    const suffix = pathSuffix(target.path, conflictingPaths);
-    if (suffix !== void 0) return `${target.path}-${suffix}`;
-    return target.path;
-  }
-  #assertUniqueUrls(candidate) {
-    const claims = this.#getUrlClaims();
-    const urls = this.#candidateUrls(candidate);
-    for (const url of urls) {
-      const key = this.#urlClaimKey(candidate.workspace, candidate.root, url);
-      const existing = claims.get(key);
-      if (existing && existing.id !== candidate.id) {
-        throw new EntryUrlConflictError({
-          url,
-          entryId: existing.id,
-          workspace: candidate.workspace,
-          root: candidate.root
-        });
-      }
-    }
-    for (const [key, claim] of claims) {
-      if (claim.id === candidate.id) claims.delete(key);
-    }
-    for (const url of urls) {
-      claims.set(this.#urlClaimKey(candidate.workspace, candidate.root, url), {
-        id: candidate.id,
-        url
-      });
-    }
-  }
-  #candidateUrls(candidate) {
-    return [this.#resolvedUrl(candidate), ...aliasUrlsFromData(candidate.data)];
-  }
-  #resolvedUrl(candidate) {
-    const type = this.#config.schema[candidate.type];
-    assert(type, `Type not found: ${candidate.type}`);
-    if (candidate.url !== void 0) return candidate.url;
-    return entryUrl(type, {
-      config: this.#config,
-      path: candidate.path,
-      parentPaths: candidate.parentPaths ?? this.#parentPaths(candidate.parentId, candidate.locale),
-      locale: candidate.locale,
-      status: "published",
-      workspace: candidate.workspace,
-      root: candidate.root,
-      data: candidate.data
-    });
-  }
-  #dataWithPreviousUrlAlias(candidate, previousEntry) {
-    if (!previousEntry) return candidate.data;
-    const previousUrl = this.#resolvedUrl(previousEntry);
-    const currentUrl = this.#resolvedUrl(candidate);
-    if (previousUrl === currentUrl) return candidate.data;
-    const type = this.#config.schema[candidate.type];
-    assert(type, `Type not found: ${candidate.type}`);
-    return dataWithUrlAlias(type, candidate.data, previousUrl, currentUrl);
-  }
-  #publishedEntry(id, locale) {
-    return this.#index.findFirst((entry) => {
-      return entry.id === id && entry.locale === locale && entry.status === "published";
-    });
-  }
-  #parentPaths(parentId, locale) {
-    const result = Array();
-    let current = parentId ? this.#index.byId(parentId) : void 0;
-    while (current) {
-      const language = current.get(locale);
-      assert(language, `Missing parent language node`);
-      result.unshift(language.main.path);
-      current = current.parent ?? void 0;
-    }
-    return result;
-  }
-  #getUrlClaims() {
-    if (this.#urlClaims) return this.#urlClaims;
-    const claims = /* @__PURE__ */ new Map();
-    for (const entry of this.#index.findMany((entry2) => {
-      return entry2.status === "published";
-    })) {
-      for (const url of [
-        this.#resolvedUrl(entry),
-        ...aliasUrlsFromData(entry.data)
-      ]) {
-        claims.set(this.#urlClaimKey(entry.workspace, entry.root, url), {
-          id: entry.id,
-          url
-        });
-      }
-    }
-    this.#urlClaims = claims;
-    return claims;
-  }
-  #urlClaimKey(workspace, root, url) {
-    return `${workspace}\0${root}\0${url}`;
-  }
-  #persistSharedFields(id, locale, type, data) {
-    const index = this.#index;
-    const typeInstance = this.#config.schema[type];
-    assert(type, `Type not found: ${type}`);
-    const shared = Type.sharedData(typeInstance, data);
-    if (shared) {
-      const translations = index.findMany((entry) => {
-        return entry.id === id && entry.locale !== locale;
-      });
-      for (const translation of translations) {
-        this.#checks.push([translation.filePath, translation.fileHash]);
-        const record = createRecord(
-          {
-            id,
-            type: translation.type,
-            index: translation.index,
-            path: translation.path,
-            seeded: translation.seeded,
-            data: {
-              ...translation.data,
-              ...shared
-            }
-          },
-          translation.status
-        );
-        const contents = new TextEncoder().encode(
-          JSON.stringify(record, null, 2)
-        );
-        this.#tx.add(translation.filePath, contents);
-      }
-    }
-  }
-  #moveUrlAliasUpdates(target) {
-    const updates = Array();
-    for (const entry of this.#index.findMany((entry2) => {
-      return entry2.status === "published" && (entry2.id === target.id || entry2.parents.includes(target.id));
-    })) {
-      const parentPaths = this.#movedParentPaths(entry, target);
-      const candidate = {
-        id: entry.id,
-        type: entry.type,
-        path: entry.path,
-        parentId: entry.id === target.id ? target.parentId : entry.parentId,
-        parentPaths,
-        workspace: target.workspace,
-        root: target.root,
-        locale: entry.locale,
-        data: entry.data
-      };
-      const data = this.#dataWithPreviousUrlAlias(candidate, entry);
-      this.#assertUniqueUrls({ ...candidate, data });
-      updates.push({
-        entry,
-        data,
-        filePath: this.#movedFilePath(entry, target)
-      });
-    }
-    return updates;
-  }
-  #movedParentPaths(entry, target) {
-    const moved = this.#index.byId(target.id);
-    assert(moved, `Entry not found: ${target.id}`);
-    const movedLanguage = moved.get(entry.locale);
-    assert(movedLanguage, `Missing moved entry language node`);
-    const newParentPaths = this.#parentPaths(target.parentId, entry.locale);
-    if (entry.id === target.id) return newParentPaths;
-    const currentParentPaths = this.#parentPaths(entry.parentId, entry.locale);
-    const oldPrefix = this.#parentPaths(moved.parentId, entry.locale).concat(
-      movedLanguage.main.path
-    );
-    const newPrefix = newParentPaths.concat(movedLanguage.main.path);
-    assert(
-      startsWithSegments(currentParentPaths, oldPrefix),
-      `Moved child is outside moved entry path`
-    );
-    return newPrefix.concat(currentParentPaths.slice(oldPrefix.length));
-  }
-  #movedFilePath(entry, target) {
-    const moved = this.#index.byId(target.id);
-    assert(moved, `Entry not found: ${target.id}`);
-    const movedLanguage = moved.get(entry.locale);
-    assert(movedLanguage, `Missing moved entry language node`);
-    const parent = target.parentId ? this.#index.findFirst((parentEntry) => {
-      return parentEntry.id === target.parentId && parentEntry.locale === entry.locale;
-    }) : void 0;
-    const parentDir = parent ? parent.childrenDir : Config.filePath(
-      this.#config,
-      target.workspace,
-      target.root,
-      entry.locale
-    );
-    const nextPrefix = paths.join(parentDir, movedLanguage.main.path);
-    if (entry.id === target.id) {
-      return `${nextPrefix}${entry.status === "published" ? "" : `.${entry.status}`}.json`;
-    }
-    const previousPrefix = movedLanguage.main.childrenDir;
-    assert(
-      entry.filePath === previousPrefix || entry.filePath.startsWith(`${previousPrefix}/`),
-      `Moved child file is outside moved entry directory`
-    );
-    const suffix = entry.filePath.slice(previousPrefix.length).replace(/^\//, "");
-    return paths.join(nextPrefix, suffix);
-  }
-  publish({ id, locale, status }) {
-    const index = this.#index;
-    const entry = index.findFirst((entry2) => {
-      return entry2.id === id && entry2.locale === locale && entry2.status === status;
-    });
-    assert(entry, `Entry not found: ${id}`);
-    this.#policy.assert(Permission.Publish, entry);
-    const pathChange = entry.data.path && entry.data.path !== entry.path;
-    let path = slugify(entry.data.path ?? entry.path);
-    let data = entry.data;
-    path = this.#getAvailablePath({
-      id,
-      path,
-      parentId: entry.parentId,
-      root: entry.root,
-      workspace: entry.workspace,
-      locale
-    });
-    const childrenDir = paths.join(entry.parentDir, path);
-    const urlCandidate = {
-      id,
-      type: entry.type,
-      path,
-      parentId: entry.parentId,
-      root: entry.root,
-      workspace: entry.workspace,
-      locale,
-      data
-    };
-    data = this.#dataWithPreviousUrlAlias(
-      urlCandidate,
-      this.#publishedEntry(id, locale)
-    );
-    if (entry.locale !== null)
-      this.#persistSharedFields(id, entry.locale, entry.type, data);
-    this.#assertUniqueUrls({ ...urlCandidate, data });
-    const versions = index.byId(id)?.get(locale);
-    if (versions)
-      for (const [_, version] of versions) {
-        this.#tx.remove(version.filePath);
-      }
-    this.#checks.push([entry.filePath, entry.fileHash]);
-    this.#tx.remove(entry.filePath);
-    const record = createRecord({ ...entry, path, data }, "published");
-    const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
-    if (pathChange) {
-      this.#tx.remove(`${entry.parentDir}/${entry.path}.json`);
-      this.#tx.rename(entry.childrenDir, childrenDir);
-    }
-    this.#tx.add(`${childrenDir}.json`, contents);
-    this.#messages.push(this.#reportOp("publish", entry.title));
-    return this;
-  }
-  unpublish({ id, locale }) {
-    const index = this.#index;
-    const versions = index.byId(id)?.get(locale);
-    const mainEntry = versions?.main;
-    assert(mainEntry, `Entry not found: ${id}`);
-    this.#policy.assert(Permission.Publish, mainEntry);
-    for (const [_, version] of versions) {
-      if (version === mainEntry) continue;
-      this.#tx.remove(version.filePath);
-    }
-    this.#checks.push([mainEntry.filePath, mainEntry.fileHash]);
-    this.#tx.rename(mainEntry.filePath, `${mainEntry.childrenDir}.draft.json`);
-    this.#messages.push(this.#reportOp("unpublish", mainEntry.title));
-    return this;
-  }
-  archive({ id, locale }) {
-    const index = this.#index;
-    const versions = index.byId(id)?.get(locale);
-    const mainEntry = versions?.main;
-    assert(mainEntry, `Entry not found: ${id}`);
-    this.#policy.assert(Permission.Archive, mainEntry);
-    for (const [_, version] of versions) {
-      if (version === mainEntry) continue;
-      this.#tx.remove(version.filePath);
-    }
-    this.#checks.push([mainEntry.filePath, mainEntry.fileHash]);
-    this.#tx.rename(
-      mainEntry.filePath,
-      `${mainEntry.childrenDir}.archived.json`
-    );
-    this.#messages.push(this.#reportOp("archive", mainEntry.title));
-    return this;
-  }
-  move({ id, target, dropPosition, targetType }) {
-    const index = this.#index;
-    targetType ??= "entry";
-    const entries2 = Array.from(index.findMany((entry) => entry.id === id));
-    assert(entries2.length > 0, `Entry not found: ${id}`);
-    const targetEntry = targetType === "root" ? void 0 : index.findFirst((entry) => {
-      return entry.id === target;
-    });
-    assert(targetType === "root" || targetEntry, `Target not found: ${target}`);
-    assert(
-      targetType === "entry" || dropPosition === "on",
-      `Cannot move ${dropPosition} root ${target}`
-    );
-    const parentId = targetType === "root" ? null : dropPosition === "on" ? target : targetEntry?.parentId ?? null;
-    const root = targetType === "root" ? target : targetEntry?.root ?? entries2[0].root;
-    const workspace = targetEntry?.workspace ?? entries2[0].workspace;
-    const action = parentId !== entries2[0].parentId || root !== entries2[0].root ? Permission.Move : Permission.Reorder;
-    for (const entry of entries2) this.#policy.assert(action, entry);
-    if (action === Permission.Move && parentId === null) {
-      this.#policy.assert(Permission.Move, { workspace, root });
-    }
-    const siblingList = Array.from(
-      index.findMany((entry) => {
-        return entry.workspace === workspace && entry.root === root && entry.parentId === parentId && entry.id !== id;
-      })
-    );
-    let insertIndex = siblingList.length;
-    if (targetType !== "root") {
-      const targetIndex = siblingList.findIndex((entry) => entry.id === target);
-      if (dropPosition === "before") {
-        assert(targetIndex >= 0, `Sibling not found: ${target}`);
-        insertIndex = targetIndex;
-      } else if (dropPosition === "after") {
-        assert(targetIndex >= 0, `Sibling not found: ${target}`);
-        insertIndex = targetIndex + 1;
-      }
-    }
-    const previous = siblingList[insertIndex - 1] ?? null;
-    const next = siblingList[insertIndex] ?? null;
-    const seen = /* @__PURE__ */ new Set();
-    const hasDuplicates = siblingList.some((entry) => {
-      const wasSeen = seen.has(entry.index);
-      if (wasSeen) return true;
-      seen.add(entry.index);
-      return false;
-    });
-    let newIndex;
-    if (hasDuplicates) {
-      const self = index.findFirst((entry) => entry.id === id);
-      assert(self, `Entry not found: ${id}`);
-      siblingList.splice(insertIndex, 0, self);
-      for (const sibling of siblingList) {
-        this.#policy.assert(Permission.Reorder, sibling);
-      }
-      const newKeys = generateNKeysBetween(null, null, siblingList.length);
-      for (const [i, key] of newKeys.entries()) {
-        const id2 = siblingList[i].id;
-        const node = index.byId(id2);
-        assert(node);
-        for (const locale of node.keys()) {
-          for (const [_, version] of node.get(locale)) {
-            const record = createRecord(
-              {
-                id: id2,
-                type: version.type,
-                index: key,
-                path: version.path,
-                seeded: version.seeded,
-                data: version.data
-              },
-              version.status
-            );
-            const contents = new TextEncoder().encode(
-              JSON.stringify(record, null, 2)
-            );
-            this.#tx.add(version.filePath, contents);
-          }
-        }
-      }
-      newIndex = newKeys[insertIndex];
-    } else {
-      newIndex = generateKeyBetween(
-        previous?.index ?? null,
-        next?.index ?? null
-      );
-    }
-    const moveUrlAliasUpdates = action === Permission.Move ? this.#moveUrlAliasUpdates({ id, parentId, workspace, root }) : [];
-    const moveUrlAliasData = new Map(
-      moveUrlAliasUpdates.map((update) => [update.entry.filePath, update.data])
-    );
-    let info;
-    for (const entry of entries2) {
-      info = entry;
-      const parent = parentId ? index.findFirst((e) => {
-        return e.id === parentId && e.locale === entry.locale;
-      }) : void 0;
-      if (action === Permission.Move && parentId) {
-        assert(!entry.seeded, `Cannot move seeded entry ${entry.filePath}`);
-        assert(parent, `Parent not found: ${parentId}`);
-        this.#policy.assert(Permission.Move, parent);
-        assert(
-          !parent?.childrenDir.startsWith(entry.childrenDir),
-          "Cannot move entry into its own children"
-        );
-        const parentType = this.#config.schema[parent.type];
-        const childType = this.#config.schema[entry.type];
-        const allowed = Config.typeContains(this.#config, parentType, childType);
-        assert(
-          allowed,
-          `Parent of type ${parent.type} does not allow children of type ${entry.type}`
-        );
-      }
-      const parentDir = parent ? parent.childrenDir : Config.filePath(this.#config, workspace, root, entry.locale);
-      const childrenDir = paths.join(parentDir, entry.path);
-      const filePath = `${childrenDir}${entry.status === "published" ? "" : `.${entry.status}`}.json`;
-      const data = moveUrlAliasData.get(entry.filePath) ?? entry.data;
-      const record = createRecord(
-        {
-          id,
-          type: entry.type,
-          index: newIndex,
-          path: entry.path,
-          seeded: entry.seeded,
-          root,
-          workspace,
-          parentId,
-          data
-        },
-        entry.status
-      );
-      const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
-      if (action === Permission.Move) {
-        this.#tx.remove(entry.filePath);
-        this.#tx.rename(entry.childrenDir, childrenDir);
-      }
-      this.#tx.add(filePath, contents);
-    }
-    for (const update of moveUrlAliasUpdates) {
-      const entry = update.entry;
-      if (entry.id === id || update.data === entry.data) continue;
-      const record = createRecord(
-        {
-          ...entry,
-          root,
-          workspace,
-          data: update.data
-        },
-        entry.status
-      );
-      const contents = new TextEncoder().encode(JSON.stringify(record, null, 2));
-      this.#tx.add(update.filePath, contents);
-    }
-    this.#messages.push(this.#reportOp("move", info.title));
-    return this;
-  }
-  remove({ id, locale, status }) {
-    const index = this.#index;
-    const entries2 = index.findMany((entry) => {
-      const matchesStatus = status === void 0 || entry.status === status;
-      const matchesLocale = locale === void 0 || entry.locale === locale;
-      return entry.id === id && matchesLocale && matchesStatus;
-    });
-    let info;
-    for (const entry of entries2) {
-      if (entry.status === "published")
-        assert(!entry.seeded, `Cannot remove seeded entry ${entry.filePath}`);
-      info = entry;
-      this.#checks.push([entry.filePath, entry.fileHash]);
-      this.#tx.remove(entry.filePath);
-      if (entry.status !== "draft") {
-        this.#tx.remove(entry.childrenDir);
-      }
-      if (entry.type === "MediaLibrary") {
-        const files = index.findMany((f) => {
-          return f.workspace === entry.workspace && f.root === entry.root && f.filePath.startsWith(entry.childrenDir) && f.type === "MediaFile";
-        });
-        for (const file of files) {
-          this.removeFile({
-            location: MediaLocation.storagePath(
-              this.#config,
-              entry.workspace,
-              file.data.location
-            )
-          });
-        }
-      }
-      if (entry.type === "MediaFile") {
-        this.removeFile({
-          location: MediaLocation.storagePath(
-            this.#config,
-            entry.workspace,
-            entry.data.location
-          )
-        });
-      }
-    }
-    if (info) {
-      this.#policy.assert(Permission.Delete, info);
-      this.#messages.unshift(this.#reportOp("remove", info.title));
-    }
-    return this;
-  }
-  removeFile(mutation) {
-    this.#policy.assert(Permission.Delete);
-    assert(mutation.location, "Missing location");
-    this.#messages.push(this.#reportOp("remove", mutation.location));
-    this.#fileChanges.push({ op: "removeFile", ...mutation });
-    return this;
-  }
-  uploadFile(mutation) {
-    this.#policy.assert(Permission.Upload);
-    this.#fileChanges.push({ op: "uploadFile", ...mutation });
-    return this;
-  }
-  description() {
-    return this.#messages.map((message, index, all) => {
-      if (index > 0) return message;
-      const suffix = all.length > 1 ? ` (and ${all.length - 1} other edits)` : "";
-      return `${message + suffix}`;
-    }).join("\n");
-  }
-  #reportOp(op, title) {
-    return `(${op}) ${title}`;
-  }
-  apply(mutations) {
-    for (const mutation of mutations) {
-      switch (mutation.op) {
-        case "create":
-          this.create(mutation);
-          break;
-        case "update":
-          this.update(mutation);
-          break;
-        case "publish":
-          this.publish(mutation);
-          break;
-        case "unpublish":
-          this.unpublish(mutation);
-          break;
-        case "archive":
-          this.archive(mutation);
-          break;
-        case "move":
-          this.move(mutation);
-          break;
-        case "remove":
-          this.remove(mutation);
-          break;
-        case "removeFile":
-          this.removeFile(mutation);
-          break;
-        case "uploadFile":
-          this.uploadFile(mutation);
-          break;
-        default:
-          unreachable(mutation);
-      }
-    }
-  }
-  async toRequest() {
-    const { from, into, changes } = await this.#tx.compile();
-    return {
-      fromSha: from.sha,
-      intoSha: into.sha,
-      description: this.description(),
-      checks: this.#checks,
-      changes: this.#fileChanges.concat(commitChanges(changes))
-    };
-  }
-};
-function aliasUrlsFromData(data) {
-  const result = /* @__PURE__ */ new Set();
-  for (const alias of aliasesFromData(data) ?? []) {
-    const url = aliasUrl(alias);
-    if (url) result.add(url);
-  }
-  return Array.from(result);
-}
-function dataWithUrlAlias(type, data, previousUrl, currentUrl) {
-  const target = typeAliasTarget(type);
-  if (!target) return data;
-  const aliasUrls = aliasUrlsFromData(data);
-  if (aliasUrls.includes(previousUrl)) return data;
-  const nextData = aliasUrls.includes(currentUrl) ? dataWithoutUrlAlias(data, currentUrl) : data;
-  const metadata = isRecord(nextData.metadata) ? nextData.metadata : {};
-  const aliases = target === "metadata" ? Array.isArray(metadata.aliases) ? metadata.aliases : [] : Array.isArray(nextData.aliases) ? nextData.aliases : [];
-  return dataWithAliases(
-    nextData,
-    target,
-    metadata,
-    aliases.concat(createUrlAliasRow(previousUrl, aliases))
-  );
-}
-function dataWithoutUrlAlias(data, url) {
-  let result = data;
-  if (Array.isArray(data.aliases)) {
-    result = {
-      ...result,
-      aliases: data.aliases.filter((alias) => aliasUrl(alias) !== url)
-    };
-  }
-  const metadata = data.metadata;
-  if (isRecord(metadata) && Array.isArray(metadata.aliases)) {
-    result = {
-      ...result,
-      metadata: {
-        ...metadata,
-        aliases: metadata.aliases.filter((alias) => aliasUrl(alias) !== url)
-      }
-    };
-  }
-  return result;
-}
-function dataWithAliases(data, target, metadata, aliases) {
-  if (target === "aliases") return { ...data, aliases };
-  return {
-    ...data,
-    metadata: {
-      ...metadata,
-      aliases
-    }
-  };
-}
-function typeAliasTarget(type) {
-  if (Type.field(type, "aliases")) return "aliases";
-  const metadata = Type.field(type, "metadata");
-  if (!metadata) return void 0;
-  const options = Field.options(metadata);
-  const fields = options.fields;
-  if (!Type.isType(fields)) return void 0;
-  return Type.field(fields, "aliases") ? "metadata" : void 0;
-}
-function createUrlAliasRow(url, aliases) {
-  const orderedAliases = aliases.filter(isOrderedUrlAliasRow);
-  const editor = new ListEditor(orderedAliases);
-  const created = editor.add("alias", { url }).value().at(-1);
-  assert(created);
-  return created;
-}
-function isOrderedUrlAliasRow(value) {
-  if (!isRecord(value)) return false;
-  const id = value[ListRow.id];
-  const index = value[ListRow.index];
-  const type = value[ListRow.type];
-  const url = value.url;
-  return typeof id === "string" && typeof index === "string" && isValidOrderKey(index) && type === "alias" && typeof url === "string";
-}
-function startsWithSegments(value, prefix) {
-  return prefix.every((segment, index) => value[index] === segment);
-}
-export {
-  EntryTransaction
-};