rimecms 0.29.0 → 0.30.0

package/dist/panel/context/documentForm.svelte.js

@@ -1,8 +1,7 @@
 import { applyAction, deserialize } from '$app/forms';
 import { page } from '$app/state';
-import { compileDocumentConfig } from '../../core/config/shared/compile.js';
 import { PARAMS, VERSIONS_STATUS } from '../../core/constant.js';
-import { getFieldConfigByPath } from '../../core/fields/util.js';
+import { getFieldAtPath } from '../../core/fields/util.js';
 import { buildConfigMap } from '../../core/operations/configMap/index.js';
 import { isJSONContent, richTextJSONToText } from '../../fields/rich-text/index.js';
 import { normalizeFieldPath } from '../../util/doc.js';
@@ -28,7 +27,7 @@ function createDocumentFormState({ initial, config, readOnly, key, onNestedDocum
     let initialDoc = $state(initial);
     let doc = $state(initial);
     let formElement = $state();
-    const documentConfig = compileDocumentConfig(config);
+    const documentConfig = config;
     const changes = $derived(diff(initialDoc, doc));
     let isDisabled = $state(readOnly);
     let processing = $state(false);
@@ -335,32 +334,43 @@ function createDocumentFormState({ initial, config, readOnly, key, onNestedDocum
         // Return primitive values as is
         return data;
     };
+    /**
+     * `config` is the raw compiled field data, same as every field component
+     * (Text.svelte, Group.svelte, ...) already works with — this mirrors
+     * `form.svelte.ts`'s `useField` on purpose, since both read plain field
+     * data (`.required`, `.isEmpty(value)`, `.validate(...)`, `.access.read`,
+     * `.condition(...)`), never builder methods. `config` is only omitted by
+     * callers with just a path in hand (e.g. `Group.svelte`'s `getField`), in
+     * which case it's resolved from `documentConfig.fields` and unwrapped via
+     * `.get` — the field must exist in the document's own field tree for that
+     * to work, which doesn't hold for standalone fields like the panel's
+     * password inputs (see AuthFooter.svelte), so those always pass `config`.
+     */
     function useField(path, config) {
         if (!config) {
-            config = getFieldConfigByPath(path, documentConfig.fields);
-            if (!config)
+            const resolved = getFieldAtPath(path, documentConfig.fields);
+            if (!resolved)
                 throw new Error(`can't find config for field : ${path}`);
+            config = resolved;
         }
         path = path ? normalizeFieldPath(path) : config.name;
         const parts = $derived(path.split('.'));
         const validate = (value) => {
-            if (config.required && config.isEmpty(value)) {
+            if (config.get.required && config.run.isEmpty(value)) {
                 errors.set(path, 'required::required_field');
                 return 'required';
             }
-            if (config.validate) {
-                const validated = config.validate(value, {
-                    data: doc,
-                    locale: locale.code,
-                    id: doc.id ?? undefined,
-                    operation: doc.id ? 'update' : 'create',
-                    user: user.attributes,
-                    config
-                });
-                if (validated !== true) {
-                    errors.set(path, validated);
-                    return false;
-                }
+            const validated = config.run.validate(value, {
+                data: doc,
+                locale: locale.code,
+                id: doc.id ?? undefined,
+                operation: doc.id ? 'update' : 'create',
+                user: user.attributes,
+                config: config.get
+            });
+            if (validated !== true) {
+                errors.set(path, validated);
+                return false;
             }
             if (errors.has(path)) {
                 errors.delete(path);
@@ -398,25 +408,20 @@ function createDocumentFormState({ initial, config, readOnly, key, onNestedDocum
                 setFieldValue(removeIds(defaultLocaleValue));
             }
         };
-        const setFieldValue = (value) => {
+        const setFieldValue = async (value) => {
+            value = await config.run.beforeValidate(value, { config, data: doc });
             const valid = validate(value);
-            if (!config.access?.update)
-                return;
-            if (operation === 'update' && !config.access.update(user.attributes)) {
+            if (operation === 'update' && !config.run.canUpdate(user.attributes)) {
                 return;
             }
             if (valid) {
                 setValue(path, value);
-                if (Array.isArray(config.hooks?.onChange)) {
-                    for (const hook of config.hooks?.onChange || []) {
-                        hook(value, {
-                            siblings: getSiblings(),
-                            useField,
-                            useBlocks,
-                            useTree
-                        });
-                    }
-                }
+                config.run.onChange?.(value, {
+                    siblings: getSiblings(),
+                    useField,
+                    useBlocks,
+                    useTree
+                });
             }
         };
         return {
@@ -431,35 +436,24 @@ function createDocumentFormState({ initial, config, readOnly, key, onNestedDocum
             get editable() {
                 if (readOnly)
                     return false;
-                if (!config.access)
-                    return false;
                 if (operation === 'create') {
-                    return config.access.create(user.attributes);
+                    return !!config.run.canCreate?.(user.attributes);
                 }
                 else {
-                    return config.access.update(user.attributes);
+                    return !!config.run.canUpdate?.(user.attributes);
                 }
             },
             get visible() {
-                if (config.access?.read && !config.access?.read(user.attributes)) {
+                if (!config.run.canRead(user.attributes)) {
                     return false;
                 }
-                let visible = true;
-                if (config.condition) {
-                    try {
-                        visible = config.condition(doc, getSiblings());
-                    }
-                    catch (err) {
-                        console.error(err.message);
-                    }
-                }
-                return visible;
+                return config.run.condition(doc, getSiblings());
             },
             get error() {
                 return errors.value[path] || false;
             },
             get isEmpty() {
-                return !!config.isEmpty && config.isEmpty(getValueAtPath(path, doc));
+                return config.run.isEmpty(getValueAtPath(path, doc));
             }
         };
     }
@@ -618,7 +612,7 @@ function createDocumentFormState({ initial, config, readOnly, key, onNestedDocum
             let data = { ...defaultLocaleDoc, locale: locale.code };
             const configMap = buildConfigMap(defaultLocaleDoc, documentConfig.fields);
             for (const [key, field] of Object.entries(configMap)) {
-                if (field.localized) {
+                if (field.get.localized) {
                     let value = getValueAtPath(key, data);
                     value = removeIds(value);
                     data = setValueAtPath(key, data, value);
@@ -693,8 +687,7 @@ export function setDocumentFormContext(args) {
     const initial = {
         ...args.initial,
         _type: args.initial._type || args.config.type,
-        _prototype: args.initial._prototype || args.config.slug,
-        title: args.initial.title || '[untitled]'
+        _prototype: args.initial._prototype || args.config.slug
     };
     const store = createDocumentFormState({ ...args, initial });
     return setContext(`${FORM_KEY}.${args.key}`, store);

package/dist/panel/context/form.svelte.d.ts

@@ -1,9 +1,10 @@
-import type { FormField, SimplerField } from '../../fields/types.js';
+import type { FormFieldBuilder } from '../../core/fields/builders/form-field-builder';
+import type { FormField } from '../../fields/types.js';
 import type { Dic } from '../../util/types.js';
 import type { SubmitFunction } from '@sveltejs/kit';
 export declare function setFormContext(initial: Dic, key: string): {
     setValue: (path: string, value: any) => void;
-    useField: (path: string | undefined, config: SimplerField<FormField>) => {
+    useField: (path: string | undefined, config: FormFieldBuilder<FormField>) => {
         path: string;
         value: any;
         readonly editable: boolean;
@@ -43,7 +44,7 @@ export declare function setFormContext(initial: Dic, key: string): {
 };
 export declare function getFormContext(key: string): {
     setValue: (path: string, value: any) => void;
-    useField: (path: string | undefined, config: SimplerField<FormField>) => {
+    useField: (path: string | undefined, config: FormFieldBuilder<FormField>) => {
         path: string;
         value: any;
         readonly editable: boolean;

package/dist/panel/context/form.svelte.js

@@ -43,29 +43,27 @@ function createFormStore(initial, key) {
         const validate = (value) => {
             let isEmpty;
             try {
-                isEmpty = config.isEmpty(value);
+                isEmpty = config.run.isEmpty(value);
             }
             catch (err) {
                 console.error(err.message);
                 throw new Error(config.type + ' ' + err.message);
             }
-            if (config.required && isEmpty) {
+            if (config.get.required && isEmpty) {
                 errors.value[path] = 'required::required_field';
                 return false;
             }
-            if (config.validate) {
-                const validated = config.validate(value, {
-                    data: form,
-                    id: undefined,
-                    operation: undefined,
-                    user: undefined,
-                    locale: undefined,
-                    config
-                });
-                if (validated !== true) {
-                    errors.value[path] = validated;
-                    return false;
-                }
+            const validated = config.run.validate(value, {
+                data: form,
+                id: undefined,
+                operation: undefined,
+                user: undefined,
+                locale: undefined,
+                config: config.get
+            });
+            if (validated !== true) {
+                errors.value[path] = validated;
+                return false;
             }
             if (errors.has(path)) {
                 errors.delete(path);
@@ -87,7 +85,7 @@ function createFormStore(initial, key) {
                 }
             },
             get visible() {
-                return config.condition ? config.condition(form, {}) : true;
+                return config.run.condition(form, {});
             },
             get error() {
                 return errors.value[path] || false;

package/dist/panel/pages/auth/fields.d.ts

@@ -1,4 +1,4 @@
-import type { EmailField, SimplerField, TextField } from '../../../fields/types.js';
-export declare const passwordField: SimplerField<TextField>;
-export declare const emailField: SimplerField<EmailField>;
-export declare const nameField: SimplerField<TextField>;
+export declare const passwordField: import("../../../fields/text/index.js").TextFieldBuilder;
+export declare const confirmPasswordField: import("../../../fields/text/index.js").TextFieldBuilder;
+export declare const emailField: import("../../../fields/email/index.js").EmailFieldBuilder;
+export declare const nameField: import("../../../fields/text/index.js").TextFieldBuilder;

package/dist/panel/pages/auth/fields.js

@@ -1,23 +1,7 @@
+import { email } from '../../../fields/email/index.js';
+import { text } from '../../../fields/text/index.js';
 import { email as validateEmail } from '../../../util/validate.js';
-export const passwordField = {
-    name: 'password',
-    type: 'text',
-    layout: 'compact',
-    required: true,
-    isEmpty: (value) => !value
-};
-export const emailField = {
-    name: 'email',
-    type: 'email',
-    layout: 'compact',
-    required: true,
-    validate: validateEmail,
-    isEmpty: (value) => !value
-};
-export const nameField = {
-    name: 'name',
-    type: 'text',
-    layout: 'compact',
-    required: true,
-    isEmpty: (value) => !value
-};
+export const passwordField = text('password').required();
+export const confirmPasswordField = text('confirmPassword').required();
+export const emailField = email('email').layout('compact').required().validate(validateEmail);
+export const nameField = text('name').layout('compact').required();

package/dist/panel/pages/auth/reset-password/ResetPassword.svelte

@@ -4,7 +4,7 @@
   import AuthForm from '../../../components/sections/auth/AuthForm.svelte';
   import Button from '../../../components/ui/button/button.svelte';
   import { setFormContext } from '../../../context/form.svelte';
-  import { passwordField } from '../fields.js';
+  import { confirmPasswordField, passwordField } from '../fields.js';
   import { authClient } from '../../../util/auth';
   import { toast } from 'svelte-sonner';
 
@@ -19,15 +19,8 @@
   };
   const { data }: Props = $props();
 
-  const passwordConfig = {
-    ...passwordField,
-    placeholder: t__('common.newPassword')
-  };
-  const confirmPasswordConfig = {
-    ...passwordField,
-    name: 'confirmPassword',
-    placeholder: t__('common.confirmPassword')
-  };
+  const passwordConfig = passwordField.placeholder(t__('common.newPassword'));
+  const confirmPasswordConfig = confirmPasswordField.placeholder(t__('common.confirmPassword'));
 
   async function resetPassword() {
     const token = new URLSearchParams(window.location.search).get('token');

package/dist/util/doc.js

@@ -1,4 +1,6 @@
 import { isUploadConfig } from '../core/collections/upload/util/config.js';
+import { FormFieldBuilder } from '../core/fields/builders/form-field-builder.js';
+import { GroupFieldBuilder } from '../fields/group/index.js';
 import { TabsBuilder } from '../fields/tabs/index.js';
 import { getValueAtPath } from './object.js';
 import { snapshot } from './state.js';
@@ -20,28 +22,24 @@ export const createBlankDocument = (config, event) => {
     function reduceFieldsToBlankDocument(prev, curr) {
         try {
             if (curr instanceof TabsBuilder) {
-                curr.raw.tabs.forEach((tab) => {
-                    prev[tab.name] = tab.raw.fields.reduce(reduceFieldsToBlankDocument, {});
+                curr.get.tabs.forEach((tab) => {
+                    prev[tab.name] = tab.get.fields.reduce(reduceFieldsToBlankDocument, {});
                 });
             }
             else if (['blocks', 'relation', 'tree'].includes(curr.type)) {
-                prev[curr.raw.name] = [];
+                prev[curr.name] = [];
             }
-            else if ('fields' in curr.raw) {
-                prev[curr.raw.name] = curr.raw.fields.reduce(reduceFieldsToBlankDocument, {});
+            else if (curr instanceof GroupFieldBuilder) {
+                prev[curr.name] = curr.get.fields.reduce(reduceFieldsToBlankDocument, {});
             }
-            else {
-                if (curr.raw.defaultValue !== undefined) {
-                    if (typeof curr.raw.defaultValue === 'function') {
-                        prev[curr.raw.name] = curr.raw.defaultValue({ event });
-                    }
-                    else {
-                        prev[curr.raw.name] = curr.raw.defaultValue;
-                    }
-                }
-                else {
-                    prev[curr.raw.name] = null;
-                }
+            else if (curr instanceof FormFieldBuilder) {
+                // Presentational fields (separator, bare component()) are plain
+                // FieldBuilder, never FormFieldBuilder, and get skipped here rather
+                // than assigned `prev['']` (they never got a real name) — that used
+                // to corrupt the parent object into looking array-like once
+                // flattened/unflattened.
+                const defaultValue = curr.run.defaultValue({ event });
+                prev[curr.name] = defaultValue !== undefined ? defaultValue : null;
             }
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rimecms",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "homepage": "https://github.com/bienbiendev/rime",
   "scripts": {
     "dev": "vite dev",
@@ -17,9 +17,10 @@
     "test:multilang": "playwright test -c ./tests/multilang/playwright.config.multilang.ts",
     "test:basic": "playwright test -c ./tests/basic/playwright.config.basic.ts",
     "test:empty": "playwright test -c ./tests/empty/playwright.config.empty.ts",
+    "test:fields": "playwright test -c ./tests/fields/playwright.config.fields.ts",
     "test:versions": "playwright test -c ./tests/versions/playwright.config.versions.ts",
     "test:versions-multilang": "playwright test -c ./tests/versions-multilang/playwright.config.versions.ts",
-    "test": "pnpm test:empty && pnpm test:multilang && pnpm test:versions && pnpm test:versions-multilang && pnpm test:basic",
+    "test": "pnpm test:empty && pnpm test:fields && pnpm test:multilang && pnpm test:versions && pnpm test:versions-multilang && pnpm test:basic",
     "check:circular-deps": "pnpm dlx madge -c --extensions ts ./src/",
     "local-pack": "npm run build && npm pack && echo \"Package created at: $(pwd)/$(npm pack | tail -1)\""
   },

package/dist/fields/relation/index.server.d.ts

@@ -1,4 +0,0 @@
-import type { ToSchema, ToType } from '../index.server.js';
-import type { RelationFieldBuilder } from './index.js';
-export declare const toSchema: ToSchema<RelationFieldBuilder<any>>;
-export declare const toType: ToType<RelationFieldBuilder<any>>;

package/dist/fields/relation/index.server.js

@@ -1,13 +0,0 @@
-import { templateUniqueRequired } from '../../adapter-sqlite/generate-schema/templates.server.js';
-import { getSchemaColumnNames } from '../../adapter-sqlite/generate-schema/util.server.js';
-import { capitalize } from '../../util/string.js';
-export const toSchema = (field, parentPath) => {
-    const { camel, snake } = getSchemaColumnNames({ name: field.name, parentPath });
-    const suffix = templateUniqueRequired(field.raw, {});
-    if (field._generateSchema)
-        return field._generateSchema({ camel, snake, suffix });
-    return `${camel}: text('${snake}', { mode: 'json' })${suffix}`;
-};
-export const toType = (field) => {
-    return `${field.name}${field.raw.required ? '' : '?'}: RelationValue<${capitalize(field.raw.relationTo)}Doc>`;
-};