rimecms 0.31.5 → 0.32.0

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

@@ -0,0 +1,274 @@
+import { getFieldAtPath, resolvedReferencesOf } from '../core/fields/util.js';
+import { BlocksBuilder } from '../fields/blocks/index.js';
+import { getColumns } from 'drizzle-orm';
+import { RelationFieldBuilder } from '../fields/relation/index.js';
+import { TreeBuilder } from '../fields/tree/index.js';
+import { baseTableName, childTableNames, joinName, tableName } from './naming.server.js';
+/** What a joined target is projected to, beside its `id`: whatever of these its table has. */
+const JOINED_COLUMNS = ['name', 'email', 'title', 'filename'];
+/**
+ * The `with` joining each resolved reference's target onto this table's rows.
+ *
+ * `table` is the base or the content table. A versioned config keeps its `$root()` references
+ * on the first and the rest on the second, so each table is asked only for its own. With a
+ * `select`, only the selected ones.
+ */
+export const resolvedReferenceJoins = (args) => {
+    const { table, tables, config, select } = args;
+    const isBase = table === baseTableName(config.slug);
+    const withParam = {};
+    for (const reference of resolvedReferencesOf(config.fields)) {
+        if (config._versions && reference.root !== isBase)
+            continue;
+        if (select?.length && !select.includes(reference.path))
+            continue;
+        const target = tables[baseTableName(reference.to)];
+        if (!target)
+            continue;
+        const targetColumns = Object.keys(getColumns(target));
+        const columns = ['id', ...JOINED_COLUMNS.filter((column) => targetColumns.includes(column))];
+        withParam[joinName(reference.column)] = {
+            columns: Object.fromEntries(columns.map((column) => [column, true]))
+        };
+    }
+    return withParam;
+};
+export const buildWithParam = (args) => {
+    const { table, select = [], locale, fallback, tables, config: documentConfig } = args;
+    // A child row — a block, a tree node — belongs to one locale. Its locales branch, and the
+    // document's, are read for every locale in the order and merged in `transform`.
+    const branchWhere = branchFilter(locale, fallback);
+    if (!select.length) {
+        return {
+            ...buildFullWithParam({ table, locale, fallback, tables }),
+            ...resolvedReferenceJoins({ table, tables, config: documentConfig })
+        };
+    }
+    const withParam = resolvedReferenceJoins({ table, tables, config: documentConfig, select });
+    // Track paths for different field types
+    const directRelationPaths = [];
+    const blockPaths = [];
+    const treePaths = [];
+    for (const path of select) {
+        // Convert dot notation to double underscore notation for SQLite queries
+        const sqlPath = path.replace(/\./g, '__');
+        const fieldConfig = getFieldAtPath(path, documentConfig.fields);
+        if (fieldConfig instanceof RelationFieldBuilder) {
+            // Handle relation fields
+            directRelationPaths.push(path);
+        }
+        else if (fieldConfig instanceof BlocksBuilder) {
+            // Handle blocks fields
+            blockPaths.push(path);
+            const blocksTables = childTableNames(table, 'blocks', tables);
+            for (const blocksTable of blocksTables) {
+                if (!withParam[blocksTable]) {
+                    let params = { orderBy: { position: 'asc' } };
+                    const columns = getColumns(tables[blocksTable]);
+                    const hasLocale = Object.keys(columns).includes('locale');
+                    if (locale && hasLocale) {
+                        params = { ...params, where: { locale } };
+                    }
+                    withParam[blocksTable] = params;
+                    // Handle localized blocks
+                    const localesBlockTable = tableName({ owner: blocksTable, branch: 'locales' });
+                    if (locale && localesBlockTable in tables) {
+                        withParam[blocksTable] = {
+                            ...withParam[blocksTable],
+                            with: {
+                                [localesBlockTable]: {
+                                    where: branchWhere
+                                }
+                            }
+                        };
+                    }
+                }
+            }
+        }
+        else if (fieldConfig instanceof TreeBuilder) {
+            // Handle tree fields
+            treePaths.push(path);
+            const treeTables = childTableNames(table, 'tree', tables);
+            for (const treeTable of treeTables) {
+                if (!withParam[treeTable]) {
+                    let params = { orderBy: { position: 'asc' } };
+                    const columns = getColumns(tables[treeTable]);
+                    const hasLocale = Object.keys(columns).includes('locale');
+                    if (locale && hasLocale) {
+                        params = { ...params, where: { locale } };
+                    }
+                    withParam[treeTable] = params;
+                    // Handle localized trees
+                    const localesTreeTables = tableName({ owner: treeTable, branch: 'locales' });
+                    if (locale && localesTreeTables in tables) {
+                        withParam[treeTable] = {
+                            ...withParam[treeTable],
+                            with: {
+                                [localesTreeTables]: {
+                                    where: branchWhere
+                                }
+                            }
+                        };
+                    }
+                }
+            }
+        }
+        else if (fieldConfig) {
+            // Handle regular fields
+            if (fieldConfig.get.localized && locale) {
+                const localesTableName = tableName({ owner: table, branch: 'locales' });
+                if (localesTableName in tables) {
+                    // `locale` too: the merge picks each column by the locale its row is for.
+                    if (withParam[localesTableName]) {
+                        withParam[localesTableName].columns = {
+                            ...withParam[localesTableName].columns,
+                            [sqlPath]: true
+                        };
+                    }
+                    else {
+                        withParam[localesTableName] = {
+                            where: branchWhere,
+                            columns: { locale: true, [sqlPath]: true }
+                        };
+                    }
+                }
+            }
+        }
+    }
+    // Compute direct relationships if defined
+    // this ensure we only fetch the necessary relations
+    if (directRelationPaths.length) {
+        withParam[tableName({ owner: table, child: { kind: 'rels' } })] = {
+            where: { OR: directRelationPaths.map((path) => ({ path })) },
+            orderBy: { path: 'asc', position: 'asc' }
+        };
+    }
+    // Handle nested relationships
+    // 1. Include relations table if container paths exist (blocks or trees).
+    //    If container paths are present we include relations for those containers
+    //    and also include any direct relation paths.
+    if ((blockPaths.length > 0 || treePaths.length > 0) &&
+        tableName({ owner: table, child: { kind: 'rels' } }) in tables) {
+        // Create a where condition that matches relations within any of the container paths,
+        // and include direct relation paths as exact matches.
+        withParam[tableName({ owner: table, child: { kind: 'rels' } })] = {
+            where: {
+                OR: [
+                    // A container's rows sit under its path; a direct relation is the path itself.
+                    ...[...blockPaths, ...treePaths].map((path) => ({ path: { like: `${path}__%` } })),
+                    ...directRelationPaths.map((path) => ({ path }))
+                ]
+            },
+            orderBy: { path: 'asc', position: 'asc' }
+        };
+    }
+    // 2. Include tree tables for blocks that might contain trees
+    if (blockPaths.length > 0) {
+        const treeTables = childTableNames(table, 'tree', tables);
+        for (const treeTable of treeTables) {
+            if (!withParam[treeTable]) {
+                withParam[treeTable] = {
+                    where: { OR: blockPaths.map((path) => ({ path: { like: `${path}__%` } })) },
+                    orderBy: { position: 'asc' }
+                };
+                // Handle localized trees
+                const localesTreeTable = tableName({ owner: treeTable, branch: 'locales' });
+                if (locale && localesTreeTable in tables) {
+                    withParam[treeTable] = {
+                        ...withParam[treeTable],
+                        with: {
+                            [localesTreeTable]: {
+                                where: branchWhere
+                            }
+                        }
+                    };
+                }
+            }
+        }
+    }
+    // 3. Include block tables for trees that might contain blocks
+    if (treePaths.length > 0) {
+        const blocksTables = childTableNames(table, 'blocks', tables);
+        for (const blocksTable of blocksTables) {
+            if (!withParam[blocksTable]) {
+                withParam[blocksTable] = {
+                    where: { OR: treePaths.map((path) => ({ path: { like: `${path}__%` } })) },
+                    orderBy: { position: 'asc' }
+                };
+                // Handle localized blocks
+                const localesBlockTable = tableName({ owner: blocksTable, branch: 'locales' });
+                if (locale && localesBlockTable in tables) {
+                    withParam[blocksTable] = {
+                        ...withParam[blocksTable],
+                        with: {
+                            [localesBlockTable]: {
+                                where: branchWhere
+                            }
+                        }
+                    };
+                }
+            }
+        }
+    }
+    // If withParam is empty
+    if (Object.keys(withParam).length === 0) {
+        return undefined;
+    }
+    return withParam;
+};
+/** The filter on a locales branch: every locale in the fallback order, else the one requested. */
+const branchFilter = (locale, fallback) => fallback && fallback.length > 1 ? { locale: { in: fallback } } : { locale };
+const buildFullWithParam = ({ table, locale, fallback, tables }) => {
+    const branchWhere = branchFilter(locale, fallback);
+    const blocksTables = childTableNames(table, 'blocks', tables);
+    const treeTables = childTableNames(table, 'tree', tables);
+    const withParam = Object.fromEntries([...blocksTables, ...treeTables].map((key) => {
+        const blockOrTreeTable = tables[key];
+        let params = { orderBy: { position: 'asc' } };
+        const columns = getColumns(blockOrTreeTable);
+        const hasLocale = Object.keys(columns).includes('locale');
+        if (locale && hasLocale) {
+            params = { ...params, where: { locale } };
+        }
+        return [key, params];
+    }));
+    if (locale) {
+        const localesTableName = tableName({ owner: table, branch: 'locales' });
+        if (localesTableName in tables) {
+            withParam[localesTableName] = { where: branchWhere };
+        }
+        for (const blocksTable of blocksTables) {
+            const localesBlockTable = tableName({ owner: blocksTable, branch: 'locales' });
+            if (localesBlockTable in tables) {
+                withParam[blocksTable] = {
+                    ...withParam[blocksTable],
+                    with: {
+                        [localesBlockTable]: {
+                            where: branchWhere
+                        }
+                    }
+                };
+            }
+        }
+        for (const treeTable of treeTables) {
+            const localesTreeTable = tableName({ owner: treeTable, branch: 'locales' });
+            if (localesTreeTable in tables) {
+                withParam[treeTable] = {
+                    ...withParam[treeTable],
+                    with: {
+                        [localesTreeTable]: {
+                            where: branchWhere
+                        }
+                    }
+                };
+            }
+        }
+    }
+    if (tableName({ owner: table, child: { kind: 'rels' } }) in tables) {
+        const tableNameRelationFields = tableName({ owner: table, child: { kind: 'rels' } });
+        withParam[tableNameRelationFields] = {
+            orderBy: { path: 'asc', position: 'asc' }
+        };
+    }
+    return withParam;
+};

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

@@ -0,0 +1,18 @@
+import type { TableHandle } from '../core/adapter.js';
+import type { GetRegisterType } from '../index.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+/**
+ * Handles for the tables features declared — see `FeatureDefinition.tables`.
+ *
+ * The counterpart to `prototype.server.ts`, and much smaller for one reason: a declared table has
+ * no config behind it. Nothing to resolve a path against, no locales branch, no children, no
+ * blank to merge. So the filter is a flat column-to-value map and the verbs are three.
+ *
+ * This is what let `AuthHandle` collapse to Better-auth's own adapter. Its last three methods
+ * read and wrote `auth_users`, `auth_sessions` and `auth_accounts` — real tables that core simply
+ * had no way to name until a feature could declare one.
+ */
+export declare const createTableHandles: (args: {
+    db: LibSQLDatabase<GetRegisterType<"Relations">>;
+    tables: GetRegisterType<"Tables">;
+}) => (slug: string) => TableHandle;

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

@@ -0,0 +1,63 @@
+import { RimeError } from '../core/errors/index.js';
+import { and, eq } from 'drizzle-orm';
+import { declaredTableProperty } from './naming.server.js';
+/**
+ * Handles for the tables features declared — see `FeatureDefinition.tables`.
+ *
+ * The counterpart to `prototype.server.ts`, and much smaller for one reason: a declared table has
+ * no config behind it. Nothing to resolve a path against, no locales branch, no children, no
+ * blank to merge. So the filter is a flat column-to-value map and the verbs are three.
+ *
+ * This is what let `AuthHandle` collapse to Better-auth's own adapter. Its last three methods
+ * read and wrote `auth_users`, `auth_sessions` and `auth_accounts` — real tables that core simply
+ * had no way to name until a feature could declare one.
+ */
+export const createTableHandles = (args) => {
+    const { db, tables } = args;
+    const get = (slug) => {
+        const name = declaredTableProperty(slug);
+        const table = tables[name];
+        if (!table) {
+            throw new RimeError(RimeError.OPERATION_ERROR, `no table declared for "${slug}" — the schema has no "${name}"`);
+        }
+        /** Every condition, ANDed. An unknown column is a caller error, not an empty filter. */
+        const conditions = (where) => Object.entries(where).map(([column, value]) => {
+            if (!(column in table)) {
+                throw new RimeError(RimeError.OPERATION_ERROR, `"${slug}" has no column "${column}"`);
+            }
+            return eq(table[column], value);
+        });
+        /**
+         * The filter for a write. Empty is refused rather than treated as "everything": `and()` of
+         * nothing is `undefined`, which drizzle renders as a statement with no `WHERE` clause.
+         */
+        const writeFilter = (where, verb) => {
+            const built = conditions(where);
+            if (!built.length) {
+                throw new RimeError(RimeError.OPERATION_ERROR, `refusing to ${verb} every row of "${slug}"`);
+            }
+            return and(...built);
+        };
+        return {
+            find: async ({ where = {}, select, limit } = {}) => {
+                const columns = select?.length
+                    ? Object.fromEntries(select.map((column) => [column, table[column]]))
+                    : undefined;
+                let query = (columns ? db.select(columns) : db.select()).from(table);
+                const built = conditions(where);
+                if (built.length)
+                    query = query.where(and(...built));
+                if (limit)
+                    query = query.limit(limit);
+                return (await query);
+            },
+            update: async ({ where, data }) => {
+                await db.update(table).set(data).where(writeFilter(where, 'update'));
+            },
+            delete: async ({ where }) => {
+                await db.delete(table).where(writeFilter(where, 'delete'));
+            }
+        };
+    };
+    return get;
+};

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

@@ -1,22 +1,23 @@
+import type { DocumentRows } from '../core/adapter.js';
 import type { Config } from '../core/config/types.js';
+import type { PrototypeSlug, RawDoc } from '../core/prototype/types.js';
 import type { ConfigContext } from '../core/rime.server.js';
-import type { AreaSlug, CollectionSlug, GenericDoc, RawDoc } from '../core/types/doc.js';
-import type { RequestEvent } from '@sveltejs/kit';
 /**
- * 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 declare const transformerFacade: <const C extends Config>(args: {
+export declare const createTransformHandle: <const C extends Config>(args: {
     configCtx: ConfigContext<C>;
     tables: any;
 }) => {
-    doc: <T extends GenericDoc = GenericDoc>(args: {
+    rows: (args: {
         doc: RawDoc;
-        slug: AreaSlug | CollectionSlug;
+        slug: PrototypeSlug;
         locale?: string;
-        event: RequestEvent;
-        depth?: number;
-        withBlank?: boolean;
-    }) => Promise<T>;
+        localeFallback?: boolean;
+    }) => Promise<DocumentRows>;
 };