alinea 2.0.0-preview.13 → 2.0.0-preview.14

package/dist/dashboard/contexts.js

@@ -20,13 +20,14 @@ function useEditor() {
 }
 function useFieldInfo(field) {
   const editor = useEditor();
+  if (typeof field === "string")
+    throw new Error(`Pass the field instead of its key: ${field}`);
   const info = editor.get(field);
   assert(info, "Field info not found in editor");
   return info;
 }
 function useFieldNode(field) {
-  const { key } = useFieldInfo(field);
-  const editor = useEditor();
+  const { key, editor } = useFieldInfo(field);
   const nodes = useAtomValueRaw(editor.node.nodes);
   assert(nodes[key], `Node not found for field key: ${key}`);
   return nodes[key];

package/dist/dashboard/hook/UseEntryEditor.d.ts

@@ -1,13 +1,13 @@
 import type { EntryStatus } from 'alinea/core/Entry';
 export interface EntryEditorVersionData {
     path: string;
-    status: EntryStatus;
 }
 export interface EntryEditorVersion {
     data: EntryEditorVersionData;
     id: string;
     locale: string | null;
     path: string;
+    status: EntryStatus;
     title: string;
     type: string;
 }

package/dist/dashboard/hook/UseEntryEditor.js

@@ -6,13 +6,15 @@ function useEntryEditor() {
   const entry = useEntry();
   if (!entry) return void 0;
   const version = strictObject("entry editor activeVersion", {
+    // In 1.x data held the field values: only path is kept here, reading
+    // another field (a custom `status` too) throws instead of guessing
     data: strictObject("entry editor activeVersion.data", {
-      path: entry.path,
-      status: entry.status
+      path: entry.path
     }),
     id: entry.id,
     locale: entry.locale,
     path: entry.path,
+    status: entry.status,
     title: entry.title,
     type: entry.type
   });
@@ -32,7 +34,9 @@ function strictObject(label, value) {
       if (typeof property === "symbol")
         return Reflect.get(target, property, receiver);
       if (property in target) return Reflect.get(target, property, receiver);
-      throw new Error(`${label}.${property} is not supported in dashboard v2`);
+      throw new Error(
+        `${label}.${property} is not supported in dashboard v2, read the entry with useEntry() from alinea/cms`
+      );
     }
   });
 }

package/dist/dashboard/icons.d.ts

@@ -181,3 +181,4 @@ export declare function IcRoundAudioFile(props: SVGProps<SVGSVGElement>): import
 export declare function IcRoundRotateRight(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
 export declare function IcRoundCrop(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
 export declare function IcRoundDriveFileMove(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
+export declare function IcRoundDownload(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;

package/dist/dashboard/icons.js

@@ -2640,6 +2640,20 @@ function IcRoundDriveFileMove(props) {
     }
   ) });
 }
+function IcRoundDownload(props) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "1em",
+      height: "1em",
+      viewBox: "0 0 24 24",
+      fill: "currentColor",
+      ...props,
+      children: /* @__PURE__ */ jsx("path", { d: "M16.59 9H15V4c0-.55-.45-1-1-1h-4c-.55 0-1 .45-1 1v5H7.41c-.89 0-1.34 1.08-.71 1.71l4.59 4.59c.39.39 1.02.39 1.41 0l4.59-4.59c.63-.63.19-1.71-.7-1.71M5 19c0 .55.45 1 1 1h12c.55 0 1-.45 1-1s-.45-1-1-1H6c-.55 0-1 .45-1 1" })
+    }
+  );
+}
 export {
   IcAlignCenter,
   IcAlignJustify,
@@ -2704,6 +2718,7 @@ export {
   IcRoundDelete,
   IcRoundDescription,
   IcRoundDesktopWindows,
+  IcRoundDownload,
   IcRoundDragHandle,
   IcRoundDragIndicator,
   IcRoundDriveFileMove,

package/dist/database/BrowserEntryStore.js

@@ -16,19 +16,32 @@ import { DatabaseSource } from "./DatabaseSource.js";
 import { wasmHandle, wasmSqlite } from "./driver/WasmDatabase.js";
 var cacheSize = -65536;
 var keepBranches = 2;
+var rewriteLimit = 1;
 var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
   #session;
   #storage;
   #stored;
   #written = Promise.resolve();
   #cleanup = Promise.resolve();
+  /**
+   * The entries were derived again from a base of another config. Refetching
+   * everything after each deploy that changes the config costs more than
+   * the layout that deriving leaves, so its first save is not counted.
+   */
+  #derived = false;
   static async open(config, options) {
     const { name, fingerprint } = options;
     const storage = options.storage ?? indexedDBSnapshots(`${versionedCacheName(name)}-snapshots`);
     const cleanup = !options.storage && globalThis.indexedDB ? cleanupOldCaches(indexedDB, name).catch(() => {
     }) : Promise.resolve();
     const Database = await wasmSqlite();
-    const session = options.reset ? storage.session(new Database(), { branch: fingerprint }) : await openBase(storage, Database, fingerprint);
+    const empty = () => storage.session(new Database(), { branch: fingerprint });
+    let session = options.reset ? empty() : await openBase(storage, Database, fingerprint);
+    const base = session.snapshot;
+    if (base && rewritten(base) > base.size * rewriteLimit) {
+      await session.close();
+      session = empty();
+    }
     const store = await _BrowserEntryStore.#on(
       config,
       session,
@@ -36,12 +49,7 @@ var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
       fingerprint
     ).catch((error) => {
       if (!session.snapshot) throw error;
-      return _BrowserEntryStore.#on(
-        config,
-        storage.session(new Database(), { branch: fingerprint }),
-        storage,
-        fingerprint
-      );
+      return _BrowserEntryStore.#on(config, empty(), storage, fingerprint);
     });
     store.#cleanup = cleanup;
     return store;
@@ -60,9 +68,11 @@ var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
       await db.run(sql`pragma page_size = 16384`);
       await EntryDatabase.createSchema(db, config, ReadonlyTree.EMPTY.sha);
       const database = new EntryDatabase(config, db, { fork: preview });
-      if (branch !== void 0 && branch !== fingerprint)
-        await withoutJournal(sqlite, () => database.reindex(config));
-      return new _BrowserEntryStore(config, database, session, storage);
+      const derived = branch !== void 0 && branch !== fingerprint;
+      if (derived) await withoutJournal(sqlite, () => database.reindex(config));
+      const store = new _BrowserEntryStore(config, database, session, storage);
+      store.#derived = derived;
+      return store;
     } catch (error) {
       await db.close();
       throw error;
@@ -89,9 +99,17 @@ var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
     const session = this.#session;
     const storage = this.#storage;
     const key = `${revision}-${session.branch}`;
-    const save = (key2) => this.database.whileIdle(async () => ({
-      saved: session.held ? session.save({ key: key2, meta: { tree: revision } }) : void 0
-    })).then(({ saved }) => saved);
+    const save = (key2) => this.database.whileIdle(async () => {
+      if (!session.held) return void 0;
+      const base = session.snapshot;
+      const added = this.#derived ? 0 : session.held;
+      this.#derived = false;
+      const meta = {
+        tree: revision,
+        rewritten: base ? rewritten(base) + added : 0
+      };
+      return { saved: session.save({ key: key2, meta }) };
+    }).then((result) => result?.saved);
     const written = save(key).then(
       (result) => result?.status === "mismatch" ? save(`${key}-${crypto.randomUUID()}`) : result
     ).then(() => storage.retain({ branches: keepBranches })).catch(() => {
@@ -106,6 +124,10 @@ var BrowserEntryStore = class _BrowserEntryStore extends EntryStore {
     await super.close();
   }
 };
+function rewritten(base) {
+  const value = base.meta.rewritten;
+  return typeof value === "number" ? value : 0;
+}
 var corruptCodes = /* @__PURE__ */ new Set(["SQLITE_CORRUPT", "SQLITE_NOTADB"]);
 var corruptMessage = /database disk image is malformed|file is not a database/;
 function isCorruptDatabaseError(error) {

package/dist/database/DatabaseTables.js

@@ -4,7 +4,7 @@ import {
   number,
   text,
   varchar
-} from "../chunks/chunk-5H4D5JQL.js";
+} from "../chunks/chunk-2PP7WJUJ.js";
 import {
   table
 } from "../chunks/chunk-PYDOMKJZ.js";

package/dist/database/EntryDatabase.d.ts

@@ -93,5 +93,14 @@ export declare class EntryDatabase extends Graph implements AsyncDisposable {
     getSourceFileStats(): Promise<Map<string, FileStat>>;
     /** Replace the recorded file stats after syncing from a filesystem source. */
     setSourceFileStats(stats: ReadonlyMap<string, FileStat>): Promise<void>;
-    compact(): Promise<void>;
+    /**
+     * Optimize the database and rewrite it when it has pages to reclaim, or
+     * always with `rewrite`. A file that synced many changes keeps the pages of
+     * its tables scattered over it, without any to reclaim: readers that read
+     * ahead, such as the dashboard reading a stored copy, then read it page by
+     * page. Rewriting lays every table out in order.
+     */
+    compact(options?: {
+        rewrite?: boolean;
+    }): Promise<void>;
 }

package/dist/database/EntryDatabase.js

@@ -67,6 +67,11 @@ var EntryDatabase = class _EntryDatabase extends Graph {
   #tree;
   #initialTree;
   #recordsTree;
+  /**
+   * Overlays answer one preview payload and are thrown away; they keep the
+   * statistics of the database they fork.
+   */
+  #analyzes = true;
   /** The connection is already inside a transaction: never open nested ones. */
   #transactional = false;
   #changeListeners = /* @__PURE__ */ new Set();
@@ -124,6 +129,7 @@ var EntryDatabase = class _EntryDatabase extends Graph {
       recordsTree: false
     });
     overlay.#tree = tree;
+    overlay.#analyzes = false;
     try {
       await overlay.syncWith(source);
       return overlay;
@@ -172,7 +178,7 @@ var EntryDatabase = class _EntryDatabase extends Graph {
         tree: revision === ReadonlyTree.EMPTY.sha ? ReadonlyTree.EMPTY : null
       });
     await syncFieldIndexes(db, config);
-    await analyze(db);
+    if (!await hasStatistics(db)) await analyze(db);
   }
   /**
    * Synchronize a source through this database's single prepared syncer,
@@ -193,7 +199,8 @@ var EntryDatabase = class _EntryDatabase extends Graph {
           previousTree: this.#tree?.sha === current ? this.#tree : void 0,
           withinTransaction: this.#transactional,
           validate: options?.validate ?? true,
-          recordsTree: this.#recordsTree
+          recordsTree: this.#recordsTree,
+          onProgress: options?.onProgress
         });
         this.#tree = tree;
         if (changed.length > 0) await this.#optimize();
@@ -392,7 +399,7 @@ var EntryDatabase = class _EntryDatabase extends Graph {
     return this.close();
   }
   async #optimize() {
-    if (!this.#transactional) await analyze(this.#db);
+    if (this.#analyzes && !this.#transactional) await analyze(this.#db);
   }
   getRevision() {
     return this.#queue.run(() => this.#getRevision(this.#db));
@@ -525,28 +532,42 @@ var EntryDatabase = class _EntryDatabase extends Graph {
       )
     );
   }
-  async compact() {
+  /**
+   * Optimize the database and rewrite it when it has pages to reclaim, or
+   * always with `rewrite`. A file that synced many changes keeps the pages of
+   * its tables scattered over it, without any to reclaim: readers that read
+   * ahead, such as the dashboard reading a stored copy, then read it page by
+   * page. Rewriting lays every table out in order.
+   */
+  async compact(options = {}) {
     await this.#queue.run(async () => {
       await this.#db.run(sql`pragma optimize`);
       const free = await this.#db.get(
         sql`pragma freelist_count`
       );
-      if (free?.freelist_count) await this.#db.run(sql`vacuum`);
+      if (options.rewrite || free?.freelist_count)
+        await this.#db.run(sql`vacuum`);
     });
   }
 };
 async function analyze(db) {
   try {
     await db.run(sql`pragma analysis_limit = 400`);
-    const entries = getTable(EntryIndexTable).name;
-    const stats = await db.get(
-      sql`select 1 from sqlite_master where name = 'sqlite_stat1'`
+    await db.run(
+      await hasStatistics(db) ? sql`pragma optimize = 0x10002` : sql`analyze`
     );
-    const analyzed = stats && await db.get(sql`select 1 from sqlite_stat1 where tbl = ${entries}`);
-    await db.run(analyzed ? sql`pragma optimize = 0x10002` : sql`analyze`);
   } catch {
   }
 }
+async function hasStatistics(db) {
+  const entries = getTable(EntryIndexTable).name;
+  const stats = await db.get(
+    sql`select 1 from sqlite_master where name = 'sqlite_stat1'`
+  );
+  return Boolean(
+    stats && await db.get(sql`select 1 from sqlite_stat1 where tbl = ${entries}`)
+  );
+}
 export {
   EntryDatabase
 };

package/dist/database/EntryStore.js

@@ -1,7 +1,7 @@
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/database/EntryStore.ts
-import { applyChangesFrom } from "alinea/core/source/Source";
+import { applyChangesFrom, sourceAtTree } from "alinea/core/source/Source";
 import { OverlaySource } from "alinea/core/source/OverlaySource";
 import { ReadonlyTree } from "alinea/core/source/Tree";
 import { createRecord } from "alinea/core/EntryRecord";
@@ -215,16 +215,6 @@ async function changesSince(source, from) {
   await changes.applyChangesFrom(source, from.diff(tree), tree);
   return changes;
 }
-function sourceAtTree(source, tree) {
-  return {
-    async getTreeIfDifferent(revision) {
-      return revision === tree.sha ? void 0 : tree;
-    },
-    getBlobs(shas, options) {
-      return source.getBlobs(shas, options);
-    }
-  };
-}
 export {
   EntryStore
 };

package/dist/database/entry/EntryTable.d.ts

@@ -139,9 +139,11 @@ export declare function isOrderedField(field: unknown): boolean;
 /** Metadata fields whose queries order by their stored value. */
 export declare const orderedMetadata: Set<string>;
 /**
- * Index the stored value of every ordered field in the config, per type, and
- * of the ordered metadata. Field names are identifiers, so the dotted metadata
- * names cannot collide with them.
+ * Index the stored value of every ordered field in the config, and of the
+ * ordered metadata. A field is indexed per type that has it, over the rows of
+ * that type only: queries of one type find the index, and the rows of other
+ * types don't take up space in it. The metadata is indexed over every row.
+ * Index names are `type:field` and `metadata.name`, which can't collide.
  */
 export declare function syncFieldIndexes(db: Database, config: Config): Promise<void>;
 /** An Entry plus the physical-version and local-index fields. */

package/dist/database/entry/EntryTable.js

@@ -4,7 +4,7 @@ import {
   json,
   text,
   varchar
-} from "../../chunks/chunk-5H4D5JQL.js";
+} from "../../chunks/chunk-2PP7WJUJ.js";
 import {
   primaryKey,
   table
@@ -118,11 +118,13 @@ function isOrderedField(field) {
 var fieldIndexPrefix = "alinea_entry_index_by_field_";
 var orderedMetadata = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
 async function syncFieldIndexes(db, config) {
-  const wanted = /* @__PURE__ */ new Set();
-  for (const name of orderedMetadata) wanted.add(`metadata.${name}`);
-  for (const type of Object.values(config.schema))
+  const wanted = /* @__PURE__ */ new Map();
+  for (const name of orderedMetadata)
+    wanted.set(`metadata.${name}`, { path: ["metadata", name] });
+  for (const [typeName, type] of Object.entries(config.schema))
     for (const [name, field] of Object.entries(Type.fields(type)))
-      if (isOrderedField(field)) wanted.add(name);
+      if (isOrderedField(field))
+        wanted.set(`${typeName}:${name}`, { type: typeName, path: [name] });
   const rows = await db.all(
     sql`select name from sqlite_master where type = 'index'`
   );
@@ -133,13 +135,28 @@ async function syncFieldIndexes(db, config) {
   for (const name of existing)
     if (!wanted.has(name))
       await db.run(sql`drop index ${sql.identifier(fieldIndexPrefix + name)}`);
-  for (const name of wanted) {
+  for (const [name, { type, path }] of wanted) {
     if (existing.has(name)) continue;
-    const value = jsonField(sql.identifier("data"), name.split("."));
+    const value = jsonField(sql.identifier("data"), path);
+    const where = type ? sql`where ${sql.identifier("type")} = ${sql.inline(type)}` : sql``;
     await db.run(sql`create index ${sql.identifier(fieldIndexPrefix + name)}
       on ${EntryIndexTable}(${sql.identifier("type")}, ${value},
-        ${sql.identifier("index")}, ${sql.identifier("filePath")})`);
+        ${sql.identifier("index")}, ${sql.identifier("filePath")}) ${where}`);
   }
+  await createRecentIndexes(db);
+}
+async function createRecentIndexes(db) {
+  const workspace = sql.identifier("workspace");
+  const index2 = sql.identifier("index");
+  const filePath = sql.identifier("filePath");
+  const updatedAt = jsonField(sql.identifier("data"), ["metadata", "updatedAt"]);
+  await db.run(sql`create index if not exists
+    ${sql.identifier("alinea_entry_index_recent_updated")}
+    on ${EntryIndexTable}(${workspace}, ${updatedAt}, ${index2}, ${filePath})`);
+  await db.run(sql`create index if not exists
+    ${sql.identifier("alinea_entry_index_recent_id")}
+    on ${EntryIndexTable}(${workspace}, ${sql.identifier("id")} desc,
+      ${index2}, ${filePath})`);
 }
 function entryIndexRow(entry) {
   const payload = entry.payload ?? JSON.stringify(createRecord(entry, entry.versionStatus), null, 2);

package/dist/database/query/Condition.d.ts

@@ -1,5 +1,8 @@
+import { type RelationCondition } from 'alinea/core/Filter';
 import { type HasSql, type Sql } from 'rado';
 type FieldSql = (name: string) => HasSql;
+/** Whether a query of entries related to a field finds an entry */
+type RelationSql = (name: string, query: RelationCondition) => Sql<boolean>;
 export declare function jsonField(target: HasSql, segments: Array<string>): HasSql<unknown>;
 /**
  * Match a column against a JSON array parameter, so one prepared statement
@@ -8,6 +11,6 @@ export declare function jsonField(target: HasSql, segments: Array<string>): HasS
 export declare function inJson(column: HasSql, values: HasSql<string>): Sql<boolean>;
 /** Compile a condition; `depth` names the array items it iterates. */
 export declare function compileCondition(field: HasSql, condition: unknown, depth?: number): Sql<boolean>;
-export declare function compileFilter(filter: unknown, field: FieldSql): Sql<boolean>;
+export declare function compileFilter(filter: unknown, field: FieldSql, relation?: RelationSql): Sql<boolean>;
 export declare function arrayIncludes(field: HasSql, predicate: (item: HasSql) => Sql<boolean>, depth?: number): Sql<boolean>;
 export {};

package/dist/database/query/Condition.js

@@ -49,20 +49,29 @@ function equals(field, value) {
 function compileCondition(field, condition, depth = 0) {
   return conditionSql(field, parseCondition(condition), depth);
 }
-function compileFilter(filter, field) {
-  return filterSql(parseFilter(filter), field, 0);
+function compileFilter(filter, field, relation) {
+  return filterSql(parseFilter(filter), field, 0, relation);
 }
-function filterSql(node, field, depth) {
+function filterSql(node, field, depth, relation) {
   switch (node.op) {
     case "and": {
-      const clauses = node.nodes.map((node2) => filterSql(node2, field, depth));
+      const clauses = node.nodes.map(
+        (node2) => filterSql(node2, field, depth, relation)
+      );
       return clauses.length ? and(...clauses) : sql.value(true);
     }
     case "or": {
-      const clauses = node.nodes.map((node2) => filterSql(node2, field, depth));
+      const clauses = node.nodes.map(
+        (node2) => filterSql(node2, field, depth, relation)
+      );
       return clauses.length ? or(...clauses) : sql.value(false);
     }
     case "field":
+      if (node.condition.op === "relation") {
+        if (!relation)
+          throw new Error("Relation conditions are not supported here");
+        return relation(node.name, node.condition.query);
+      }
       return conditionSql(field(node.name), node.condition, depth);
   }
 }
@@ -107,6 +116,8 @@ function conditionSql(field, node, depth) {
         (item) => conditionSql(item, node.item, depth + 1),
         depth
       );
+    case "relation":
+      throw new Error("Relation conditions only apply to entries");
   }
 }
 function arrayIncludes(field, predicate, depth = 0) {

package/dist/database/query/EntryQuery.js

@@ -44,6 +44,7 @@ import {
 } from "alinea/core/Internal";
 import { getScope } from "alinea/core/Scope";
 import { isRecord } from "alinea/core/util/Objects";
+import { LinksField } from "alinea/field/link/LinkField";
 import {
   EntryIndexTable,
   EntryReferenceTable,
@@ -58,7 +59,11 @@ import {
   jsonField
 } from "./Condition.js";
 import { searchableText, searchQuery } from "./Search.js";
-import { linkRelation, relationCondition } from "./Relation.js";
+import {
+  linkRelation,
+  referencedByCondition,
+  relationCondition
+} from "./Relation.js";
 var builder = new Builder();
 function readJson(value, specs) {
   if (value === null) return void 0;
@@ -131,10 +136,10 @@ var Expressions = class {
       case "entryField":
         return selecting ? this.selection(internal.name, internal.path) : this.index(internal.name, internal.path);
       case "field": {
-        const name = this.#scope.nameOf(expression);
-        if (!name)
+        const path = this.#scope.dataPathOf(expression);
+        if (!path)
           throw new Error("Field expression is not in the configured schema");
-        return this.data([name], selecting);
+        return this.data(path, selecting);
       }
       case "value":
         return sql.value(internal.value);
@@ -218,8 +223,24 @@ function compileEntryQuery(config, query, options = {}) {
     throw new Error("SQL preview requires its dedicated query stage");
   const scope = getScope(config);
   function scalar(relationQuery) {
+    if (relationQuery.count) {
+      const { rows: rows2 } = compileEntryQuery(
+        config,
+        { ...relationQuery, status: query.status ?? "published" },
+        {
+          source: entry,
+          entry: alias(baseEntry, `alinea_scalar_${depth + 1}`),
+          depth: depth + 1,
+          baseEntry
+        }
+      );
+      const matches = rows2.as(`alinea_scalar_count_${depth + 1}`);
+      return sql`(${getQuery(builder.select(count()).from(matches))})`;
+    }
     if (!isRecord(relationQuery.select) || !hasExpr(relationQuery.select))
-      throw new Error("A relation expression must select a single expression");
+      throw new Error(
+        "A relation expression must select a single expression or count"
+      );
     const { rows } = compileEntryQuery(
       config,
       { ...relationQuery, status: query.status ?? "published" },
@@ -247,6 +268,14 @@ function compileEntryQuery(config, query, options = {}) {
       const name = scope.nameOf(edge.field);
       if (!name) throw new Error("Link field is not in the configured schema");
       links = linkRelation(source, name, edge.edge === "entryMultiple");
+    } else if (edge.edge === "referencedBy") {
+      const field = edge.field;
+      const path = field && scope.dataPathOf(field);
+      if (field && !path)
+        throw new Error("Link field is not in the configured schema");
+      const via = path && { path, multiple: field instanceof LinksField };
+      const ownLocale = query.locale === void 0 && !query.preferredLocale;
+      conditions.push(referencedByCondition(entry, source, via, ownLocale));
     } else conditions.push(relationCondition(entry, edge, source));
   }
   conditions.push(statusCondition(entry, query.status));
@@ -290,7 +319,9 @@ function compileEntryQuery(config, query, options = {}) {
       if (!name) throw new Error("Query type is not in the configured schema");
       return name;
     });
-    conditions.push(compileCondition(membership.index("type"), { in: names }));
+    conditions.push(
+      names.length === 1 ? eq(entry.type, names[0]) : compileCondition(membership.index("type"), { in: names })
+    );
   }
   const location = Array.isArray(query.location) ? query.location : query.location && scope.locationOf(query.location);
   if (location && location.length >= 1 && location.length <= 3) {
@@ -307,8 +338,29 @@ function compileEntryQuery(config, query, options = {}) {
         (item) => compileCondition(jsonField(item, ["url"]), query.alias, 1)
       )
     );
+  function related(name, condition) {
+    if (name !== "_referenced" || condition.edge !== "referencedBy")
+      throw new Error(`Unsupported relation condition on ${name}`);
+    const { rows } = compileEntryQuery(
+      config,
+      {
+        ...condition,
+        count: true,
+        status: query.status ?? "published"
+      },
+      {
+        source: entry,
+        entry: alias(baseEntry, `alinea_exists_${depth + 1}`),
+        depth: depth + 1,
+        baseEntry
+      }
+    );
+    return exists(rows);
+  }
   if (query.filter !== void 0)
-    conditions.push(compileFilter(query.filter, (name) => membership.field(name)));
+    conditions.push(
+      compileFilter(query.filter, (name) => membership.field(name), related)
+    );
   if (Array.isArray(query.groupBy))
     throw new Error("groupBy must be a single field");
   const grouping = query.groupBy ? [membership.expr(query.groupBy)] : void 0;

package/dist/database/query/Relation.d.ts

@@ -1,6 +1,6 @@
 import type { EdgeQuery } from 'alinea/core/Graph';
 import { type Sql } from 'rado';
-import type { EntryIndexTarget } from '../entry/EntryTable.js';
+import { type EntryIndexTarget } from '../entry/EntryTable.js';
 /** Expand the stored references as SQL rows, retaining list order and duplicates. */
 export declare function linkRelation(source: EntryIndexTarget, field: string, multiple: boolean): {
     target: Sql<unknown>;
@@ -9,3 +9,15 @@ export declare function linkRelation(source: EntryIndexTarget, field: string, mu
 };
 /** Restrict related identities in SQL before the query's own filters/paging. */
 export declare function relationCondition(entry: EntryIndexTarget, query: EdgeQuery, source: EntryIndexTarget): Sql<boolean>;
+/** A link field the referencing entries link through */
+export interface ReferenceField {
+    /** Where the field is stored in the entry data */
+    path: Array<string>;
+    multiple: boolean;
+}
+/**
+ * Entries that link to the source: the reference index finds them, a link
+ * field narrows them down to the ones linking through it. They share the
+ * locale of the source, unless either has none.
+ */
+export declare function referencedByCondition(entry: EntryIndexTarget, source: EntryIndexTarget, field?: ReferenceField, sameLocale?: boolean): Sql<boolean>;

package/dist/database/query/Relation.js

@@ -29,7 +29,10 @@ import {
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/database/query/Relation.ts
-import { jsonField } from "./Condition.js";
+import {
+  EntryReferenceTable
+} from "../entry/EntryTable.js";
+import { arrayIncludes, jsonField } from "./Condition.js";
 function linkRelation(source, field, multiple) {
   const value = getSql(jsonField(source.data, [field])).forSelection();
   const array = multiple ? value : sql`json_array(json(${value}))`;
@@ -117,7 +120,22 @@ function relationCondition(entry, query, source) {
       throw new Error(`SQL link relation is not implemented: ${query.edge}`);
   }
 }
+function referencedByCondition(entry, source, field, sameLocale = true) {
+  const references = new Builder().select(EntryReferenceTable.source).from(EntryReferenceTable).where(eq(EntryReferenceTable.targetId, source.id));
+  const value = field && jsonField(entry.data, field.path);
+  const linked = !value ? sql.value(true) : field.multiple ? arrayIncludes(value, (item) => eq(jsonField(item, ["_entry"]), source.id)) : eq(jsonField(value, ["_entry"]), source.id);
+  return and(
+    inArray(entry.rowid, references),
+    linked,
+    sameLocale ? or(
+      sql`${source.locale} is null`,
+      sql`${entry.locale} is null`,
+      eq(entry.locale, source.locale)
+    ) : sql.value(true)
+  );
+}
 export {
   linkRelation,
+  referencedByCondition,
   relationCondition
 };