alinea 1.7.0 → 2.0.0-preview.0

package/dist/dashboard/atoms/entry.js

@@ -0,0 +1,609 @@
+import {
+  unwrap
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/dashboard/atoms/entry.ts
+import { JsonLoader } from "alinea/backend/loader/JsonLoader";
+import { Config } from "alinea/core/Config";
+import { Entry } from "alinea/core/Entry";
+import { createRecord, parseRecord } from "alinea/core/EntryRecord";
+import { getRoot, getWorkspace } from "alinea/core/Internal";
+import { createPreview } from "alinea/core/media/CreatePreview.browser";
+import { Permission } from "alinea/core/Role";
+import { Root } from "alinea/core/Root";
+import { createFilePatch } from "alinea/core/source/FilePatch";
+import { Type } from "alinea/core/Type";
+import { assert } from "alinea/core/util/Assert";
+import { entries } from "alinea/core/util/Objects";
+import { join } from "alinea/core/util/Paths";
+import { encodePreviewPayload } from "alinea/preview/PreviewPayload";
+import { parents, translations } from "alinea/query";
+import { clientAtom, configAtom, graphAtom } from "./core.js";
+import { entryRevisionAtom, shaAtom } from "./graph.js";
+import { ReactiveNode } from "./ReactiveNode.js";
+import { policyAtom, userAtom } from "./user.js";
+import { dispense, loader } from "./utils.js";
+var selection = {
+  id: Entry.id,
+  type: Entry.type,
+  parentId: Entry.parentId,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  parents: parents({
+    select: {
+      id: Entry.id,
+      path: Entry.path,
+      type: Entry.type,
+      status: Entry.status,
+      main: Entry.main
+    }
+  }),
+  entries: translations({ select: Entry, includeSelf: true })
+};
+function prepareData(get, node, type, action, user) {
+  const current = get(node.value);
+  return {
+    checkpoint: current,
+    data: Type.beforeSave(type, current, {
+      action,
+      user,
+      now: /* @__PURE__ */ new Date()
+    })
+  };
+}
+var EntryLocaleAtoms = class {
+  constructor(entry, requestedLocale) {
+    this.entry = entry;
+    this.requestedLocale = requestedLocale;
+  }
+  entry;
+  requestedLocale;
+  currentlyEditing = atom();
+  untranslated = atom((get) => {
+    const data = get(this.entry.data);
+    return !data.entries.some((entry) => entry.locale === this.requestedLocale);
+  });
+  #selectedTranslationSourceLocale = atom();
+  translationSourceLocale = atom(
+    (get) => {
+      const data = get(this.entry.data);
+      const locales = data.entries.flatMap((entry) => {
+        return entry.locale === null ? [] : [entry.locale];
+      });
+      const selected = get(this.#selectedTranslationSourceLocale);
+      return selected && locales.includes(selected) ? selected : locales[0] ?? null;
+    },
+    (get, set, next) => {
+      set(this.#selectedTranslationSourceLocale, next);
+      set(this.currentlyEditing, void 0);
+    }
+  );
+  parentNeedsTranslation = atom(async (get) => {
+    const data = get(this.entry.data);
+    const translated = data.entries.some(
+      (entry) => entry.locale === this.requestedLocale
+    );
+    if (translated || !this.requestedLocale || !data.parentId) return false;
+    const graph = get(graphAtom);
+    const parent = await graph.first({
+      select: Entry.id,
+      id: data.parentId,
+      locale: this.requestedLocale,
+      status: "preferDraft"
+    });
+    return !parent;
+  });
+  selectedVersion = atom(null);
+  versions = atom((get) => {
+    const data = get(this.entry.data);
+    const selectedLocale = data.entries.some(
+      (entry) => entry.locale === this.requestedLocale
+    ) ? this.requestedLocale : get(this.translationSourceLocale);
+    return new Map(
+      data.entries.filter((entry) => entry.locale === selectedLocale).map((entry) => [entry.status, entry])
+    );
+  });
+  availableStatuses = atom((get) => {
+    return Array.from(get(this.versions).keys());
+  });
+  selectedEntry = atom(async (get) => {
+    const data = get(this.entry.data);
+    const translated = data.entries.some(
+      (entry) => entry.locale === this.requestedLocale
+    );
+    const sourceLocale = translated ? this.requestedLocale : get(this.translationSourceLocale);
+    const localeEntries = data.entries.filter(
+      (entry) => entry.locale === sourceLocale
+    );
+    assert(localeEntries.length > 0, `No readable entry for "${this.entry.id}"`);
+    const version = get(this.selectedVersion);
+    if (!version) return localeEntries[0];
+    if (version.type === "status")
+      return localeEntries.find((entry) => entry.status === version.status) ?? localeEntries[0];
+    const client = get(clientAtom);
+    const revision = await client.revisionData(version.file, version.ref);
+    const activeEntry = localeEntries[0];
+    if (!revision) return activeEntry;
+    const historyData = parseRecord(revision).data;
+    return {
+      ...activeEntry,
+      title: typeof historyData.title === "string" ? historyData.title : activeEntry.title,
+      path: typeof historyData.path === "string" ? historyData.path : activeEntry.path,
+      data: historyData
+    };
+  });
+  historyReady = atom(async (get) => {
+    const versions = get(this.versions);
+    const entry = Array.from(versions.values()).find((version) => version.active) ?? versions.values().next().value;
+    assert(entry, `No readable entry for "${this.entry.id}"`);
+    const config = get(configAtom);
+    const client = get(clientAtom);
+    const file = join(Config.contentDir(config), entry.filePath);
+    return (await client.revisions(file)).slice(1);
+  });
+  history = unwrap(this.historyReady, (previous) => previous ?? []);
+  selectedNode = atom(async (get) => {
+    const version = get(this.selectedVersion);
+    const entry = await get(this.selectedEntry);
+    const isUntranslated = get(this.untranslated);
+    if (!version || version.type === "status" && entry.active) {
+      const editing = get(this.currentlyEditing);
+      if (editing) return editing;
+    }
+    const config = get(configAtom);
+    const type = config.schema[entry.type];
+    assert(type, `Type "${entry.type}" not found in config`);
+    const policy = get(policyAtom);
+    const readOnly = version?.type === "history" || !isUntranslated && (!entry.active || !policy.canUpdate(entry));
+    const value = Type.withInitialValue(type, {
+      ...Type.initialValue(type),
+      ...entry.data,
+      ...isUntranslated ? { path: void 0 } : void 0
+    });
+    return new ReactiveNode(value, readOnly);
+  });
+  anchors = atom(async (get) => {
+    const entry = await get(this.selectedEntry);
+    const node = await get(this.selectedNode);
+    const type = get(configAtom).schema[entry.type];
+    assert(type, `Type "${entry.type}" not found in config`);
+    return Type.anchors(type, get(node.value));
+  });
+  #previewRetry = atom(0);
+  retryPreviewUrl = atom(null, (get, set) => {
+    set(this.#previewRetry, (current) => current + 1);
+  });
+  previewEntryReady = atom(async (get) => {
+    const activeEntry = await get(this.selectedEntry);
+    const node = await get(this.selectedNode);
+    const value = get(node.value);
+    return {
+      ...activeEntry,
+      title: typeof value.title === "string" ? value.title : activeEntry.title,
+      path: typeof value.path === "string" ? value.path : activeEntry.path,
+      data: value
+    };
+  });
+  previewEntry = unwrap(this.previewEntryReady, (previous) => previous);
+  #previewTargetUrl = atom((get) => {
+    const versions = get(this.versions);
+    const entry = Array.from(versions.values()).find((version) => version.active) ?? versions.values().next().value;
+    return entry?.url;
+  });
+  previewUrlReady = atom(async (get) => {
+    get(this.#previewRetry);
+    const targetUrl = get(this.#previewTargetUrl);
+    if (!targetUrl) return void 0;
+    const config = get(configAtom);
+    const client = get(clientAtom);
+    if (typeof client.previewToken !== "function") return void 0;
+    try {
+      const base = new URL(
+        config.handlerUrl ?? "",
+        Config.baseUrl(config) ?? (typeof location === "undefined" ? "http://localhost" : location.href)
+      );
+      base.searchParams.set("preview", await client.previewToken());
+      base.searchParams.set("returnTo", targetUrl);
+      return base.toString();
+    } catch {
+      return void 0;
+    }
+  });
+  previewUrl = unwrap(this.previewUrlReady, (previous) => previous);
+  previewPayloadSignal = atom((get) => {
+    const version = get(this.selectedVersion);
+    const editing = get(this.currentlyEditing);
+    return [version, editing ? get(editing.value) : void 0];
+  });
+  updatePreviewPayload = atom(null, async (get) => {
+    const node = await get(this.selectedNode);
+    const value = get(node.value);
+    const activeEntry = Array.from(get(this.versions).values()).find(
+      (version) => version.active
+    );
+    if (!activeEntry) return void 0;
+    const contentHash = await get(shaAtom);
+    if (!contentHash) return void 0;
+    const selected = get(this.selectedVersion);
+    const status = selected?.type === "status" ? selected.status : activeEntry.status;
+    const nextEntry = {
+      ...activeEntry,
+      title: typeof value.title === "string" ? value.title : activeEntry.title,
+      path: typeof value.path === "string" ? value.path : activeEntry.path,
+      data: value,
+      status
+    };
+    const schema = get(configAtom).schema;
+    const decoder = new TextDecoder();
+    const baseText = decoder.decode(
+      JsonLoader.format(schema, createRecord(activeEntry, activeEntry.status))
+    );
+    const nextText = decoder.decode(
+      JsonLoader.format(schema, createRecord(nextEntry, status))
+    );
+    return encodePreviewPayload({
+      locale: activeEntry.locale,
+      entryId: activeEntry.id,
+      contentHash,
+      status,
+      patch: await createFilePatch(baseText, nextText)
+    });
+  });
+  saveDraft = atom(null, async (get, set, node) => {
+    const dataState = get(this.entry.data);
+    const { id, type } = dataState;
+    const policy = get(policyAtom);
+    const config = get(configAtom);
+    const typeConfig = config.schema[type];
+    assert(typeConfig, `Type "${type}" not found in config`);
+    const activeEntry = dataState.entries.find((entry) => {
+      return entry.locale === this.requestedLocale && entry.active;
+    });
+    assert(activeEntry, `No active entry for locale "${this.requestedLocale}"`);
+    const graph = get(graphAtom);
+    const { checkpoint, data } = prepareData(
+      get,
+      node,
+      typeConfig,
+      "update",
+      get(userAtom)
+    );
+    policy.assert(Permission.Update, activeEntry);
+    const saved = await graph.create({
+      type: typeConfig,
+      id,
+      locale: this.requestedLocale,
+      status: "draft",
+      set: data,
+      overwrite: true,
+      select: Entry.data
+    });
+    set(node.rebase, { checkpoint, saved });
+  });
+  publishEdits = atom(null, async (get, set, node) => {
+    const dataState = get(this.entry.data);
+    const { id, type } = dataState;
+    const policy = get(policyAtom);
+    const config = get(configAtom);
+    const typeConfig = config.schema[type];
+    assert(typeConfig, `Type "${type}" not found in config`);
+    const activeEntry = dataState.entries.find((entry) => {
+      return entry.locale === this.requestedLocale && entry.active;
+    });
+    assert(activeEntry, `No active entry for locale "${this.requestedLocale}"`);
+    const graph = get(graphAtom);
+    const { checkpoint, data } = prepareData(
+      get,
+      node,
+      typeConfig,
+      "publish",
+      get(userAtom)
+    );
+    policy.assert(Permission.Publish, activeEntry);
+    const saved = await graph.create({
+      type: typeConfig,
+      id,
+      locale: this.requestedLocale,
+      status: "published",
+      set: data,
+      overwrite: true,
+      select: Entry.data
+    });
+    set(node.rebase, { checkpoint, saved });
+  });
+  saveTranslation = atom(null, async (get, set, node) => {
+    assert(
+      this.requestedLocale,
+      `Cannot translate entry "${this.entry.id}" without a locale`
+    );
+    const dataState = get(this.entry.data);
+    const sourceEntry = await get(this.selectedEntry);
+    const policy = get(policyAtom);
+    policy.assert(Permission.Update, {
+      ...sourceEntry,
+      locale: this.requestedLocale
+    });
+    if (dataState.parentId) {
+      const graph2 = get(graphAtom);
+      const parent = await graph2.first({
+        select: Entry.id,
+        id: dataState.parentId,
+        locale: this.requestedLocale,
+        status: "preferDraft"
+      });
+      assert(parent, "Parent entry must be translated first");
+    }
+    const config = get(configAtom);
+    const type = config.schema[dataState.type];
+    assert(type, `Type "${dataState.type}" not found in config`);
+    const { checkpoint, data } = prepareData(
+      get,
+      node,
+      type,
+      "translate",
+      get(userAtom)
+    );
+    const graph = get(graphAtom);
+    const saved = await graph.create({
+      type,
+      id: this.entry.id,
+      parentId: dataState.parentId,
+      locale: this.requestedLocale,
+      status: config.enableDrafts ? "draft" : "published",
+      set: data,
+      select: Entry.data
+    });
+    set(node.rebase, { checkpoint, saved });
+  });
+  #activeEntry(get) {
+    const data = get(this.entry.data);
+    const entry = data.entries.find((candidate) => {
+      return candidate.locale === this.requestedLocale && candidate.active;
+    });
+    assert(entry, `No active entry for locale "${this.requestedLocale}"`);
+    return entry;
+  }
+  publishDraft = atom(null, async (get) => {
+    const entry = this.#activeEntry(get);
+    get(policyAtom).assert(Permission.Publish, entry);
+    await get(graphAtom).publish({
+      id: this.entry.id,
+      locale: this.requestedLocale,
+      status: "draft"
+    });
+  });
+  discardDraft = atom(null, async (get) => {
+    const entry = this.#activeEntry(get);
+    get(policyAtom).assert(Permission.Update, entry);
+    await get(graphAtom).discard({
+      id: this.entry.id,
+      locale: this.requestedLocale,
+      status: "draft"
+    });
+  });
+  unpublish = atom(null, async (get) => {
+    const entry = this.#activeEntry(get);
+    get(policyAtom).assert(Permission.Publish, entry);
+    await get(graphAtom).unpublish({
+      id: this.entry.id,
+      locale: this.requestedLocale
+    });
+  });
+  archive = atom(null, async (get) => {
+    const entry = this.#activeEntry(get);
+    get(policyAtom).assert(Permission.Archive, entry);
+    await get(graphAtom).archive({
+      id: this.entry.id,
+      locale: this.requestedLocale
+    });
+  });
+  publishArchived = atom(null, async (get) => {
+    const entry = this.#activeEntry(get);
+    get(policyAtom).assert(Permission.Publish, entry);
+    await get(graphAtom).publish({
+      id: this.entry.id,
+      locale: this.requestedLocale,
+      status: "archived"
+    });
+  });
+  deleteEntry = atom(null, async (get) => {
+    const entry = this.#activeEntry(get);
+    get(policyAtom).assert(Permission.Delete, entry);
+    await get(graphAtom).remove(this.entry.id);
+  });
+  replaceFile = atom(null, async (get, set, file) => {
+    const entry = this.#activeEntry(get);
+    const policy = get(policyAtom);
+    policy.assert(Permission.Update, entry);
+    policy.assert(Permission.Upload, entry);
+    await get(graphAtom).upload({
+      file,
+      createPreview,
+      replaceId: this.entry.id,
+      parentId: entry.parentId,
+      workspace: entry.workspace,
+      root: entry.root
+    });
+    set(this.currentlyEditing, void 0);
+  });
+};
+var EntryAtoms = class {
+  constructor(id, data) {
+    this.id = id;
+    this.data = data;
+  }
+  id;
+  data;
+  // Should UI show overview or editor?
+  #selectedView = atom();
+  previousVersionsOpen = atom(false);
+  incomingReferencesReady = atom(async (get) => {
+    get(entryRevisionAtom(this.id));
+    const graph = get(graphAtom);
+    const policy = get(policyAtom);
+    const result = await graph.referencesTo({
+      targetId: this.id,
+      status: "preferDraft"
+    });
+    const sourceIds = Array.from(
+      new Set(result.references.map((reference) => reference.sourceId))
+    );
+    const sources = sourceIds.length === 0 ? [] : await graph.find({
+      id: { in: sourceIds },
+      status: "preferDraft",
+      select: {
+        id: Entry.id,
+        title: Entry.title,
+        type: Entry.type,
+        workspace: Entry.workspace,
+        root: Entry.root,
+        locale: Entry.locale,
+        status: Entry.status,
+        path: Entry.path,
+        url: Entry.url
+      }
+    });
+    const sourceByLocale = new Map(
+      sources.map((source) => [referenceSourceKey(source), source])
+    );
+    const sourceById = new Map(sources.map((source) => [source.id, source]));
+    const references = result.references.flatMap((reference) => {
+      const source = sourceByLocale.get(referenceKey(reference)) ?? sourceById.get(reference.sourceId);
+      if (!source || !policy.canRead(source)) return [];
+      return [{ reference, source }];
+    });
+    return { references, total: result.total, scan: result.scan };
+  });
+  incomingReferences = unwrap(
+    this.incomingReferencesReady,
+    (previous) => previous
+  );
+  #settings = atom((get) => {
+    const data = get(this.data);
+    const typeConfig = get(configAtom).schema[data.type];
+    const config = get(configAtom);
+    const workspace = config.workspaces[data.workspace];
+    assert(workspace, `Workspace "${data.workspace}" not found in config`);
+    const root = getWorkspace(workspace).roots[data.root];
+    assert(root, `Root "${data.root}" not found in config`);
+    assert(typeConfig, `Type "${data.type}" not found in config`);
+    const defaultView = Type.defaultView(typeConfig) ?? (data.hasChildren ? "overview" : "edit");
+    const rootData = getRoot(root);
+    const workspaceData = getWorkspace(workspace);
+    const preview = Type.preview(typeConfig) ?? rootData.preview ?? workspaceData.preview ?? config.preview;
+    return { defaultView, mediaI18n: Root.mediaI18n(rootData), preview };
+  });
+  type = atom((get) => get(this.data).type);
+  parentId = atom((get) => get(this.data).parentId);
+  workspace = atom((get) => get(this.data).workspace);
+  root = atom((get) => get(this.data).root);
+  hasChildren = atom((get) => get(this.data).hasChildren);
+  canPublishParents = atom(
+    (get) => get(this.data).parents.every((parent) => parent.status === "published")
+  );
+  parentUnpublished = atom(
+    (get) => get(this.data).parents.some((parent) => parent.status === "draft")
+  );
+  mediaI18n = atom((get) => get(this.#settings).mediaI18n);
+  preview = atom((get) => get(this.#settings).preview);
+  translationSourceLocales = atom((get) => {
+    const data = get(this.data);
+    return Array.from(
+      new Set(
+        data.entries.flatMap(
+          (entry) => entry.locale === null ? [] : [entry.locale]
+        )
+      )
+    );
+  });
+  view = atom(
+    (get) => get(this.#selectedView) ?? get(this.#settings).defaultView,
+    (get, set, next) => {
+      set(this.#selectedView, next);
+    }
+  );
+  locales = dispense(
+    (locale) => new EntryLocaleAtoms(this, locale)
+  );
+};
+var entryAtoms = dispense((entryId) => {
+  const data = atom(async (get) => {
+    get(entryRevisionAtom(entryId));
+    const load = get(entryLoader);
+    const [result, error] = await load(entryId);
+    if (error) {
+      throw error;
+    }
+    assert(result, `Entry "${entryId}" not found`);
+    return result;
+  });
+  let entry;
+  return atom(async (get) => {
+    const initial = await get(data);
+    return entry ??= new EntryAtoms(
+      entryId,
+      unwrap(data, (previous) => previous ?? initial)
+    );
+  });
+});
+function referenceKey(reference) {
+  return `${reference.sourceId}\0${reference.sourceLocale ?? ""}`;
+}
+function referenceSourceKey(source) {
+  return `${source.id}\0${source.locale ?? ""}`;
+}
+var entryLoader = atom((get) => {
+  const config = get(configAtom);
+  const graph = get(graphAtom);
+  const policy = get(policyAtom);
+  const visibleTypes = entries(config.schema).filter(([, type]) => !Type.isHidden(type)).map(([name]) => name);
+  return loader(async (ids) => {
+    const rows = await graph.find({
+      groupBy: Entry.id,
+      select: selection,
+      id: { in: ids },
+      status: "preferDraft"
+    });
+    const parentIds = await graph.find({
+      select: Entry.parentId,
+      parentId: { in: ids },
+      filter: { _type: { in: visibleTypes } },
+      groupBy: Entry.parentId,
+      status: "preferDraft"
+    });
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    return ids.map((id) => {
+      const row = byId.get(id);
+      if (!row) return [null, new MissingEntryError(id)];
+      const readableEntries = row.entries.filter((entry) => policy.canRead(entry));
+      if (readableEntries.length === 0)
+        return [null, new MissingEntryError(id)];
+      return [
+        {
+          ...row,
+          entries: readableEntries,
+          hasChildren: parentIds.includes(id)
+        },
+        null
+      ];
+    });
+  });
+});
+var MissingEntryError = class extends Error {
+  constructor(id) {
+    super(`Missing entry ${id}`);
+    this.id = id;
+    this.name = "MissingEntryError";
+  }
+  id;
+};
+export {
+  EntryAtoms,
+  EntryLocaleAtoms,
+  MissingEntryError,
+  entryAtoms
+};