@byline/richtext-lexical 2.5.0 → 2.5.2

package/dist/field/lexical-populate-shared.d.ts

@@ -97,9 +97,15 @@ interface RunPopulateOptions {
 /**
  * Walk every supplied rich-text value, collect the union of pending
  * hydrations across all visitors, batch-fetch by source collection, and
- * apply. Threading `readContext` keeps the visited-set / `afterReadFired`
- * / read-budget machinery in sync with relation populate and user-land
- * `afterRead` hooks.
+ * apply.
+ *
+ * `readContext` is accepted (factories thread it through from
+ * `RichTextPopulateContext` / `RichTextEmbedContext`) but currently unused —
+ * the batch fetch goes straight to `getDocumentsByDocumentIds` and doesn't
+ * recurse into populate or `afterRead`, so there's no visited-set or
+ * read-budget state to share. Retained on the options shape so a future
+ * visitor that performs nested populate can opt back in without another
+ * contract churn.
  */
 export declare function runLexicalPopulate(options: RunPopulateOptions): Promise<void>;
 export {};

package/dist/field/lexical-populate-shared.js

@@ -17,7 +17,7 @@ function* iterAllNodes(node) {
     if (Array.isArray(node.children)) for (const child of node.children)yield* iterAllNodes(child);
 }
 async function runLexicalPopulate(options) {
-    const { client, readContext, visitors, values } = options;
+    const { client, visitors, values } = options;
     const pending = [];
     for (const value of values){
         const root = getLexicalRoot(value);
@@ -39,17 +39,19 @@ async function runLexicalPopulate(options) {
     const fetched = new Map();
     await Promise.all(Array.from(idsByCollection.entries()).map(async ([collectionPath, idSet])=>{
         const ids = Array.from(idSet);
-        const result = await client.collection(collectionPath).find({
-            where: {
-                id: {
-                    $in: ids
-                }
-            },
-            pageSize: ids.length,
-            _readContext: readContext
+        const collectionId = await client.resolveCollectionId(collectionPath);
+        const rawDocs = await client.db.queries.documents.getDocumentsByDocumentIds({
+            collection_id: collectionId,
+            document_ids: ids,
+            readMode: 'published'
         });
         const byId = new Map();
-        for (const d of result.docs)if ('string' == typeof d.id) byId.set(d.id, d);
+        for (const raw of rawDocs)if ('string' == typeof raw.document_id) byId.set(raw.document_id, {
+            id: raw.document_id,
+            path: raw.path,
+            status: raw.status,
+            fields: raw.fields
+        });
         fetched.set(collectionPath, byId);
     }));
     for (const p of pending){

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "license": "MPL-2.0",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -72,9 +72,9 @@
     "npm-run-all": "^4.1.5",
     "prism-react-renderer": "^2.4.1",
     "react-error-boundary": "^6.1.1",
-    "@byline/client": "2.5.0",
-    "@byline/core": "2.5.0",
-    "@byline/ui": "2.5.0"
+    "@byline/client": "2.5.2",
+    "@byline/core": "2.5.2",
+    "@byline/ui": "2.5.2"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/field/lexical-populate-shared.ts

@@ -140,12 +140,18 @@ interface RunPopulateOptions {
 /**
  * Walk every supplied rich-text value, collect the union of pending
  * hydrations across all visitors, batch-fetch by source collection, and
- * apply. Threading `readContext` keeps the visited-set / `afterReadFired`
- * / read-budget machinery in sync with relation populate and user-land
- * `afterRead` hooks.
+ * apply.
+ *
+ * `readContext` is accepted (factories thread it through from
+ * `RichTextPopulateContext` / `RichTextEmbedContext`) but currently unused —
+ * the batch fetch goes straight to `getDocumentsByDocumentIds` and doesn't
+ * recurse into populate or `afterRead`, so there's no visited-set or
+ * read-budget state to share. Retained on the options shape so a future
+ * visitor that performs nested populate can opt back in without another
+ * contract churn.
  */
 export async function runLexicalPopulate(options: RunPopulateOptions): Promise<void> {
-  const { client, readContext, visitors, values } = options
+  const { client, visitors, values } = options
 
   const pending: PendingHydration[] = []
   for (const value of values) {
@@ -172,18 +178,34 @@ export async function runLexicalPopulate(options: RunPopulateOptions): Promise<v
     bucket.add(p.documentId)
   }
 
+  // Fetch directly through the adapter rather than the client's `find()` —
+  // `parseWhere` has no handler for `id`, so `find({ where: { id: { $in } } })`
+  // silently dropped the filter and returned arbitrary docs ordered by
+  // `created_at desc`. This is the same primitive relation populate uses
+  // (`packages/core/src/services/populate.ts`) when it batches by document id.
   const fetched = new Map<string, Map<string, Record<string, any>>>()
   await Promise.all(
     Array.from(idsByCollection.entries()).map(async ([collectionPath, idSet]) => {
       const ids = Array.from(idSet)
-      const result = await client.collection(collectionPath).find({
-        where: { id: { $in: ids } },
-        pageSize: ids.length,
-        _readContext: readContext,
+      const collectionId = await client.resolveCollectionId(collectionPath)
+      const rawDocs = await client.db.queries.documents.getDocumentsByDocumentIds({
+        collection_id: collectionId,
+        document_ids: ids,
+        readMode: 'published',
       })
       const byId = new Map<string, Record<string, any>>()
-      for (const d of result.docs as Array<Record<string, any>>) {
-        if (typeof d.id === 'string') byId.set(d.id, d)
+      for (const raw of rawDocs as Array<Record<string, any>>) {
+        if (typeof raw.document_id !== 'string') continue
+        // Normalise the raw storage shape (`document_id` / `path` / `status` /
+        // `fields`) to the `{ id, path, status, fields }` shape the visitors
+        // expect — matches the shaped `ClientDocument` the previous `find()`
+        // path returned.
+        byId.set(raw.document_id, {
+          id: raw.document_id,
+          path: raw.path,
+          status: raw.status,
+          fields: raw.fields,
+        })
       }
       fetched.set(collectionPath, byId)
     })