@karibsen/eponyme 0.6.0 → 0.8.0

package/dist/runtime/server/services/eponyme-store.js

@@ -1,11 +1,15 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { createDefaultEponymeData } from "../../utils/create-default-eponyme-data.js";
+import { isArrayItemFieldDefinition } from "../../utils/get-field-default-value.js";
 import { getEponymeCollections, getEponymeSchemas } from "../../utils/get-eponyme-schemas.js";
 import { normalizeSlug } from "../../utils/normalize-slug.js";
 import { applyPreviewSlug } from "../../utils/preview.js";
 import { validateEponymeData, validateEponymePatch } from "../../utils/validate-eponyme-data.js";
+import { normalizeEponymeValues } from "../../utils/normalize-eponyme-values.js";
+import { buildEponymeIndexRows, describeEponymeIndexSchema, eponymeIndexKeys, foldEponymeIndexValue } from "../../utils/eponyme-entry-index.js";
 export const COLLECTION_METADATA_KEYS = ["updatedAt", "publishedAt", "title", "slug"];
+const IMPORT_TRANSACTION_MS = 12e4;
 export class EponymeService {
   constructor(config, client, options = {}) {
     this.client = client;
@@ -43,7 +47,118 @@ export class EponymeService {
   invalidate(name) {
     this.cache.delete(`row:${name}`);
     const collection = this.getCollectionEntry(name)?.name;
-    if (collection) this.cache.delete(`rows:${collection}`);
+    if (collection) {
+      for (const key of this.cache.keys()) if (key.startsWith(`rows:${collection}:`)) this.cache.delete(key);
+    }
+  }
+  /**
+   * Replaces an entry's filterable values, in the same transaction as the write that
+   * changed them.
+   *
+   * Deleting before inserting rather than diffing: an entry carries a handful of rows, the
+   * two statements are cheap, and a diff is one more place for the index to drift from the
+   * content it describes — a failure mode that returns wrong listings without erroring.
+   */
+  async reindexEntry(db, name, state) {
+    const schema = this.getSchema(name);
+    if (!schema) return;
+    await db.eponymeEntryIndex.deleteMany({ where: { entryName: name } });
+    const rows = buildEponymeIndexRows(name, schema, state.__eponyme);
+    if (rows.length) await db.eponymeEntryIndex.createMany({ data: rows });
+  }
+  collectionFilterKeys(name) {
+    const definition = this.collections[name];
+    return definition ? eponymeIndexKeys(definition.fields) : void 0;
+  }
+  /**
+   * One transaction per entry rather than one for the whole collection: a collection has no
+   * bound, and a single transaction over it would exceed Prisma's timeout on anything real.
+   * The unit that has to be atomic is the entry, and it is.
+   */
+  async reindexName(name) {
+    const definition = this.collections[name];
+    if (!definition) {
+      const state = await this.loadState(name);
+      if (!state) return 0;
+      await this.transaction(async (tx) => await this.reindexEntry(tx, name, state));
+      return 1;
+    }
+    let entries = 0;
+    for (const row of await this.liveCollectionRows(name)) {
+      const slug = row.name.slice(name.length + 1);
+      if (!slug || slug.includes("/")) continue;
+      const state = this.rowToState(definition.fields, row);
+      await this.transaction(async (tx) => await this.reindexEntry(tx, row.name, state));
+      entries++;
+    }
+    return entries;
+  }
+  indexedNames() {
+    return [...Object.keys(this.schemas), ...Object.keys(this.collections)];
+  }
+  /**
+   * The unconditional rebuild, for a first backfill or a manual repair. It refreshes the
+   * recorded fingerprints too, so a repair does not leave the next boot with work to redo.
+   */
+  async reindexAll() {
+    let entries = 0;
+    for (const name of this.indexedNames()) {
+      entries += await this.reindexName(name);
+      await this.writeIndexState(name);
+    }
+    return { entries };
+  }
+  /**
+   * Rebuilds only what a configuration change invalidated, and nothing when nothing changed.
+   *
+   * This is what makes the index self-maintaining. Ordinary writes keep it current, but a
+   * newly filterable field leaves the entries already stored without any row for that key —
+   * and a filter on them then answers "none" rather than failing, which is the worst way for
+   * this to break.
+   *
+   * Unchanged configuration costs one read of a table with one row per collection.
+   */
+  async syncIndexState() {
+    const recorded = new Map((await this.client.eponymeIndexState.findMany()).map((row) => [row.name, row.fingerprint]));
+    const reindexed = [];
+    for (const name of this.indexedNames()) {
+      if (recorded.get(name) === this.indexFingerprint(name)) continue;
+      await this.reindexName(name);
+      await this.writeIndexState(name);
+      reindexed.push(name);
+    }
+    const stale = [...recorded.keys()].filter((name) => !this.schemas[name] && !this.collections[name]);
+    if (stale.length) await this.client.eponymeIndexState.deleteMany({ where: { name: { in: stale } } });
+    return { reindexed };
+  }
+  indexFingerprint(name) {
+    const schema = this.collections[name]?.fields ?? this.schemas[name];
+    return createHash("sha256").update(describeEponymeIndexSchema(schema ?? {})).digest("hex").slice(0, 32);
+  }
+  async writeIndexState(name) {
+    const fingerprint = this.indexFingerprint(name);
+    await this.client.eponymeIndexState.upsert({
+      where: { name },
+      create: { name, fingerprint },
+      update: { fingerprint }
+    });
+  }
+  /**
+   * Runs writes that have to land together, then drops what they invalidated.
+   *
+   * The callback reports the entries it touched rather than invalidating them itself:
+   * inside the transaction the write has not landed yet, and a read racing an
+   * uncommitted change would re-cache the old row and hold it for the whole TTL. The
+   * drop is deliberate on a rollback too — losing a cache entry costs one query, while
+   * keeping a wrong one costs the TTL.
+   */
+  async transaction(fn, options) {
+    const touched = /* @__PURE__ */ new Set();
+    try {
+      return await this.client.$transaction((tx) => fn(tx, (name) => touched.add(name)), options);
+    } finally {
+      for (const name of touched) this.invalidate(name);
+    }
   }
   getSchema(name) {
     return this.schemas[name] ?? this.getCollectionEntry(name)?.definition.fields;
@@ -63,15 +178,43 @@ export class EponymeService {
   async syncAll() {
     await Promise.all(Object.keys(this.schemas).map((name) => this.loadState(name, { heal: true })));
   }
+  /**
+   * Brings a stored document back in line with the schema: keys the schema no longer declares
+   * are dropped, and a key it declares but the document lacks takes its default.
+   *
+   * Recursive, because a field added inside a section, a tab or an array item is otherwise
+   * never filled in: the container it lives in already exists and is still valid, so a
+   * top-level pass keeps it untouched and the new field reads as missing forever. That was
+   * silent — `defaultValue` simply did nothing for anything but a root field.
+   */
   reconcile(schema, value, mode) {
-    const persisted = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    const persisted = isPlainObject(value) ? value : {};
     const defaults = createDefaultEponymeData(schema);
     return Object.fromEntries(Object.keys(schema).map((key) => {
-      const candidate = key in persisted ? persisted[key] : defaults[key];
-      const errors = validateEponymeData({ [key]: schema[key] }, { [key]: candidate }, mode);
+      const definition = schema[key];
+      const candidate = key in persisted ? this.reconcileField(definition, persisted[key], mode) : defaults[key];
+      const errors = validateEponymeData({ [key]: definition }, { [key]: candidate }, mode);
       return [key, Object.keys(errors).length ? defaults[key] : candidate];
     }));
   }
+  /** Descends into the containers; a leaf is returned untouched for `reconcile` to judge. */
+  reconcileField(definition, value, mode) {
+    if (definition.type === "section")
+      return isPlainObject(value) ? this.reconcile(definition.options.fields, value, mode) : value;
+    if (definition.type === "tabs") {
+      if (!isPlainObject(value)) return value;
+      return Object.fromEntries(Object.entries(definition.options.tabs).map(([tabName, tab]) => [
+        tabName,
+        this.reconcile(tab.fields, value[tabName], mode)
+      ]));
+    }
+    if (definition.type === "array") {
+      const of = definition.options.of;
+      if (!Array.isArray(value) || isArrayItemFieldDefinition(of)) return value;
+      return value.map((item) => isPlainObject(item) ? this.reconcile(of, item, mode) : item);
+    }
+    return value;
+  }
   createState(schema, value) {
     const data = this.reconcile(schema, value ?? createDefaultEponymeData(schema), "publish");
     return {
@@ -84,6 +227,12 @@ export class EponymeService {
       }
     };
   }
+  /**
+   * Reads a state out of an envelope. Live content is in columns now, so this serves the two
+   * places an envelope still exists: a history row, which deliberately keeps the old shape so
+   * that versions written before this change stay restorable, and an import, which rebuilds
+   * one from the portable file.
+   */
   normalizeState(schema, value) {
     const stored = getStoredState(value);
     if (!stored) return this.createState(schema, value);
@@ -97,6 +246,17 @@ export class EponymeService {
       }
     };
   }
+  rowToState(schema, row) {
+    return {
+      __eponyme: {
+        version: 1,
+        draft: this.reconcile(schema, row.draft, "draft"),
+        published: this.reconcile(schema, row.published, "publish"),
+        status: row.status === "draft" ? "draft" : "published",
+        publishedAt: toIsoOrNull(row.publishedAt)
+      }
+    };
+  }
   /**
    * A singleton row is created on first read, but only when it is genuinely missing.
    * An `upsert` would send a write on every read instead, and each one costs a database
@@ -106,7 +266,7 @@ export class EponymeService {
     const row = await this.client.eponyme.findUnique({ where: { name } });
     if (row) return row;
     try {
-      return await this.client.eponyme.create({ data: { name, data: this.createState(schema) } });
+      return await this.client.eponyme.create({ data: { name, ...stateToColumns(this.createState(schema)) } });
     } catch (error) {
       if (isPrismaError(error, "P2002")) return await this.client.eponyme.findUnique({ where: { name } });
       throw error;
@@ -131,11 +291,11 @@ export class EponymeService {
     if (!schema) return void 0;
     const row = this.getCollectionEntry(name) ? await this.client.eponyme.findUnique({ where: { name } }) : await this.loadSingletonRow(name, schema);
     if (!row || row.deletedAt) return void 0;
-    const state = this.normalizeState(schema, row.data);
-    if (sameData(state, row.data)) return { state, updatedAt: row.updatedAt };
+    const state = this.rowToState(schema, row);
+    if (sameRow(state, row)) return { state, updatedAt: row.updatedAt };
     if (!heal && this.healedByRead.has(name)) return { state, updatedAt: row.updatedAt };
     this.healedByRead.add(name);
-    const healed = await this.client.eponyme.update({ where: { name }, data: { data: state } });
+    const healed = await this.client.eponyme.update({ where: { name }, data: stateToColumns(state) });
     this.invalidate(name);
     return { state, updatedAt: healed.updatedAt ?? row.updatedAt };
   }
@@ -146,34 +306,90 @@ export class EponymeService {
    * Writes a new state only if the row still carries the `updatedAt` we read.
    * Returns false when a concurrent editor won the race, so the caller can report a conflict
    * instead of silently discarding their changes.
+   *
+   * Dropping the cached row is left to `transaction`, which does it once the write has
+   * actually committed rather than while it is still in flight.
    */
-  async writeState(name, next, expectedUpdatedAt) {
-    const data = next;
-    try {
-      if (!expectedUpdatedAt) {
-        await this.client.eponyme.update({ where: { name }, data: { data } });
-        return true;
-      }
-      const { count } = await this.client.eponyme.updateMany({ where: { name, updatedAt: expectedUpdatedAt }, data: { data } });
-      return count > 0;
-    } finally {
-      this.invalidate(name);
+  async writeState(name, next, expectedUpdatedAt, db) {
+    const data = stateToColumns(next);
+    if (!expectedUpdatedAt) {
+      await db.eponyme.update({ where: { name }, data });
+      return true;
     }
+    const { count } = await db.eponyme.updateMany({ where: { name, updatedAt: expectedUpdatedAt }, data });
+    return count > 0;
   }
   /**
-   * The live rows of a collection, shared by the public listing and the sitemap so both
-   * read them once. The trash and the export deliberately query around it: one wants the
-   * rows this filter excludes, the other must not see a cached view of the content.
+   * Every live row of a collection, payload included. The reindex needs both versions of the
+   * content, so this is the one read that still selects everything; a listing goes through
+   * `collectionRows` with a narrower select.
    */
-  async liveCollectionRows(name, cache = false) {
-    const load = () => this.client.eponyme.findMany({
+  async liveCollectionRows(name) {
+    return await this.client.eponyme.findMany({
       where: { name: { startsWith: `${name}/` }, deletedAt: null },
       orderBy: [
         { updatedAt: "desc" },
         { name: "asc" }
       ]
     });
-    return cache ? await this.cached(`rows:${name}`, load) : await load();
+  }
+  /**
+   * The names a `where` keeps, resolved from the index table before a single row of content
+   * is read. This is the point of the index: a filtered listing loads and normalizes the
+   * entries it returns, not the whole collection.
+   *
+   * One query per key, intersected: the values of a key are ORed by the query itself, and
+   * the keys are ANDed by narrowing the set. An empty set short-circuits the whole listing.
+   */
+  async resolveFilter(name, version, where) {
+    let matching;
+    const excluded = /* @__PURE__ */ new Set();
+    for (const [key, condition] of Object.entries(where)) {
+      const { positive, negative } = splitCondition(condition);
+      if (positive) {
+        const names = await this.indexNames(name, version, key, positive);
+        matching = matching === void 0 ? names : new Set([...matching].filter((entry) => names.has(entry)));
+        if (!matching.size) return matching;
+      }
+      if (negative) {
+        for (const entry of await this.indexNames(name, version, key, negative)) excluded.add(entry);
+      }
+    }
+    const result = matching ?? await this.collectionEntryNames(name);
+    for (const entry of excluded) result.delete(entry);
+    return result;
+  }
+  async indexNames(name, version, key, value) {
+    const rows = await this.client.eponymeEntryIndex.findMany({
+      where: { entryName: { startsWith: `${name}/` }, version, key, value },
+      select: { entryName: true }
+    });
+    return new Set(rows.map((row) => row.entryName));
+  }
+  async collectionEntryNames(name) {
+    const rows = await this.client.eponyme.findMany({
+      where: { name: { startsWith: `${name}/` }, deletedAt: null },
+      orderBy: [{ name: "asc" }],
+      select: { name: true }
+    });
+    return new Set(rows.flatMap((row) => {
+      const slug = row.name.slice(name.length + 1);
+      return !slug || slug.includes("/") ? [] : [row.name];
+    }));
+  }
+  /**
+   * The rows a filter selected. Never cached: the shared `rows:` key holds the whole
+   * collection, and one key per filter combination would evict it for no reuse.
+   */
+  async filteredCollectionRows(names) {
+    return await this.client.eponyme.findMany({
+      // The index knows nothing about the trash, so the live filter still has to apply.
+      where: { name: { in: [...names] }, deletedAt: null },
+      orderBy: [
+        { updatedAt: "desc" },
+        { name: "asc" }
+      ]
+    });
   }
   async get(name, version = "published") {
     return (await this.getResult(name, version))?.data;
@@ -218,11 +434,65 @@ export class EponymeService {
   async listCollection(name, version = "published", query = {}) {
     const definition = this.collections[name];
     if (!definition) return void 0;
-    const rows = await this.liveCollectionRows(name, version === "published");
-    const entries = rows.flatMap((row) => {
+    let names;
+    if (query.where && Object.keys(query.where).length) {
+      names = await this.resolveFilter(name, version, query.where);
+      if (!names.size) return { entries: [], total: 0 };
+    }
+    const where = {
+      name: names ? { in: [...names] } : { startsWith: `${name}/` },
+      deletedAt: null,
+      // The predicate that used to force everything into memory. It is a column now, so the
+      // database can apply it before counting, ordering and paginating.
+      ...version === "published" ? { publishedAt: { not: null } } : {}
+    };
+    const select = version === "published" ? { name: true, published: true, publishedAt: true, updatedAt: true } : { name: true, draft: true, status: true, publishedAt: true, updatedAt: true };
+    const pushdown = pushdownOrderBy(query.orderBy, query.order ?? "desc");
+    if (pushdown) {
+      const [rows2, total] = await Promise.all([
+        this.client.eponyme.findMany({
+          where,
+          orderBy: pushdown,
+          skip: Math.max(0, Math.trunc(query.skip ?? 0) || 0),
+          ...query.take === void 0 ? {} : { take: Math.max(0, Math.trunc(query.take) || 0) },
+          select
+        }),
+        this.client.eponyme.count({ where })
+      ]);
+      return { entries: this.toCollectionEntries(name, definition, version, rows2), total };
+    }
+    const rows = await this.collectionRows(name, version, where, select, names === void 0);
+    const entries = this.toCollectionEntries(name, definition, version, rows);
+    const sorted = query.orderBy ? sortCollectionEntries(entries, query.orderBy, query.order ?? "desc") : entries;
+    const skip = Math.max(0, Math.trunc(query.skip ?? 0) || 0);
+    const take = query.take === void 0 ? void 0 : Math.max(0, Math.trunc(query.take) || 0);
+    return {
+      entries: take === void 0 ? sorted.slice(skip) : sorted.slice(skip, skip + take),
+      total: sorted.length
+    };
+  }
+  /**
+   * The unpaginated read, still cached: an unfiltered listing of one collection is what a
+   * page hits repeatedly, and the key carries the version so a draft view cannot answer a
+   * public one.
+   */
+  async collectionRows(name, version, where, select, cache) {
+    const load = () => this.client.eponyme.findMany({
+      where,
+      orderBy: [{ updatedAt: "desc" }, { name: "asc" }],
+      select
+    });
+    return cache && version === "published" ? await this.cached(`rows:${name}:${version}`, load) : await load();
+  }
+  /**
+   * `findMany` already carries every payload, so the state is built here rather than re-read
+   * one entry at a time: a listing costs one query, not N+1.
+   */
+  toCollectionEntries(name, definition, version, rows) {
+    return rows.flatMap((row) => {
       const slug = row.name.slice(name.length + 1);
       if (!slug || slug.includes("/")) return [];
-      const state = this.normalizeState(definition.fields, row.data);
+      const state = this.rowToState(definition.fields, row);
       return [{
         slug,
         title: String(state.__eponyme[version][definition.titleField] || slug),
@@ -232,14 +502,6 @@ export class EponymeService {
         updatedAt: row.updatedAt ? new Date(row.updatedAt).toISOString() : null
       }];
     });
-    const visible = version === "draft" ? entries : entries.filter((entry) => entry.publishedAt);
-    const sorted = query.orderBy ? sortCollectionEntries(visible, query.orderBy, query.order ?? "desc") : visible;
-    const skip = Math.max(0, Math.trunc(query.skip ?? 0) || 0);
-    const take = query.take === void 0 ? void 0 : Math.max(0, Math.trunc(query.take) || 0);
-    return {
-      entries: take === void 0 ? sorted.slice(skip) : sorted.slice(skip, skip + take),
-      total: sorted.length
-    };
   }
   /**
    * Builds the public URL list configured by `previewPaths`.
@@ -256,13 +518,15 @@ export class EponymeService {
       }
       if (!path.includes(":slug"))
         throw new Error(`[Eponyme] previewPaths.${name} must include ":slug" to generate collection sitemap URLs.`);
-      const rows = await this.liveCollectionRows(name, true);
+      const rows = await this.cached(`rows:${name}:sitemap`, () => this.client.eponyme.findMany({
+        where: { name: { startsWith: `${name}/` }, deletedAt: null, publishedAt: { not: null } },
+        orderBy: [{ name: "asc" }],
+        select: { name: true, publishedAt: true }
+      }));
       return rows.flatMap((row) => {
         const slug = row.name.slice(name.length + 1);
         if (!slug || slug.includes("/")) return [];
-        const state = this.normalizeState(collection.fields, row.data);
-        if (!state.__eponyme.publishedAt) return [];
-        return [withLastmod(applyPreviewSlug(path, slug), state.__eponyme.publishedAt)];
+        return [withLastmod(applyPreviewSlug(path, slug), toIsoOrNull(row.publishedAt))];
       });
     }));
     const entries = /* @__PURE__ */ new Map();
@@ -294,7 +558,7 @@ export class EponymeService {
       for (const row of rows) {
         const slug = row.name.slice(name.length + 1);
         if (!slug || slug.includes("/")) continue;
-        entries.push({ name: row.name, collection: name, ...toExportEntry(this.normalizeState(definition.fields, row.data)) });
+        entries.push({ name: row.name, collection: name, ...toExportEntry(this.rowToState(definition.fields, row)) });
       }
     }
     return {
@@ -307,7 +571,9 @@ export class EponymeService {
    * upserted, everything else is left alone. Nothing is ever deleted.
    *
    * The schema check runs first and refuses the whole file, so an import can never
-   * land half of its entries into a configuration that no longer matches.
+   * land half of its entries into a configuration that no longer matches. The writes then
+   * run in one transaction, so a failure partway through leaves nothing behind either —
+   * an interrupted import can simply be replayed.
    */
   async importContent(file, options = {}) {
     const parsed = parseExportFile(file);
@@ -327,6 +593,20 @@ export class EponymeService {
         schemaMismatch: mismatch
       };
     }
+    if (options.dryRun) return await this.applyImport(parsed, options, this.client, () => {
+    });
+    return await this.transaction(
+      (tx, invalidate) => this.applyImport(parsed, options, tx, invalidate),
+      // An import is one unit, so its transaction lasts as long as the file it carries —
+      // well past the five seconds Prisma allows by default.
+      { maxWait: IMPORT_TRANSACTION_MS, timeout: IMPORT_TRANSACTION_MS }
+    );
+  }
+  /**
+   * The body of an import, over whichever client it was handed: the live one for a dry
+   * run, a transaction for the real thing.
+   */
+  async applyImport(parsed, options, db, invalidate) {
     const result = { dryRun: Boolean(options.dryRun), created: 0, updated: 0, skipped: [] };
     for (const entry of parsed.entries) {
       const collectionEntry = this.getCollectionEntry(entry.name);
@@ -335,7 +615,7 @@ export class EponymeService {
         result.skipped.push({ name: entry.name, reason: "No schema is configured for this entry." });
         continue;
       }
-      const row = await this.client.eponyme.findUnique({ where: { name: entry.name } });
+      const row = await db.eponyme.findUnique({ where: { name: entry.name } });
       if (row?.deletedAt) {
         result.skipped.push({ name: entry.name, reason: "An entry with this name is in the trash. Restore it or delete it permanently first." });
         continue;
@@ -356,9 +636,11 @@ export class EponymeService {
       }
       if (!options.dryRun) {
         const data = state;
-        await this.client.eponyme.upsert({ where: { name: entry.name }, create: { name: entry.name, data }, update: { data } });
-        this.invalidate(entry.name);
-        await this.client.eponymeVersion.create({
+        const columns = stateToColumns(state);
+        invalidate(entry.name);
+        await db.eponyme.upsert({ where: { name: entry.name }, create: { name: entry.name, ...columns }, update: columns });
+        await this.reindexEntry(db, entry.name, state);
+        await db.eponymeVersion.create({
           data: {
             entryName: entry.name,
             data,
@@ -386,7 +668,7 @@ export class EponymeService {
     const taken = await this.slugTakenError(definition, entryName);
     if (taken) return taken;
     const defaults = createDefaultEponymeData(definition.fields);
-    const data = { ...defaults, ...input, [definition.slugField]: slug };
+    const data = normalizeEponymeValues(definition.fields, { ...defaults, ...input, [definition.slugField]: slug });
     const errors = validateEponymePatch(definition.fields, data, data, "draft");
     if (Object.keys(errors).length) return { errors };
     const state = {
@@ -398,14 +680,19 @@ export class EponymeService {
         publishedAt: null
       }
     };
+    const stored = state;
+    const columns = stateToColumns(state);
     try {
-      await this.client.eponyme.create({ data: { name: entryName, data: state } });
-      this.invalidate(entryName);
+      await this.transaction(async (tx, invalidate) => {
+        invalidate(entryName);
+        await tx.eponyme.create({ data: { name: entryName, ...columns } });
+        await this.reindexEntry(tx, entryName, state);
+        await tx.eponymeVersion.create({ data: { entryName, data: stored, action: "draft", status: "draft", userId: actorId ?? null } });
+      });
     } catch (error) {
       if (isPrismaError(error, "P2002")) return await this.slugTakenError(definition, entryName) ?? { errors: { [definition.slugField]: ["This slug is already in use."] } };
       throw error;
     }
-    await this.client.eponymeVersion.create({ data: { entryName, data: state, action: "draft", status: "draft", userId: actorId ?? null } });
     return { slug, data, status: "draft", publishedAt: null };
   }
   /**
@@ -468,7 +755,7 @@ export class EponymeService {
     const entries = rows.flatMap((row) => {
       const slug = row.name.slice(name.length + 1);
       if (!slug || slug.includes("/")) return [];
-      const state = this.normalizeState(definition.fields, row.data);
+      const state = this.rowToState(definition.fields, row);
       return [{
         slug,
         title: String(state.__eponyme.draft[definition.titleField] || slug),
@@ -494,8 +781,8 @@ export class EponymeService {
       if (submittedSlug !== collectionEntry.slug)
         return { errors: { [collectionEntry.definition.slugField]: ["The slug cannot be changed after creation."] } };
     }
-    const data = { ...state.__eponyme.draft, ...payload };
-    const patchErrors = validateEponymePatch(schema, payload, data, action);
+    const data = normalizeEponymeValues(schema, { ...state.__eponyme.draft, ...payload });
+    const patchErrors = validateEponymePatch(schema, normalizeEponymeValues(schema, payload), data, action);
     const errors = action === "publish" ? mergeErrors(patchErrors, validateEponymeData(schema, data, "publish")) : patchErrors;
     if (Object.keys(errors).length) return { errors };
     const publishedAt = action === "publish" ? (/* @__PURE__ */ new Date()).toISOString() : state.__eponyme.publishedAt;
@@ -508,16 +795,22 @@ export class EponymeService {
         publishedAt
       }
     };
-    if (!await this.writeState(name, next, updatedAt)) return { conflict: true };
-    await this.client.eponymeVersion.create({
-      data: {
-        entryName: name,
-        data: next,
-        action,
-        status: next.__eponyme.status,
-        userId: actorId ?? null
-      }
+    const written = await this.transaction(async (tx, invalidate) => {
+      invalidate(name);
+      if (!await this.writeState(name, next, updatedAt, tx)) return false;
+      await this.reindexEntry(tx, name, next);
+      await tx.eponymeVersion.create({
+        data: {
+          entryName: name,
+          data: next,
+          action,
+          status: next.__eponyme.status,
+          userId: actorId ?? null
+        }
+      });
+      return true;
     });
+    if (!written) return { conflict: true };
     return { data, status: next.__eponyme.status, publishedAt };
   }
   async history(name, limit = 50) {
@@ -544,16 +837,22 @@ export class EponymeService {
     const current = await this.loadRow(name, { heal: true });
     if (!current) return void 0;
     const state = this.normalizeState(schema, version.data);
-    if (!await this.writeState(name, state, current.updatedAt)) return { conflict: true };
-    await this.client.eponymeVersion.create({
-      data: {
-        entryName: name,
-        data: state,
-        action: "restore",
-        status: state.__eponyme.status,
-        userId: actorId ?? null
-      }
+    const written = await this.transaction(async (tx, invalidate) => {
+      invalidate(name);
+      if (!await this.writeState(name, state, current.updatedAt, tx)) return false;
+      await this.reindexEntry(tx, name, state);
+      await tx.eponymeVersion.create({
+        data: {
+          entryName: name,
+          data: state,
+          action: "restore",
+          status: state.__eponyme.status,
+          userId: actorId ?? null
+        }
+      });
+      return true;
     });
+    if (!written) return { conflict: true };
     return {
       data: state.__eponyme.draft,
       status: state.__eponyme.status,
@@ -643,8 +942,35 @@ function mergeErrors(...groups) {
 export function isPrismaError(error, code) {
   return Boolean(error && typeof error === "object" && error.code === code);
 }
-function sameData(left, right) {
-  return isDeepStrictEqual(left, right);
+function stateToColumns(state) {
+  const { draft, published, status, publishedAt } = state.__eponyme;
+  return { draft, published, status, publishedAt: publishedAt ? new Date(publishedAt) : null };
+}
+function toIsoOrNull(value) {
+  if (value === null || value === void 0) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function sameRow(state, row) {
+  const stored = state.__eponyme;
+  return isDeepStrictEqual(stored.draft, row.draft) && isDeepStrictEqual(stored.published, row.published) && stored.status === row.status && stored.publishedAt === toIsoOrNull(row.publishedAt);
+}
+function splitCondition(condition) {
+  if (typeof condition === "string") return { positive: foldEponymeIndexValue(condition) };
+  if (Array.isArray(condition)) return { positive: { in: condition.map(foldEponymeIndexValue) } };
+  const positive = {};
+  if (condition.in?.length) positive.in = condition.in.map(foldEponymeIndexValue);
+  if (condition.contains) positive.contains = foldEponymeIndexValue(condition.contains);
+  for (const bound of ["gte", "lte", "gt", "lt"]) {
+    const value = condition[bound];
+    if (value !== void 0) positive[bound] = foldEponymeIndexValue(value);
+  }
+  return {
+    // An operator object carrying only `not` has no positive part, and an empty one filters
+    // nothing at all rather than matching nothing.
+    positive: Object.keys(positive).length ? positive : void 0,
+    negative: condition.not?.length ? { in: condition.not.map(foldEponymeIndexValue) } : void 0
+  };
 }
 function sortValue(entry, key) {
   if (COLLECTION_METADATA_KEYS.includes(key))
@@ -654,6 +980,12 @@ function sortValue(entry, key) {
 function isEmptyValue(value) {
   return value === void 0 || value === null || value === "";
 }
+function pushdownOrderBy(orderBy, order) {
+  if (orderBy === void 0) return [{ updatedAt: "desc" }, { name: "asc" }];
+  if (orderBy === "updatedAt") return [{ updatedAt: order }, { name: "asc" }];
+  if (orderBy === "publishedAt") return [{ publishedAt: { sort: order, nulls: "last" } }, { name: "asc" }];
+  return void 0;
+}
 function sortCollectionEntries(entries, key, direction) {
   const factor = direction === "asc" ? 1 : -1;
   return [...entries].sort((left, right) => {