rimecms 0.22.0

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

@@ -0,0 +1,62 @@
+import { logger } from '../../../logger/index.server.js';
+import { deleteValueAtPath, getValueAtPath, hasProp, setValueAtPath } from '../../../../util/object.js';
+import { buildConfigMap } from '../../configMap/index.js';
+import { getDefaultValue } from '../before-upsert/set-default-values.server.js';
+import { Hooks } from '../index.server.js';
+export const processDocumentFields = Hooks.beforeRead(async (args) => {
+    const { event } = args;
+    let doc = args.doc;
+    const configMap = buildConfigMap(doc, args.config.fields.map((f) => f.compile()));
+    for (const [key, config] of Object.entries(configMap)) {
+        let value = getValueAtPath(key, doc);
+        let isEmpty;
+        try {
+            isEmpty = config.isEmpty(value);
+        }
+        catch {
+            isEmpty = false;
+            logger.warn(`Error in config.isEmpty for field ${key}`);
+        }
+        if (isEmpty && hasProp('defaultValue', config)) {
+            value = await getDefaultValue({ key, config, adapter: args.event.locals.rime.adapter });
+            doc = setValueAtPath(key, doc, value);
+        }
+        if (config.type === 'blocks') {
+            const value = getValueAtPath(key, doc);
+            // Filter out possible undefined block or residual
+            // Case undefined : When in dev mode, if a block table is deleted in a migration, a blocks array value could includes undefined ex :
+            // * blocks: [ { ... }, undefined, { ... } ]
+            // * Because blocks are populated based on path.position
+            // Case residual : a block type has been removed but was including a relation, this gives ex :
+            // * blocks: [ { id:..., values,... }, { image: {...}} ]
+            //                                         ^
+            // * the image has been placed but the block doesn't exist anymore
+            if (value) {
+                const withoutResidualBlock = value
+                    .filter((b) => b && 'id' in b) // get only blocks that have .id
+                    .map((b, index) => ({
+                    ...b,
+                    position: index
+                }));
+                doc = setValueAtPath(key, doc, withoutResidualBlock);
+            }
+        }
+        if (config.access && config.access.read) {
+            const authorized = config.access.read(event.locals.user);
+            if (!authorized) {
+                doc = deleteValueAtPath(doc, key);
+                continue;
+            }
+        }
+        if (config.hooks?.beforeRead) {
+            let value = getValueAtPath(key, doc);
+            if (value) {
+                for (const hook of config.hooks.beforeRead) {
+                    value = await hook(value, { event, config, operation: args.context, documentId: doc.id });
+                    doc = setValueAtPath(key, doc, value);
+                }
+            }
+        }
+    }
+    return { ...args, doc };
+});

package/dist/core/operations/hooks/before-read/set-document-locale.server.d.ts

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

package/dist/core/operations/hooks/before-read/set-document-locale.server.js

@@ -0,0 +1,15 @@
+import { Hooks } from '../index.server.js';
+export const setDocumentLocale = Hooks.beforeRead(async (args) => {
+    let doc = args.doc;
+    // Set doc.locale only if :
+    // - locale is defined meaning that the config has a localized prop
+    // AND
+    // - the 'select' param includes 'locale' or no 'select' param at all
+    const hasSelect = Array.isArray(args.context.params.select) && args.context.params.select.length;
+    const locale = args.context.params.locale || args.event.locals.locale;
+    const shouldSetLocale = locale && !doc.locale && (!hasSelect || args.context.params.select?.includes('locale'));
+    if (shouldSetLocale) {
+        doc = { ...doc, locale: args.event.locals.locale };
+    }
+    return { ...args, doc };
+});

package/dist/core/operations/hooks/before-read/set-document-thumbnail.server.d.ts

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

package/dist/core/operations/hooks/before-read/set-document-thumbnail.server.js

@@ -0,0 +1,34 @@
+import { isRelationResolved } from '../../../../fields/relation/index.js';
+import {} from '../../../../types.js';
+import { getValueAtPath } from '../../../../util/object.js';
+import { Hooks } from '../index.server.js';
+export const setDocumentThumbnail = Hooks.beforeRead(async (args) => {
+    const config = args.config;
+    let doc = args.doc;
+    const hasThumbnail = (c) => {
+        return config.type === 'collection' && !!config.asThumbnail;
+    };
+    const paramSelect = args.context.params.select;
+    const hasSelect = Array.isArray(paramSelect) && paramSelect.length;
+    const shouldSetThumbnail = hasThumbnail(config) &&
+        !doc._thumbnail &&
+        (!hasSelect || (hasSelect && paramSelect.includes('_thumbnail')));
+    if (shouldSetThumbnail) {
+        const relationValue = getValueAtPath(config.asThumbnail, doc);
+        if (!relationValue)
+            return args;
+        const unwraped = Array.isArray(relationValue) ? relationValue[0] : relationValue;
+        if (typeof unwraped === 'string')
+            return args;
+        const relationResolved = isRelationResolved(unwraped)
+            ? unwraped
+            : await args.event.locals.rime
+                .collection(unwraped.relationTo)
+                .findById({ id: unwraped.documentId });
+        doc = {
+            _thumbnail: relationResolved._thumbnail,
+            ...doc
+        };
+    }
+    return { ...args, doc };
+});

package/dist/core/operations/hooks/before-read/set-document-title.server.d.ts

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

package/dist/core/operations/hooks/before-read/set-document-title.server.js

@@ -0,0 +1,16 @@
+import { getValueAtPath } from '../../../../util/object.js';
+import { Hooks } from '../index.server.js';
+export const setDocumentTitle = Hooks.beforeRead(async (args) => {
+    const config = args.config;
+    let doc = args.doc;
+    const paramSelect = args.context.params.select;
+    const hasSelect = Array.isArray(paramSelect) && paramSelect.length;
+    const shouldSetTitle = !doc.title && (!hasSelect || (hasSelect && paramSelect.includes('title')));
+    if (shouldSetTitle) {
+        doc = {
+            title: getValueAtPath(config.asTitle, doc),
+            ...doc
+        };
+    }
+    return { ...args, doc };
+});

package/dist/core/operations/hooks/before-read/set-document-type.server.d.ts

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

package/dist/core/operations/hooks/before-read/set-document-type.server.js

@@ -0,0 +1,14 @@
+import { Hooks } from '../index.server.js';
+export const setDocumentType = Hooks.beforeRead(async (args) => {
+    const config = args.config;
+    let doc = args.doc;
+    const hasSelect = Array.isArray(args.context.params.select) && args.context.params.select.length;
+    if (!hasSelect) {
+        doc = {
+            ...doc,
+            _prototype: config.type,
+            _type: config.slug
+        };
+    }
+    return { ...args, doc };
+});

package/dist/core/operations/hooks/before-read/sort-document-props.server.d.ts

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

package/dist/core/operations/hooks/before-read/sort-document-props.server.js

@@ -0,0 +1,61 @@
+import { isObjectLiteral } from '../../../../util/object.js';
+import { Hooks } from '../index.server.js';
+export const sortDocumentProps = Hooks.beforeRead(async (args) => {
+    return { ...args, doc: sortDocumentKeys(args.doc) };
+});
+function sortDocumentKeys(obj) {
+    const specificOrder = ['id', 'title', 'status'];
+    const endOrder = [
+        'locale',
+        'path',
+        'position',
+        'ownerId',
+        'createdAt',
+        'updatedAt',
+        '_type',
+        '_prototype',
+        '_live',
+        '_children',
+        '_parent',
+        '_position'
+    ];
+    function sortObjectKeys(obj) {
+        // If not an object or is null, return the value as-is
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        // If array, process each object in the array
+        if (Array.isArray(obj)) {
+            return obj.map((item) => (typeof item === 'object' ? sortObjectKeys(item) : item));
+        }
+        // Sort the keys
+        const keys = Object.keys(obj).sort((a, b) => {
+            const aIndexSpecific = specificOrder.indexOf(a);
+            const bIndexSpecific = specificOrder.indexOf(b);
+            const aIndexEnd = endOrder.indexOf(a);
+            const bIndexEnd = endOrder.indexOf(b);
+            if (aIndexSpecific !== -1 && bIndexSpecific !== -1) {
+                return aIndexSpecific - bIndexSpecific;
+            }
+            if (aIndexEnd !== -1 && bIndexEnd !== -1) {
+                return aIndexEnd - bIndexEnd;
+            }
+            if (aIndexSpecific !== -1)
+                return -1;
+            if (bIndexSpecific !== -1)
+                return 1;
+            if (aIndexEnd !== -1)
+                return 1;
+            if (bIndexEnd !== -1)
+                return -1;
+            return a.localeCompare(b);
+        });
+        // Create new object with sorted keys
+        const sorted = {};
+        keys.forEach((key) => {
+            const shouldOrder = Array.isArray(obj[key]) || isObjectLiteral(obj[key]);
+            sorted[key] = shouldOrder ? sortObjectKeys(obj[key]) : obj[key];
+        });
+        return sorted;
+    }
+    return sortObjectKeys(obj);
+}

package/dist/core/operations/hooks/before-update/define-version-operation.server.d.ts

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

package/dist/core/operations/hooks/before-update/define-version-operation.server.js

@@ -0,0 +1,18 @@
+import { defineVersionUpdateOperation } from '../../../collections/versions/operations.js';
+import { Hooks } from '../index.server.js';
+export const defineVersionOperation = Hooks.beforeUpdate(async (args) => {
+    const { config } = args;
+    // Define the kind of update operation depending on versions config
+    const versionOperation = defineVersionUpdateOperation({
+        draft: args.context.params.draft,
+        versionId: args.context.params.versionId,
+        config
+    });
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            versionOperation
+        }
+    };
+});

package/dist/core/operations/hooks/before-update/get-original-document.server.d.ts

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

package/dist/core/operations/hooks/before-update/get-original-document.server.js

@@ -0,0 +1,37 @@
+import { VersionOperations } from '../../../collections/versions/operations.js';
+import { RimeError } from '../../../errors/index.js';
+import { Hooks } from '../index.server.js';
+export const getOriginalDocument = Hooks.beforeUpdate(async (args) => {
+    const { event, config, context } = args;
+    const { rime } = event.locals;
+    let original;
+    if (!context.versionOperation)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing versionOperation @getOriginalDocument');
+    switch (config.type) {
+        //
+        case 'collection':
+            if (!context.params.id)
+                throw new RimeError(RimeError.OPERATION_ERROR, 'missing id @getOriginalDocument');
+            original = await rime.collection(config.slug).findById({
+                locale: context.params.locale,
+                id: context.params.id,
+                versionId: context.params.versionId,
+                draft: VersionOperations.shouldRetrieveDraft(context.versionOperation)
+            });
+            break;
+        case 'area':
+            original = await rime.area(config.slug).find({
+                locale: context.params.locale,
+                versionId: context.params.versionId,
+                draft: VersionOperations.shouldRetrieveDraft(context.versionOperation)
+            });
+            break;
+    }
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            originalDoc: original
+        }
+    };
+});

package/dist/core/operations/hooks/before-upsert/data-config-map.server.d.ts

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

package/dist/core/operations/hooks/before-upsert/data-config-map.server.js

@@ -0,0 +1,12 @@
+import { buildConfigMap } from '../../configMap/index.js';
+import { Hooks } from '../index.server.js';
+export const buildDataConfigMap = Hooks.beforeUpsert(async (args) => {
+    const configMap = buildConfigMap(args.data, args.config.fields.map((f) => f.compile()));
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            configMap
+        }
+    };
+});

package/dist/core/operations/hooks/before-upsert/handle-new-version.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles version-related operations for document updates
+ * Manages specific version updates and new version creation
+ */
+export declare const handleNewVersion: import("../index.server.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/operations/hooks/before-upsert/handle-new-version.server.js

@@ -0,0 +1,94 @@
+import { filePathToFile } from '../../../collections/upload/util/converter.js';
+import { VersionOperations } from '../../../collections/versions/operations.js';
+import { VERSIONS_STATUS } from '../../../constant.js';
+import { RimeError } from '../../../errors/index.js';
+import { withVersionsSuffix } from '../../../naming.js';
+import path from 'path';
+import { fallbackDataFromOriginal } from '../../shared/fallback-data-from-original.js';
+import { Hooks } from '../index.server.js';
+/**
+ * Handles version-related operations for document updates
+ * Manages specific version updates and new version creation
+ */
+export const handleNewVersion = Hooks.beforeUpsert(async (args) => {
+    const { config, event } = args;
+    const { rime } = event.locals;
+    const { versionOperation, originalDoc, originalConfigMap, params } = args.context;
+    if (!originalConfigMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalConfigMap @handleNewVersion');
+    if (!originalDoc)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @handleNewVersion');
+    if (!versionOperation)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing versionOperation @handleNewVersion');
+    let versionId;
+    let data;
+    switch (true) {
+        case VersionOperations.isSpecificVersionUpdate(versionOperation):
+            versionId = originalDoc.versionId;
+            break;
+        case VersionOperations.isNewVersionCreation(versionOperation): {
+            data = await prepareDataForNewVersion({
+                data: args.data,
+                originalDoc,
+                config,
+                originalConfigMap
+            });
+            const versionsSlug = withVersionsSuffix(config.slug);
+            const document = await rime.collection(versionsSlug).create({
+                data,
+                locale: params.locale
+            });
+            if (config.versions && config.versions.maxVersions) {
+                await rime.collection(versionsSlug).delete({
+                    sort: '-updatedAt',
+                    query: 'where[status][not_equals]=published',
+                    offset: config.versions.maxVersions
+                });
+            }
+            versionId = document.id;
+            break;
+        }
+        default:
+            versionId = originalDoc.id;
+    }
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            params: {
+                ...args.context.params,
+                versionId
+            }
+        }
+    };
+});
+async function prepareDataForNewVersion(args) {
+    const { config, originalDoc, originalConfigMap } = args;
+    let data = { ...args.data };
+    const isCollection = config.type === 'collection';
+    // Add the original file if we are on an upload collection
+    if (isCollection && config.upload && !data.file && originalDoc.filename) {
+        // Create a File object from the existing file path
+        const filePath = path.resolve(process.cwd(), 'static', 'medias', originalDoc.filename);
+        try {
+            data.file = await filePathToFile(filePath);
+        }
+        catch (err) {
+            console.error(`Failed to create file from path: ${filePath}`, err);
+        }
+    }
+    // Use missing data from original version
+    data = await fallbackDataFromOriginal({
+        data,
+        original: originalDoc,
+        configMap: originalConfigMap,
+        ignore: ['status']
+    });
+    // Set default status to "draft" if no data.status
+    if (!data.status) {
+        data.status = VERSIONS_STATUS.DRAFT;
+    }
+    data.ownerId = originalDoc.id;
+    delete data.id;
+    return data;
+}

package/dist/core/operations/hooks/before-upsert/original-config-map.server.d.ts

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

package/dist/core/operations/hooks/before-upsert/original-config-map.server.js

@@ -0,0 +1,16 @@
+import { RimeError } from '../../../errors/index.js';
+import { buildConfigMap } from '../../configMap/index.js';
+import { Hooks } from '../index.server.js';
+export const buildOriginalDocConfigMap = Hooks.beforeUpsert(async (args) => {
+    const { originalDoc } = args.context;
+    if (!originalDoc)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @buildDataConfigMap');
+    const originalConfigMap = buildConfigMap(originalDoc, args.config.fields.map((f) => f.compile()));
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            originalConfigMap
+        }
+    };
+});

package/dist/core/operations/hooks/before-upsert/set-default-values.server.d.ts

@@ -0,0 +1,12 @@
+import type { Adapter } from '../../../../adapter-sqlite/index.server.js';
+import type { FormField } from '../../../../fields/types.js';
+export declare const setDefaultValues: import("../index.server.js").Hook<"raw", "create" | "update", "before">;
+type GetDefaultValue = (args: {
+    key: string;
+    config: FormField & {
+        defaultValue: any;
+    };
+    adapter: Adapter;
+}) => Promise<any>;
+export declare const getDefaultValue: GetDefaultValue;
+export {};

package/dist/core/operations/hooks/before-upsert/set-default-values.server.js

@@ -0,0 +1,75 @@
+import { getRequestEvent } from '$app/server';
+import { RimeError } from '../../../errors/index.js';
+import { logger } from '../../../logger/index.server.js';
+import { isRelationField } from '../../../../fields/relation/index.js';
+import { getValueAtPath, hasProp, setValueAtPath } from '../../../../util/object.js';
+import { eq, inArray } from 'drizzle-orm';
+import { Hooks } from '../index.server.js';
+export const setDefaultValues = Hooks.beforeUpsert(async (args) => {
+    const { operation, event } = args;
+    const { rime } = event.locals;
+    const configMap = args.context.configMap;
+    if (!configMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @setDefaultValues');
+    let output = { ...args.data };
+    for (const [key, config] of Object.entries(configMap)) {
+        let value = getValueAtPath(key, output);
+        let isEmpty;
+        const shouldAddDefault = operation === 'create' || (operation === 'update' && config.required);
+        try {
+            isEmpty = config.isEmpty(value);
+        }
+        catch {
+            isEmpty = false;
+            logger.warn(`Error in config.isEmpty for field ${key}`);
+        }
+        if (shouldAddDefault && isEmpty && hasProp('defaultValue', config)) {
+            value = await getDefaultValue({ key, config, adapter: rime.adapter });
+            output = setValueAtPath(key, output, value);
+        }
+    }
+    return {
+        ...args,
+        data: output
+    };
+});
+/**
+ * This function convert any default value string | string[] of ids
+ * to a RelationValue from an existing relation record
+ */
+const defaultRelationValue = async (config, key, adapter) => {
+    const buildRelation = async (defaultValue) => {
+        let condition;
+        //@TODO encapsulate this into adapter.relation.something
+        const relationTable = adapter.tables[config.relationTo];
+        if (typeof defaultValue === 'string') {
+            condition = eq(relationTable.id, defaultValue);
+        }
+        else if (Array.isArray(defaultValue)) {
+            condition = inArray(relationTable.id, defaultValue);
+        }
+        const existing = (await adapter.db
+            .select({ documentId: relationTable.id })
+            .from(relationTable)
+            .where(condition));
+        return existing.map(({ documentId }, index) => ({
+            id: null,
+            relationTo: config.relationTo,
+            path: key,
+            position: index,
+            documentId: documentId
+        }));
+    };
+    return await buildRelation(config.defaultValue);
+};
+export const getDefaultValue = async ({ key, config, adapter }) => {
+    if (isRelationField(config)) {
+        return await defaultRelationValue(config, key, adapter);
+    }
+    else {
+        if (typeof config.defaultValue === 'function') {
+            return config.defaultValue({ event: getRequestEvent() });
+        }
+        return config.defaultValue;
+    }
+};

package/dist/core/operations/hooks/before-upsert/validate-fields.server.d.ts

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

package/dist/core/operations/hooks/before-upsert/validate-fields.server.js

@@ -0,0 +1,132 @@
+import { PARAMS } from '../../../constant.js';
+import { RimeError, RimeFormError } from '../../../errors/index.js';
+import { logger } from '../../../logger/index.server.js';
+import { deleteValueAtPath, getValueAtPath, setValueAtPath } from '../../../../util/object.js';
+import { Hooks } from '../index.server.js';
+export const validateFields = Hooks.beforeUpsert(async (args) => {
+    const errors = {};
+    const { event, operation } = args;
+    const { rime, user } = event.locals;
+    const configMap = args.context.configMap;
+    const locale = args.context.params.locale || args.event.locals.locale;
+    const slug = args.config.slug;
+    const isCollection = rime.config.isCollection(slug);
+    let output = { ...args.data };
+    if (!configMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @validateFields');
+    // Get the skip parameter from the url
+    const paramSkip = event.url.searchParams.get(PARAMS.SKIP_VALIDATION) === 'true' || false;
+    // Skip validation on locale fallback as the validation has already been done on creation
+    const skipUnique = args.context.isFallbackLocale || paramSkip;
+    const skipValidate = args.context.isFallbackLocale || paramSkip;
+    const skipRequired = args.context.isFallbackLocale || paramSkip;
+    const skipAccess = args.context.isFallbackLocale || args.context.isSystemOperation;
+    for (const [key, config] of Object.entries(configMap)) {
+        let value = getValueAtPath(key, output);
+        /****************************************************/
+        /* Validation
+    /****************************************************/
+        // Unique
+        /** @TODO better unique check like relations, locale,... */
+        if ('unique' in config && config.unique && isCollection && !skipUnique) {
+            let query;
+            switch (operation) {
+                case 'create':
+                    query = `where[${key}][equals]=${value}`;
+                    break;
+                case 'update':
+                    if (!args.context.originalDoc)
+                        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @validateFields');
+                    query = `where[and][0][${key}][equals]=${value}&where[and][1][id][not_equals]=${args.context.originalDoc.id}&select=id`;
+            }
+            const existing = await rime
+                .collection(slug)
+                .system()
+                .find({ locale, query, select: ['id'] });
+            if (existing.length) {
+                errors[key] = RimeFormError.UNIQUE_FIELD;
+            }
+        }
+        /****************************************************/
+        /* Field hook before validate
+    /****************************************************/
+        if (config.hooks?.beforeValidate) {
+            if (value) {
+                for (const hook of config.hooks.beforeValidate) {
+                    value = await hook(value, { config, data: args.data });
+                    output = setValueAtPath(key, output, value);
+                }
+            }
+        }
+        /****************************************************/
+        /* Validate
+    /****************************************************/
+        if (config.validate && value && !skipValidate) {
+            try {
+                const valid = config.validate(value, {
+                    data: output,
+                    operation,
+                    id: operation === 'update' ? args.context.originalDoc?.id : undefined,
+                    user: user,
+                    locale,
+                    config
+                });
+                if (valid !== true) {
+                    errors[key] = valid;
+                }
+            }
+            catch {
+                logger.warn(`Error while validating field ${key}`);
+                errors[key] = RimeFormError.VALIDATION_ERROR;
+            }
+        }
+        /****************************************************/
+        /* Field hook before Save
+    /****************************************************/
+        if (config.hooks?.beforeSave) {
+            if (value) {
+                for (const hook of config.hooks.beforeSave) {
+                    value = await hook(value, { config, event, operation: args.context });
+                    output = setValueAtPath(key, output, value);
+                }
+            }
+        }
+        /****************************************************/
+        /* Access
+    /****************************************************/
+        if (config.access && config.access.update && operation === 'update' && !skipAccess) {
+            const authorizedFieldUpdate = config.access.update(user, {
+                id: args.context.originalDoc?.id
+            });
+            if (!authorizedFieldUpdate) {
+                output = deleteValueAtPath(output, key);
+                value = undefined;
+            }
+        }
+        if (config.access && config.access.create && operation === 'create' && !skipAccess) {
+            const authorizedFieldCreate = config.access.create(user, {
+                id: undefined
+            });
+            if (!authorizedFieldCreate) {
+                output = deleteValueAtPath(output, key);
+                value = undefined;
+            }
+        }
+        // Required
+        if (config.required && config.isEmpty(value)) {
+            if (skipRequired) {
+                output = setValueAtPath(key, output, '');
+            }
+            else {
+                errors[key] = RimeFormError.REQUIRED_FIELD;
+            }
+        }
+    }
+    if (Object.keys(errors).length) {
+        throw new RimeFormError(errors);
+    }
+    return {
+        ...args,
+        data: output
+    };
+});