rimecms 0.31.4 → 0.32.0

package/dist/adapter-sqlite/transform.server.js

@@ -1,219 +1,140 @@
-import { withLocalesSuffix, withVersionsSuffix } from '../core/naming.js';
-import deepmerge from 'deepmerge';
 import { getTableColumns } from 'drizzle-orm';
-import { flatten, unflatten } from 'flat';
-import { logger } from '../core/logger/index.server.js';
+import { flatten } from 'flat';
+import { logger } from '../core/logger.server.js';
 import { extractFieldName } from '../fields/tree/util.js';
-import { isObjectLiteral, omit } from '../util/object.js';
-import { getBlocksTableNames, getTreeTableNames, makeBlockTableSlug, makeTreeTableSlug } from './generate-schema/util.server.js';
-import { transformDatabaseColumnsToPaths } from './util.server.js';
+import { omit } from '../util/object.js';
+import { baseTableName, tableName as buildTableName, childTableNames, joinName } from './naming.server.js';
+import { transformDatabaseColumnsToPaths } from './columns.server.js';
+import { localeOrder, mergeLocaleRows } from './locales.server.js';
+import { resolvedReferencesOf } from '../core/fields/util.js';
 /**
- * Facade responsible of converting raw database document
- * with relations, blocks, locales,... related rows
- * to a full document object
+ * Turns the rows a read returned into the four piles core builds a document from.
+ *
+ * Everything here needs `tables`: which children hang off this document, which locales branch
+ * belongs to which row, which columns a branch has. Everything that did not — the blank merge,
+ * the key stripping, the relation assembly, the depth walk — is in
+ * `core/pipeline/build-document.server.ts`.
  */
-export const transformerFacade = (args) => {
+export const createTransformHandle = (args) => {
     const { configCtx, tables } = args;
-    const transformDoc = async (args) => {
-        //
-        const { slug, locale, event, withBlank = true, depth = 0 } = args;
-        const { rime } = event.locals;
+    /**
+     * Merges a child row's locales branch onto it — the rows the read returned, one per locale in
+     * the fallback order, each column from the first that holds it — and nulls the localized
+     * columns no locale has saved yet: a localized block fetched in a locale it was never written
+     * in reads as absent columns otherwise, and absent is not null once the blank is merged.
+     */
+    const withLocalesBranch = (row, branchTable, order) => {
+        const merged = {
+            ...mergeLocaleRows(row[branchTable], order),
+            ...row
+        };
+        const localesKeys = Object.keys(getTableColumns(tables[branchTable])).filter((key) => !['id', 'locale', 'ownerId'].includes(key));
+        return {
+            ...Object.fromEntries(localesKeys.map((k) => [k, null])),
+            ...merged
+        };
+    };
+    const rows = async (args) => {
+        const { slug, locale, localeFallback } = args;
+        const order = localeOrder(configCtx, locale, localeFallback) ?? [];
         let doc = args.doc;
-        const config = configCtx.getBySlug(slug);
-        const isVersioned = !!config.versions;
-        const tableName = isVersioned ? withVersionsSuffix(slug) : slug;
-        const tableNameRelationFields = `${tableName}Rels`;
-        const tableNameLocales = withLocalesSuffix(tableName);
-        const isPanel = event.url.pathname.startsWith('/panel');
-        let docAPI;
-        if (configCtx.isCollection(slug)) {
-            docAPI = rime.collection(slug);
-        }
-        else {
-            docAPI = rime.area(slug);
-        }
-        const blankDocument = docAPI.blank();
-        /** Add localized fields */
+        // The table this document's content is in — its own, unless the config is versioned. Read off
+        // the config rather than asked of a feature, which is what keeps this file naming none.
+        const tableName = baseTableName(configCtx.getBySlug(slug)._versions?.slug ?? slug);
+        const tableNameRelationFields = buildTableName({ owner: tableName, child: { kind: 'rels' } });
+        const tableNameLocales = buildTableName({ owner: tableName, branch: 'locales' });
+        /** Add localized fields, each from the first locale in the fallback order that holds it. */
         if (locale && tableNameLocales in tables && doc[tableNameLocales]) {
-            doc = { ...doc[tableNameLocales][0], ...doc };
+            doc = { ...mergeLocaleRows(doc[tableNameLocales], order), ...doc };
             delete doc[tableNameLocales];
             delete doc.ownerId;
         }
-        let flatDoc = flatten(doc);
-        // Transform flattened keys from database schema format to document format
-        flatDoc = transformDatabaseColumnsToPaths(flatDoc);
         /****************************************************/
-        // Blocks handling
+        // Blocks
         /****************************************************/
-        /** Extract all blocks  */
-        const blocksTables = getBlocksTableNames(tableName, tables);
-        const blocks = blocksTables.flatMap((blockTable) => doc[blockTable] || []);
-        /** Place each block in its path */
-        for (let block of blocks) {
-            const blockLocaleTableName = withLocalesSuffix(makeBlockTableSlug(tableName, block.type));
-            if (locale && blockLocaleTableName in tables) {
-                block = {
-                    ...(block[blockLocaleTableName][0] || {}),
-                    ...block
-                };
-                // Set empty locales values to null if not present in the data
-                // for exemple : localized block is fetched but some of its locales values hasn't been saved already
-                const localesKeys = Object.keys(getTableColumns(tables[blockLocaleTableName])).filter((key) => !['id', 'locale', 'ownerId'].includes(key));
-                const nullKeys = Object.fromEntries(localesKeys.map((k) => [k, null]));
-                block = {
-                    ...nullKeys,
-                    ...block
-                };
-            }
-            block = transformDatabaseColumnsToPaths(block);
-            /** Clean */
-            const { position, path } = block;
-            if (!isPanel) {
-                delete block.position;
-                delete block.path;
-                delete block.ownerId;
-                delete block.locale;
-            }
-            delete block[blockLocaleTableName];
-            /** Assign */
-            flatDoc[`${path}.${position}`] = block;
-        }
+        const blocksTables = childTableNames(tableName, 'blocks', tables);
+        const blocks = blocksTables
+            .flatMap((blockTable) => doc[blockTable] || [])
+            .map((block) => {
+            const branchTable = buildTableName({
+                owner: tableName,
+                child: { kind: 'blocks', name: block.type },
+                branch: 'locales'
+            });
+            if (locale && branchTable in tables)
+                block = withLocalesBranch(block, branchTable, order);
+            return omit([branchTable], transformDatabaseColumnsToPaths(block));
+        });
         /****************************************************/
-        // Tree handling
+        // Tree
         /****************************************************/
-        /** Extract all blocks  */
-        const treeTables = getTreeTableNames(tableName, tables);
-        let treeBlocks = treeTables.flatMap((treeTable) => doc[treeTable] || []);
-        treeBlocks = treeBlocks.sort((a, b) => a.path.localeCompare(b.path));
-        /** Place each treeBlock in its path */
-        for (let block of treeBlocks) {
+        const treeTables = childTableNames(tableName, 'tree', tables);
+        const tree = treeTables
+            .flatMap((treeTable) => doc[treeTable] || [])
+            .sort((a, b) => a.path.localeCompare(b.path))
+            .flatMap((node) => {
             try {
-                const [fieldName] = extractFieldName(block.path);
-                const treeBlockLocaleTableName = withLocalesSuffix(makeTreeTableSlug(tableName, fieldName));
-                if (locale && treeBlockLocaleTableName in tables) {
-                    block = {
-                        ...(block[treeBlockLocaleTableName][0] || {}),
-                        ...block
-                    };
-                    // Set empty locales values to null if not present in the data
-                    // for exemple : localized block is fetched but some of its locales values hasn't been saved already
-                    const localesKeys = Object.keys(getTableColumns(tables[treeBlockLocaleTableName])).filter((key) => !['id', 'locale', 'ownerId'].includes(key));
-                    const nullKeys = Object.fromEntries(localesKeys.map((k) => [k, null]));
-                    block = {
-                        ...nullKeys,
-                        ...block
-                    };
-                }
-                block = transformDatabaseColumnsToPaths(block);
-                /** Clean */
-                const { position, path } = block;
-                if (!block._children)
-                    block._children = [];
-                if (!isPanel) {
-                    delete block.position;
-                    delete block.path;
-                    delete block.ownerId;
-                    delete block.locale;
-                }
-                delete block[treeBlockLocaleTableName];
-                /** Assign */
-                flatDoc[`${path}.${position}`] = block;
+                const [fieldName] = extractFieldName(node.path);
+                const branchTable = buildTableName({
+                    owner: tableName,
+                    child: { kind: 'tree', name: fieldName },
+                    branch: 'locales'
+                });
+                if (locale && branchTable in tables)
+                    node = withLocalesBranch(node, branchTable, order);
+                return [omit([branchTable], transformDatabaseColumnsToPaths(node))];
             }
             catch {
-                logger.error('error in ', block.path);
-            }
-        }
-        /** Place relations */
-        if (doc[tableNameRelationFields]) {
-            for (const relation of doc[tableNameRelationFields]) {
-                /** Relation collection key ex: usersId */
-                const relationToIdKey = Object.keys(relation).filter((key) => key.endsWith('Id') && key !== 'ownerId' && relation[key] !== null)[0];
-                const relationToId = relation[relationToIdKey];
-                if (!relationToId) {
-                    logger.warn(`orphean ${config.slug} relation : ${relation.id}`);
-                    continue;
-                }
-                const relationPath = relation.path;
-                let relationOutput;
-                /** Get relation if depth > 0 */
-                if (depth > 0) {
-                    const relationSlug = relationToIdKey.replace('Id', '');
-                    relationOutput = await rime
-                        .collection(relationSlug)
-                        .findById({ id: relationToId, locale: relation.locale, depth: depth - 1 });
-                }
-                else {
-                    /** Clean relation */
-                    for (const key of Object.keys(relation)) {
-                        /** Delete empty [table]Id and null properties from the relation */
-                        if (relation[key] === null) {
-                            delete relation[key];
-                        }
-                        else if (key.endsWith('Id') && key !== 'ownerId') {
-                            relation.relationTo = key.replace('Id', '');
-                            relation.documentId = relation[key];
-                            delete relation[key];
-                        }
-                    }
-                    if (!isPanel) {
-                        delete relation.position;
-                        delete relation.ownerId;
-                        delete relation.path;
-                    }
-                    relationOutput = relation;
-                }
-                /** Assign relation */
-                if (!relation.locale || relation.locale === locale) {
-                    const parentPath = relationPath.split('.').slice(0, -1).join('.');
-                    // If parent path ends with .[digits], it means the relation is inside a blocks/tree array,
-                    // then check if the parent path exists in the flatDoc.
-                    if (/.*\.[\d]+$/.test(parentPath)) {
-                        if (!flatDoc[parentPath]) {
-                            logger.warn(`Orphean ${config.slug} relation at ${relationPath} with id ${relation.id} because parent path ${parentPath} doesn't exist in the document`);
-                            continue;
-                        }
-                    }
-                    flatDoc[relationPath] = [...(flatDoc[relationPath] || []), relationOutput];
-                }
-            }
-        }
-        // Clean
-        let output = unflatten(flatDoc);
-        /** Remove tree/blocks table keys */
-        const keysToDelete = [...blocksTables, ...treeTables];
-        // Remove relation table keys
-        if (tableNameRelationFields in output) {
-            keysToDelete.push(tableNameRelationFields);
-        }
-        // Filter out arrays that contains empty elements
-        function cleanEmptyElementsInArrays(obj) {
-            if (Array.isArray(obj)) {
-                return obj
-                    .map((item) => cleanEmptyElementsInArrays(item))
-                    .filter((item) => item !== null && item !== undefined);
-            }
-            else if (isObjectLiteral(obj)) {
-                const cleanedObj = {};
-                for (const key in obj) {
-                    cleanedObj[key] = cleanEmptyElementsInArrays(obj[key]);
-                }
-                return cleanedObj;
+                logger.error('error in ', node.path);
+                return [];
             }
-            return obj;
-        }
-        output = cleanEmptyElementsInArrays(output);
-        if (!isPanel || !event.locals.user) {
-            keysToDelete.push('editedBy');
+        });
+        /****************************************************/
+        // Relations
+        /****************************************************/
+        const relations = (doc[tableNameRelationFields] || []).map((relation) => resolveRelationTarget({ ...relation }));
+        /****************************************************/
+        // The document's own columns
+        /****************************************************/
+        // A resolved reference came back twice: the id in its column, and the referenced document
+        // under `<column>__$doc`. The document carries the referenced one on the column's path;
+        // nobody is null. Left alone when the read did not ask for it.
+        for (const { column } of resolvedReferencesOf(configCtx.getBySlug(slug).fields)) {
+            const key = joinName(column);
+            if (!(key in doc))
+                continue;
+            doc[column] = doc[key] ?? null;
+            delete doc[key];
         }
-        if (withBlank) {
-            output = omit(keysToDelete, deepmerge(blankDocument, output, { arrayMerge: (_, y) => y }));
+        // The child tables came back on the same row; they are their own piles now. Left on, they
+        // flatten into `pages__$blocks_hero.0.id` keys that survive every step to be stripped by name
+        // at the very end.
+        const base = transformDatabaseColumnsToPaths(flatten(omit([...blocksTables, ...treeTables, tableNameRelationFields], doc)));
+        return { base, blocks, tree, relations };
+    };
+    return { rows };
+};
+/**
+ * Names what a junction row points at.
+ *
+ * The junction has one nullable foreign key column per target collection — `pagesId`, `mediasId`
+ * — and exactly one is set. That shape is the adapter's; `relationTo` and `documentId` are what
+ * core reads. Null columns go with it, including the other targets'.
+ */
+const resolveRelationTarget = (relation) => {
+    const targetKey = Object.keys(relation).filter((key) => key.endsWith('Id') && key !== 'ownerId' && relation[key] !== null)[0];
+    // No target column set: an orphan. Left as it came so core can name it in the warning.
+    if (!targetKey || !relation[targetKey])
+        return relation;
+    for (const key of Object.keys(relation)) {
+        if (relation[key] === null) {
+            delete relation[key];
         }
-        else {
-            output = omit(keysToDelete, output);
+        else if (key.endsWith('Id') && key !== 'ownerId') {
+            relation.relationTo = key.replace('Id', '');
+            relation.documentId = relation[key];
+            delete relation[key];
         }
-        return output;
-    };
-    return {
-        doc: transformDoc
-    };
+    }
+    return relation;
 };

package/dist/adapter-sqlite/tree.server.d.ts

@@ -1,26 +1,25 @@
-import type { GenericAdapteFacadeArgs } from './types.server.js';
-import type { TreeBlock } from '../core/types/doc.js';
+import type { AdapterDeps } from './types.server.js';
+import type { PrototypeSlug, TreeBlock } from '../core/prototype/types.js';
 import type { WithRequired } from '../util/types.js';
-declare const createTreeFacade: ({ db, tables }: GenericAdapteFacadeArgs) => {
-    getBlocksTableNames: (slug: string) => string[];
+declare const createTreeHandle: ({ db, tables }: AdapterDeps) => {
     delete: DeleteBlock;
     create: CreateBlock;
     update: UpdateBlock;
 };
-export default createTreeFacade;
+export default createTreeHandle;
 /****************************************************/
 type UpdateBlock = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     block: WithRequired<TreeBlock, 'path'>;
     locale?: string;
 }) => Promise<boolean>;
 type CreateBlock = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     block: WithRequired<TreeBlock, 'path'>;
     ownerId: string;
     locale?: string;
 }) => Promise<boolean>;
 type DeleteBlock = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     block: WithRequired<TreeBlock, 'path'>;
 }) => Promise<boolean>;

package/dist/adapter-sqlite/tree.server.js

@@ -1,14 +1,17 @@
-import { withLocalesSuffix } from '../core/naming.js';
+import { baseTableName, tableName as buildTableName } from './naming.server.js';
 import { extractFieldName } from '../fields/tree/util.js';
 import { and, eq, getTableColumns } from 'drizzle-orm';
 import { omit } from '../util/object.js';
-import { toPascalCase } from '../util/string.js';
-import { generatePK, transformDataToSchema } from './util.server.js';
-const createTreeFacade = ({ db, tables }) => {
+import { generatePK, transformDataToSchema } from './columns.server.js';
+const createTreeHandle = ({ db, tables }) => {
     //
-    const buildBlockTableName = (slug, blockPath) => {
+    /** As in the blocks facade: callers name the owner by slug, the table is derived here. */
+    const buildBlockTableName = (parentSlug, blockPath) => {
         const [fieldName] = extractFieldName(blockPath);
-        return `${slug}Tree${toPascalCase(fieldName)}`;
+        return buildTableName({
+            owner: baseTableName(parentSlug),
+            child: { kind: 'tree', name: fieldName }
+        });
     };
     const update = async ({ parentSlug, block, locale }) => {
         const tableName = buildBlockTableName(parentSlug, block.path);
@@ -17,7 +20,7 @@ const createTreeFacade = ({ db, tables }) => {
         if (Object.keys(values).length) {
             await db.update(tables[tableName]).set(values).where(eq(tables[tableName].id, block.id));
         }
-        const tableLocalesName = withLocalesSuffix(tableName);
+        const tableLocalesName = buildTableName({ owner: tableName, branch: 'locales' });
         if (locale && tableLocalesName in tables) {
             const tableLocales = tables[tableLocalesName];
             const localizedColumns = getTableColumns(tableLocales);
@@ -26,7 +29,7 @@ const createTreeFacade = ({ db, tables }) => {
                 return true;
             //@ts-expect-error tableLocalesName is key of db.query
             const localizedRow = await db.query[tableLocalesName].findFirst({
-                where: and(eq(tableLocales.ownerId, block.id), eq(tableLocales.locale, locale))
+                where: { ownerId: block.id, locale }
             });
             if (!localizedRow) {
                 await db.insert(tableLocales).values({
@@ -53,7 +56,7 @@ const createTreeFacade = ({ db, tables }) => {
     const create = async ({ parentSlug, block, ownerId, locale }) => {
         const table = buildBlockTableName(parentSlug, block.path);
         const blockId = generatePK();
-        const tableLocales = withLocalesSuffix(table);
+        const tableLocales = buildTableName({ owner: table, branch: 'locales' });
         if (locale && tableLocales in tables) {
             const unlocalizedColumns = getTableColumns(tables[table]);
             const localizedColumns = getTableColumns(tables[tableLocales]);
@@ -83,12 +86,10 @@ const createTreeFacade = ({ db, tables }) => {
         }
         return true;
     };
-    const getBlocksTableNames = (slug) => Object.keys(tables).filter((key) => key.startsWith(`${slug}Tree`) && !key.endsWith('Locales'));
     return {
-        getBlocksTableNames,
         delete: deleteBlock,
         create,
         update
     };
 };
-export default createTreeFacade;
+export default createTreeHandle;

package/dist/adapter-sqlite/types.server.d.ts

@@ -2,12 +2,14 @@ import type { GetRegisterType } from '../index.js';
 import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
-import type { PrototypeSlug } from '../types.js';
-export type GenericAdapteFacadeArgs = {
-    db: LibSQLDatabase<GetRegisterType<'Schema'>>;
+/**
+ * What every facade in this folder is built from: the connection and the generated tables.
+ */
+export type AdapterDeps = {
+    db: LibSQLDatabase<GetRegisterType<'Relations'>>;
     tables: GenericTables;
 };
-type GenericColumn = SQLiteColumn<ColumnBaseConfig<ColumnDataType, string>, Record<string, unknown>>;
+type GenericColumn = SQLiteColumn<ColumnBaseConfig<ColumnDataType>, Record<string, unknown>>;
 type GenericColumns = {
     [x: string]: GenericColumn;
 };
@@ -18,5 +20,4 @@ export type GenericTable = SQLiteTableWithColumns<{
     schema: undefined;
 }>;
 export type GenericTables = Record<string, GenericTable | SQLiteTableWithColumns<any>>;
-export type TableLocaleName = `${PrototypeSlug}Locales`;
 export {};

package/dist/adapter-sqlite/where.server.d.ts

@@ -3,14 +3,36 @@ import { type GetRegisterType } from '../index.js';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { ParsedQs } from 'qs';
 import type { PrototypeSlug } from '../types.js';
+import type { GenericTable } from './types.server.js';
 type BuildWhereArgs = {
     query: ParsedQs;
     slug: PrototypeSlug;
     locale?: string;
-    db: LibSQLDatabase<GetRegisterType<'Schema'>>;
-    draft?: boolean;
+    db: LibSQLDatabase<GetRegisterType<'Relations'>>;
     tables: GetRegisterType<'Tables'>;
     configCtx: ConfigContext;
+    /**
+     * The prototype `slug` is the versions table of, when it is one.
+     *
+     * Two conditions are resolved differently against a versions table: `id` means the base row rather than
+     * the content row, and the hierarchy columns (`_parent`, `_position`, `_path`) live on the base
+     * table and have to be reached through it.
+     *
+     * Named by the caller, which read it off registration to pick this slug in the first place —
+     * never inferred here from how a slug happens to be spelled.
+     */
+    base?: PrototypeSlug;
+    /**
+     * The table the outer condition is built against.
+     *
+     * A relational query renames the table it selects from — `from "pages" as "d0"` — so a
+     * condition naming `pages` matches nothing. Those callers pass what the `RAW` callback handed
+     * them; `update` and `delete` do not alias and pass nothing.
+     *
+     * Only the outer reference. Every subquery below reaches other tables, which are not aliased,
+     * and keeps using the real objects out of `tables`.
+     */
+    rootTable?: GenericTable;
 };
-export declare const buildWhereParam: ({ query, slug, db, locale, tables, configCtx }: BuildWhereArgs) => any;
+export declare const buildWhereParam: ({ query, slug, db, locale, tables, configCtx, base, rootTable }: BuildWhereArgs) => any;
 export {};