rimecms 0.29.0 → 0.30.0

package/dist/core/handlers/routes.server.js

@@ -1,3 +1,4 @@
+import { prototypeKebabToSlug } from '../naming.js';
 import buildNavigation from '../../panel/navigation.js';
 import { areaFormActions } from '../../panel/pages/area/actions.server.js';
 import { areaLoad } from '../../panel/pages/area/load.server.js';
@@ -55,10 +56,22 @@ export const routeHandlers = {
 };
 export const handleRoutes = async ({ event, resolve }) => {
     const { rime, user } = event.locals;
-    const isSignInRoute = event.url.pathname === '/panel/sign-in';
-    const isPanelRoute = event.url.pathname.startsWith('/panel') && !isSignInRoute;
+    const IS_SIGN_IN_ROUTE = event.url.pathname === '/panel/sign-in';
+    const IS_API_ROUTE = event.url.pathname.startsWith('/api');
+    const IS_PANEL_ROUTE = event.url.pathname.startsWith('/panel') && !IS_SIGN_IN_ROUTE;
+    // event.params.slug comes straight from the URL, always kebab-case (see
+    // src/params/collection.ts, area.ts). Collection/area slugs themselves are
+    // camelCase, so rewrite once here — every downstream handler (panel
+    // load/actions, REST) can then keep comparing event.params.slug directly
+    // against the config's `slug`. Scoped to routes actually matched via our
+    // own [slug=collection]/[slug=area] param matchers (route.id carries the
+    // matcher name) — a consumer's own app route can also use a `slug` param
+    // (e.g. (front)/pages/[slug]) and must be left untouched.
+    if ((IS_API_ROUTE || IS_PANEL_ROUTE) && event.params.slug) {
+        event.params.slug = prototypeKebabToSlug(event.params.slug);
+    }
     // build panel navigation
-    if (isPanelRoute && event.request.method === 'GET') {
+    if (IS_PANEL_ROUTE && event.request.method === 'GET') {
         event.locals.navigation = buildNavigation(rime.config.raw, user);
     }
     event.locals.routes = routeHandlers;

package/dist/core/naming.d.ts

@@ -10,6 +10,17 @@ import type { CollectionSlug } from '../types.js';
  * withDirectoriesSuffix('pages_versions');
  */
 export declare const withDirectoriesSuffix: (slug: string) => CollectionSlug;
+/**
+ * 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 declare const withoutDirectoriesSuffix: (slug: string) => CollectionSlug;
 /**
  * Add a _versions suffix to a given name.
  * Used for document versioning slug and tables.
@@ -19,6 +30,15 @@ export declare const withDirectoriesSuffix: (slug: string) => CollectionSlug;
  * withVersionsSuffix('pages');
  */
 export declare const withVersionsSuffix: (name: string) => CollectionSlug;
+/**
+ * Remove a _versions suffix from a given name.
+ * Used for document versioning slug and tables.
+ *
+ * @example
+ * // Returns 'pages'
+ * withoutVersionsSuffix('pages_versions');
+ */
+export declare const withoutVersionsSuffix: (name: string) => CollectionSlug;
 /**
  * Check if a slug is a verioned collection slug
  *  * @example
@@ -46,3 +66,17 @@ export declare const hasDirectoriesSuffix: (slug: string) => boolean;
  * withLocalesSuffix('pages_versions');
  */
 export declare const withLocalesSuffix: (name: string) => string;
+/**
+ * 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 declare const prototypeKebabToSlug: (kebab: string) => string;

package/dist/core/naming.js

@@ -9,6 +9,17 @@
  * 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.
@@ -18,6 +29,15 @@ export const withDirectoriesSuffix = (slug) => `${slug.replace('_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
@@ -45,3 +65,22 @@ export const hasDirectoriesSuffix = (slug) => slug.endsWith('_directories');
  * 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.js

@@ -10,7 +10,7 @@ export function defineBlocksDiff({ existingBlocks, incomingBlocks, context }) {
     // - 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;
+            const isLocalized = configMap[block.path]?.get.localized || false;
             if (isLocalized) {
                 delete block.id;
                 block.locale = context.isFallbackLocale;

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

@@ -5,7 +5,7 @@ export function extractBlocks({ data, configMap }) {
     Object.entries(configMap).forEach(([path, config]) => {
         if (config.type === 'blocks') {
             const value = getValueAtPath(path, data);
-            const isEmptyValue = config.isEmpty(value);
+            const isEmptyValue = config.run.isEmpty(value);
             if (value && !isEmptyValue) {
                 value.forEach((block, index) => {
                     if (block.type) {

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

@@ -1,3 +1,4 @@
-import type { TreeFieldRaw } from '../../../fields/tree/index.js';
+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: TreeFieldRaw, treeItems: any[], basePath: string): ConfigMap;
+export declare function buildTreeFieldsMap(treeConfig: TreeBuilder, treeItems: TreeBlock[], basePath: string): ConfigMap;

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

@@ -3,7 +3,7 @@ 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) {
+        for (const field of treeConfig.get.fields) {
             if (isFormField(field)) {
                 treeMap[`${path}.${field.name}`] = field;
             }

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

@@ -1,5 +1,6 @@
+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: Field[]) => ConfigMap;
+export declare const buildConfigMap: (data: DeepPartial<GenericDoc>, incomingFields: FieldBuilder<Field>[]) => ConfigMap;

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

@@ -1,8 +1,8 @@
 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 { 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 = {};
@@ -11,10 +11,10 @@ export const buildConfigMap = (data, incomingFields) => {
             return;
         basePath = basePath === '' ? basePath : `${basePath}.`;
         for (const field of fields) {
-            if (isTabsFieldRaw(field)) {
-                for (const tab of field.tabs) {
+            if (field instanceof TabsBuilder) {
+                for (const tab of field.get.tabs) {
                     if (tab.name in data) {
-                        traverseData(data[tab.name], tab.fields, tab.name);
+                        traverseData(data[tab.name], tab.get.fields, tab.name);
                     }
                 }
                 continue;
@@ -26,13 +26,13 @@ export const buildConfigMap = (data, incomingFields) => {
             const value = data[field.name];
             const path = `${basePath}${field.name}`;
             map[path] = field;
-            if (isBlocksFieldRaw(field) && value && Array.isArray(value)) {
+            if (field instanceof BlocksBuilder && 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);
+                        const blockConfig = field.get.blocks.find((b) => b.name === block.type);
                         if (blockConfig) {
-                            traverseData(block, blockConfig.fields, `${path}.${index}`);
+                            traverseData(block, blockConfig.get.fields, `${path}.${index}`);
                         }
                     }
                     catch {
@@ -40,12 +40,12 @@ export const buildConfigMap = (data, incomingFields) => {
                     }
                 }
             }
-            else if (isTreeFieldRaw(field) && value && Array.isArray(value)) {
+            else if (field instanceof TreeBuilder && value && Array.isArray(value)) {
                 const treeMap = buildTreeFieldsMap(field, value, path);
                 map = { ...map, ...treeMap };
             }
-            else if (isGroupFieldRaw(field)) {
-                traverseData(value, field.fields, path);
+            else if (field instanceof GroupFieldBuilder) {
+                traverseData(value, field.get.fields, path);
             }
         }
     };

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

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

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

@@ -1,38 +1,35 @@
 import { logger } from '../../../logger/index.server.js';
-import { deleteValueAtPath, getValueAtPath, hasProp, setValueAtPath } from '../../../../util/object.js';
+import { deleteValueAtPath, getValueAtPath, 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()));
+    const configMap = buildConfigMap(doc, args.config.fields);
     for (const [key, config] of Object.entries(configMap)) {
         let value = getValueAtPath(key, doc);
         let isEmpty;
-        if (config.access && config.access.read) {
-            const authorized = config.access.read(event.locals.user);
-            if (!authorized) {
-                doc = deleteValueAtPath(doc, key);
-                continue;
-            }
+        if (!config.run.canRead(event.locals.user)) {
+            doc = deleteValueAtPath(doc, key);
+            continue;
         }
-        if (config.hooks?.beforeRead) {
-            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);
-                }
-            }
+        if (value !== undefined && value !== null) {
+            value = await config.run.beforeRead(value, {
+                event,
+                operation: args.context,
+                documentId: doc.id
+            });
+            doc = setValueAtPath(key, doc, value);
         }
         try {
-            isEmpty = config.isEmpty(value);
+            isEmpty = config.run.isEmpty(value);
         }
         catch {
             isEmpty = false;
             logger.warn(`Error in config.isEmpty for field ${key}`);
         }
-        if (isEmpty && hasProp('defaultValue', config)) {
+        if (isEmpty && config.get.defaultValue !== undefined) {
             value = await getDefaultValue({ key, config, adapter: args.event.locals.rime.adapter });
             doc = setValueAtPath(key, doc, value);
         }

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

@@ -1,7 +1,7 @@
 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()));
+    const configMap = buildConfigMap(args.data, args.config.fields);
     return {
         ...args,
         context: {

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

@@ -5,7 +5,7 @@ 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()));
+    const originalConfigMap = buildConfigMap(originalDoc, args.config.fields);
     return {
         ...args,
         context: {

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

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

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

@@ -1,8 +1,8 @@
 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 { RelationFieldBuilder } from '../../../../fields/relation/index.js';
+import { getValueAtPath, setValueAtPath } from '../../../../util/object.js';
 import { eq, inArray } from 'drizzle-orm';
 import { Hooks } from '../index.server.js';
 export const setDefaultValues = Hooks.beforeUpsert(async (args) => {
@@ -15,15 +15,15 @@ export const setDefaultValues = Hooks.beforeUpsert(async (args) => {
     for (const [key, config] of Object.entries(configMap)) {
         let value = getValueAtPath(key, output);
         let isEmpty;
-        const shouldAddDefault = operation === 'create' || (operation === 'update' && config.required);
+        const shouldAddDefault = operation === 'create' || (operation === 'update' && config.get.required);
         try {
-            isEmpty = config.isEmpty(value);
+            isEmpty = config.run.isEmpty(value);
         }
         catch {
             isEmpty = false;
             logger.warn(`Error in config.isEmpty for field ${key}`);
         }
-        if (shouldAddDefault && isEmpty && hasProp('defaultValue', config)) {
+        if (shouldAddDefault && isEmpty && config.get.defaultValue !== undefined) {
             value = await getDefaultValue({ key, config, adapter: rime.adapter });
             output = setValueAtPath(key, output, value);
         }
@@ -41,7 +41,7 @@ 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];
+        const relationTable = adapter.tables[config.get.relationTo];
         if (typeof defaultValue === 'string') {
             condition = eq(relationTable.id, defaultValue);
         }
@@ -54,22 +54,17 @@ const defaultRelationValue = async (config, key, adapter) => {
             .where(condition));
         return existing.map(({ documentId }, index) => ({
             id: null,
-            relationTo: config.relationTo,
+            relationTo: config.get.relationTo,
             path: key,
             position: index,
             documentId: documentId
         }));
     };
-    return await buildRelation(config.defaultValue);
+    return await buildRelation(config.run.defaultValue({ event: getRequestEvent() }));
 };
 export const getDefaultValue = async ({ key, config, adapter }) => {
-    if (isRelationField(config)) {
+    if (config instanceof RelationFieldBuilder) {
         return await defaultRelationValue(config, key, adapter);
     }
-    else {
-        if (typeof config.defaultValue === 'function') {
-            return config.defaultValue({ event: getRequestEvent() });
-        }
-        return config.defaultValue;
-    }
+    return config.run.defaultValue({ event: getRequestEvent() });
 };

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

@@ -7,7 +7,13 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
     const errors = {};
     const { event, operation } = args;
     const { rime, user } = event.locals;
-    const configMap = args.context.configMap;
+    // Own copy — an access-denied field gets deleted from here too, not just
+    // from `output`. `updateById` turns this map's keys into `incomingPaths`,
+    // which saveRelations/saveBlocks/saveTreeBlocks use to decide which
+    // existing rows are even in scope for this request; leaving a denied
+    // field's path in there made its silently-dropped write look like an
+    // explicit "no relations/blocks here anymore" and delete the existing data.
+    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);
@@ -16,9 +22,15 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         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
+    // Skip validation/hooks on locale fallback — this data is `omitId(document)`
+    // read back from the just-created document (see create.ts's other-locales
+    // loop), already fully processed once. skipHooks gates validate() as well
+    // as beforeValidate/beforeSave: a non-idempotent hook (e.g. appending a
+    // suffix) would otherwise re-apply itself on every other locale and
+    // corrupt non-localized fields, which share the same underlying storage
+    // across locales.
     const skipUnique = args.context.isFallbackLocale || paramSkip;
-    const skipValidate = args.context.isFallbackLocale || paramSkip;
+    const skipHooks = 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)) {
@@ -28,7 +40,7 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         /****************************************************/
         // Unique
         /** @TODO better unique check like relations, locale,... */
-        if ('unique' in config && config.unique && isCollection && !skipUnique) {
+        if ('unique' in config.get && config.get.unique && isCollection && !skipUnique) {
             let query;
             switch (operation) {
                 case 'create':
@@ -50,72 +62,74 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
         /****************************************************/
         /* 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);
-                }
-            }
+        if (value !== undefined && value !== null && !skipHooks) {
+            value = await config.run.beforeValidate(value, { config, data: args.data });
+            output = setValueAtPath(key, output, value);
         }
         /****************************************************/
         /* Validate
         /****************************************************/
-        if (config.validate && value && !skipValidate) {
+        if (config.get.validate && value !== undefined && value !== null && !skipHooks) {
             try {
-                const valid = config.validate(value, {
+                const valid = config.run.validate(value, {
                     data: output,
                     operation,
                     id: operation === 'update' ? args.context.originalDoc?.id : undefined,
                     user: user,
                     locale,
-                    config
+                    config: config.get
                 });
                 if (valid !== true) {
                     errors[key] = valid;
                 }
             }
-            catch {
+            catch (err) {
                 logger.warn(`Error while validating field ${key}`);
+                console.debug(`[validateFields] field "${key}" threw:`, err);
                 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);
-                }
-            }
+        */
+        if (value !== undefined && value !== null && !skipHooks) {
+            value = await config.run.beforeSave(value, {
+                config: config.get,
+                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, {
+        if (operation === 'update' && !skipAccess) {
+            const authorizedFieldUpdate = config.run.canUpdate(user, {
                 id: args.context.originalDoc?.id
             });
             if (!authorizedFieldUpdate) {
                 output = deleteValueAtPath(output, key);
+                delete configMap[key];
                 value = undefined;
             }
         }
-        if (config.access && config.access.create && operation === 'create' && !skipAccess) {
-            const authorizedFieldCreate = config.access.create(user, {
+        if (operation === 'create' && !skipAccess) {
+            const authorizedFieldCreate = config.run.canCreate(user, {
                 id: undefined
             });
             if (!authorizedFieldCreate) {
                 output = deleteValueAtPath(output, key);
+                delete configMap[key];
                 value = undefined;
             }
         }
         // Required
-        if (config.required && config.isEmpty(value)) {
+        if (config.get.required && config.run.isEmpty(value)) {
             if (skipRequired) {
-                output = setValueAtPath(key, output, '');
+                // The field's own type-correct default (falling back to '' only
+                // when none is set) — a hardcoded '' here was wrong for every
+                // non-string required field (number, checkbox, date, ...).
+                output = setValueAtPath(key, output, config.run.defaultValue({ event }) ?? '');
             }
             else {
                 errors[key] = RimeFormError.REQUIRED_FIELD;
@@ -127,6 +141,10 @@ export const validateFields = Hooks.beforeUpsert(async (args) => {
     }
     return {
         ...args,
-        data: output
+        data: output,
+        context: {
+            ...args.context,
+            configMap
+        }
     };
 });

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

@@ -1,17 +1,17 @@
-import { isRelationField } from '../../../fields/relation/index.js';
+import { RelationFieldBuilder } from '../../../fields/relation/index.js';
 import { getValueAtPath } from '../../../util/object.js';
 export const extractRelations = ({ ownerId, data, configMap, locale }) => {
     const relations = [];
     for (const [path, config] of Object.entries(configMap)) {
-        if (isRelationField(config)) {
+        if (config instanceof RelationFieldBuilder) {
             const value = getValueAtPath(path, data);
-            const localized = config.localized;
+            const localized = config.get.localized;
             const relationRawValue = value;
             let output = [];
             const relationFromString = ({ value, position = 0 }) => {
                 const result = {
                     position,
-                    relationTo: config.relationTo,
+                    relationTo: config.get.relationTo,
                     documentId: value,
                     ownerId,
                     path
@@ -25,7 +25,7 @@ export const extractRelations = ({ ownerId, data, configMap, locale }) => {
                 const result = {
                     id: value.id || undefined,
                     position,
-                    relationTo: config.relationTo,
+                    relationTo: config.get.relationTo,
                     documentId: value.documentId,
                     ownerId,
                     path

package/dist/core/operations/shared/fallback-data-from-original.js

@@ -10,13 +10,13 @@ export const fallbackDataFromOriginal = async (args) => {
         if (ignore.includes(key))
             continue;
         // skip if not required and mode is 'required'
-        const shouldUpdate = (config.required && mode === 'required') || mode === 'all';
+        const shouldUpdate = (config.get.required && mode === 'required') || mode === 'all';
         if (!shouldUpdate)
             continue;
         let value = getValueAtPath(key, output);
         let isEmpty;
         try {
-            isEmpty = config.isEmpty(value);
+            isEmpty = config.run.isEmpty(value);
         }
         catch {
             isEmpty = false;

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

@@ -12,7 +12,7 @@ export function defineTreeBlocksDiff({ existingBlocks, incomingBlocks, context }
     // - 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;
+            const isLocalized = configMap[block.path]?.get.localized || false;
             if (isLocalized) {
                 delete block.id;
                 block.locale = context.isFallbackLocale;

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

@@ -22,7 +22,7 @@ export function extractTreeBlocks({ data, configMap }) {
     Object.entries(configMap).forEach(([path, config]) => {
         if (config.type === 'tree') {
             const value = getValueAtPath(path, data);
-            const isEmptyValue = config.isEmpty(value);
+            const isEmptyValue = config.run.isEmpty(value);
             if (value && !isEmptyValue) {
                 value.forEach((item, index) => {
                     processTreeItem(item, index, path, undefined);