rimecms 0.33.0 → 1.0.0

package/dist/core/i18n/fr/fields.js

@@ -1,7 +1,46 @@
 export default {
   password: 'mot de passe',
   write_something: 'Écrivez quelque chose...',
+  write_or_slash: 'Écrivez, ou tapez / pour insérer…',
   new_tab: 'Nouvel onglet',
+  link_url: 'URL',
+  link_email: 'E-mail',
+  link_tel: 'Téléphone',
+  link_anchor: 'Ancre',
+  focus: 'Focus',
+  add: 'Ajouter',
+  block: 'Bloc',
+  paste_after: 'Coller après',
+  exit_focus: 'Quitter le focus',
+  inspector: 'Inspecteur',
+  pick_a_block: 'Sélectionnez un bloc pour le modifier.',
+  selected_count: '$1 sélectionné(s)',
+  done: 'Terminé',
+  choose_media: 'Choisir un média',
+  choose_medias: 'Choisir des médias',
+  edit_selection: 'Modifier la sélection',
+  replace: 'Remplacer',
+  remove: 'Retirer',
+  layers: 'Calques',
+  blocks: 'Blocs',
+  search_blocks: 'Rechercher un bloc…',
+  picker_add: 'pour ajouter',
+  blocks_count: '$1 {bloc|bloc|blocs|blocs}',
+  no_blocks_yet: 'Aucun bloc pour l’instant. Ajoutez-en un à droite, ou avec ⌘K.',
+  no_blocks_yet_render: 'Aucun bloc pour l’instant. Ajoutez-en un avec ⌘K.',
+  render_failed: 'Le rendu de ce bloc a échoué.',
+  go_to: 'Aller à',
+  move_up: 'Monter',
+  move_down: 'Descendre',
+  move_into: 'Déplacer dans $1',
+  copy_block: 'Copier',
+  paste_block: 'Coller',
+  paste_refused: 'Rien à coller ici',
+  collapse_all: 'Tout replier',
+  expand_all: 'Tout déplier',
+  edit: 'Modifier',
+  remove_with_children_title: 'Supprimer ce bloc ?',
+  remove_with_children_text: 'Les blocs qu’il contient partent avec lui.',
   add_block: 'Ajouter un bloc',
   no_block: 'Aucun bloc',
   delete_block: 'Supprimer le bloc',
@@ -10,5 +49,34 @@ export default {
   get_data_from: 'Importer les données',
   filter_by_type: 'Filtrer par type',
   all_types: 'Tous les types',
-  select: 'Sélectionner'
+  select: 'Sélectionner',
+  choose_from_library: 'Choisir dans la médiathèque',
+  choose_in_library: 'choisissez dans la médiathèque',
+  upload: 'Importer',
+  uploading: 'Import de $1 sur $2…',
+  upload_progress: '$1 sur $2 importé(s)',
+  upload_failed: 'Non importé(s) : $1',
+  clear: 'Effacer',
+  add_images: 'Ajouter $1 {image|image|images|images}',
+  add_files: 'Ajouter $1 {fichier|fichier|fichiers|fichiers}',
+  remove_item: 'Retirer $1',
+  open_editor: 'Ouvrir l’éditeur',
+  open_in_editor: 'Ouvrir dans l’éditeur',
+  add_a_block: 'Ajouter un bloc',
+  block_actions: 'Actions du bloc',
+  fold: 'Replier',
+  unfold: 'Déplier',
+  item_actions: 'Actions de l’élément',
+  delete_item: 'Supprimer l’élément',
+  inside: 'Dans $1',
+  nothing_inside: 'Rien dedans pour l’instant : déposez un élément ici, ou ajoutez-en un.',
+  type_to_add_block: 'Tapez $1 pour ajouter un bloc',
+  slug_hint: 'Lettres minuscules, chiffres et tirets.',
+  build_from: 'Le générer depuis le champ $1',
+  choose: 'Choisir…',
+  nothing_to_select: 'Pas de $1 à sélectionner',
+  file_name: 'Nom du fichier',
+  file_size: 'Taille',
+  file_type: 'Type',
+  select_date: 'Choisir une date'
 };

package/dist/core/i18n/index.d.ts

@@ -5,9 +5,35 @@ export type Namespace = (typeof namespaces)[number];
 export type Dictionaries = Record<string, Record<string, string>>;
 export type TranslationKey = `${Namespace}.${string}`;
 export type ModifiedKey = `${TranslationKey}|${'m' | 'f'}` | `${TranslationKey}|${'m' | 'f'}|p`;
+export type Translate = (key: TranslationKey | ModifiedKey | string, ...params: string[]) => string;
+/** A translator over one set of dictionaries. */
+export type I18n = {
+    t__: Translate;
+};
+/**
+ * A translator over the dictionaries it is given, sharing nothing with any other.
+ *
+ * Dictionaries are keyed by namespace, then by key. A key whose namespace or entry is not there
+ * comes back as is. `$1`, `$2`… take the parameters in order. A `{he|she|they|they}` variant in
+ * a text is picked by the modifiers on the key: `|m`, `|f`, `|m|p`, `|f|p`.
+ *
+ * ```ts
+ * const { t__ } = createI18n({ site: { hello: 'Hello $1', more: 'more' } });
+ * t__('site.hello', 'Ada')  // 'Hello Ada'
+ * t__('shop.more')          // 'shop.more'
+ * ```
+ *
+ * A function reads the dictionaries on every call. In a Svelte component, a function over `data`
+ * follows a locale switch on its own:
+ *
+ * ```ts
+ * setI18nContext(createI18n(() => data.dictionary));
+ * ```
+ */
+export declare function createI18n(source?: Dictionaries | (() => Dictionaries)): I18n;
 declare const i18n: {
-    init: (newDictionaries: Partial<Dictionaries>) => void;
-    t__: (key: TranslationKey | ModifiedKey | string, ...params: string[]) => string;
+    init: (loaded: Partial<Dictionaries>) => void;
+    t__: Translate;
 };
-export declare const t__: (key: TranslationKey | ModifiedKey | string, ...params: string[]) => string;
+export declare const t__: Translate;
 export default i18n;

package/dist/core/i18n/index.js

@@ -1,12 +1,32 @@
 export const languages = ['fr', 'en'];
 export const namespaces = ['errors', 'fields', 'common', 'mail'];
-function createI18n() {
-    let dictionaries = {};
+/**
+ * A translator over the dictionaries it is given, sharing nothing with any other.
+ *
+ * Dictionaries are keyed by namespace, then by key. A key whose namespace or entry is not there
+ * comes back as is. `$1`, `$2`… take the parameters in order. A `{he|she|they|they}` variant in
+ * a text is picked by the modifiers on the key: `|m`, `|f`, `|m|p`, `|f|p`.
+ *
+ * ```ts
+ * const { t__ } = createI18n({ site: { hello: 'Hello $1', more: 'more' } });
+ * t__('site.hello', 'Ada')  // 'Hello Ada'
+ * t__('shop.more')          // 'shop.more'
+ * ```
+ *
+ * A function reads the dictionaries on every call. In a Svelte component, a function over `data`
+ * follows a locale switch on its own:
+ *
+ * ```ts
+ * setI18nContext(createI18n(() => data.dictionary));
+ * ```
+ */
+export function createI18n(source = {}) {
+    const read = typeof source === 'function' ? source : () => source;
     const templateCache = new Map();
     const compileTemplate = (text) => {
-        if (templateCache.has(text)) {
-            return templateCache.get(text);
-        }
+        const cached = templateCache.get(text);
+        if (cached)
+            return cached;
         const compiled = (gender, plural) => {
             return text.replace(/\{([^}]+)\}/g, (_, options) => {
                 const variants = options.split('|');
@@ -24,35 +44,41 @@ function createI18n() {
         return compiled;
     };
     const t__ = (key, ...params) => {
-        const isNamespacedKey = namespaces.some((ns) => key.startsWith(`${ns}.`));
-        if (!isNamespacedKey) {
-            return key;
-        }
         const [baseKey, gender, plural] = key.split('|');
-        const [namespace, translationKey] = baseKey.split('.');
-        if (!dictionaries[namespace]) {
-            console.warn(`Namespace ${namespace} not loaded`);
-        }
-        const text = dictionaries[namespace]?.[translationKey] ?? key;
-        const compiled = compileTemplate(text);
-        const resolved = compiled(gender, plural);
+        const dot = baseKey.indexOf('.');
+        if (dot === -1)
+            return key;
+        const text = read()[baseKey.slice(0, dot)]?.[baseKey.slice(dot + 1)];
+        if (text === undefined)
+            return key;
+        const resolved = compileTemplate(text)(gender, plural);
         return resolved.replace(/\$(\d+)/g, (_, index) => params[index - 1] ?? '');
     };
-    const init = (newDictionaries) => {
-        dictionaries = newDictionaries;
+    return { t__ };
+}
+/**
+ * The panel's translator, in the panel language the config names.
+ *
+ * On the server, one instance for the whole process, filled once at boot. In the browser, one per
+ * tab, filled by the panel's root layout. An app's own texts go through `createI18n`: feeding
+ * this one from a layout would translate the panel for everyone in the language of the last
+ * request.
+ */
+function createPanelI18n() {
+    let dictionaries = {};
+    const { t__ } = createI18n(() => dictionaries);
+    const init = (loaded) => {
+        dictionaries = loaded;
     };
-    return {
-        init,
-        t__
+    const translate = (key, ...params) => {
+        const namespace = key.split('|')[0].split('.')[0];
+        if (namespaces.includes(namespace) && !dictionaries[namespace]) {
+            console.warn(`Namespace ${namespace} not loaded`);
+        }
+        return t__(key, ...params);
     };
+    return { init, t__: translate };
 }
-let instance;
-const getInstance = () => {
-    if (instance)
-        return instance;
-    instance = createI18n();
-    return instance;
-};
-const i18n = getInstance();
+const i18n = createPanelI18n();
 export const t__ = i18n.t__;
 export default i18n;

package/dist/core/locale/copy.server.js

@@ -1,6 +1,4 @@
 import { buildConfigMap } from '../pipeline/config-map/index.js';
-import { BlocksBuilder } from '../../fields/blocks/index.js';
-import { TreeBuilder } from '../../fields/tree/index.js';
 import { getValueAtPath, isObjectLiteral, matchStructure, omitId, setValueAtPath } from '../../util/object.js';
 /**
  * Copies the other locales of one row onto another, as `duplicate` does for a copy and
@@ -39,14 +37,16 @@ export const copyLocales = async (args) => {
         const written = Object.entries(configMap).some(([key, field]) => field.get.localized && !field.use.isEmpty(getValueAtPath(key, data)));
         if (!written)
             continue;
+        // Only the fields stored as rows of their own carry ids to keep or drop.
         for (const [key, field] of Object.entries(configMap)) {
-            if (!(field instanceof BlocksBuilder) && !(field instanceof TreeBuilder))
+            if (!field.use.nodes().some((node) => node.storage))
                 continue;
             if (field.get.localized) {
                 const value = (getValueAtPath(key, data) ?? []).map((block) => omitId(block));
                 data = setValueAtPath(key, data, value);
                 continue;
             }
+            // A tree row has no type; a block keeps its id only across the same type.
             const sameType = (a, b) => field.type === 'tree' || a.type === b.type;
             const targetBlocks = getValueAtPath(key, target.doc) ?? [];
             targetBlocks.forEach((block, index) => {

package/dist/core/logger.server.js

@@ -43,8 +43,14 @@ const formatMessage = (args) => {
 /**
  * Clean up old log files that exceed the maximum retention period
  */
+// The cleanup lists the log directory; once an hour is plenty, once a line was every request.
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+let lastCleanup = 0;
+
 const cleanupOldLogs = async () => {
   if (!LOG_TO_FILE) return;
+  if (Date.now() - lastCleanup < CLEANUP_INTERVAL_MS) return;
+  lastCleanup = Date.now();
 
   try {
     // Create logs directory if it doesn't exist
@@ -129,13 +135,16 @@ const isLevelEnabled = (level) => {
   return level >= currentLogLevel;
 };
 
+// One formatter, built once: `toLocaleTimeString` with options builds one per call.
+const localTime = new Intl.DateTimeFormat(undefined, {
+  hour: 'numeric',
+  minute: '2-digit',
+  second: '2-digit',
+  hour12: true
+});
+
 function getFormattedLocalTime(date) {
-  return date.toLocaleTimeString(undefined, {
-    hour: 'numeric',
-    minute: '2-digit',
-    second: '2-digit',
-    hour12: true
-  });
+  return localTime.format(date);
 }
 
 const rimeFormatted = chalk.bold(chalk.gray('[rime]'));

package/dist/core/pipeline/build-document.server.d.ts

@@ -2,6 +2,7 @@ import type { DocumentRows } from '../adapter.js';
 import type { BuiltArea, BuiltCollection } from '../config/types.js';
 import type { GenericDoc } from '../prototype/types.js';
 import type { RequestEvent } from '@sveltejs/kit';
+import { type Populated } from './populate-relations.server.js';
 /**
  * Assembles one document out of the rows it is stored across.
  *
@@ -15,6 +16,8 @@ export declare const buildDocument: <T extends GenericDoc = GenericDoc>(rows: Do
     event: RequestEvent;
     locale?: string | undefined;
     depth?: number;
+    /** What the relations point at, read ahead for the whole list. Read when `depth > 0`. */
+    populated?: Populated;
     /** Merge the blank document, so every field the config declares is present. */
     withBlank?: boolean;
     /**

package/dist/core/pipeline/build-document.server.js

@@ -1,7 +1,7 @@
-import { isObjectLiteral, omit } from '../../util/object.js';
-import deepmerge from 'deepmerge';
+import { isObjectLiteral, omit, withDefaults } from '../../util/object.js';
 import { unflatten } from 'flat';
 import { logger } from '../logger.server.js';
+import { populatedKey } from './populate-relations.server.js';
 /**
  * Assembles one document out of the rows it is stored across.
  *
@@ -11,7 +11,7 @@ import { logger } from '../logger.server.js';
  * happens to them from here is a question about documents.
  */
 export const buildDocument = async (rows, args) => {
-    const { config, event, locale, depth = 0, withBlank = true, withRowMeta = false } = args;
+    const { config, event, locale, depth = 0, populated, withBlank = true, withRowMeta = false } = args;
     const { rime } = event.locals;
     const flatDoc = { ...rows.base };
     for (const block of rows.blocks) {
@@ -40,9 +40,12 @@ export const buildDocument = async (rows, args) => {
         }
         let output;
         if (depth > 0) {
-            output = await rime
-                .collection(relation.relationTo)
-                .findById({ id: relation.documentId, locale: relation.locale, depth: depth - 1 });
+            const target = populated?.get(populatedKey(relation.relationTo, relation.locale, relation.documentId));
+            // Missing, or not readable by this reader: the relation is left out.
+            if (!target)
+                continue;
+            // A copy per placement: two documents never share an object a hook could change.
+            output = structuredClone(target);
         }
         else {
             output = (withRowMeta ? relation : omit(['position', 'ownerId', 'path'], relation));
@@ -54,7 +57,7 @@ export const buildDocument = async (rows, args) => {
         const blank = rime.config.isCollection(config.slug)
             ? rime.collection(config.slug).blank()
             : rime.area(config.slug).blank();
-        doc = deepmerge(blank, doc, { arrayMerge: (_, incoming) => incoming });
+        doc = withDefaults(doc, blank);
     }
     return doc;
 };

package/dist/core/pipeline/config-map/index.d.ts

@@ -3,4 +3,13 @@ import type { GenericDoc } from '../../prototype/types.js';
 import type { Field } from '../../../fields/types.js';
 import type { DeepPartial } from '../../../util/types.js';
 import type { ConfigMap } from './types.js';
+/**
+ * Every field a document carries, keyed by the path its value sits at.
+ *
+ * The keys are the on-disk path format, so the block type the walk names is stripped:
+ *
+ * ```
+ * layout.0:hero.title -> layout.0.title
+ * ```
+ */
 export declare const buildConfigMap: (data: DeepPartial<GenericDoc>, incomingFields: FieldBuilder<Field>[]) => ConfigMap;

package/dist/core/pipeline/config-map/index.js

@@ -1,54 +1,20 @@
 import { isFormField } from '../../fields/util.js';
-import { BlocksBuilder } from '../../../fields/blocks/index.js';
-import { GroupFieldBuilder } from '../../../fields/group/index.js';
-import { TabsBuilder } from '../../../fields/tabs/index.js';
-import { TreeBuilder } from '../../../fields/tree/index.js';
-import { buildTreeFieldsMap } from './build-tree-map.js';
+import { walkValues } from '../../fields/walk.js';
+import { normalizeFieldPath } from '../../../util/string.js';
+/**
+ * Every field a document carries, keyed by the path its value sits at.
+ *
+ * The keys are the on-disk path format, so the block type the walk names is stripped:
+ *
+ * ```
+ * layout.0:hero.title -> layout.0.title
+ * ```
+ */
 export const buildConfigMap = (data, incomingFields) => {
-    let map = {};
-    const traverseData = (data, fields, basePath) => {
-        if (!data)
-            return;
-        basePath = basePath === '' ? basePath : `${basePath}.`;
-        for (const field of fields) {
-            if (field instanceof TabsBuilder) {
-                for (const tab of field.get.tabs) {
-                    if (tab.name in data) {
-                        traverseData(data[tab.name], tab.get.fields, tab.name);
-                    }
-                }
-                continue;
-            }
-            if (!isFormField(field))
-                continue;
-            if (!(field.name in data))
-                continue;
-            const value = data[field.name];
-            const path = `${basePath}${field.name}`;
-            map[path] = field;
-            if (field instanceof BlocksBuilder && value && Array.isArray(value)) {
-                const blocks = value;
-                for (const [index, block] of blocks.entries()) {
-                    try {
-                        const blockConfig = field.get.blocks.find((b) => b.name === block.type);
-                        if (blockConfig) {
-                            traverseData(block, blockConfig.get.fields, `${path}.${index}`);
-                        }
-                    }
-                    catch {
-                        console.warn(`block at path ${path} and postition ${index} not found but there are some residual data owned by this block`);
-                    }
-                }
-            }
-            else if (field instanceof TreeBuilder && value && Array.isArray(value)) {
-                const treeMap = buildTreeFieldsMap(field, value, path);
-                map = { ...map, ...treeMap };
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                traverseData(value, field.get.fields, path);
-            }
-        }
-    };
-    traverseData(data, incomingFields, '');
+    const map = {};
+    for (const { field, path } of walkValues(incomingFields, data)) {
+        if (isFormField(field))
+            map[normalizeFieldPath(path)] = field;
+    }
     return map;
 };

package/dist/core/pipeline/hooks/process-document-fields.server.d.ts

@@ -1,5 +1,8 @@
 /**
  * Walks every field of the document on the way out: drops what the reader may not see, fills an
  * empty one from its default, and hands each value to the field's own `hooks.beforeRead`.
+ *
+ * One copy of the document, walked in place. A config-map key is already normalized, so it is
+ * its segments and nothing else; a copy of the document per key was most of this hook.
  */
 export declare const processDocumentFields: import("../types.js").Hook<"raw", "read", "before">;

package/dist/core/pipeline/hooks/process-document-fields.server.js

@@ -1,31 +1,35 @@
 import { Hooks } from '../define-hook.js';
 import { logger } from '../../logger.server.js';
-import { deleteValueAtPath, getValueAtPath, setValueAtPath } from '../../../util/object.js';
 import { buildConfigMap } from '../config-map/index.js';
 import { getDefaultValue } from './set-default-values.server.js';
 /**
  * Walks every field of the document on the way out: drops what the reader may not see, fills an
  * empty one from its default, and hands each value to the field's own `hooks.beforeRead`.
+ *
+ * One copy of the document, walked in place. A config-map key is already normalized, so it is
+ * its segments and nothing else; a copy of the document per key was most of this hook.
  */
 export const processDocumentFields = Hooks.beforeRead(async function processDocumentFields(args) {
     const { event } = args;
-    let doc = args.doc;
+    const doc = { ...args.doc };
     const configMap = buildConfigMap(doc, args.config.fields);
     for (const [key, config] of Object.entries(configMap)) {
-        let value = getValueAtPath(key, doc);
-        let isEmpty;
+        const parts = key.split('.');
         if (!config.use.accessRead(event.locals.user)) {
-            doc = deleteValueAtPath(doc, key);
+            deleteAt(doc, parts);
             continue;
         }
-        if (value !== undefined && value !== null) {
+        let value = getAt(doc, parts);
+        // A field with no hook has nothing to wait for.
+        if (value !== undefined && value !== null && config.get.hooks?.beforeRead?.length) {
             value = await config.use.beforeRead(value, {
                 event,
                 operation: args.context,
                 documentId: doc.id
             });
-            doc = setValueAtPath(key, doc, value);
+            setAt(doc, parts, value);
         }
+        let isEmpty;
         try {
             isEmpty = config.use.isEmpty(value);
         }
@@ -35,10 +39,10 @@ export const processDocumentFields = Hooks.beforeRead(async function processDocu
         }
         if (isEmpty && config.get.defaultValue !== undefined) {
             value = await getDefaultValue({ key, config, adapter: args.event.locals.rime.adapter });
-            doc = setValueAtPath(key, doc, value);
+            setAt(doc, parts, value);
         }
         if (config.type === 'blocks') {
-            const value = getValueAtPath(key, doc);
+            const blocks = getAt(doc, parts);
             // Filter out possible undefined block or residual
             // Case undefined : When in dev mode, if a block table is deleted in a migration, a blocks array value could includes undefined ex :
             // * blocks: [ { ... }, undefined, { ... } ]
@@ -47,16 +51,48 @@ export const processDocumentFields = Hooks.beforeRead(async function processDocu
             // * blocks: [ { id:..., values,... }, { image: {...}} ]
             //                                         ^
             // * the image has been placed but the block doesn't exist anymore
-            if (value) {
-                const withoutResidualBlock = value
+            if (blocks) {
+                const withoutResidualBlock = blocks
                     .filter((b) => b && 'id' in b) // get only blocks that have .id
                     .map((b, index) => ({
                     ...b,
                     position: index
                 }));
-                doc = setValueAtPath(key, doc, withoutResidualBlock);
+                setAt(doc, parts, withoutResidualBlock);
             }
         }
     }
     return { ...args, doc };
 });
+/** The value the segments lead to, `undefined` past a missing one. */
+const getAt = (doc, parts) => {
+    let current = doc;
+    for (const part of parts) {
+        if (current === undefined || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+};
+/** Writes at the segments, opening an object — an array before an index — where one is missing. */
+const setAt = (doc, parts, value) => {
+    let current = doc;
+    for (let index = 0; index < parts.length - 1; index++) {
+        const part = parts[index];
+        if (!current[part])
+            current[part] = /^\d+$/.test(parts[index + 1]) ? [] : {};
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+};
+/** Removes what the segments lead to; nothing, past a missing one. */
+const deleteAt = (doc, parts) => {
+    let current = doc;
+    for (const part of parts.slice(0, -1)) {
+        if (current === undefined || current === null || !(part in current))
+            return;
+        current = current[part];
+    }
+    if (current !== undefined && current !== null)
+        delete current[parts[parts.length - 1]];
+};

package/dist/core/pipeline/hooks/set-default-values.server.d.ts

@@ -12,5 +12,6 @@ type GetDefaultValue = (args: {
     config: FormFieldBuilder;
     adapter: Adapter;
 }) => Promise<any>;
+/** A relation's default is ids; they become junction rows, checked against the collection. */
 export declare const getDefaultValue: GetDefaultValue;
 export {};

package/dist/core/pipeline/hooks/set-default-values.server.js

@@ -71,6 +71,7 @@ const defaultRelationValue = async (config, key, adapter) => {
     };
     return await buildRelation(config.use.defaultValue({ event: getRequestEvent() }));
 };
+/** A relation's default is ids; they become junction rows, checked against the collection. */
 export const getDefaultValue = async ({ key, config, adapter }) => {
     if (config instanceof RelationFieldBuilder) {
         return await defaultRelationValue(config, key, adapter);

package/dist/core/pipeline/persist/blocks/extract.server.js

@@ -1,4 +1,4 @@
-import { normalizeFieldPath } from '../../../../util/path.js';
+import { normalizeFieldPath } from '../../../../util/string.js';
 import { getValueAtPath } from '../../../../util/object.js';
 export function extractBlocks({ data, configMap }) {
     const blocks = [];

package/dist/core/pipeline/persist/relations/extract.server.js

@@ -2,6 +2,8 @@ import { RelationFieldBuilder } from '../../../../fields/relation/index.js';
 import { getValueAtPath } from '../../../../util/object.js';
 export const extractRelations = ({ ownerId, data, configMap, locale }) => {
     const relations = [];
+    // The config map keys every field the document holds; relations are the ones stored as junction
+    // rows, and the key is the `path` those rows carry.
     for (const [path, config] of Object.entries(configMap)) {
         if (config instanceof RelationFieldBuilder) {
             const value = getValueAtPath(path, data);

package/dist/core/pipeline/populate-relations.server.d.ts

@@ -0,0 +1,27 @@
+import type { DocumentRows } from '../adapter.js';
+import type { GenericDoc } from '../prototype/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * The documents a list's relations point at, keyed by `populatedKey`.
+ *
+ * Read for one operation, by one reader, and dropped with it.
+ */
+export type Populated = Map<string, GenericDoc>;
+export declare const populatedKey: (slug: string, locale: string | undefined, id: string) => string;
+/**
+ * Reads what the relations of a whole list point at, one `findByIds` per collection and locale.
+ *
+ * ```ts
+ * // 20 pages, 2 relations each, 22 distinct targets
+ * // 40 × findById  ->  1 × findByIds({ ids: [...22] })
+ * ```
+ *
+ * A relation row keeps its own locale, or none: the target is read in that locale, else in the
+ * request's, as `findById` would. A target that is missing or refused to this reader is absent
+ * from the map.
+ */
+export declare const populateRelations: (rows: DocumentRows[], args: {
+    event: RequestEvent;
+    locale?: string;
+    depth: number;
+}) => Promise<Populated>;

package/dist/core/pipeline/populate-relations.server.js

@@ -0,0 +1,42 @@
+export const populatedKey = (slug, locale, id) => `${slug}:${locale ?? ''}:${id}`;
+/**
+ * Reads what the relations of a whole list point at, one `findByIds` per collection and locale.
+ *
+ * ```ts
+ * // 20 pages, 2 relations each, 22 distinct targets
+ * // 40 × findById  ->  1 × findByIds({ ids: [...22] })
+ * ```
+ *
+ * A relation row keeps its own locale, or none: the target is read in that locale, else in the
+ * request's, as `findById` would. A target that is missing or refused to this reader is absent
+ * from the map.
+ */
+export const populateRelations = async (rows, args) => {
+    const { event, locale, depth } = args;
+    const groups = new Map();
+    for (const relation of rows.flatMap((row) => row.relations)) {
+        if (!relation.documentId)
+            continue;
+        // A row written in another locale is not part of this read.
+        if (relation.locale && relation.locale !== locale)
+            continue;
+        const key = `${relation.relationTo}:${relation.locale ?? ''}`;
+        const group = groups.get(key) ?? {
+            slug: relation.relationTo,
+            locale: relation.locale ?? undefined,
+            ids: new Set()
+        };
+        group.ids.add(relation.documentId);
+        groups.set(key, group);
+    }
+    const populated = new Map();
+    await Promise.all([...groups.values()].map(async (group) => {
+        const docs = await event.locals.rime
+            .collection(group.slug)
+            .findByIds({ ids: [...group.ids], locale: group.locale, depth: depth - 1 });
+        for (const doc of docs) {
+            populated.set(populatedKey(group.slug, group.locale, doc.id), doc);
+        }
+    }));
+    return populated;
+};