rimecms 0.28.10 → 0.30.0

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.d.ts

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

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/handle-new-version.server.d.ts

@@ -2,4 +2,4 @@
  * 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">;
+export declare const handleNewVersion: import("../index.server.js").Hook<"raw", "update" | "create", "before">;

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

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

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';
-export declare const setDefaultValues: import("../index.server.js").Hook<"raw", "create" | "update", "before">;
+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.d.ts

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

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);

package/dist/core/plugins/api-init/index.server.js

@@ -1,5 +1,5 @@
 import { dev } from '$app/environment';
-import { handleError } from '../../errors/handler.server.js';
+import { ERROR_CONTEXT, handleError } from '../../errors/handler.server.js';
 import { RimeError, RimeFormError } from '../../errors/index.js';
 import { extractData } from '../../operations/extract-data.server.js';
 import { trycatch, trycatchSync } from '../../../util/function.js';
@@ -12,13 +12,18 @@ export const apiInit = definePlugin(() => {
             throw new RimeError(RimeError.NOT_FOUND);
         const hasAuthUser = await event.locals.rime.adapter.auth.hasAuthUser();
         if (hasAuthUser || (!hasAuthUser && !dev)) {
-            throw handleError(new RimeError(RimeError.NOT_FOUND), { context: 'api' });
+            throw handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+        }
+        const [extractError, data] = await trycatch(() => extractData(event.request));
+        if (extractError) {
+            throw handleError(new RimeError(RimeError.INVALID_DATA, extractError.message), {
+                context: ERROR_CONTEXT.API
+            });
         }
-        const data = await extractData(event.request);
         const [error] = trycatchSync(() => validateForm(data));
         if (error) {
-            throw handleError(error, {
-                context: 'action',
+            throw handleError(new RimeError(RimeError.INVALID_DATA, error.message), {
+                context: ERROR_CONTEXT.ACTION,
                 formData: { email: data.email }
             });
         }

package/dist/core/plugins/cache/cache.server.js

@@ -1,12 +1,9 @@
 import { getRequestEvent } from '$app/server';
-import { RimeError } from '../../errors';
+import { RimeError } from '../../errors/index.js';
 import { logger } from '../../logger/index.server.js';
 import fs from 'fs';
 import path from 'path';
 const cachePath = path.resolve(process.cwd(), '.cache');
-if (!fs.existsSync(cachePath)) {
-    fs.mkdirSync(cachePath);
-}
 const IS_ENV_CACHE_ENABLED = process.env.RIME_CACHE_ENABLED === 'true';
 export class Cache {
     static memoryCache = new Map();
@@ -68,6 +65,9 @@ export class Cache {
         this.memoryCache.set(key, value);
     }
     static async setToDisk(key, value) {
+        if (!fs.existsSync(cachePath)) {
+            fs.mkdirSync(cachePath);
+        }
         const keyPath = path.join(cachePath, key + '.txt');
         await fs.promises.writeFile(keyPath, value);
     }

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

@@ -1761,13 +1761,13 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         $Infer: {
                             body: ({
                                 permission: {
-                                    readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                    readonly user?: ("update" | "create" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
                                     readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                                 };
                                 permissions?: never | undefined;
                             } | {
                                 permissions: {
-                                    readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                    readonly user?: ("update" | "create" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
                                     readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                                 };
                                 permission?: never | undefined;
@@ -1982,9 +1982,9 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
         isValidLocale: (locale: string) => boolean;
         getArea: (slug: string) => import("./config/types.js").BuiltArea;
         getCollection: (slug: string) => import("./config/types.js").BuiltCollection;
-        getBySlug: (slug: string) => import("./config/types.js").BuiltCollection | import("./config/types.js").BuiltArea;
-        isCollection: (slug: string) => slug is import("./types/doc.js").CollectionSlug;
-        isArea: (slug: string) => slug is import("./types/doc.js").AreaSlug;
+        getBySlug: (slug: string) => import("./config/types.js").BuiltArea | import("./config/types.js").BuiltCollection;
+        isCollection: (slug?: string) => slug is import("./types/doc.js").CollectionSlug;
+        isArea: (slug?: string) => slug is import("./types/doc.js").AreaSlug;
         getDocumentPrototype(slug: import("./types/doc.js").PrototypeSlug): "area" | "collection";
     };
     readonly plugins: {
@@ -3767,13 +3767,13 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             $Infer: {
                                 body: ({
                                     permission: {
-                                        readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                        readonly user?: ("update" | "create" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
                                         readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                                     };
                                     permissions?: never | undefined;
                                 } | {
                                     permissions: {
-                                        readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                        readonly user?: ("update" | "create" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
                                         readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                                     };
                                     permission?: never | undefined;
@@ -4004,9 +4004,9 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
             isValidLocale: (locale: string) => boolean;
             getArea: (slug: string) => import("./config/types.js").BuiltArea;
             getCollection: (slug: string) => import("./config/types.js").BuiltCollection;
-            getBySlug: (slug: string) => import("./config/types.js").BuiltCollection | import("./config/types.js").BuiltArea;
-            isCollection: (slug: string) => slug is import("./types/doc.js").CollectionSlug;
-            isArea: (slug: string) => slug is import("./types/doc.js").AreaSlug;
+            getBySlug: (slug: string) => import("./config/types.js").BuiltArea | import("./config/types.js").BuiltCollection;
+            isCollection: (slug?: string) => slug is import("./types/doc.js").CollectionSlug;
+            isArea: (slug?: string) => slug is import("./types/doc.js").AreaSlug;
             getDocumentPrototype(slug: import("./types/doc.js").PrototypeSlug): "area" | "collection";
         };
         /**

package/dist/core/rime.server.js

@@ -79,7 +79,11 @@ export async function createRime(config) {
     function defineLocale(event) {
         // locale present inside the url params ex : /en/foo
         const params = event.params;
-        const paramLocale = 'locale' in params && typeof params.locale === 'string' ? params.locale : null;
+        const paramLocale = 'locale' in params &&
+            typeof params.locale === 'string' &&
+            configCtx.getLocalesCodes().includes(params.locale)
+            ? params.locale
+            : null;
         // locale present as a search param ex : ?locale=en
         const searchParams = event.url.searchParams;
         const hasParams = searchParams.toString();