rimecms 0.31.4 → 0.32.0

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

@@ -1,357 +0,0 @@
-import { RimeError } from '../core/errors/index.js';
-import { isObjectLiteral, omit, pick } from '../util/object.js';
-import { randomId } from '../util/random.js';
-import { and, desc, eq, getTableColumns, Table } from 'drizzle-orm';
-import { getTableConfig } from 'drizzle-orm/sqlite-core';
-import qs from 'qs';
-/**
- * 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: and(eq(tableLocales.ownerId, ownerId), eq(tableLocales.locale, 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 (nested) : _parent and _position
- * - directory props (upload) : _path
- * return an object with the data filtered and the rootData.
- */
-export function extractRootData(data) {
-    const rootData = {};
-    // extract nested collection props
-    if ('_parent' in data) {
-        rootData._parent = data._parent;
-        delete data._parent;
-    }
-    if ('_position' in data) {
-        rootData._position = data._position;
-        delete data._position;
-    }
-    // extract upload directory props
-    if ('_path' in data) {
-        rootData._path = data._path;
-        delete data._path;
-    }
-    return { data, 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
-        };
-    }
-}
-/**
- * Merges a document with its version data to create a complete document representation
- *
- * In versioned collections/areas, data is split between:
- * - Root document table (containing hierarchy fields like _parent, _position, and metadata like createdAt)
- * - Version table (containing the actual content fields)
- *
- * This function combines these two data sources into a single document object:
- * 1. Validates that version data exists or throw 404
- * 2. Handles field selection if specified
- * 3. Preserves root document fields (id, createdAt, updatedAt, _parent, _position)
- * 4. Adds version fields while avoiding duplicates
- * 5. Includes the versionId in the result
- */
-export function mergeRawDocumentWithVersion(doc, versionTableName, select) {
-    // Check if we have version data
-    // Note: Versions data can be empty when a query returns no result
-    if (!doc[versionTableName] || doc[versionTableName].length === 0) {
-        throw new RimeError(RimeError.NOT_FOUND);
-    }
-    const versionData = doc[versionTableName][0];
-    if (select && Array.isArray(select) && select.length) {
-        const rootProps = ['createdAt', 'updatedAt', '_parent', '_position', 'id'];
-        const hasRootSelectColumn = rootProps.some((column) => select.includes(column));
-        // Pick "createdAt" and "updatedAt" on doc if they are in select, or only the "id"
-        const docFields = hasRootSelectColumn
-            ? pick([...select.filter((field) => rootProps.includes(field)), 'id'], doc)
-            : pick(['id'], doc);
-        // Filter out root props as they should come from the doc,
-        // plus the ownerId wich is equals to doc.id
-        const versionFields = omit([...rootProps, 'ownerId'], versionData);
-        // `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,
-            ...versionFields,
-            versionId: versionData.id
-        };
-    }
-    // Default case - return all fields
-    // `versionTableName` 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([versionTableName], doc),
-        ...omit(['id', 'ownerId', 'createdAt', 'updatedAt'], versionData),
-        versionId: versionData.id
-    };
-}
-/**
- * Build the query params to get either the latest updated document
- * or the published one if version.draft is enabled and draft is true
- */
-export function buildPublishedOrLatestVersionParams(args) {
-    const { config, table, draft } = args;
-    const hasStatus = config.versions && config.versions.draft;
-    return hasStatus && !draft
-        ? {
-            where: eq(table.status, 'published'),
-            limit: 1
-        }
-        : {
-            orderBy: [desc(table.updatedAt)],
-            limit: 1
-        };
-}
-/**
- * Convert and validate on incoming query to a complient query
- * for the buildWhereParam wich require an object with a root prop where.
- *
- * @example
- * // returns
- * { where: queryObject }
- */
-export function normalizeQuery(incomingQuery) {
-    let query;
-    if (typeof incomingQuery === 'string') {
-        try {
-            query = qs.parse(incomingQuery);
-        }
-        catch (err) {
-            throw new RimeError(RimeError.INVALID_DATA, 'Unable to parse given string query ' + err.message);
-        }
-    }
-    else {
-        if (!isObjectLiteral(incomingQuery)) {
-            throw new RimeError(RimeError.INVALID_DATA, 'Query is not an object');
-        }
-        query = incomingQuery;
-    }
-    if (!query.where) {
-        throw new RimeError(RimeError.INVALID_DATA, 'Query must have a root where property');
-    }
-    return query;
-}
-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 versions table, add it to our select
-            if (sqlPath in table) {
-                selectColumns[sqlPath] = true;
-            }
-        }
-    }
-    return Object.keys(selectColumns).length ? selectColumns : undefined;
-}
-/**
- * Get the primary key name given a table
- */
-export function getPrimaryKey(table) {
-    const columnsPrimary = getTableConfig(table).columns.filter((c) => c.primary);
-    return columnsPrimary.length ? columnsPrimary[0].name : 'id';
-}
-/**
- * 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) => path.replace(/__/g, '.');
-/**
- * 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/with.server.d.ts

@@ -1,9 +0,0 @@
-import type { BuiltArea, BuiltCollection } from '../types.js';
-import type { Dic } from '../util/types.js';
-export declare const buildWithParam: (args: {
-    slug: string;
-    select?: string[];
-    locale?: string;
-    tables: any;
-    config: BuiltCollection | BuiltArea;
-}) => Dic | undefined;

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

@@ -1,266 +0,0 @@
-import { getFieldAtPath } from '../core/fields/util.js';
-import { withLocalesSuffix } from '../core/naming.js';
-import { BlocksBuilder } from '../fields/blocks/index.js';
-import { RelationFieldBuilder } from '../fields/relation/index.js';
-import { TreeBuilder } from '../fields/tree/index.js';
-import { asc, eq, getTableColumns, or, SQL } from 'drizzle-orm';
-import { getBlocksTableNames, getTreeTableNames } from './generate-schema/util.server.js';
-export const buildWithParam = (args) => {
-    const { slug, select = [], locale, tables, config: documentConfig } = args;
-    if (!select.length) {
-        return buildFullWithParam({
-            slug,
-            locale,
-            tables
-        });
-    }
-    const withParam = {};
-    // 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 = getBlocksTableNames(slug, tables);
-            for (const blocksTable of blocksTables) {
-                if (!withParam[blocksTable]) {
-                    const blocksTableObj = tables[blocksTable];
-                    let params = { orderBy: [asc(blocksTableObj.position)] };
-                    const columns = getTableColumns(blocksTableObj);
-                    const hasLocale = Object.keys(columns).includes('locale');
-                    if (locale && hasLocale) {
-                        params = { ...params, where: eq(blocksTableObj.locale, locale) };
-                    }
-                    withParam[blocksTable] = params;
-                    // Handle localized blocks
-                    const localesBlockTable = withLocalesSuffix(blocksTable);
-                    if (locale && localesBlockTable in tables) {
-                        withParam[blocksTable] = {
-                            ...withParam[blocksTable],
-                            with: {
-                                [localesBlockTable]: {
-                                    where: eq(tables[localesBlockTable].locale, locale)
-                                }
-                            }
-                        };
-                    }
-                }
-            }
-        }
-        else if (fieldConfig instanceof TreeBuilder) {
-            // Handle tree fields
-            treePaths.push(path);
-            const treeTables = getTreeTableNames(slug, tables);
-            for (const treeTable of treeTables) {
-                if (!withParam[treeTable]) {
-                    const treeTableObj = tables[treeTable];
-                    let params = { orderBy: [asc(treeTableObj.position)] };
-                    const columns = getTableColumns(treeTableObj);
-                    const hasLocale = Object.keys(columns).includes('locale');
-                    if (locale && hasLocale) {
-                        params = { ...params, where: eq(treeTableObj.locale, locale) };
-                    }
-                    withParam[treeTable] = params;
-                    // Handle localized trees
-                    const localesTreeTables = withLocalesSuffix(treeTable);
-                    if (locale && localesTreeTables in tables) {
-                        withParam[treeTable] = {
-                            ...withParam[treeTable],
-                            with: {
-                                [localesTreeTables]: {
-                                    where: eq(tables[localesTreeTables].locale, locale)
-                                }
-                            }
-                        };
-                    }
-                }
-            }
-        }
-        else if (fieldConfig) {
-            // Handle regular fields
-            if (fieldConfig.get.localized && locale) {
-                const localesTableName = withLocalesSuffix(slug);
-                if (localesTableName in tables) {
-                    const tableLocales = tables[localesTableName];
-                    if (withParam[localesTableName]) {
-                        withParam[localesTableName].columns = {
-                            ...withParam[localesTableName].columns,
-                            [sqlPath]: true
-                        };
-                    }
-                    else {
-                        withParam[localesTableName] = {
-                            where: eq(tableLocales.locale, locale),
-                            columns: { [sqlPath]: true }
-                        };
-                    }
-                }
-            }
-        }
-    }
-    // Compute direct relationships if defined
-    // this ensure we only fetch the necessary relations
-    if (directRelationPaths.length) {
-        withParam[`${slug}Rels`] = {
-            where: or(...directRelationPaths.map((path) => eq(tables[`${slug}Rels`].path, path))),
-            orderBy: [asc(tables[`${slug}Rels`].path), asc(tables[`${slug}Rels`].position)]
-        };
-    }
-    // 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) && `${slug}Rels` in tables) {
-        const relsTable = tables[`${slug}Rels`];
-        // Create a where condition that matches relations within any of the container paths,
-        // and include direct relation paths as exact matches.
-        withParam[`${slug}Rels`] = {
-            where: (relation, { like, or }) => {
-                const conditions = [];
-                // Add conditions for block paths
-                for (const path of blockPaths) {
-                    conditions.push(like(relation.path, `${path}__%`));
-                }
-                // Add conditions for tree paths
-                for (const path of treePaths) {
-                    conditions.push(like(relation.path, `${path}__%`));
-                }
-                // Add direct relation paths if any (exact match via like)
-                for (const path of directRelationPaths) {
-                    conditions.push(eq(relation.path, path));
-                }
-                return or(...conditions);
-            },
-            orderBy: [asc(relsTable.path), asc(relsTable.position)]
-        };
-    }
-    // 2. Include tree tables for blocks that might contain trees
-    if (blockPaths.length > 0) {
-        const treeTables = getTreeTableNames(slug, tables);
-        for (const treeTable of treeTables) {
-            if (!withParam[treeTable]) {
-                const treeTableObj = tables[treeTable];
-                withParam[treeTable] = {
-                    where: (tree, { like, or }) => {
-                        const conditions = blockPaths.map((path) => {
-                            return like(tree.path, `${path}__%`);
-                        });
-                        return or(...conditions);
-                    },
-                    orderBy: [asc(treeTableObj.position)]
-                };
-                // Handle localized trees
-                const localesTreeTable = withLocalesSuffix(treeTable);
-                if (locale && localesTreeTable in tables) {
-                    withParam[treeTable] = {
-                        ...withParam[treeTable],
-                        with: {
-                            [localesTreeTable]: {
-                                where: eq(tables[localesTreeTable].locale, locale)
-                            }
-                        }
-                    };
-                }
-            }
-        }
-    }
-    // 3. Include block tables for trees that might contain blocks
-    if (treePaths.length > 0) {
-        const blocksTables = getBlocksTableNames(slug, tables);
-        for (const blocksTable of blocksTables) {
-            if (!withParam[blocksTable]) {
-                const blocksTableObj = tables[blocksTable];
-                withParam[blocksTable] = {
-                    where: (block, { like, or }) => {
-                        const conditions = treePaths.map((path) => {
-                            return like(block.path, `${path}__%`);
-                        });
-                        return or(...conditions);
-                    },
-                    orderBy: [asc(blocksTableObj.position)]
-                };
-                // Handle localized blocks
-                const localesBlockTable = withLocalesSuffix(blocksTable);
-                if (locale && localesBlockTable in tables) {
-                    withParam[blocksTable] = {
-                        ...withParam[blocksTable],
-                        with: {
-                            [localesBlockTable]: {
-                                where: eq(tables[localesBlockTable].locale, locale)
-                            }
-                        }
-                    };
-                }
-            }
-        }
-    }
-    // If withParam is empty
-    if (Object.keys(withParam).length === 0) {
-        return undefined;
-    }
-    return withParam;
-};
-const buildFullWithParam = ({ slug, locale, tables }) => {
-    const blocksTables = getBlocksTableNames(slug, tables);
-    const treeTables = getTreeTableNames(slug, tables);
-    const withParam = Object.fromEntries([...blocksTables, ...treeTables].map((key) => {
-        const blockOrTreeTable = tables[key];
-        let params = { orderBy: [asc(blockOrTreeTable.position)] };
-        const columns = getTableColumns(blockOrTreeTable);
-        const hasLocale = Object.keys(columns).includes('locale');
-        if (locale && hasLocale) {
-            params = { ...params, where: eq(blockOrTreeTable.locale, locale) };
-        }
-        return [key, params];
-    }));
-    if (locale) {
-        const localesTableName = withLocalesSuffix(slug);
-        if (localesTableName in tables) {
-            const tableLocales = tables[localesTableName];
-            withParam[localesTableName] = { where: eq(tableLocales.locale, locale) };
-        }
-        for (const blocksTable of blocksTables) {
-            const localesBlockTable = withLocalesSuffix(blocksTable);
-            if (localesBlockTable in tables) {
-                withParam[blocksTable] = {
-                    ...withParam[blocksTable],
-                    with: {
-                        [localesBlockTable]: {
-                            where: eq(tables[localesBlockTable].locale, locale)
-                        }
-                    }
-                };
-            }
-        }
-        for (const treeTable of treeTables) {
-            const localesTreeTable = withLocalesSuffix(treeTable);
-            if (localesTreeTable in tables) {
-                withParam[treeTable] = {
-                    ...withParam[treeTable],
-                    with: {
-                        [localesTreeTable]: {
-                            where: eq(tables[localesTreeTable].locale, locale)
-                        }
-                    }
-                };
-            }
-        }
-    }
-    if (`${slug}Rels` in tables) {
-        const tableNameRelationFields = `${slug}Rels`;
-        const tableRelationFields = tables[tableNameRelationFields];
-        withParam[tableNameRelationFields] = {
-            orderBy: [asc(tableRelationFields.path), asc(tableRelationFields.position)]
-        };
-    }
-    return withParam;
-};

package/dist/core/areas/config/augment-hooks.server.d.ts

@@ -1,10 +0,0 @@
-import type { Area, AreaHooks } from '../../../types.js';
-type PartialConfig = {
-    $hooks?: AreaHooks<any>;
-    $url?: Area<any>['$url'];
-};
-/**
- * Augment an area config with hooks
- */
-export declare const augmentHooks: <T extends PartialConfig>(area: T) => T;
-export {};