rimecms 0.31.4 → 0.32.0

package/dist/core/naming.js

@@ -1,86 +0,0 @@
-/**
- * Add a _directories suffix to a given name.
- * Used for uploads path slug and tables.
- * Prevent a version table name from being used, force the use of the main one.
- *
- * @example
- * // Returns both 'pages_directories'
- * withDirectoriesSuffix('pages');
- * withDirectoriesSuffix('pages_versions');
- */
-export const withDirectoriesSuffix = (slug) => `${slug.replace('_versions', '')}_directories`;
-/**
- * Remove a _directories suffix to a given name.
- * Used for uploads path slug and tables.
- * Prevent a version table name from being used, force the use of the main one.
- *
- * @example
- * // Returns 'pages'
- * withoutDirectoriesSuffix('pages_directories');
- * withoutDirectoriesSuffix('pages_versions_directories');
- */
-export const withoutDirectoriesSuffix = (slug) => slug.replace('_directories', '');
-/**
- * Add a _versions suffix to a given name.
- * Used for document versioning slug and tables.
- *
- * @example
- * // Returns 'pages_versions'
- * withVersionsSuffix('pages');
- */
-export const withVersionsSuffix = (name) => `${name}_versions`;
-/**
- * Remove a _versions suffix from a given name.
- * Used for document versioning slug and tables.
- *
- * @example
- * // Returns 'pages'
- * withoutVersionsSuffix('pages_versions');
- */
-export const withoutVersionsSuffix = (name) => name.replace('_versions', '');
-/**
- * Check if a slug is a verioned collection slug
- *  * @example
- * // Returns true
- * hasVersionsSuffix('pages_versions');
- *
- */
-export const hasVersionsSuffix = (slug) => slug.endsWith('_versions');
-/**
- * Check if a slug is a _directories collection slug
- *
- * @example
- * // Returns true
- * hasDirectoriesSuffix('medias_directories');
- */
-export const hasDirectoriesSuffix = (slug) => slug.endsWith('_directories');
-/**
- * Add a i18n suffix to a given name.
- * Used for localized tables name
- *
- * @example
- * // Returns 'pagesLocales'
- * withLocalesSuffix('pages');
- * // Returns 'pages_versionsLocales'
- * withLocalesSuffix('pages_versions');
- */
-export const withLocalesSuffix = (name) => `${name}Locales`;
-/**
- * Convert a kebab-case prototype slug.
- * Basically used to convert param matchers slug into a collection/area slug.
- * Only a literal trailing `_directories`/`_versions` suffix is preserved as a
- * suffix — everything else, including a plain `-versions`/`-directories`
- * word, is camelCased like any other segment.
- *
- * @example
- * prototypeKebabToSlug('my-collection') // returns 'myCollection'
- * prototypeKebabToSlug('my-collection_directories') // returns 'myCollection_directories'
- * prototypeKebabToSlug('my-collection_versions') // returns 'myCollection_versions'
- * prototypeKebabToSlug('my-collection-versions') // returns 'myCollectionVersions'
- */
-export const prototypeKebabToSlug = (kebab) => {
-    const suffixMatch = kebab.match(/(_(?:directories|versions))$/);
-    const suffix = suffixMatch ? suffixMatch[1] : '';
-    const base = suffix ? kebab.slice(0, -suffix.length) : kebab;
-    return base.replace(/-([a-z])/g, (_, char) => char.toUpperCase()) + suffix;
-};

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

@@ -1,15 +0,0 @@
-import type { GenericBlock } from '../../types/doc.js';
-import type { WithOptional } from '../../../util/types.js';
-import type { OperationContext } from '../hooks/index.server.js';
-type BlocksDiff = {
-    toAdd: WithOptional<GenericBlock, 'id'>[];
-    toDelete: GenericBlock[];
-    toUpdate: GenericBlock[];
-};
-type DefineBlocksDiffArgs = {
-    existingBlocks: GenericBlock[];
-    incomingBlocks: WithOptional<GenericBlock, 'id'>[];
-    context: OperationContext;
-};
-export declare function defineBlocksDiff({ existingBlocks, incomingBlocks, context }: DefineBlocksDiffArgs): BlocksDiff;
-export {};

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

@@ -1,82 +0,0 @@
-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]?.get.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

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

@@ -1,33 +0,0 @@
-import { normalizeFieldPath } from '../../../util/doc.js';
-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.use.isEmpty(value);
-            if (value && !isEmptyValue) {
-                value.forEach((block, index) => {
-                    if (block.type) {
-                        const cleanBlock = {
-                            ...block,
-                            path: normalizeFieldPath(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

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

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

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

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

@@ -1,6 +0,0 @@
-import type { FieldBuilder } from '../../fields/builders/field-builder.js';
-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: FieldBuilder<Field>[]) => ConfigMap;

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

@@ -1,54 +0,0 @@
-import { isFormField } from '../../fields/util.js';
-import { BlocksBuilder } from '../../../fields/blocks/index.js';
-import { GroupFieldBuilder } from '../../../fields/group/index.js';
-import { TabsBuilder } from '../../../fields/tabs/index.js';
-import { TreeBuilder } 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 (field instanceof TabsBuilder) {
-                for (const tab of field.get.tabs) {
-                    if (tab.name in data) {
-                        traverseData(data[tab.name], tab.get.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 (field instanceof BlocksBuilder && value && Array.isArray(value)) {
-                const blocks = value;
-                for (const [index, block] of blocks.entries()) {
-                    try {
-                        const blockConfig = field.get.blocks.find((b) => b.name === block.type);
-                        if (blockConfig) {
-                            traverseData(block, blockConfig.get.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 (field instanceof TreeBuilder && value && Array.isArray(value)) {
-                const treeMap = buildTreeFieldsMap(field, value, path);
-                map = { ...map, ...treeMap };
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                traverseData(value, field.get.fields, path);
-            }
-        }
-    };
-    traverseData(data, incomingFields, '');
-    return map;
-};

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

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

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

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

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

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

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

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

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