rimecms 0.31.5 → 0.32.1

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

@@ -0,0 +1,307 @@
+import { RimeError } from '../core/errors/index.js';
+import { omit, pick } from '../util/object.js';
+import { randomId } from '../util/random.js';
+import { baseFieldNames } from '../core/fields/util.js';
+import { and, eq, getTableColumns } from 'drizzle-orm';
+import { JOIN_SUFFIX } from './naming.server.js';
+/**
+ * Main function to generated primaryKeys
+ */
+export const generatePK = () => {
+    return crypto.randomUUID();
+};
+/**
+ * Updates a database table with the provided data and timestamp
+ */
+export async function updateTableRecord(db, tables, tableName, options) {
+    const { recordId, data } = options;
+    if (Object.keys(data).length) {
+        await db.update(tables[tableName]).set(data).where(eq(tables[tableName].id, recordId));
+    }
+}
+/**
+ * Inserts a new record into a database table
+ * @returns The ID of the inserted record
+ */
+export async function insertTableRecord(db, tables, tableName, data) {
+    const recordId = data.id || generatePK();
+    await db.insert(tables[tableName]).values({
+        ...data,
+        id: recordId
+    });
+    return recordId;
+}
+/**
+ * Updates or inserts localized data for a record
+ */
+export async function upsertLocalizedData(db, tables, tableLocalesName, options) {
+    const { ownerId, data, locale } = options;
+    if (Object.keys(data).length) {
+        const tableLocales = tables[tableLocalesName];
+        const localizedRow = await db.query[tableLocalesName].findFirst({
+            where: { ownerId, locale }
+        });
+        if (localizedRow) {
+            // Update existing localized data
+            await db
+                .update(tableLocales)
+                .set(data)
+                .where(and(eq(tableLocales.ownerId, ownerId), eq(tableLocales.locale, locale)));
+        }
+        else {
+            // Insert new localized data
+            await db.insert(tableLocales).values({
+                id: generatePK(),
+                ...data,
+                ownerId,
+                locale
+            });
+        }
+    }
+}
+/**
+ * Extract root table properties :
+ * - hierarchy props : _parent and _position
+ * - directory props : _path
+ * return an object with the data filtered and the rootData.
+ */
+/**
+ * Prepares data for database operations by transforming it according to table schemas
+ */
+export function prepareSchemaData(data, options) {
+    const { mainTableName, localesTableName, locale, tables, fillNotNull } = options;
+    if (locale && localesTableName in tables) {
+        // Handle localized fields
+        const unlocalizedColumns = getTableColumns(tables[mainTableName]);
+        const localizedColumns = getTableColumns(tables[localesTableName]);
+        return {
+            mainData: transformDataToSchema(data, unlocalizedColumns, { fillNotNull }),
+            localizedData: transformDataToSchema(data, localizedColumns, { fillNotNull }),
+            isLocalized: true
+        };
+    }
+    else {
+        // Handle non-localized fields
+        const columns = getTableColumns(tables[mainTableName]);
+        return {
+            mainData: transformDataToSchema(data, columns, { fillNotNull }),
+            localizedData: {},
+            isLocalized: false
+        };
+    }
+}
+/**
+ * Folds a base row and its content row into one document.
+ *
+ * A prototype whose content lives on a versions table reads as two rows; a document is one. This
+ * is the fold, and only the adapter knows there were two. The content row's id goes out as
+ * `contentId`; whichever feature declared the versions names it on the document, in a hook.
+ *
+ * Which row answers what:
+ *
+ * ```
+ * id, createdAt, $root() fields   the base row — the document
+ * updatedAt, everything else      the content row — the version being read
+ * ```
+ *
+ * The base row's own `updatedAt` is not merged. It moves on every write to any version and is
+ * what the default list sort orders by; the document reports when the version it shows was
+ * written.
+ */
+export function mergeContentRow(doc, contentTable, config, select) {
+    // A base row with no content row is as good as absent — note this can be empty when a query
+    // returns no result.
+    if (!doc[contentTable] || doc[contentTable].length === 0) {
+        throw new RimeError(RimeError.NOT_FOUND);
+    }
+    const contentRow = doc[contentTable][0];
+    if (select && Array.isArray(select) && select.length) {
+        // The row's own columns, plus whatever the config keeps on the base row. Hardcoding the
+        // latter is how `_path` came to be missing from this list while being a base field.
+        const rootProps = ['createdAt', 'id', ...baseFieldNames(config)];
+        const hasRootSelectColumn = rootProps.some((column) => select.includes(column));
+        // A resolved reference's target, joined only when its column was selected.
+        const joined = Object.keys(doc).filter((key) => key.endsWith(JOIN_SUFFIX));
+        // Pick the selected base columns on doc, or only the "id"
+        const docFields = hasRootSelectColumn
+            ? pick([...select.filter((field) => rootProps.includes(field)), 'id', ...joined], doc)
+            : pick(['id', ...joined], doc);
+        // Filter out root props as they should come from the doc,
+        // plus the ownerId wich is equals to doc.id
+        const contentFields = omit([...rootProps, 'ownerId'], contentRow);
+        // `pick`/`omit` return generic Dic types, so TS can't statically confirm
+        // `id` survived — it always does, since we explicitly pick it above.
+        return {
+            ...docFields,
+            ...contentFields,
+            contentId: contentRow.id
+        };
+    }
+    // Default case - return all fields
+    // `contentTable` is a plain `string`, not a literal, so `Omit<T, string>`
+    // widens to `Omit<T, keyof T>` and TS loses track of every spread key
+    // (including `id`) — the object is correct at runtime, only its inferred
+    // type collapses, hence the double cast through `unknown`.
+    return {
+        ...omit([contentTable], doc),
+        ...omit(['id', 'ownerId', 'createdAt'], contentRow),
+        contentId: contentRow.id
+    };
+}
+export function columnsParams({ table, select }) {
+    // Create an object to hold the columns we want to select
+    const selectColumns = {};
+    // If select fields are specified, build the select columns object
+    if (select && select.length > 0) {
+        // Always include the ID column for the version
+        selectColumns.id = true;
+        // Process each requested field
+        for (const path of select) {
+            // Convert nested paths (dot notation) to SQL format (double underscore)
+            // Example: 'attributes.slug' becomes 'attributes__slug'
+            const sqlPath = path.replace(/\./g, '__');
+            // If this column exists on the content table, add it to our select
+            if (sqlPath in table) {
+                selectColumns[sqlPath] = true;
+            }
+        }
+    }
+    return Object.keys(selectColumns).length ? selectColumns : undefined;
+}
+/**
+ * Convert a document path using dot notation to a database schema path using double underscores.
+ * This transformation is needed because SQL databases don't support dots in column names.
+ *
+ * @param path - The document path with dot notation
+ * @returns The database column path with double underscore notation
+ *
+ * @example
+ * // Returns 'attributes__hero__title'
+ * pathToDatabaseColumn('attributes.hero.title');
+ */
+export const pathToDatabaseColumn = (path) => path.replace(/\./g, '__');
+/**
+ * Convert a database schema path using double underscores to a document path using dot notation.
+ * This transforms database column names back to document property paths.
+ *
+ * @param path - The database column path with double underscore notation
+ * @returns The document path with dot notation
+ *
+ * @example
+ * // Returns 'attributes.hero.title'
+ * databaseColumnToPath('attributes__hero__title');
+ */
+export const databaseColumnToPath = (path) => isStructuralKey(path) ? path : path.replace(/__/g, '.');
+/**
+ * Is this key a table name rather than a column path?
+ *
+ * Both use `__` as a separator, so converting it to `.` blindly turns a relational table's key
+ * into nested document properties: `settings__shadow__$relations` becomes
+ * `settings.versions.$relations`, which the cleanup below cannot find by its flat key, and it
+ * surfaces inside every response — silently, as a 200 with wrong data.
+ *
+ * `$` is what separates the two. The naming convention uses it to mark structure — `__$` a
+ * child, `__$$` a branch — and a column path can never contain one, since column names come
+ * from field names, which are identifiers.
+ */
+const isStructuralKey = (key) => key.includes('$');
+/**
+ * Converts an object's keys from database schema format (double underscores) to document format (dot notation).
+ *
+ * This function takes an object with keys using database column naming (e.g., 'attributes__title')
+ * and transforms them to document path format (e.g., 'attributes.title') while preserving the values.
+ *
+ * @param obj - The object with database column keys
+ * @returns A new object with keys converted to document paths
+ *
+ * @example
+ * // Returns { 'attributes.title': 'Home' }
+ * transformDatabaseColumnsToPaths({ 'attributes__title': 'Home' });
+ */
+export const transformDatabaseColumnsToPaths = (obj) => {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[databaseColumnToPath(key)] = value;
+    }
+    return result;
+};
+/**
+ * Extracts values from a data object and maps them to database column names using schema paths.
+ *
+ * This function converts document data (which may use nested objects with dot notation paths)
+ * into a flat object with keys that match the database schema (using double underscore notation).
+ * It only includes fields that exist in the provided columns schema.
+ *
+ * @param data - The document data object (may be nested)
+ * @param columns - The database schema columns definition
+ * @param params - Optional parameters for transformation
+ * @param params.fillNotNull - If true, adds default values for NOT NULL columns
+ * @returns A flat object with database column names and values
+ *
+ * @example
+ * // Returns { 'attributes__title': 'Home' }
+ * transformDataToSchema(
+ *   { attributes: { title: 'Home' } },
+ *   { 'attributes__title': { dataType: 'string', notNull: true } }
+ * );
+ *
+ * // With fillNotNull, provides defaults for missing NOT NULL columns
+ * transformDataToSchema(
+ *   { attributes: {} },
+ *   { 'attributes__title': { dataType: 'string', notNull: true } },
+ *   { fillNotNull: true }
+ * ); // Returns { 'attributes__title': '' }
+ */
+export const transformDataToSchema = (data, columns, params = { fillNotNull: false }) => {
+    const result = {};
+    for (const column of Object.keys(columns)) {
+        const columnConfig = columns[column];
+        // Convert schema path (with __) to doc path (with .)
+        const docPath = databaseColumnToPath(column);
+        // Get value from nested path
+        const pathParts = docPath.split('.');
+        let value = data;
+        for (const part of pathParts) {
+            value = value?.[part];
+            if (value === undefined)
+                break;
+        }
+        // Case 1: Value exists and is not null - always use it
+        if (value !== undefined && value !== null) {
+            result[column] = value;
+            continue;
+        }
+        // Case 2: Value is null - use it unless we need to fill it
+        if (value === null && !params.fillNotNull) {
+            result[column] = null;
+            continue;
+        }
+        // Case 3: Add placeholders for missing or null values in not-null columns
+        if (params.fillNotNull && columnConfig.notNull) {
+            if (column === 'id') {
+                result[column] = randomId(32);
+                continue;
+            }
+            console.warn(`No default value provided for ${column}, setting it with a placeholder`);
+            // Add default values for not-null columns without defaults
+            switch (columnConfig.dataType) {
+                case 'string':
+                    result[column] = '';
+                    break;
+                case 'number':
+                    result[column] = 0;
+                    break;
+                case 'boolean':
+                    result[column] = false;
+                    break;
+                case 'json':
+                    result[column] = {};
+                    break;
+                case 'date':
+                    result[column] = new Date();
+                    break;
+            }
+        }
+    }
+    return result;
+};

package/dist/adapter-sqlite/generate-schema/column.server.js

@@ -1,5 +1,5 @@
 import { templateReferences, templateUniqueRequired } from './templates.server.js';
-import { getSchemaColumnNames } from './util.server.js';
+import { getSchemaColumnNames } from '../naming.server.js';
 const COLUMN_EXPR = {
     text: (snake) => `text('${snake}')`,
     boolean: (snake) => `integer('${snake}', { mode: 'boolean' })`,

package/dist/adapter-sqlite/generate-schema/index.server.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from '../../core/config/types.js';
-export declare function generateSchemaString<T extends Config>(config: T): Promise<string>;
-declare const generateSchema: <T extends Config>(config: T) => Promise<void>;
+import type { BuiltConfig } from '../../core/config/types.js';
+export declare function generateSchemaString(config: BuiltConfig): Promise<string>;
+declare const generateSchema: (config: BuiltConfig) => Promise<void>;
 export default generateSchema;

package/dist/adapter-sqlite/generate-schema/index.server.js

@@ -1,83 +1,73 @@
-import { withVersionsSuffix } from '../../core/naming.js';
+import { authColumns } from '../../core/auth/tables.js';
+import { baseTableName, declaredTableProperty } from '../naming.server.js';
 import { date } from '../../fields/date/index.js';
-import { toCamelCase, toCamelCasePreserveTrailingUnderscoreSuffix, toPascalCase, toSnakeCase } from '../../util/string.js';
-import { toSchemaColumn } from './column.server.js';
-import { generateRelationshipDefinitions } from './relations/definition.server.js';
 import { generateJunctionTableDefinition } from './relations/junction.server.js';
-import buildRootTable from './root.server.js';
-import { templateAPIKey, templateAuth, templateExportRelationsFieldsToTable, templateExportSchema, templateExportTables, templateHead, templateImports, templateRelationMany, templateRelationOne, templateTable } from './templates.server.js';
+import buildRootTable, {} from './root.server.js';
+import { templateDeclaredTable, templateExportRelationsFieldsToTable, templateExportSchema, templateExportTables, templateHead, templateImports, templateRelations } from './templates.server.js';
 import write from './write.server.js';
 export async function generateSchemaString(config) {
-    const collections = (config.collections || []).filter((c) => c._generateSchema !== false);
-    const areas = (config.areas || []).filter((a) => a._generateSchema !== false);
+    // Every prototype config in the build, each paired with the features that extend its kind —
+    // which is what says whether the config's content lives somewhere other than its own row.
+    // One list rather than a loop per kind: the body below is two hundred lines and identical
+    // for either.
+    const allEntries = [
+        ...config.collections.map((config) => ({ config })),
+        ...config.areas.map((config) => ({ config }))
+    ];
+    const entries = allEntries.filter((entry) => entry.config._generateSchema !== false);
     const schema = [templateImports];
     let enumTables = [];
-    let enumRelations = [];
+    /** parent table -> its child tables, for the one `defineRelations` at the end. */
+    const relationTree = {};
     let relationFieldsExportDic = {};
     const blocksRegister = [];
-    for (const collection of collections) {
-        const collectionSlug = toCamelCasePreserveTrailingUnderscoreSuffix(collection.slug);
-        let rootTableName = collectionSlug;
-        let versionsRelationsDefinitions = [];
-        schema.push(templateHead(collectionSlug));
-        if (collection.versions) {
-            // Collection that have versions may need some fields forced on the root table and not root_versions
-            // process the root table with these fields first then, handle versions related tables creation
-            // 1. Process root table
-            // base root fields for versioned tables
-            const baseRootFields = [date('createdAt').hidden(), date('updatedAt').hidden()];
-            // Split fields that should be used on the root table
-            const rootFieldsFromConfig = [...collection.fields].filter((f) => f.get.root);
-            const rootFields = [...rootFieldsFromConfig, ...baseRootFields];
-            // Build the main root buildRootTable with only _root fields and created/updatedAt
-            const { schema: rootCollectionSchema } = await buildRootTable({
+    /** Every resolved reference, joined onto its owner in the same `defineRelations`. */
+    const referenceJoins = [];
+    for (const entry of entries) {
+        const prototype = entry.config;
+        // Whether this config's content lives on its own row or on a second table, asked of the
+        // features that extend the prototype rather than of a member the adapter recognises by name.
+        // A feature declaring a versions table is the only thing that makes two tables here.
+        const versions = prototype._versions;
+        // The prototype's own table, resolved from its slug rather than case-converted here —
+        // a derived slug like `$someChild` has to lose its `$` and snake-case its segments.
+        const baseName = baseTableName(prototype.slug);
+        let rootTableName = baseName;
+        schema.push(templateHead(baseName));
+        if (versions) {
+            // A versioned prototype is two tables: the base row keeps its own columns — `createdAt`,
+            // `updatedAt` and whatever the config marks `$root()` — and everything else moves onto the
+            // versions, which is what the rest of this iteration then builds.
+            const { schema: baseSchema, referenceJoins: baseReferenceJoins } = await buildRootTable({
                 blocksRegister: [],
-                fields: rootFields,
-                rootName: rootTableName,
+                fields: [
+                    ...prototype.fields.filter((field) => field.get.root),
+                    date('createdAt').hidden(),
+                    date('updatedAt').hidden()
+                ],
+                rootName: baseName,
                 locales: [],
-                hasAuth: !!collection.auth,
-                versionsFrom: false,
-                tableName: rootTableName
+                featureColumns: authColumns(prototype),
+                versionsOf: false,
+                tableName: baseName
             });
-            // Ad the root table to the schema
-            schema.push(rootCollectionSchema);
-            // 2. Handle versions table rename and relation root <-> root_verions definition
-            // overwrite the collection name with the _versions one to generate all table
-            // eg. blocks, relation related to the _versions one
-            rootTableName = withVersionsSuffix(collectionSlug);
-            // create specific relations between root <-> root_verions
-            const manyVersionsToOneName = `rel_${rootTableName}HasOne${toPascalCase(collectionSlug)}`;
-            const oneToManyVersionsName = `rel_${collectionSlug}HasMany${toPascalCase(rootTableName)}`;
-            versionsRelationsDefinitions = [
-                templateRelationOne({
-                    name: manyVersionsToOneName,
-                    table: rootTableName,
-                    parent: collectionSlug
-                }),
-                templateRelationMany({
-                    name: oneToManyVersionsName,
-                    table: collectionSlug,
-                    many: [rootTableName]
-                })
-            ];
-            // add the root table to :
-            // export tables = { ... }
-            enumTables = [...enumTables, collectionSlug];
-            // add the root <-> root_versions relations to :
-            // export schema = { ... }
-            enumRelations = [...enumRelations, manyVersionsToOneName, oneToManyVersionsName];
+            schema.push(baseSchema);
+            referenceJoins.push(...baseReferenceJoins);
+            // From here on, "root" means the versions table: its blocks, tree and relations tables hang off it.
+            rootTableName = baseTableName(versions.slug);
+            enumTables = [...enumTables, baseName];
+            (relationTree[baseName] ??= []).push(rootTableName);
         }
-        const { schema: collectionSchema, relationsDic, relationFieldsMap, relationFieldsHasLocale } = await buildRootTable({
+        const { schema: prototypeSchema, relationsDic, relationFieldsMap, relationFieldsHasLocale, referenceJoins: contentReferenceJoins } = await buildRootTable({
             blocksRegister,
-            fields: collection.versions
-                ? collection.fields.filter((f) => !f.get.root)
-                : collection.fields,
+            fields: versions ? prototype.fields.filter((field) => !field.get.root) : prototype.fields,
             rootName: rootTableName,
             locales: config.localization?.locales || [],
-            hasAuth: !!collection.auth,
-            versionsFrom: collection.versions ? collectionSlug : false,
+            featureColumns: authColumns(prototype),
+            versionsOf: versions ? baseName : false,
             tableName: rootTableName
         });
+        referenceJoins.push(...contentReferenceJoins);
         const { junctionTable, junctionTableName } = generateJunctionTableDefinition({
             tableName: rootTableName,
             relationFieldsMap,
@@ -87,93 +77,28 @@ export async function generateSchemaString(config) {
             relationsDic[rootTableName] ??= [];
             relationsDic[rootTableName].push(junctionTableName);
         }
-        const { relationsDefinitions, relationsNames } = generateRelationshipDefinitions({
-            relationsDic
-        });
         const relationsTableNames = Object.values(relationsDic).flat();
         enumTables = Array.from(new Set([...enumTables, rootTableName, ...relationsTableNames]));
-        enumRelations = [...enumRelations, ...relationsNames];
-        relationFieldsExportDic = {
-            ...relationFieldsExportDic,
-            [rootTableName]: relationFieldsMap
-        };
-        // if (collection.upload) {
-        // 	schema.push(templateDirectories(collection.slug));
-        // 	enumTables = [...enumTables, withDirectoriesSuffix(collection.slug)];
-        // }
-        schema.push(collectionSchema, junctionTable, ...versionsRelationsDefinitions, relationsDefinitions);
-    }
-    /**
-     * Areas
-     */
-    for (const area of areas) {
-        const areaSlug = toCamelCase(area.slug);
-        let rootTableName = toSnakeCase(areaSlug);
-        let versionsRelationsDefinitions = [];
-        schema.push(templateHead(areaSlug));
-        if (area.versions) {
-            // For now, areas don't need to filter out fields with or without _root
-            // as these fields would have no effect
-            // Overrite
-            rootTableName = withVersionsSuffix(areaSlug);
-            const manyVersionsToOneName = `rel_${rootTableName}HasOne${toPascalCase(areaSlug)}`;
-            const oneToManyVersionsName = `rel_${areaSlug}HasMany${toPascalCase(rootTableName)}`;
-            const baseRootFields = [date('createdAt').hidden(), date('updatedAt').hidden()];
-            const schemaResults = baseRootFields.map((field) => toSchemaColumn(field));
-            schema.push(templateTable(areaSlug, schemaResults.join(',\n')));
-            versionsRelationsDefinitions = [
-                templateRelationOne({
-                    name: manyVersionsToOneName,
-                    table: rootTableName,
-                    parent: areaSlug
-                }),
-                templateRelationMany({
-                    name: oneToManyVersionsName,
-                    table: areaSlug,
-                    many: [rootTableName]
-                })
-            ];
-            enumTables = [...enumTables, areaSlug];
-            enumRelations = [...enumRelations, manyVersionsToOneName, oneToManyVersionsName];
+        for (const [parent, children] of Object.entries(relationsDic)) {
+            (relationTree[parent] ??= []).push(...children);
         }
-        const { schema: areaSchema, relationsDic, relationFieldsMap, relationFieldsHasLocale } = await buildRootTable({
-            blocksRegister,
-            fields: area.fields,
-            rootName: rootTableName,
-            locales: config.localization?.locales || [],
-            tableName: rootTableName,
-            versionsFrom: area.versions ? areaSlug : false
-        });
-        const { junctionTable, junctionTableName } = generateJunctionTableDefinition({
-            tableName: rootTableName,
-            relationFieldsMap,
-            hasLocale: relationFieldsHasLocale
-        });
-        if (junctionTable.length) {
-            relationsDic[rootTableName] ??= [];
-            relationsDic[rootTableName].push(junctionTableName);
-        }
-        const { relationsDefinitions, relationsNames } = generateRelationshipDefinitions({
-            relationsDic
-        });
-        const relationsTableNames = Array.from(new Set(Object.values(relationsDic).flat()));
-        enumTables = [...enumTables, rootTableName, ...relationsTableNames];
-        enumRelations = [...enumRelations, ...relationsNames];
         relationFieldsExportDic = {
             ...relationFieldsExportDic,
             [rootTableName]: relationFieldsMap
         };
-        schema.push(areaSchema, junctionTable, ...versionsRelationsDefinitions, relationsDefinitions);
+        schema.push(prototypeSchema, junctionTable);
     }
-    const HAS_API_KEY = collections.filter((c) => c.auth?.type === 'apiKey').length;
-    schema.push(templateAuth);
-    if (HAS_API_KEY) {
-        schema.push(templateAPIKey);
-        enumTables.push('apikey');
+    // Tables no prototype declares — better-auth's own, plus whatever a plugin added during the
+    // configure phase. Nothing here knows who asked for one.
+    for (const table of config.$tables) {
+        schema.push(templateDeclaredTable(table));
+        enumTables.push(declaredTableProperty(table.slug));
     }
     schema.push(templateExportTables(enumTables));
+    // After `tables`, which `defineRelations` takes as its first argument.
+    schema.push(templateRelations(relationTree, referenceJoins));
     schema.push(templateExportRelationsFieldsToTable(relationFieldsExportDic));
-    schema.push(templateExportSchema({ enumTables, enumRelations }));
+    schema.push(templateExportSchema({ enumTables }));
     return schema.join('\n').replace(/\n{3,}/g, '\n\n');
 }
 const generateSchema = async (config) => {

package/dist/adapter-sqlite/generate-schema/relations/junction.server.d.ts

@@ -1,4 +1,5 @@
-import type { RelationFieldsMap } from './definition.server.js';
+import type { RelationFieldsMap } from '../root.server.js';
+import type { TableName } from '../../naming.server.js';
 /**
  * Generates a junction table definition for many-to-many relationships
  * Takes a table name, its relation fields mapping, and locale flag to create:
@@ -20,7 +21,7 @@ import type { RelationFieldsMap } from './definition.server.js';
  */
 export declare function generateJunctionTableDefinition(args: Args): Return;
 type Args = {
-    tableName: string;
+    tableName: TableName;
     relationFieldsMap: RelationFieldsMap;
     hasLocale: boolean;
 };

package/dist/adapter-sqlite/generate-schema/relations/junction.server.js

@@ -1,4 +1,5 @@
-import { templateRelationFieldsTable, templateRelationMany } from '../templates.server.js';
+import { tableName as buildTableName } from '../../naming.server.js';
+import { templateRelationFieldsTable } from '../templates.server.js';
 /**
  * Generates a junction table definition for many-to-many relationships
  * Takes a table name, its relation fields mapping, and locale flag to create:
@@ -21,16 +22,22 @@ import { templateRelationFieldsTable, templateRelationMany } from '../templates.
 export function generateJunctionTableDefinition(args) {
     const { tableName, relationFieldsMap, hasLocale } = args;
     let junctionTable = '';
-    const relationName = `rel_${tableName}Rels`;
+    const relsTableName = buildTableName({ owner: tableName, child: { kind: 'rels' } });
     const tablesRelationsTo = [...new Set(Object.values(relationFieldsMap).map((r) => r.to))];
     if (tablesRelationsTo.length) {
-        junctionTable = [
-            templateRelationFieldsTable({ table: tableName, relations: tablesRelationsTo, hasLocale }),
-            templateRelationMany({ name: relationName, table: tableName, many: tablesRelationsTo })
-        ].join('\n');
+        // The table only. There was a `relations(pages, ({ many }) => ({ medias: many(medias) }))`
+        // beside it, and nothing ever traversed it — every `with` a read builds names a child table
+        // (blocks, tree, locales, rels), never a target collection. Relation *fields* are resolved by
+        // `relations.server.ts` with its own selects against this junction.
+        junctionTable = templateRelationFieldsTable({
+            table: tableName,
+            junctionTable: relsTableName,
+            relations: tablesRelationsTo,
+            hasLocale
+        });
     }
     return {
         junctionTable,
-        junctionTableName: `${tableName}Rels`
+        junctionTableName: relsTableName
     };
 }