rimecms 0.31.5 → 0.32.0

package/dist/core/panel/configure.d.ts

@@ -0,0 +1,63 @@
+import type { BuiltArea, BuiltCollection } from '../config/types.js';
+import type { Component } from 'svelte';
+import type { Dic } from '../../util/types.js';
+import type { IconProps } from '@lucide/svelte';
+import type { PanelConfig } from './types.js';
+/**
+ * The slug → icon map the panel navigates by, gathered from every prototype config.
+ *
+ * A feature-derived collection (upload's `<slug>Directories`, versions' aliases) has no entry:
+ * `panel` is listed before `upload` and `versions`, so they do not exist yet when this runs. That
+ * is the behaviour the chain had before the panel became a feature, and the feature list is where
+ * it is now declared — see index.ts.
+ */
+declare const withIcons: <const T extends {
+    collections?: BuiltCollection[];
+    areas?: BuiltArea[];
+}>(config: T) => T & {
+    readonly icons: Dic<Component<import("@lucide/svelte").LucideProps, {}, string>>;
+};
+/**
+ * What every config needs before a panel can render it: the slug → icon map, and `panel` itself
+ * with its navigation groups, language and header components filled in.
+ *
+ * Two steps and one order — the icon map covers the collections that exist when it runs, so it
+ * goes first, and `config/configure.ts` places this whole thing before the two steps that derive
+ * collections. They were two exports called from a one-line lambda in the config chain; the
+ * chain names one step per folder now.
+ */
+export declare const configurePanel: <T extends Parameters<typeof withIcons>[0]>(config: T) => {
+    panel?: Omit<PanelConfig, "$access">;
+} & {
+    readonly panel: {
+        readonly routes: Record<string, import("./types.js").CustomPanelRoute>;
+        readonly language: "fr" | "en";
+        readonly navigation: {
+            readonly groups: readonly [...{
+                label: string;
+                icon: Component<IconProps>;
+            }[], {
+                readonly label: "content";
+                readonly icon: Component<import("@lucide/svelte").LucideProps, {}, "">;
+            }, {
+                readonly label: "system";
+                readonly icon: Component<import("@lucide/svelte").LucideProps, {}, "">;
+            }, {
+                readonly label: "collections";
+                readonly icon: Component<import("@lucide/svelte").LucideProps, {}, "">;
+            }, {
+                readonly label: "areas";
+                readonly icon: Component<import("@lucide/svelte").LucideProps, {}, "">;
+            }];
+        };
+        readonly components: {
+            readonly dashboard?: Component<{
+                entries: import("../../panel/pages/dashboard/types").DashboardEntry[];
+                user?: import("../auth/types").User;
+            }, {}, string> | undefined;
+            readonly header: Component<{}, {}, string>[];
+        };
+        readonly css?: string;
+    };
+};
+export {};

package/dist/core/panel/configure.js

@@ -0,0 +1,56 @@
+import { Book, BookCopy, BookType, SlidersVertical } from '@lucide/svelte';
+/**
+ * The slug → icon map the panel navigates by, gathered from every prototype config.
+ *
+ * A feature-derived collection (upload's `<slug>Directories`, versions' aliases) has no entry:
+ * `panel` is listed before `upload` and `versions`, so they do not exist yet when this runs. That
+ * is the behaviour the chain had before the panel became a feature, and the feature list is where
+ * it is now declared — see index.ts.
+ */
+const withIcons = (config) => {
+    const icons = {};
+    // Add icons
+    for (const collection of config.collections || []) {
+        icons[collection.slug] = collection.icon;
+    }
+    for (const area of config.areas || []) {
+        icons[area.slug] = area.icon;
+    }
+    return { ...config, icons };
+};
+/**
+ * The panel's own config defaults: navigation groups, language, header components.
+ *
+ * Read `index.ts` for what this is part of. This file is one half of it; `icons.ts` is the other.
+ */
+const withDefaults = (config) => {
+    //
+    const panelNavigationGroups = [
+        ...(config.panel?.navigation?.groups || []),
+        { label: 'content', icon: BookType },
+        { label: 'system', icon: SlidersVertical },
+        { label: 'collections', icon: BookCopy },
+        { label: 'areas', icon: Book }
+    ];
+    const panel = {
+        ...config.panel,
+        routes: config.panel?.routes ? config.panel.routes : {},
+        language: config.panel?.language || 'en',
+        navigation: { groups: panelNavigationGroups },
+        components: {
+            header: config.panel?.components?.header || [],
+            ...(config.panel?.components?.dashboard && { dashboard: config.panel.components.dashboard })
+        }
+    };
+    return { ...config, panel };
+};
+/**
+ * What every config needs before a panel can render it: the slug → icon map, and `panel` itself
+ * with its navigation groups, language and header components filled in.
+ *
+ * Two steps and one order — the icon map covers the collections that exist when it runs, so it
+ * goes first, and `config/configure.ts` places this whole thing before the two steps that derive
+ * collections. They were two exports called from a one-line lambda in the config chain; the
+ * chain names one step per folder now.
+ */
+export const configurePanel = (config) => withDefaults(withIcons(config));

package/dist/core/panel/types.d.ts

@@ -0,0 +1,61 @@
+import type { Component } from 'svelte';
+import type { IconProps } from '@lucide/svelte';
+import type { User } from '../auth/types.js';
+import type { PanelLanguage } from '../i18n/index.js';
+import type { DashboardEntry } from '../../panel/pages/dashboard/types.js';
+import type { BuiltCollectionClient } from '../config/types.js';
+/** The groups the panel's sidebar shows, and the icon each carries. */
+export type NavigationConfig = {
+    groups: Array<{
+        label: string;
+        icon: Component<IconProps>;
+    }>;
+};
+/** What an author writes under `panel`. */
+export type PanelConfig = {
+    /** who can accesss the panel */
+    $access?: (user: User | undefined) => boolean;
+    /** Custom panel routes that render a given component */
+    routes?: Record<string, CustomPanelRoute>;
+    /** The panel language, "en" or "fr" supports only */
+    language?: PanelLanguage;
+    /** Sidebar navigation groups labels and icons */
+    navigation?: NavigationConfig;
+    /** Specific components */
+    components?: {
+        /** Dashboard header */
+        header?: Component[];
+        /** Collection header */
+        collectionHeader?: Component<{
+            config: BuiltCollectionClient;
+        }>[];
+        /** Full dashboard component */
+        dashboard?: Component<{
+            entries: DashboardEntry[];
+            user?: User;
+        }>;
+    };
+    /** a relative path from the "static" directory or an external url
+     * @example
+     * // for static/assets/custom.css
+     * css : '/assets/custom.css'
+     */
+    css?: string;
+};
+export type CollectionPanelConfig = false | {
+    /** Description for the collection/area, basically displayed on the dashboard */
+    description?: string;
+    /** Sidebar navigation group */
+    group?: string;
+    /** Dashboard settings */
+    dashboard?: {
+        layout?: 'rows' | 'grid';
+        maxEntries?: number;
+    } | false;
+};
+export type CustomPanelRoute = {
+    group?: string;
+    label: string;
+    icon?: Component<IconProps>;
+    component: Component;
+};

package/dist/core/pipeline/build-document.server.d.ts

@@ -0,0 +1,26 @@
+import type { DocumentRows } from '../adapter.js';
+import type { BuiltArea, BuiltCollection } from '../config/types.js';
+import type { GenericDoc } from '../prototype/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Assembles one document out of the rows it is stored across.
+ *
+ * This half used to live in the adapter, which is why the database layer merged a blank document,
+ * read `event.params.panel` to decide which bookkeeping to keep, and called back up into the local
+ * API to walk relations. None of it needs a table: rows arrive keyed by document path, and what
+ * happens to them from here is a question about documents.
+ */
+export declare const buildDocument: <T extends GenericDoc = GenericDoc>(rows: DocumentRows, args: {
+    config: BuiltCollection | BuiltArea;
+    event: RequestEvent;
+    locale?: string | undefined;
+    depth?: number;
+    /** Merge the blank document, so every field the config declares is present. */
+    withBlank?: boolean;
+    /**
+     * Keep a child row's own bookkeeping on it — `position`, `path`, `ownerId`, `locale` — and
+     * the edit lock on the document. An API read wants the document; an editor that writes blocks
+     * back in place wants the bookkeeping too.
+     */
+    withRowMeta?: boolean;
+}) => Promise<T>;

package/dist/core/pipeline/build-document.server.js

@@ -0,0 +1,83 @@
+import { isObjectLiteral, omit } from '../../util/object.js';
+import deepmerge from 'deepmerge';
+import { unflatten } from 'flat';
+import { logger } from '../logger.server.js';
+/**
+ * Assembles one document out of the rows it is stored across.
+ *
+ * This half used to live in the adapter, which is why the database layer merged a blank document,
+ * read `event.params.panel` to decide which bookkeeping to keep, and called back up into the local
+ * API to walk relations. None of it needs a table: rows arrive keyed by document path, and what
+ * happens to them from here is a question about documents.
+ */
+export const buildDocument = async (rows, args) => {
+    const { config, event, locale, depth = 0, withBlank = true, withRowMeta = false } = args;
+    const { rime } = event.locals;
+    const flatDoc = { ...rows.base };
+    for (const block of rows.blocks) {
+        flatDoc[`${block.path}.${block.position}`] = stripRowMeta(block, withRowMeta);
+    }
+    for (const node of rows.tree) {
+        if (!node._children)
+            node._children = [];
+        flatDoc[`${node.path}.${node.position}`] = stripRowMeta(node, withRowMeta);
+    }
+    for (const relation of rows.relations) {
+        if (!relation.documentId) {
+            logger.warn(`orphean ${config.slug} relation : ${relation.id}`);
+            continue;
+        }
+        // A relation row belongs to the locale it was written in, or to every locale if it has none.
+        if (relation.locale && relation.locale !== locale)
+            continue;
+        const path = relation.path;
+        const parentPath = path.split('.').slice(0, -1).join('.');
+        // A parent path ending in `.<digits>` means the relation sits inside a blocks or tree array,
+        // so its owner must have been placed above. If it was not, the row outlived it.
+        if (/.*\.[\d]+$/.test(parentPath) && !flatDoc[parentPath]) {
+            logger.warn(`Orphean ${config.slug} relation at ${path} with id ${relation.id} because parent path ${parentPath} doesn't exist in the document`);
+            continue;
+        }
+        let output;
+        if (depth > 0) {
+            output = await rime
+                .collection(relation.relationTo)
+                .findById({ id: relation.documentId, locale: relation.locale, depth: depth - 1 });
+        }
+        else {
+            output = (withRowMeta ? relation : omit(['position', 'ownerId', 'path'], relation));
+        }
+        flatDoc[path] = [...(flatDoc[path] || []), output];
+    }
+    let doc = cleanEmptyElementsInArrays(unflatten(flatDoc));
+    if (withBlank) {
+        const blank = rime.config.isCollection(config.slug)
+            ? rime.collection(config.slug).blank()
+            : rime.area(config.slug).blank();
+        doc = deepmerge(blank, doc, { arrayMerge: (_, incoming) => incoming });
+    }
+    return doc;
+};
+/**
+ * A child row's own bookkeeping, dropped unless the caller asked to keep it.
+ *
+ * `path` and `position` are read before this to place the row, so they are only ever removed
+ * from what the document carries, never from what the assembly needs.
+ */
+const stripRowMeta = (row, withRowMeta) => withRowMeta ? row : omit(['position', 'path', 'ownerId', 'locale'], row);
+/** Drop the holes left where a row was expected and none came back. */
+const cleanEmptyElementsInArrays = (value) => {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => cleanEmptyElementsInArrays(item))
+            .filter((item) => item !== null && item !== undefined);
+    }
+    if (isObjectLiteral(value)) {
+        const cleaned = {};
+        for (const key in value) {
+            cleaned[key] = cleanEmptyElementsInArrays(value[key]);
+        }
+        return cleaned;
+    }
+    return value;
+};

package/dist/core/pipeline/build.server.d.ts

@@ -0,0 +1,23 @@
+import type { PrototypeDefinition } from '../prototype/define.js';
+import type { Dic } from '../../util/types.js';
+/** One config, with its `$hooks` resolved: the authored hooks going in, the pipeline coming out. */
+export declare const augmentHooks: <T extends Dic>(definition: Pick<PrototypeDefinition, "hooks">, config: T) => T & {
+    $hooks: Dic;
+};
+/**
+ * Resolves every prototype config's pipeline, once the whole config exists.
+ *
+ * The **last** step of the config chain, and the only place a pipeline is built. By the time it
+ * runs, the features have derived whatever they derive — upload's `<slug>Directories`, versions'
+ * version tables — so a derived config is resolved by the same line as an authored one, from the same
+ * three inputs: the prototype's own hooks, the hooks of the features this config enables, and the
+ * author's `$hooks`.
+ *
+ * That is why nothing carries a second copy of anything: a config derived before this runs never
+ * has a pipeline to inherit, and never needs one rebuilt.
+ *
+ * Each prototype's `features` comes off its **isomorphic** half and its hooks from the
+ * `hooks.server.ts` beside it — never through `definition.server.ts`, which spreads `{ ...base }`
+ * at module scope. See rule 3 in CONTRIBUTING.md; the failure has no symptom but a missing title.
+ */
+export declare const resolvePipelines: <T extends Dic>(config: T) => T;

package/dist/core/pipeline/build.server.js

@@ -0,0 +1,76 @@
+import { areaHooks } from '../prototype/area/hooks.server.js';
+import { collectionHooks } from '../prototype/collection/hooks.server.js';
+import { sortDocumentProps } from './hooks/sort-document-props.server.js';
+/** Every timing a pipeline can carry. A prototype declares nothing for the ones it has no use
+ *  for — an area has no create or delete. */
+const TIMINGS = [
+    'beforeOperation',
+    'beforeRead',
+    'beforeCreate',
+    'afterCreate',
+    'beforeUpdate',
+    'afterUpdate',
+    'beforeDelete',
+    'afterDelete'
+];
+/**
+ * Composes one config's pipeline out of the two layers that contribute to it, and orders it.
+ *
+ * **The list order is the run order**, and that is the whole of it. Whether a hook applies to this
+ * config is the guard beside it in the list — `when(isAuth, …)` — so all this adds is the
+ * consumer's own hooks and the finaliser.
+ */
+const buildPipeline = (definition, config, consumer) => {
+    const pipeline = {};
+    for (const timing of TIMINGS) {
+        pipeline[timing] = [
+            // A hook belonging to a feature runs only where that feature is enabled; a hook belonging
+            // to none is the prototype's own and always runs.
+            // Every placed hook. Which of them *applies* to this config is the guard beside it in the
+            // list — `when(isAuth, …)` — asked when the hook runs rather than filtered here, so a
+            // config and its pipeline are the same list.
+            ...(definition.hooks?.[timing] ?? []),
+            // A consumer's hooks are appended. They cannot interleave with the placed ones, which is
+            // the cost of a written order.
+            ...(consumer?.[timing] ?? []),
+            /**
+             * And then the finaliser, after everything including the consumer's.
+             *
+             * `sortDocumentProps` is not a participant — nothing may precede it and nothing may follow,
+             * so it is appended rather than placed. In no list, because a list is for things whose
+             * position is a choice.
+             */
+            ...(timing === 'beforeRead' ? [sortDocumentProps] : [])
+        ];
+    }
+    return pipeline;
+};
+/** One config, with its `$hooks` resolved: the authored hooks going in, the pipeline coming out. */
+export const augmentHooks = (definition, config) => ({
+    ...config,
+    $hooks: buildPipeline(definition, config, config.$hooks)
+});
+/**
+ * Resolves every prototype config's pipeline, once the whole config exists.
+ *
+ * The **last** step of the config chain, and the only place a pipeline is built. By the time it
+ * runs, the features have derived whatever they derive — upload's `<slug>Directories`, versions'
+ * version tables — so a derived config is resolved by the same line as an authored one, from the same
+ * three inputs: the prototype's own hooks, the hooks of the features this config enables, and the
+ * author's `$hooks`.
+ *
+ * That is why nothing carries a second copy of anything: a config derived before this runs never
+ * has a pipeline to inherit, and never needs one rebuilt.
+ *
+ * Each prototype's `features` comes off its **isomorphic** half and its hooks from the
+ * `hooks.server.ts` beside it — never through `definition.server.ts`, which spreads `{ ...base }`
+ * at module scope. See rule 3 in CONTRIBUTING.md; the failure has no symptom but a missing title.
+ */
+export const resolvePipelines = (config) => {
+    const resolve = (definition, configs) => (configs ?? []).map((c) => augmentHooks(definition, c));
+    return {
+        ...config,
+        collections: resolve({ hooks: collectionHooks }, config.collections),
+        areas: resolve({ hooks: areaHooks }, config.areas)
+    };
+};

package/dist/core/pipeline/config-map/build-tree-map.d.ts

@@ -0,0 +1,4 @@
+import type { TreeBlock } from '../../prototype/types.js';
+import type { TreeBuilder } from '../../../fields/tree/index.js';
+import type { ConfigMap } from './types.js';
+export declare function buildTreeFieldsMap(treeConfig: TreeBuilder, treeItems: TreeBlock[], basePath: string): ConfigMap;

package/dist/core/pipeline/config-map/index.d.ts

@@ -0,0 +1,6 @@
+import type { FieldBuilder } from '../../fields/builders/field-builder.js';
+import type { GenericDoc } from '../../prototype/types.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: FieldBuilder<Field>[]) => ConfigMap;

package/dist/core/pipeline/config-map/index.js

@@ -0,0 +1,54 @@
+import { isFormField } from '../../fields/util.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 './build-tree-map.js';
+export const buildConfigMap = (data, incomingFields) => {
+    let map = {};
+    const traverseData = (data, fields, basePath) => {
+        if (!data)
+            return;
+        basePath = basePath === '' ? basePath : `${basePath}.`;
+        for (const field of fields) {
+            if (field instanceof TabsBuilder) {
+                for (const tab of field.get.tabs) {
+                    if (tab.name in data) {
+                        traverseData(data[tab.name], tab.get.fields, tab.name);
+                    }
+                }
+                continue;
+            }
+            if (!isFormField(field))
+                continue;
+            if (!(field.name in data))
+                continue;
+            const value = data[field.name];
+            const path = `${basePath}${field.name}`;
+            map[path] = field;
+            if (field instanceof BlocksBuilder && value && Array.isArray(value)) {
+                const blocks = value;
+                for (const [index, block] of blocks.entries()) {
+                    try {
+                        const blockConfig = field.get.blocks.find((b) => b.name === block.type);
+                        if (blockConfig) {
+                            traverseData(block, blockConfig.get.fields, `${path}.${index}`);
+                        }
+                    }
+                    catch {
+                        console.warn(`block at path ${path} and postition ${index} not found but there are some residual data owned by this block`);
+                    }
+                }
+            }
+            else if (field instanceof TreeBuilder && value && Array.isArray(value)) {
+                const treeMap = buildTreeFieldsMap(field, value, path);
+                map = { ...map, ...treeMap };
+            }
+            else if (field instanceof GroupFieldBuilder) {
+                traverseData(value, field.get.fields, path);
+            }
+        }
+    };
+    traverseData(data, incomingFields, '');
+    return map;
+};

package/dist/core/pipeline/define-hook.d.ts

@@ -0,0 +1,42 @@
+import type { DocType } from '../prototype/types.js';
+import type { Hook, HookBeforeOperation, Operation } from './types.js';
+/**
+ * Types a hook to its timing. **The argument is the function.**
+ *
+ * ```ts
+ * export const removePrivateFields = Hooks.beforeRead(async function removePrivateFields(args) {
+ *   …
+ * });
+ * ```
+ *
+ * A **named function expression**, not an arrow: the chart and the order specs read `fn.name`, and
+ * an arrow passed as an argument has none.
+ *
+ * Each timing returns the function untouched — `run.server.ts` calls hooks directly, so a wrapper
+ * here would break every call site.
+ *
+ * Where a hook runs, and whether it applies, are both said where it is placed: a prototype's
+ * `hooks.server.ts`.
+ */
+export declare const Hooks: {
+    /** Creates a before operation hook */
+    beforeOperation: <S extends DocType = "raw">(run: HookBeforeOperation<S, Operation>) => HookBeforeOperation<S, Operation>;
+    /** Creates a before read hook */
+    beforeRead: <S extends DocType = "raw">(run: Hook<S, "read", "before">) => Hook<S, "read", "before">;
+    /** Creates a before create hook */
+    beforeCreate: <S extends DocType = "raw">(run: Hook<S, "create", "before">) => Hook<S, "create", "before">;
+    /** A hook that runs before both create and update — `augmentFieldsPassword` is the one. */
+    beforeUpsert: <S extends DocType = "raw">(run: Hook<S, "create" | "update", "before">) => Hook<S, "create" | "update", "before">;
+    /** Creates a before update hook */
+    beforeUpdate: <S extends DocType = "raw">(run: Hook<S, "update", "before">) => Hook<S, "update", "before">;
+    /** Creates a before delete hook */
+    beforeDelete: <S extends DocType = "raw">(run: Hook<S, "delete", "before">) => Hook<S, "delete", "before">;
+    /** Creates an after create hook */
+    afterCreate: <S extends DocType = "raw">(run: Hook<S, "create", "after">) => Hook<S, "create", "after">;
+    /** Creates a hook that runs after both create and update */
+    afterUpsert: <S extends DocType = "raw">(run: Hook<S, "create" | "update", "after">) => Hook<S, "create" | "update", "after">;
+    /** Creates an after update hook */
+    afterUpdate: <S extends DocType = "raw">(run: Hook<S, "update", "after">) => Hook<S, "update", "after">;
+    /** Creates an after delete hook */
+    afterDelete: <S extends DocType = "raw">(run: Hook<S, "delete", "after">) => Hook<S, "delete", "after">;
+};

package/dist/core/pipeline/define-hook.js

@@ -0,0 +1,40 @@
+/**
+ * Types a hook to its timing. **The argument is the function.**
+ *
+ * ```ts
+ * export const removePrivateFields = Hooks.beforeRead(async function removePrivateFields(args) {
+ *   …
+ * });
+ * ```
+ *
+ * A **named function expression**, not an arrow: the chart and the order specs read `fn.name`, and
+ * an arrow passed as an argument has none.
+ *
+ * Each timing returns the function untouched — `run.server.ts` calls hooks directly, so a wrapper
+ * here would break every call site.
+ *
+ * Where a hook runs, and whether it applies, are both said where it is placed: a prototype's
+ * `hooks.server.ts`.
+ */
+export const Hooks = {
+    /** Creates a before operation hook */
+    beforeOperation: (run) => run,
+    /** Creates a before read hook */
+    beforeRead: (run) => run,
+    /** Creates a before create hook */
+    beforeCreate: (run) => run,
+    /** A hook that runs before both create and update — `augmentFieldsPassword` is the one. */
+    beforeUpsert: (run) => run,
+    /** Creates a before update hook */
+    beforeUpdate: (run) => run,
+    /** Creates a before delete hook */
+    beforeDelete: (run) => run,
+    /** Creates an after create hook */
+    afterCreate: (run) => run,
+    /** Creates a hook that runs after both create and update */
+    afterUpsert: (run) => run,
+    /** Creates an after update hook */
+    afterUpdate: (run) => run,
+    /** Creates an after delete hook */
+    afterDelete: (run) => run
+};

package/dist/core/pipeline/extract-data.server.d.ts

@@ -0,0 +1,18 @@
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Turns an incoming request body into document data.
+ *
+ * Lives in operations/, not rest/: both the REST handlers and the panel's form actions call it,
+ * and what it produces is exactly what an operation consumes.
+ *
+ * Extracts data from a request based on its content type
+ * Handles both multipart/form-data, form-urlencoded and JSON requests
+ *
+ * @example
+ * // In a route handler
+ * const [error, data] = await trycatch(() => extractData(event.request));
+ * if (error) {
+ *   return handleError(error, { context: 'api' });
+ * }
+ */
+export declare const extractData: <T extends Record<string, any>>(request: RequestEvent["request"]) => Promise<T>;

package/dist/core/pipeline/extract-data.server.js

@@ -0,0 +1,78 @@
+import { RimeFormError } from '../errors/index.js';
+import { normalizeValue } from '../../util/coerce.js';
+import { flatten, unflatten } from 'flat';
+/**
+ * Converts FormData to a structured document object
+ * Normalizes form values and handles flattened key structures
+ *
+ * @example
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.active', 'true');
+ * const data = formDataToData(formData);
+ * // Result: { user: { name: 'John', active: true } }
+ */
+const formDataToData = (formData) => {
+    const flatData = Object.fromEntries(formData.entries());
+    for (const key of Object.keys(flatData)) {
+        flatData[key] = normalizeValue(flatData[key]);
+    }
+    return unflatten(flatData);
+};
+/**
+ * Converts a JSON object to a structured document object
+ * Normalizes values and ensures consistent data structure
+ *
+ * @example
+ * const jsonData = { user: { name: 'John', active: 'true' } };
+ * const data = jsonDataToData(jsonData);
+ * // Result: { user: { name: 'John', active: true } }
+ */
+const jsonDataToData = (jsonData) => {
+    const flatData = flatten(jsonData);
+    for (const key of Object.keys(flatData)) {
+        flatData[key] = normalizeValue(flatData[key]);
+    }
+    return unflatten(flatData);
+};
+/**
+ * Turns an incoming request body into document data.
+ *
+ * Lives in operations/, not rest/: both the REST handlers and the panel's form actions call it,
+ * and what it produces is exactly what an operation consumes.
+ *
+ * Extracts data from a request based on its content type
+ * Handles both multipart/form-data, form-urlencoded and JSON requests
+ *
+ * @example
+ * // In a route handler
+ * const [error, data] = await trycatch(() => extractData(event.request));
+ * if (error) {
+ *   return handleError(error, { context: 'api' });
+ * }
+ */
+export const extractData = async (request) => {
+    let data;
+    try {
+        const contentType = request.headers.get('content-type');
+        // One branch for both form encodings on purpose: request.formData() decodes
+        // multipart/form-data and application/x-www-form-urlencoded alike, per the Fetch spec, so
+        // the two only ever differ on the wire.
+        const isFormEncoded = contentType?.startsWith('multipart/form-data') ||
+            contentType?.startsWith('application/x-www-form-urlencoded');
+        if (isFormEncoded) {
+            /** Handle formData input */
+            const formData = await request.formData();
+            data = formDataToData(formData);
+        }
+        else {
+            /** Handle JSON input */
+            const jsonData = await request.json();
+            data = jsonDataToData(jsonData);
+        }
+    }
+    catch (err) {
+        throw new RimeFormError({ _form: err.message });
+    }
+    return data;
+};

package/dist/core/pipeline/hook-name.server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A hook's declared name, or `anonymous`.
+ *
+ * All that is left of `marksOf`. Names are set on the function at runtime by `Hooks.*` rather than
+ * carried in its type — a function's own `name` is non-writable, so `declare` uses
+ * `defineProperty`, which also makes the hook show up under it in stack traces.
+ *
+ * The fallback is not defensive padding: a hook can reach a pipeline without having gone through
+ * `Hooks.*` at all, and a consumer's bare function is exactly that.
+ */
+export declare const hookName: (hook: unknown) => string;