rimecms 0.22.0

package/dist/adapter-sqlite/util.js

@@ -0,0 +1,351 @@
+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);
+        return {
+            ...docFields,
+            ...versionFields,
+            versionId: versionData.id
+        };
+    }
+    // Default case - return all fields
+    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/where.d.ts

@@ -0,0 +1,16 @@
+import type { ConfigContext } from '../core/rime.server.js';
+import { type GetRegisterType } from '../index.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { ParsedQs } from 'qs';
+import type { PrototypeSlug } from '../types.js';
+type BuildWhereArgs = {
+    query: ParsedQs;
+    slug: PrototypeSlug;
+    locale?: string;
+    db: LibSQLDatabase<GetRegisterType<'Schema'>>;
+    draft?: boolean;
+    tables: GetRegisterType<'Tables'>;
+    configCtx: ConfigContext;
+};
+export declare const buildWhereParam: ({ query, slug, db, locale, tables, configCtx }: BuildWhereArgs) => any;
+export {};

package/dist/adapter-sqlite/where.js

@@ -0,0 +1,146 @@
+import { RimeError } from '../core/errors/index.js';
+import { getFieldConfigByPath } from '../core/fields/util.js';
+import { logger } from '../core/logger/index.server.js';
+import { hasVersionsSuffix, withLocalesSuffix } from '../core/naming.js';
+import { isRelationField } from '../fields/relation/index.js';
+import {} from '../index.js';
+import * as drizzleORM from 'drizzle-orm';
+import { and, eq, getTableColumns, inArray, or } from 'drizzle-orm';
+export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx }) => {
+    function getTable(key) {
+        return tables[key];
+    }
+    const table = getTable(slug);
+    const tableNameLocales = withLocalesSuffix(slug);
+    const tableLocales = getTable(tableNameLocales);
+    const localizedColumns = locale && tableNameLocales in tables ? Object.keys(getTableColumns(tableLocales)) : [];
+    const unlocalizedColumns = Object.keys(getTableColumns(table));
+    const buildCondition = (conditionObject) => {
+        // Handle nested AND conditions
+        if ('and' in conditionObject && Array.isArray(conditionObject.and)) {
+            const subConditions = conditionObject.and
+                .map((condition) => buildCondition(condition))
+                .filter(Boolean);
+            return subConditions.length ? and(...subConditions) : false;
+        }
+        // Handle nested OR conditions
+        if ('or' in conditionObject && Array.isArray(conditionObject.or)) {
+            const subConditions = conditionObject.or
+                .map((condition) => buildCondition(condition))
+                .filter(Boolean);
+            return subConditions.length ? or(...subConditions) : false;
+        }
+        // Handle id field for versioned collections
+        // if "id" inside the query it should refer to the root table
+        // record id not from the versions table
+        if (hasVersionsSuffix(slug) && 'id' in conditionObject) {
+            // Replace id with ownerId and keep the same operator and value
+            const idOperator = conditionObject.id;
+            delete conditionObject.id;
+            conditionObject.ownerId = idOperator;
+        }
+        // Handle regular field conditions
+        const [column, operatorObj] = Object.entries(conditionObject)[0];
+        const [operator, rawValue] = Object.entries(operatorObj)[0];
+        if (!isOperator(operator)) {
+            throw new RimeError(RimeError.INVALID_DATA, operator + 'is not supported');
+        }
+        // get the correct Drizzle operator
+        const fn = operators[operator];
+        // Format compared value to support Date, Arrays,...
+        const value = formatValue({ operator, value: rawValue });
+        // Convert dot notation to double underscore
+        // for fields included in groups or tabs
+        const sqlColumn = column.replace(/\./g, '__');
+        // Handle hierarchy fields (_parent, _position) in versioned collections
+        if (hasVersionsSuffix(slug) &&
+            (sqlColumn === '_parent' || sqlColumn === '_position' || sqlColumn === '_path')) {
+            // Get the root table name by removing the '_versions' suffix
+            const rootSlug = slug.replace('_versions', '');
+            const rootTable = getTable(rootSlug);
+            // Query the root table for the hierarchy field
+            return inArray(table.ownerId, db.select({ ownerId: rootTable.id }).from(rootTable).where(fn(rootTable[sqlColumn], value)));
+        }
+        // Handle regular fields
+        if (unlocalizedColumns.includes(sqlColumn)) {
+            return fn(table[sqlColumn], value);
+        }
+        // Handle localized fields
+        if (locale && localizedColumns.includes(sqlColumn)) {
+            return inArray(table.id, db
+                .select({ id: tableLocales.ownerId })
+                .from(tableLocales)
+                .where(and(fn(tableLocales[sqlColumn], value), eq(tableLocales.locale, locale))));
+        }
+        // Look for a relation field
+        // Get document config
+        const documentConfig = configCtx.getBySlug(slug);
+        if (!documentConfig) {
+            throw new Error(`${slug} not found (should never happen)`);
+        }
+        // Get the field config
+        const fieldConfig = getFieldConfigByPath(column, documentConfig.fields.map((f) => f.compile()));
+        if (!fieldConfig) {
+            // @TODO handle relation props ex: author.email
+            logger.warn(`the query contains the field "${column}", not found for ${documentConfig.slug} document`);
+            // Return a condition that will always be false instead of returning false
+            // This ensures no documents match when a non-existent field is queried
+            return eq(table.id, '-1'); // No document will have ID = -1, so this will always be false
+        }
+        // Not a relation
+        if (!isRelationField(fieldConfig)) {
+            logger.warn(`the query contains the field "${column}", not found for ${documentConfig.slug} document`);
+            // Return a condition that will always be false
+            return eq(table.id, '-1'); // No document will have ID = -1, so this will always be false
+        }
+        // Only compare with the relation ID for now
+        // @TODO handle relation props ex: author.email
+        const [to, localized] = [fieldConfig.relationTo, fieldConfig.localized];
+        const relationTableName = `${slug}Rels`;
+        const relationTable = getTable(relationTableName);
+        const conditions = [fn(relationTable[`${to}Id`], value)];
+        if (localized) {
+            conditions.push(eq(relationTable.locale, locale));
+        }
+        return inArray(table.id, db
+            .select({ id: relationTable.ownerId })
+            .from(relationTable)
+            .where(and(...conditions)));
+    };
+    return buildCondition(query.where);
+};
+const operators = {
+    equals: drizzleORM.eq,
+    not_equals: drizzleORM.ne,
+    in_array: drizzleORM.inArray,
+    like: drizzleORM.like,
+    ilike: drizzleORM.ilike,
+    between: drizzleORM.between,
+    not_between: drizzleORM.notBetween,
+    not_like: drizzleORM.notLike,
+    not_in_array: drizzleORM.notInArray,
+    is_not_null: drizzleORM.isNotNull,
+    is_null: drizzleORM.isNull,
+    less_than_or_equals: drizzleORM.lte,
+    less_than: drizzleORM.lt,
+    greater_than_or_equals: drizzleORM.gte,
+    greater_than: drizzleORM.gt
+};
+const isOperator = (str) => Object.keys(operators).includes(str);
+const formatValue = ({ operator, value }) => {
+    switch (true) {
+        case typeof value === 'string' &&
+            /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/.test(value):
+            return new Date(value);
+        case ['in_array', 'not_in_array'].includes(operator):
+            // Value is an array do nothing
+            if (Array.isArray(value))
+                return value;
+            // Handle string value with "," separators for url params
+            return value.split(',');
+        case ['like', 'ilike', 'not_like'].includes(operator):
+            return !value.includes('%') ? `%${value}%` : value;
+        default:
+            return value;
+    }
+};

package/dist/adapter-sqlite/with.d.ts

@@ -0,0 +1,9 @@
+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;