rimecms 0.22.0

package/dist/core/operations/blocks/diff.server.js

@@ -0,0 +1,82 @@
+import { RimeError } from '../../errors/index.js';
+// Utility to filter out blocks that haven't id
+const blockHasId = (b) => !!b.id;
+export function defineBlocksDiff({ existingBlocks, incomingBlocks, context }) {
+    const configMap = context.configMap;
+    if (!configMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @defineBlocksDiff');
+    // On fallback locale :
+    // - If a block is localized, it should not keep its id so a new one is created
+    // - If a block is not localized than it should keep its id so block is updated
+    if (context.isFallbackLocale) {
+        incomingBlocks = incomingBlocks.map((block) => {
+            const isLocalized = configMap[block.path]?.localized || false;
+            if (isLocalized) {
+                delete block.id;
+                block.locale = context.isFallbackLocale;
+            }
+            return block;
+        });
+    }
+    /////////////////////////////////////////////
+    // Handle add diff
+    //////////////////////////////////////////////
+    // Consider blocks as new if they have temp ID OR no ID at all
+    const toAdd = incomingBlocks.filter((block) => !block.id || block.id.startsWith('temp-'));
+    /////////////////////////////////////////////
+    // Handle delete diff
+    //////////////////////////////////////////////
+    // Consider block to be deleted if its id is not present in incomingBlocks
+    // Note: Existing blocks have been filtered before diff
+    // by removing elements with a path not present in incoming data,
+    // in order to not delete unmodified blocks fields
+    const toDelete = existingBlocks.filter((existing) => {
+        return !incomingBlocks.filter(blockHasId).some((newBlock) => {
+            // Only compare blocks that have real IDs
+            if (newBlock.id.startsWith('temp-'))
+                return false;
+            return newBlock.id === existing.id;
+        });
+    });
+    /////////////////////////////////////////////
+    // Handle update diff
+    //////////////////////////////////////////////
+    // Consider a block that need update :
+    // if its id is present in existing blocks and
+    // if they didn't share same (normalized) props
+    /**
+     * Compare two potential equals block
+     * based on prop normalization and JSON comparaison
+     */
+    function isEqualValues(old, incoming) {
+        // Remove nested blocks to compare block values
+        const normalizeForComparison = (block) => {
+            return Object.entries(block).reduce((acc, [key, value]) => {
+                if (Array.isArray(value) && value[0]?.type) {
+                    return acc;
+                }
+                return { ...acc, [key]: value };
+            }, {});
+        };
+        // Compare
+        const normalizedOld = normalizeForComparison(old);
+        const normalizedNew = normalizeForComparison(incoming);
+        return JSON.stringify(normalizedOld) === JSON.stringify(normalizedNew);
+    }
+    /**
+     * Check wether a block need to be updated
+     */
+    function needUpdate(newBlock) {
+        // Skip blocks with temp IDs
+        if (newBlock.id.startsWith('temp-'))
+            return false;
+        // Check in incomming block if one has the same id than this one
+        const existing = existingBlocks.find((e) => e.id === newBlock.id);
+        if (!existing)
+            return false;
+        // return comparaison
+        return !isEqualValues(existing, newBlock);
+    }
+    const toUpdate = incomingBlocks.filter(blockHasId).filter(needUpdate);
+    return { toAdd, toDelete, toUpdate };
+}

package/dist/core/operations/blocks/extract.server.d.ts

@@ -0,0 +1,9 @@
+import type { GenericBlock } from '../../types/doc.js';
+import type { Dic } from '../../../util/types.js';
+import type { ConfigMap } from '../configMap/types.js';
+type ExtractBlocksArgs = {
+    data: Dic;
+    configMap: ConfigMap;
+};
+export declare function extractBlocks({ data, configMap }: ExtractBlocksArgs): GenericBlock[];
+export {};

package/dist/core/operations/blocks/extract.server.js

@@ -0,0 +1,32 @@
+import { getValueAtPath } from '../../../util/object.js';
+export function extractBlocks({ data, configMap }) {
+    const blocks = [];
+    Object.entries(configMap).forEach(([path, config]) => {
+        if (config.type === 'blocks') {
+            const value = getValueAtPath(path, data);
+            const isEmptyValue = config.isEmpty(value);
+            if (value && !isEmptyValue) {
+                value.forEach((block, index) => {
+                    if (block.type) {
+                        const cleanBlock = {
+                            ...block,
+                            path: block.path || path,
+                            position: block.position ?? index
+                        };
+                        // Remove children blocks
+                        const finalBlock = Object.entries(cleanBlock).reduce((acc, [key, value]) => {
+                            const nestedPath = `${path}.${index}.${key}`;
+                            if (configMap[nestedPath]?.type === 'blocks') {
+                                return acc;
+                            }
+                            // @TODO should maybe remove tree also
+                            return { ...acc, [key]: value };
+                        }, {});
+                        blocks.push(finalBlock);
+                    }
+                });
+            }
+        }
+    });
+    return blocks;
+}

package/dist/core/operations/blocks/index.server.d.ts

@@ -0,0 +1,26 @@
+import type { Adapter } from '../../../adapter-sqlite/index.server.js';
+import type { BuiltArea, BuiltCollection } from '../../config/types.js';
+import type { GenericBlock } from '../../types/doc.js';
+import type { Dic } from '../../../util/types.js';
+import type { OperationContext } from '../hooks/index.server.js';
+/**
+ * Saves blocks to the database by comparing incoming blocks with existing ones
+ * and performing create, update, and delete operations as needed.
+ *
+ * This function handles the complete lifecycle of block persistence:
+ * 1. Extract blocks from form data
+ * 2. Compare with existing blocks to determine changes
+ * 3. Execute database operations (create/update/delete)
+ */
+export declare const saveBlocks: (args: {
+    context: OperationContext;
+    ownerId: string;
+    data: Dic;
+    incomingPaths: string[];
+    adapter: Adapter;
+    config: BuiltArea | BuiltCollection;
+}) => Promise<{
+    toAdd: import("../../../util/types.js").WithOptional<GenericBlock, "id">[];
+    toDelete: GenericBlock[];
+    toUpdate: GenericBlock[];
+}>;

package/dist/core/operations/blocks/index.server.js

@@ -0,0 +1,71 @@
+import { RimeError } from '../../errors/index.js';
+import { withVersionsSuffix } from '../../naming.js';
+import { defineBlocksDiff } from './diff.server.js';
+import { extractBlocks } from './extract.server.js';
+/**
+ * Saves blocks to the database by comparing incoming blocks with existing ones
+ * and performing create, update, and delete operations as needed.
+ *
+ * This function handles the complete lifecycle of block persistence:
+ * 1. Extract blocks from form data
+ * 2. Compare with existing blocks to determine changes
+ * 3. Execute database operations (create/update/delete)
+ */
+export const saveBlocks = async (args) => {
+    //
+    const { context, ownerId, data, incomingPaths, adapter, config } = args;
+    const { locale } = context.params;
+    const { originalDoc: original, configMap, originalConfigMap } = context;
+    if (!configMap || !ownerId)
+        throw new RimeError(RimeError.OPERATION_ERROR, '@saveBlocks');
+    // Determine the correct table name based on versioning configuration
+    const parentTable = config.versions ? withVersionsSuffix(config.slug) : config.slug;
+    // Extract all blocks from the incoming form data using the current config
+    const incomingBlocks = extractBlocks({
+        data,
+        configMap
+    });
+    let existingBlocks = [];
+    // If we have an original document (i.e., this is an update operation)
+    if (original) {
+        if (!originalConfigMap)
+            throw new RimeError(RimeError.OPERATION_ERROR, 'missing original');
+        // Extract blocks from the original document using its config
+        const blocks = extractBlocks({
+            data: original,
+            configMap: originalConfigMap
+        });
+        // Only consider existing blocks that are in paths being updated
+        // This optimization prevents deletion of blocks in unmodified form sections
+        // For example, if only "content.hero" was modified, we don't want to
+        // accidentally delete blocks in "content.footer"
+        existingBlocks = blocks.filter((block) => {
+            return incomingPaths.some((path) => block.path?.startsWith(path));
+        });
+    }
+    // Calculate what blocks need to be added, updated, or deleted
+    // This handles localization logic and compares block properties
+    const blocksDiff = defineBlocksDiff({
+        existingBlocks,
+        incomingBlocks,
+        context
+    });
+    // Execute delete operations first to avoid potential conflicts
+    if (blocksDiff.toDelete.length) {
+        await Promise.all(blocksDiff.toDelete.map((block) => adapter.blocks.delete({ parentSlug: parentTable, block })));
+    }
+    // Create new blocks (blocks without IDs or with temporary IDs)
+    if (blocksDiff.toAdd.length) {
+        await Promise.all(blocksDiff.toAdd.map((block) => adapter.blocks.create({
+            parentSlug: parentTable,
+            ownerId,
+            block,
+            locale
+        })));
+    }
+    // Update existing blocks that have changed properties
+    if (blocksDiff.toUpdate.length) {
+        await Promise.all(blocksDiff.toUpdate.map((block) => adapter.blocks.update({ parentSlug: parentTable, block, locale: locale })));
+    }
+    return blocksDiff;
+};

package/dist/core/operations/configMap/buildTreeMap.d.ts

@@ -0,0 +1,3 @@
+import type { TreeFieldRaw } from '../../../fields/tree/index.js';
+import type { ConfigMap } from './types.js';
+export declare function buildTreeFieldsMap(treeConfig: TreeFieldRaw, treeItems: any[], basePath: string): ConfigMap;

package/dist/core/operations/configMap/buildTreeMap.js

@@ -0,0 +1,30 @@
+import { isFormField } from '../../fields/util.js';
+export function buildTreeFieldsMap(treeConfig, treeItems, basePath) {
+    const treeMap = {};
+    // Helper to add field configs for a specific path
+    const addFieldConfigs = (path) => {
+        for (const field of treeConfig.fields) {
+            if (isFormField(field)) {
+                treeMap[`${path}.${field.name}`] = field;
+            }
+        }
+    };
+    // Process each item in the tree
+    const processItem = (item, itemPath) => {
+        // Add configs for current item
+        addFieldConfigs(itemPath);
+        // If item has children, process them
+        if (item._children && Array.isArray(item._children)) {
+            item._children.forEach((child, childIndex) => {
+                const childPath = `${itemPath}._children.${childIndex}`;
+                processItem(child, childPath);
+            });
+        }
+    };
+    // Process each root level item
+    treeItems.forEach((item, index) => {
+        const itemPath = `${basePath}.${index}`;
+        processItem(item, itemPath);
+    });
+    return treeMap;
+}

package/dist/core/operations/configMap/index.d.ts

@@ -0,0 +1,5 @@
+import type { GenericDoc } from '../../types/doc.js';
+import type { Field } from '../../../fields/types.js';
+import type { DeepPartial } from '../../../util/types.js';
+import type { ConfigMap } from './types.js';
+export declare const buildConfigMap: (data: DeepPartial<GenericDoc>, incomingFields: Field[]) => ConfigMap;

package/dist/core/operations/configMap/index.js

@@ -0,0 +1,54 @@
+import { isFormField } from '../../fields/util.js';
+import { isBlocksFieldRaw } from '../../../fields/blocks/index.js';
+import { isGroupFieldRaw } from '../../../fields/group/index.js';
+import { isTabsFieldRaw } from '../../../fields/tabs/index.js';
+import { isTreeFieldRaw } from '../../../fields/tree/index.js';
+import { buildTreeFieldsMap } from './buildTreeMap.js';
+export const buildConfigMap = (data, incomingFields) => {
+    let map = {};
+    const traverseData = (data, fields, basePath) => {
+        if (!data)
+            return;
+        basePath = basePath === '' ? basePath : `${basePath}.`;
+        for (const field of fields) {
+            if (isTabsFieldRaw(field)) {
+                for (const tab of field.tabs) {
+                    if (tab.name in data) {
+                        traverseData(data[tab.name], tab.fields, tab.name);
+                    }
+                }
+                continue;
+            }
+            if (!isFormField(field))
+                continue;
+            if (!(field.name in data))
+                continue;
+            const value = data[field.name];
+            const path = `${basePath}${field.name}`;
+            map[path] = field;
+            if (isBlocksFieldRaw(field) && value && Array.isArray(value)) {
+                const blocks = value;
+                for (const [index, block] of blocks.entries()) {
+                    try {
+                        const blockConfig = field.blocks.find((b) => b.name === block.type);
+                        if (blockConfig) {
+                            traverseData(block, blockConfig.fields, `${path}.${index}`);
+                        }
+                    }
+                    catch {
+                        console.warn(`block at path ${path} and postition ${index} not found but there are some residual data owned by this block`);
+                    }
+                }
+            }
+            else if (isTreeFieldRaw(field) && value && Array.isArray(value)) {
+                const treeMap = buildTreeFieldsMap(field, value, path);
+                map = { ...map, ...treeMap };
+            }
+            else if (isGroupFieldRaw(field)) {
+                traverseData(value, field.fields, path);
+            }
+        }
+    };
+    traverseData(data, incomingFields, '');
+    return map;
+};

package/dist/core/operations/configMap/types.d.ts

@@ -0,0 +1,2 @@
+import type { FormField } from '../../../fields/types.js';
+export type ConfigMap = Record<string, FormField>;

package/dist/core/operations/configMap/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/operations/extract-data.server.d.ts

@@ -0,0 +1,37 @@
+import type { GenericDoc } from '../types/doc.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Extracts data from a request based on its content type
+ * Handles both multipart/form-data, form-urlencoded and JSON requests
+ *
+ * @example
+ * // In a route handler
+ * const [error, data] = await trycatch(() => extractData(event.request));
+ * if (error) {
+ *   return handleError(error, { context: 'api' });
+ * }
+ */
+export declare const extractData: <T extends Record<string, any>>(request: RequestEvent["request"]) => Promise<T>;
+/**
+ * Converts FormData to a structured document object
+ * Normalizes form values and handles flattened key structures
+ *
+ * @example
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.active', 'true');
+ * const data = formDataToData(formData);
+ * // Result: { user: { name: 'John', active: true } }
+ */
+export declare const formDataToData: (formData: FormData) => GenericDoc;
+/**
+ * Converts a JSON object to a structured document object
+ * Normalizes values and ensures consistent data structure
+ *
+ * @example
+ * const jsonData = { user: { name: 'John', active: 'true' } };
+ * const data = jsonDataToData(jsonData);
+ * // Result: { user: { name: 'John', active: true } }
+ */
+export declare const jsonDataToData: (jsonData: Dic) => GenericDoc;

package/dist/core/operations/extract-data.server.js

@@ -0,0 +1,101 @@
+import { RimeFormError } from '../errors/index.js';
+import { flatten, unflatten } from 'flat';
+/**
+ * Extracts data from a request based on its content type
+ * Handles both multipart/form-data, form-urlencoded and JSON requests
+ *
+ * @example
+ * // In a route handler
+ * const [error, data] = await trycatch(() => extractData(event.request));
+ * if (error) {
+ *   return handleError(error, { context: 'api' });
+ * }
+ */
+export const extractData = async (request) => {
+    let data;
+    try {
+        const contentType = request.headers.get('content-type');
+        const isMultiPartFormData = contentType?.startsWith('multipart/form-data');
+        const isFormURLEncoded = contentType?.startsWith('application/x-www-form-urlencoded');
+        if (isMultiPartFormData || isFormURLEncoded) {
+            /** Handle formData input */
+            const formData = await request.formData();
+            data = formDataToData(formData);
+        }
+        else {
+            /** Handle JSON input */
+            const jsonData = await request.json();
+            data = jsonDataToData(jsonData);
+        }
+    }
+    catch (err) {
+        throw new RimeFormError({ _form: err.message });
+    }
+    return data;
+};
+/**
+ * Converts FormData to a structured document object
+ * Normalizes form values and handles flattened key structures
+ *
+ * @example
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.active', 'true');
+ * const data = formDataToData(formData);
+ * // Result: { user: { name: 'John', active: true } }
+ */
+export const formDataToData = (formData) => {
+    const flatData = Object.fromEntries(formData.entries());
+    for (const key of Object.keys(flatData)) {
+        flatData[key] = normalizeValue(flatData[key]);
+    }
+    return unflatten(flatData);
+};
+/**
+ * Converts a JSON object to a structured document object
+ * Normalizes values and ensures consistent data structure
+ *
+ * @example
+ * const jsonData = { user: { name: 'John', active: 'true' } };
+ * const data = jsonDataToData(jsonData);
+ * // Result: { user: { name: 'John', active: true } }
+ */
+export const jsonDataToData = (jsonData) => {
+    const flatData = flatten(jsonData);
+    for (const key of Object.keys(flatData)) {
+        flatData[key] = normalizeValue(flatData[key]);
+    }
+    return unflatten(flatData);
+};
+/**
+ * Normalizes string values to appropriate types
+ * Converts 'true'/'false' strings to boolean values
+ * Handles null values and numeric conversions
+ */
+const normalizeValue = (value) => {
+    if (value === 'false' || value === 'true') {
+        return value === 'true';
+    }
+    if (value === 'null') {
+        return null;
+    }
+    if (value === 'undefined') {
+        return undefined;
+    }
+    if (value === '[]') {
+        return [];
+    }
+    // For time values return raw value
+    if (/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/.test(value)) {
+        return value;
+    }
+    // For integers parseInt
+    if (/^[\d]+$/.test(value)) {
+        return parseInt(value);
+    }
+    // For floats parseFloat
+    if (/^[\d]+\.[\d]+$/.test(value)) {
+        return parseFloat(value);
+    }
+    return value;
+};

package/dist/core/operations/hooks/before-create/merge-with-blank.server.d.ts

@@ -0,0 +1 @@
+export declare const mergeWithBlankDocument: import("../index.server.js").Hook<"raw", "create", "before">;

package/dist/core/operations/hooks/before-create/merge-with-blank.server.js

@@ -0,0 +1,24 @@
+import { isUploadConfig } from '../../../collections/upload/util/config.js';
+import { createBlankDocument } from '../../../../util/doc.js';
+import deepmerge from 'deepmerge';
+import { Hooks } from '../index.server.js';
+export const mergeWithBlankDocument = Hooks.beforeCreate(async (args) => {
+    const { config } = args;
+    const data = args.data;
+    let file;
+    if (config.type === 'collection' && isUploadConfig(config) && 'file' in data) {
+        file = data.file;
+        delete data.file;
+    }
+    const dataMergedWithBlankDocument = deepmerge(createBlankDocument(config, args.event), data, {
+        arrayMerge: (_, y) => y
+    });
+    // Add file after merge
+    if (file) {
+        dataMergedWithBlankDocument.file = file;
+    }
+    return {
+        ...args,
+        data: dataMergedWithBlankDocument
+    };
+});

package/dist/core/operations/hooks/before-operation/authorize.server.d.ts

@@ -0,0 +1 @@
+export declare const authorize: import("../index.server.js").HookBeforeOperation<"raw", import("../index.server.js").Operation>;

package/dist/core/operations/hooks/before-operation/authorize.server.js

@@ -0,0 +1,32 @@
+import { RimeError } from '../../../errors/index.js';
+import { logger } from '../../../logger/index.server.js';
+import { Hooks } from '../index.server.js';
+export const authorize = Hooks.beforeOperation(async (args) => {
+    const { config, event, operation, context } = args;
+    let authorized = false;
+    const params = {
+        event,
+        id: context.params.id
+    };
+    if (args.context.isSystemOperation)
+        return args;
+    switch (operation) {
+        case 'create':
+            authorized = config.access.create(event.locals.user, params);
+            break;
+        case 'read':
+            authorized = config.access.read(event.locals.user, params);
+            break;
+        case 'update':
+            authorized = config.access.update(event.locals.user, params);
+            break;
+        case 'delete':
+            authorized = config.access.delete(event.locals.user, params);
+            break;
+    }
+    if (!authorized) {
+        logger.error(RimeError.UNAUTHORIZED);
+        throw new RimeError(RimeError.UNAUTHORIZED);
+    }
+    return args;
+});

package/dist/core/operations/hooks/before-read/populate-url.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook to populate _children property on document from a nested collection
+ */
+export declare const populateURL: import("../index.server.js").Hook<"generic", "read", "before">;

package/dist/core/operations/hooks/before-read/populate-url.server.js

@@ -0,0 +1,99 @@
+import { logger } from '../../../logger/index.server.js';
+import { getValueAtPath } from '../../../../util/object.js';
+import { Hooks } from '../index.server.js';
+/**
+ * Hook to populate _children property on document from a nested collection
+ */
+export const populateURL = Hooks.beforeRead(async (args) => {
+    const select = args.context.params.select && Array.isArray(args.context.params.select)
+        ? args.context.params.select
+        : [];
+    const HAS_SELECT = select.length > 0;
+    // If there is a select param, populate url only if included
+    if (HAS_SELECT)
+        return args;
+    // Else populate url
+    const { config, event, context } = args;
+    const locale = context.params.locale;
+    const document = args.doc;
+    if (config.$url) {
+        let url;
+        try {
+            url = config.$url(document);
+        }
+        catch (err) {
+            logger.error(`Error while generating url of ${config.slug} with id: ${args.doc.id}, ${err.message}`);
+            return args;
+        }
+        const match = url.match(/\[\.\.\.parent\.(\w+(?:\.\w+)*)\]/);
+        if (match) {
+            const fullMatch = match[0];
+            const attributePath = match[1];
+            // Create array to store parent attributes
+            const attributesArray = [];
+            const MAX_DEPTH = 6;
+            let depth = 0;
+            let parent = document._parent;
+            while (parent && depth < MAX_DEPTH) {
+                depth++;
+                const docs = await event.locals.rime.collection(config.slug).find({
+                    query: `where[id][equals]=${parent}`,
+                    select: [attributePath, '_parent'],
+                    locale
+                });
+                // Check if there is a result
+                if (docs && docs.length > 0) {
+                    const parentDoc = docs[0];
+                    const parentAttribute = getValueAtPath(attributePath, parentDoc);
+                    if (parentAttribute && typeof parentAttribute === 'string') {
+                        attributesArray.push(parentAttribute);
+                    }
+                    else if (parentAttribute) {
+                        logger.warn('Bad URL property: not a string', { attributePath, parentAttribute });
+                    }
+                    // Move up to the next parent
+                    parent = parentDoc._parent;
+                }
+                else {
+                    parent = null;
+                }
+            }
+            if (attributesArray.length) {
+                // Replace the parent reference with the joined attributes
+                url = url.replace(fullMatch, attributesArray.reverse().join('/'));
+            }
+            else {
+                url = url.replace('/' + fullMatch, '');
+            }
+        }
+        else {
+            // replace "/[...parent.whatever.something.foo]" with ""
+            url = url.replace(/\/\[\.\.\.parent\.\w+(?:\.\w+)*\]/, '');
+        }
+        if (!url) {
+            return args;
+        }
+        if (url.includes('undefined')) {
+            logger.warn('Missing document properties to generate URL for : ' + document.id);
+            return args;
+        }
+        // Add the url if successfully generated
+        if (url) {
+            if (args.doc.url !== url) {
+                args.event.locals.rime.adapter.updateDocumentUrl(url, {
+                    id: args.doc.id,
+                    versionId: args.doc.versionId,
+                    config,
+                    locale
+                });
+            }
+            args.doc = { ...args.doc, url };
+        }
+        // Add the live url if needed
+        if (config.live && event.locals.user && url) {
+            args.doc._live = `${process.env.PUBLIC_RIME_URL}/live?src=${url}&slug=${config.slug}&id=${args.doc.id}`;
+            args.doc._live += locale ? `&locale=${locale}` : '';
+        }
+    }
+    return args;
+});

package/dist/core/operations/hooks/before-read/process-document-fields.server.d.ts

@@ -0,0 +1 @@
+export declare const processDocumentFields: import("../index.server.js").Hook<"raw", "read", "before">;