rimecms 0.28.0 → 0.28.1

package/dist/core/config/server/validate.server.js

@@ -1,10 +1,12 @@
 import { isAuthConfig } from '../../collections/auth/util.js';
 import cache from '../../dev/cache/index.server.js';
 import { isFormField } from '../../fields/util.js';
+import { logger } from '../../logger/index.server';
 import { isBlocksFieldRaw } from '../../../fields/blocks/index.js';
 import { isGroupFieldRaw } from '../../../fields/group/index.js';
+import { isRelationField } from '../../../fields/relation';
 import { isSelectField } from '../../../fields/select/index.js';
-import { isTabsFieldRaw } from '../../../fields/tabs/index.js';
+import { isTabsFieldRaw } from '../../../fields/tabs';
 import { isTreeFieldRaw } from '../../../fields/tree/index.js';
 function hasDuplicates(arr) {
     return [...new Set(arr.filter((e, i, a) => a.indexOf(e) !== i))];
@@ -45,11 +47,11 @@ function hasUsersSlug(config) {
 const validateFields = (config) => {
     let errors = [];
     for (const collection of config.collections || []) {
-        const collectionErrors = validateDocumentFields(collection);
+        const collectionErrors = validateDocumentFields(collection, config);
         errors = [...errors, ...collectionErrors];
     }
     for (const area of config.areas || []) {
-        const collectionErrors = validateDocumentFields(area);
+        const collectionErrors = validateDocumentFields(area, config);
         errors = [...errors, ...collectionErrors];
     }
     return errors;
@@ -57,12 +59,12 @@ const validateFields = (config) => {
 /**
  *
  */
-const validateDocumentFields = (config) => {
+const validateDocumentFields = (documentConfig, config) => {
     const errors = [];
-    const isCollection = (config) => config.type === 'collection';
-    const isAuth = isCollection(config) && isAuthConfig(config);
+    const isCollection = (documentConfig) => documentConfig.type === 'collection';
+    const isAuth = isCollection(documentConfig) && isAuthConfig(documentConfig);
     const registeredBlocks = {};
-    const fieldsCompiled = config.fields.map((f) => f.compile());
+    const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
     if (isAuth) {
         const rolesField = fieldsCompiled
             .filter(isFormField)
@@ -73,28 +75,37 @@ const validateDocumentFields = (config) => {
             .filter(isFormField)
             .find((f) => f.name === 'email' && f.type === 'email');
         if (!rolesField)
-            errors.push(`Field roles is missing in collection ${config.slug}`);
-        if (!emailField && config.auth.type !== 'apiKey')
-            errors.push(`Field email is missing in collection ${config.slug}`);
+            errors.push(`Field roles is missing in collection ${documentConfig.slug}`);
+        if (!emailField && documentConfig.auth.type !== 'apiKey')
+            errors.push(`Field email is missing in collection ${documentConfig.slug}`);
         if (!nameField)
-            errors.push(`Field name is missing in collection ${config.slug}`);
+            errors.push(`Field name is missing in collection ${documentConfig.slug}`);
         if (!rolesField.many)
             errors.push(`Field roles must have "many" enabled : select('roles').options(...).many(), even with a single option`);
     }
     const validateBlockField = (fields, blockType) => {
         const reserved = ['path', 'type', 'ownerId', 'position', 'locale'];
         for (const key of reserved) {
-            if (fields.map((f) => f.name).filter((name) => name === key).length > 1) {
+            if (fields
+                .filter(isFormField)
+                .map((f) => f.name)
+                .filter((name) => name === key).length > 1) {
                 errors.push(`${key} is a reserved field in blocks (block ${blockType})`);
             }
         }
     };
-    const validateFormFields = (fields) => {
+    const validateRelationField = (field) => {
+        const collectionsSlugs = (config.collections || []).map((c) => c.slug);
+        if (!collectionsSlugs.includes(field.relationTo)) {
+            errors.push(`Relation field ${field.name} references unknown collection ${field.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
+        }
+    };
+    const validateFields = (fields) => {
         // Check for field name duplication at this level
-        const duplicates = hasDuplicates(fields.map((f) => f.name));
+        const duplicates = hasDuplicates(fields.filter(isFormField).map((f) => f.name));
         if (duplicates.length) {
             for (const duplicate of duplicates) {
-                errors.push(`Duplicate field '${duplicate}' in ${config.type} '${config.slug}'`);
+                errors.push(`Duplicate field '${duplicate}' in ${documentConfig.type} '${documentConfig.slug}'`);
             }
         }
         function validateFieldName(name) {
@@ -104,16 +115,33 @@ const validateDocumentFields = (config) => {
             // Check if string matches pattern and doesn't contain spaces or hyphens
             return pattern.test(name) && !name.includes('-') && !name.includes(' ');
         }
+        function validateTabs(field) {
+            const duplicates = hasDuplicates(field.tabs.map((t) => t.name));
+            if (duplicates.length) {
+                errors.push(`Dupplicate tab name ${duplicates} in ${documentConfig.slug}`);
+            }
+        }
         for (const field of fields) {
+            // Recursive check first into Tabs since tabs are not Formfields
+            if (isTabsFieldRaw(field)) {
+                validateTabs(field);
+                for (const tab of field.tabs) {
+                    validateFields(tab.fields);
+                }
+            }
+            // If field is not a Formfield eg. Separator then continue
+            if (!isFormField(field)) {
+                continue;
+            }
             // Check that a field wich has field._root = true is not localized
             if ('_root' in field && field._root && field.localized) {
-                errors.push(`Field ${field.name} of ${config.type} ${config.slug} with _root = true, can't be localized`);
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with _root = true, can't be localized`);
             }
             // Check for malformed field.name
             if (!validateFieldName(field.name)) {
-                errors.push(`Field ${field.name} of ${config.type} ${config.slug} should be camelCase`);
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
             }
-            // Recursive check into Blocks Groups and Tabs
+            // Recursive check into Blocks
             if (isBlocksFieldRaw(field)) {
                 for (const block of field.blocks) {
                     if (block.name in registeredBlocks) {
@@ -125,24 +153,25 @@ const validateDocumentFields = (config) => {
                     else {
                         registeredBlocks[block.name] = block;
                     }
-                    validateFormFields(block.fields.filter(isFormField));
+                    validateFields(block.fields.filter(isFormField));
                     validateBlockField(block.fields.filter(isFormField), block.name);
                 }
+                // Recursive check into Tree
             }
             else if (isTreeFieldRaw(field)) {
-                validateFormFields(field.fields.filter(isFormField));
-            }
-            else if (isTabsFieldRaw(field)) {
-                for (const tab of field.tabs) {
-                    validateFormFields(tab.fields.filter(isFormField));
-                }
+                validateFields(field.fields.filter(isFormField));
+                // Recursive check into Tabs
             }
             else if (isGroupFieldRaw(field)) {
-                validateFormFields(field.fields.filter(isFormField));
+                validateFields(field.fields.filter(isFormField));
+                // Check relation field
+            }
+            else if (isRelationField(field)) {
+                validateRelationField(field);
             }
         }
     };
-    validateFormFields(config.fields.map((f) => f.compile()).filter(isFormField));
+    validateFields(documentConfig.fields.map((f) => f.compile()));
     return errors;
 };
 const hasDatabase = (config) => {
@@ -163,6 +192,7 @@ function validateAuthCollections(config) {
     return errors;
 }
 function validate(config) {
+    logger.debug('Validating config...');
     const validateFunctions = [
         hasDuplicateSlug,
         hasUsersSlug,
@@ -174,9 +204,11 @@ function validate(config) {
         const errors = isValid(config);
         if (errors.length) {
             cache.clear();
-            throw new Error('Config error : ' + errors[0]);
+            errors.map((err) => logger.error(err));
+            return false;
         }
     }
+    logger.debug('Config is valid');
     return true;
 }
 export default validate;

package/dist/core/dev/cli/build/templates.d.ts

@@ -1 +1 @@
-export declare const polkaServer = "import polka from 'polka';\nimport serveStatic from 'serve-static';\nimport { handler } from './build/handler.js';\n\nconst serve = serveStatic('./static');\n\npolka()\n\t.use(serve)\n\t.use(handler)\n\t.listen(3000, () => {\n\t\tconsole.log(\"server running\");\n\t});\n";
+export declare const polkaServer = "import polka from 'polka';\nimport serveStatic from 'serve-static';\nimport { handler } from './build/handler.js';\n\nconst serve = serveStatic('./static');\n\nconst port = process.env.PORT || 3000;\nconst host = process.env.HOST || '127.0.0.1';\n\npolka()\n\t.use(serve)\n\t.use(handler)\n\t.listen(port, host, () => {\n\t\tconsole.log(`server running on ${host}:${port}`);\n\t});\n";

package/dist/core/dev/cli/build/templates.js

@@ -4,10 +4,13 @@ import { handler } from './build/handler.js';
 
 const serve = serveStatic('./static');
 
+const port = process.env.PORT || 3000;
+const host = process.env.HOST || '127.0.0.1';
+
 polka()
 	.use(serve)
 	.use(handler)
-	.listen(3000, () => {
-		console.log("server running");
+	.listen(port, host, () => {
+		console.log(\`server running on \${host}:\${port}\`);
 	});
 `;

package/dist/core/dev/cli/generate/index.server.js

@@ -1,4 +1,3 @@
-import cache from '../../cache/index.server.js';
 import { sanitize } from '../../generate/sanitize/index.server.js';
 import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
 import { logger } from '../../../logger/index.server.js';
@@ -62,18 +61,23 @@ export const generate = async (args) => {
         ensureUserConfigExist();
         await sanitizeConfig();
         const importPathJS = ensureGeneratedConfig();
-        logger.info('Generate');
+        logger.info('Starting vite server...');
         const vite = await createServer();
-        await vite.ssrLoadModule(importPathJS);
-        while (cache.get('.init')) {
-            await new Promise((resolve) => setTimeout(resolve, 200));
+        try {
+            const mod = await vite.ssrLoadModule(importPathJS);
+            // The generated config's default export is the createRime() promise;
+            // ssrLoadModule only awaits the module's synchronous evaluation, so we
+            // must await it directly to observe init failures (e.g. config validation).
+            await mod.default;
+            logger.info('[✓] Generation completed successfully');
+        }
+        finally {
+            await vite.close();
         }
-        await vite.close();
-        logger.info('[✓] Generation completed successfully');
     }
     const [error] = await trycatch(run);
     if (error) {
-        logger.error('Error during generation:', error);
+        logger.error('[✗] Error during generation:', error);
         throw error;
     }
 };

package/dist/core/dev/cli/index.js

@@ -30,8 +30,13 @@ program
     .option('-f, --force', 'Force generation, ignore cache, overwrite routes', false)
     .action(async (args) => {
     const generate = await import('./generate/index.server.js').then((m) => m.generate);
-    generate({
-        force: args.force
-    });
+    try {
+        await generate({
+            force: args.force
+        });
+    }
+    catch {
+        process.exitCode = 1;
+    }
 });
 program.parse(process.argv);

package/dist/core/dev/vite/index.server.js

@@ -36,15 +36,19 @@ export function rime() {
                     }
                     catch (error) {
                         logger.error('Error while sanitizing config:', error.message);
-                        throw error;
+                        return;
                     }
                     // Trigger generation
                     try {
-                        await server.ssrLoadModule(`src/lib/${OUTPUT_DIR}/rime.config.server.ts`);
+                        const mod = await server.ssrLoadModule(`src/lib/${OUTPUT_DIR}/rime.config.server.ts`);
+                        // The config's default export is the createRime() promise; ssrLoadModule
+                        // only awaits the module's synchronous evaluation, so we must await it
+                        // directly to observe init errors (e.g. invalid config) here instead of
+                        // letting them become unhandled rejections that crash the dev server.
+                        await mod.default;
                     }
                     catch (error) {
                         logger.error('Failed to reload the config', error.message);
-                        throw error;
                     }
                 }
             });

package/dist/core/rime.server.d.ts

@@ -76,14 +76,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             appName: string;
                             baseURL: string;
                             trustedOrigins: string[];
-                            isTrustedOrigin: (url: string, settings
-                            /**
-                             * Get a collection api
-                             * @example
-                             *
-                             * rime.collection('pages').find({ query: 'where[isHome][equals]=true' })
-                             */
-                            ?: {
+                            isTrustedOrigin: (url: string, settings?: {
                                 allowRelativePaths: boolean;
                             }) => boolean;
                             oauthConfig: {
@@ -2089,14 +2082,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 appName: string;
                                 baseURL: string;
                                 trustedOrigins: string[];
-                                isTrustedOrigin: (url: string, settings
-                                /**
-                                 * Get a collection api
-                                 * @example
-                                 *
-                                 * rime.collection('pages').find({ query: 'where[isHome][equals]=true' })
-                                 */
-                                ?: {
+                                isTrustedOrigin: (url: string, settings?: {
                                     allowRelativePaths: boolean;
                                 }) => boolean;
                                 oauthConfig: {

package/dist/core/rime.server.js

@@ -1,6 +1,5 @@
 // import type { Adapter } from '../adapter-sqlite/index.server.js';
 import { dev } from '$app/environment';
-import devCache from './dev/cache/index.server.js';
 import { betterAuth } from 'better-auth';
 import { AreaAPI } from './areas/local-api.server.js';
 import { CollectionAPI } from './collections/local-api.server.js';
@@ -29,13 +28,18 @@ export async function createRime(config) {
     // Generate schema, types, routes
     if (dev) {
         const changed = writeMemo(config);
-        const valid = changed && validate(config);
-        if (changed && !valid)
+        const valid = validate(config);
+        if (!valid) {
             throw new RimeError('Config not valid');
-        devCache.set('.init', new Date().toISOString());
-        generateRoutes(config);
-        await generateSchema(config);
-        await generateTypes(config);
+        }
+        if (changed) {
+            generateRoutes(config);
+            await generateSchema(config);
+            await generateTypes(config);
+        }
+        else {
+            logger.debug('Nothing to generate');
+        }
     }
     // Create adapter, consume the generated schema
     const adapter = await createAdapter(configCtx);
@@ -53,9 +57,6 @@ export async function createRime(config) {
     // Register dictionaries for panel Language
     const dictionnaries = await registerTranslation(config.panel.language);
     i18n.init(dictionnaries);
-    if (dev) {
-        devCache.delete('.init');
-    }
     /**
      * Function that define the locale to use in a request event
      * based on this priority, high to low :

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rimecms",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "homepage": "https://github.com/bienbiendev/rime",
   "scripts": {
     "dev": "vite dev",