rimecms 0.31.4 → 0.32.0

package/dist/core/prototype/collection/upload/disk/delete.server.js

@@ -0,0 +1,106 @@
+import { logger } from '../../../../logger.server.js';
+import { isFormField } from '../../../../fields/util.js';
+import { existsSync, unlink, unlinkSync } from 'fs';
+import path from 'path';
+/**
+ * Whether this collection's **own table** holds `name` — which is the only question this file has
+ * about where a filename can be.
+ *
+ * A config with a versions table keeps only its `$root()` fields on its own table; everything else is the
+ * versions's, and the versions table is a registered collection in its own right. `filename` is not a root
+ * field (only `_path` is, on upload), so on a versioned upload collection it lives on the versions table
+ * and the base table has no such column at all.
+ *
+ * This replaces a pair of tests that named the versions feature — `!hasVersionsSuffix(slug)` to
+ * drop the version tables from the scan, then `versions ? withVersionsSuffix(slug) : slug` to map each
+ * base onto one. Same set of slugs, arrived at by asking the schema instead of reading a suffix,
+ * and with no feature importing another feature to do it.
+ */
+const ownsField = (rime, config, name) => {
+    const field = config.fields.filter(isFormField).find((one) => one.name === name);
+    if (!field)
+        return false;
+    return config._versions ? !!field.get.root : true;
+};
+/**
+ * A given filename on disk can be shared by several document rows across unrelated upload
+ * collections — saveFile dedupes any byte-identical upload to a single file (see isSameFile).
+ *
+ * The scan goes table by table, not collection by collection, and that distinction is load-bearing
+ * for a collection whose content lives on a versions table: querying the *collection* returns one row per
+ * document (the read joins in a single content row), so a filename referenced only by an older
+ * revision would be missed and the file deleted out from under it. Querying the versions table directly
+ * sees every revision. `ownsField` above is what picks the right table without knowing why there
+ * are two.
+ *
+ * `selfId` must already be in whichever id-space `selfSlug` resolves to — a versions table row's own id,
+ * not the base row's (see `contentId` in mergeContentRow).
+ *
+ * Every configured locale is checked since a localized collection's query can otherwise miss rows
+ * in non-default locales, even though `filename` itself is never a localized field.
+ */
+const isFilenameStillReferenced = async (args) => {
+    const { rime, filename, selfSlug, selfId } = args;
+    // Every table a row carrying this filename could be in. `upload` narrows it to collections that
+    // store files at all; `ownsField` picks the one table of each that actually has the column.
+    const targetSlugs = Object.values(rime.config.collections)
+        .filter((c) => c?.upload && ownsField(rime, c, 'filename'))
+        .map((c) => c.slug);
+    const locales = rime.config.getLocalesCodes();
+    const localesToQuery = locales.length ? locales : [undefined];
+    for (const slug of targetSlugs) {
+        for (const locale of localesToQuery) {
+            const docs = await rime.collection(slug).find({
+                query: `where[filename][equals]=${filename}`,
+                latest: true,
+                locale,
+                limit: slug === selfSlug ? 2 : 1
+            });
+            const referenced = docs.some((doc) => slug !== selfSlug || doc.id !== selfId);
+            if (referenced)
+                return true;
+        }
+    }
+    return false;
+};
+export const cleanUpDocumentFile = async (args) => {
+    //
+    const { config, rime, id } = args;
+    const doc = await rime.collection(config.slug).findById({ id, latest: true });
+    try {
+        if (!doc.filename)
+            return doc;
+        const stillReferenced = await isFilenameStillReferenced({
+            rime,
+            filename: doc.filename,
+            // The table this document's own filename is in — the same expression `persistRelational`
+            // uses, read off the config rather than asked of the adapter.
+            selfSlug: config._versions?.slug ?? config.slug,
+            // The content row's id — `contentId` rather than `versionId`, so upload names no
+            // other feature. See mergeContentRow.
+            selfId: doc.contentId ?? doc.id
+        });
+        if (stillReferenced)
+            return doc;
+        const filePath = path.resolve(process.cwd(), `static/medias/${doc.filename}`);
+        // Delete original
+        unlinkSync(filePath);
+        const unlinkPath = (sizePath) => {
+            if (existsSync(sizePath)) {
+                unlink(sizePath, () => { });
+            }
+        };
+        // Process all entries in doc.sizes
+        if (doc.sizes) {
+            Object.values(doc.sizes).forEach((path) => {
+                if (typeof path === 'string') {
+                    unlinkPath(`static/${path}`);
+                }
+            });
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+    return doc;
+};

package/dist/core/prototype/collection/upload/disk/save.server.d.ts

@@ -0,0 +1,32 @@
+import type { ImageSizesConfig } from '../types.js';
+import type { Dic } from '../../../../../util/types.js';
+/**
+ * Saves a file to disk with deduplication and generates image sizes if needed
+ * Checks if identical file already exists before creating a new one
+ * @example
+ * const file = event.request.formData.get('file');
+ * const { filename, imageSizes } = await saveFile(file, config.imageSizes);
+ */
+export declare const saveFile: (file: File, imagesSizes: ImageSizesConfig[] | false) => Promise<{
+    filename: string;
+    imageSizes: Record<string, string>;
+}>;
+/**
+ * Generates various image sizes based on configuration
+ * Creates resized versions and format conversions as specified
+ * @example
+ * const sizes = await generateSizes({
+ *   name: 'image',
+ *   extension: 'jpg',
+ *   sizes: imageSizesConfig,
+ *   buffer: imageBuffer
+ * });
+ */
+export declare const generateSizes: ({ sizes, buffer, name, extension }: GenerateSizeArgs) => Promise<Dic>;
+type GenerateSizeArgs = {
+    sizes: ImageSizesConfig[];
+    buffer: Buffer;
+    name: string;
+    extension: string;
+};
+export {};

package/dist/core/prototype/collection/upload/disk/save.server.js

@@ -0,0 +1,190 @@
+import { RimeError } from '../../../../errors/index.js';
+import { normalizeFileName } from '../../../../../util/file.js';
+import { pick } from '../../../../../util/object.js';
+import { toCamelCase } from '../../../../../util/string.js';
+import crypto from 'crypto';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
+import path from 'path';
+import sharp from 'sharp';
+/**
+ * Compares a buffer with an existing file to determine if they are identical
+ * Uses file size as a quick check before comparing content hashes
+ * @example
+ * const identical = isSameFile(fileBuffer, '/path/to/file.jpg');
+ * if (identical) {
+ *   console.log('Files are the same');
+ * }
+ */
+const isSameFile = (buffer, filePath) => {
+    try {
+        // Check if file exists
+        if (!existsSync(filePath))
+            return false;
+        // Compare file sizes first (quick check)
+        const stats = statSync(filePath);
+        if (stats.size !== buffer.length)
+            return false;
+        // Compare content hash (more thorough check)
+        const existingFileBuffer = readFileSync(filePath);
+        const existingFileHash = crypto.createHash('md5').update(existingFileBuffer).digest('hex');
+        const newFileHash = crypto.createHash('md5').update(buffer).digest('hex');
+        return existingFileHash === newFileHash;
+    }
+    catch {
+        // If any error occurs during comparison, assume files are different
+        return false;
+    }
+};
+/**
+ * Verifies if all image size variations already exist for a given base filename
+ * Returns a record of size names to filenames if all exist, empty object otherwise
+ * @example
+ * const sizes = checkImageSizesExist('image', 'jpg', imageSizesConfig);
+ * if (Object.keys(sizes).length > 0) {
+ *   console.log('All image sizes already exist');
+ * }
+ */
+const checkImageSizesExist = (name, extension, imagesSizes) => {
+    const sizes = {};
+    for (const size of imagesSizes) {
+        const whString = `${size.width}x${size.height}`;
+        if (!size.out || !size.out.length) {
+            // Check if the resized image exists
+            const filename = `${name}-${toCamelCase(size.name)}-${whString}.${extension}`;
+            const filePath = path.resolve(process.cwd(), `static/medias/${filename}`);
+            if (!existsSync(filePath)) {
+                return {}; // If any size doesn't exist, return empty object
+            }
+            sizes[toCamelCase(size.name)] = filename;
+        }
+        else {
+            // Check if all format conversions exist
+            const convertedFilenames = [];
+            for (const format of size.out) {
+                const filename = `${name}-${toCamelCase(size.name)}-${whString}.${format}`;
+                const filePath = path.resolve(process.cwd(), `static/medias/${filename}`);
+                if (!existsSync(filePath)) {
+                    return {}; // If any format doesn't exist, return empty object
+                }
+                convertedFilenames.push(filename);
+            }
+            sizes[toCamelCase(size.name)] = convertedFilenames.join('|');
+        }
+    }
+    return sizes;
+};
+/**
+ * Saves a file to disk with deduplication and generates image sizes if needed
+ * Checks if identical file already exists before creating a new one
+ * @example
+ * const file = event.request.formData.get('file');
+ * const { filename, imageSizes } = await saveFile(file, config.imageSizes);
+ */
+export const saveFile = async (file, imagesSizes) => {
+    const { name: initialName, extension } = normalizeFileName(file.name);
+    let name = initialName;
+    let sizes = {};
+    let filename = `${name}.${extension}`;
+    let filePath = path.resolve(process.cwd(), `static/medias/${filename}`);
+    // Get buffer once to avoid multiple arrayBuffer() calls
+    const buffer = Buffer.from(await file.arrayBuffer());
+    // Check if file exists and is identical
+    if (existsSync(filePath) && isSameFile(buffer, filePath)) {
+        // File already exists and is identical
+        // Check if image sizes already exist
+        if (imagesSizes && file.type.includes('image') && !file.type.includes('svg')) {
+            const existingSizes = checkImageSizesExist(name, extension, imagesSizes);
+            // If all sizes exist, use them
+            if (Object.keys(existingSizes).length > 0) {
+                return { filename, imageSizes: existingSizes };
+            }
+            // Otherwise, we'll need to generate the sizes
+            sizes = await generateSizes({
+                name,
+                extension,
+                sizes: imagesSizes,
+                buffer
+            });
+        }
+        return { filename, imageSizes: sizes };
+    }
+    // File doesn't exist or is different, find a unique name
+    while (existsSync(filePath)) {
+        name += `-${new Date().getTime().toString()}`;
+        filename = `${name}.${extension}`;
+        filePath = path.resolve(process.cwd(), `static/medias/${filename}`);
+    }
+    try {
+        writeFileSync(filePath, buffer);
+        if (imagesSizes && file.type.includes('image') && !file.type.includes('svg')) {
+            sizes = await generateSizes({
+                name,
+                extension,
+                sizes: imagesSizes,
+                buffer
+            });
+        }
+    }
+    catch (error) {
+        throw new RimeError(RimeError.UPLOAD, `Error while processing file: ${error.message}`);
+    }
+    return { filename, imageSizes: sizes };
+};
+/**
+ * Generates various image sizes based on configuration
+ * Creates resized versions and format conversions as specified
+ * @example
+ * const sizes = await generateSizes({
+ *   name: 'image',
+ *   extension: 'jpg',
+ *   sizes: imageSizesConfig,
+ *   buffer: imageBuffer
+ * });
+ */
+export const generateSizes = async ({ sizes, buffer, name, extension }) => {
+    const imageSizes = {};
+    for (const size of sizes) {
+        const wh = pick(['width', 'height'], size);
+        const resizedImage = sharp(buffer).resize(wh);
+        const whString = `${wh.width || ''}${wh.height && wh.width ? 'x' : ''}${wh.height || ''}`;
+        // If no output formats specified, keep original format
+        if (!size.out?.length) {
+            let resizedBuffer;
+            const shouldApplyCompression = extension === 'jpg' || extension === 'webp';
+            if (shouldApplyCompression) {
+                const compression = size.compression || 60;
+                if (extension === 'jpg') {
+                    resizedBuffer = await resizedImage.jpeg({ quality: compression }).toBuffer();
+                }
+                else {
+                    resizedBuffer = await resizedImage.webp({ quality: compression }).toBuffer();
+                }
+            }
+            else {
+                resizedBuffer = await resizedImage.toBuffer();
+            }
+            const filename = `${name}-${toCamelCase(size.name)}-${whString}.${extension}`;
+            const filePath = path.resolve(process.cwd(), `static/medias/${filename}`);
+            writeFileSync(filePath, resizedBuffer);
+            imageSizes[toCamelCase(size.name)] = filename;
+            continue;
+        }
+        // Handle format conversions
+        const convertedFiles = await Promise.all(size.out.map(async (format) => {
+            const compression = size.compression || 60;
+            let convertedImage;
+            if (format === 'jpg') {
+                convertedImage = await resizedImage.jpeg({ quality: compression }).toBuffer();
+            }
+            else {
+                convertedImage = await resizedImage.webp({ quality: compression }).toBuffer();
+            }
+            const filename = `${name}-${toCamelCase(size.name)}-${whString}.${format}`;
+            const filePath = path.resolve(process.cwd(), `static/medias/${filename}`);
+            writeFileSync(filePath, convertedImage);
+            return filename;
+        }));
+        imageSizes[toCamelCase(size.name)] = convertedFiles.join('|');
+    }
+    return imageSizes;
+};

package/dist/core/prototype/collection/upload/doc-type.d.ts

@@ -0,0 +1,14 @@
+import type { DocTypeContribution } from '../../../dev/codegen/types/contributions.server.js';
+import type { ImageSizesConfig } from './types.js';
+import type { Dic } from '../../../../util/types.js';
+/**
+ * What an upload document's type carries, and which of its fields describe themselves.
+ *
+ * Three reads of `collection.upload` in `dev/codegen/types` — the `UploadDoc` intersection, the
+ * `sizes` object, and the filter that keeps the per-size fields from appearing twice.
+ */
+export declare const uploadDocType: (config: {
+    upload?: {
+        imageSizes?: ImageSizesConfig[];
+    };
+} | Dic) => DocTypeContribution;

package/dist/core/prototype/collection/upload/doc-type.js

@@ -0,0 +1,28 @@
+/**
+ * What an upload document's type carries, and which of its fields describe themselves.
+ *
+ * Three reads of `collection.upload` in `dev/codegen/types` — the `UploadDoc` intersection, the
+ * `sizes` object, and the filter that keeps the per-size fields from appearing twice.
+ */
+export const uploadDocType = (config) => {
+    const sizes = config.upload?.imageSizes ?? [];
+    const contribution = { extends: ['UploadDoc'] };
+    if (!sizes.length)
+        return contribution;
+    return {
+        ...contribution,
+        members: [sizesMember(sizes)],
+        /**
+         * Each image size becomes a column named after it, and its type comes from the `sizes` object
+         * above rather than from the field's own builder — so the field itself generates nothing.
+         * Every other field, blocks and tabs included, generates its type as on any collection.
+         */
+        fields: (field) => !sizes.some((s) => s.name === field.name)
+    };
+};
+/** One member holding every generated size, matching what `generateImageSizesType` emitted. */
+const sizesMember = (sizes) => `sizes:{${sizes
+    .map((size) => size.out && size.out.length > 1
+    ? size.out.map((format) => `${size.name}_${format}: string`).join(', ')
+    : `${size.name}: string`)
+    .join(', ')}}`;

package/dist/core/prototype/collection/upload/enabled.d.ts

@@ -0,0 +1,8 @@
+import type { Dic } from '../../../../util/types.js';
+/**
+ * A collection stores files by declaring `upload`.
+ *
+ * `Dic`, not a narrow shape: an area has no `upload` member at all, and every caller that guards
+ * a step here holds one config or the other.
+ */
+export declare const isUpload: (config: Dic) => boolean;

package/dist/core/prototype/collection/upload/enabled.js

@@ -0,0 +1,7 @@
+/**
+ * A collection stores files by declaring `upload`.
+ *
+ * `Dic`, not a narrow shape: an area has no `upload` member at all, and every caller that guards
+ * a step here holds one config or the other.
+ */
+export const isUpload = (config) => !!config.upload;

package/dist/core/prototype/collection/upload/ensure.server.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltCollection } from '../../../../types.js';
+/**
+ * Creates static/medias when any collection has upload enabled.
+ *
+ * Lives with the upload feature rather than in dev/ensure.server.ts: the other ensure*
+ * helpers assert that a project was initialised and throw when it wasn't, while this one is
+ * a runtime side effect of the upload feature being switched on, and it runs on every config
+ * build (see core/config/context.server.ts).
+ */
+export declare function ensureMedias<C extends {
+    collections?: BuiltCollection[];
+}>(config: C): void;

package/dist/core/prototype/collection/upload/ensure.server.js

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Creates static/medias when any collection has upload enabled.
+ *
+ * Lives with the upload feature rather than in dev/ensure.server.ts: the other ensure*
+ * helpers assert that a project was initialised and throw when it wasn't, while this one is
+ * a runtime side effect of the upload feature being switched on, and it runs on every config
+ * build (see core/config/context.server.ts).
+ */
+export function ensureMedias(config) {
+    const hasUpload = (config.collections || []).some((collection) => !!collection.upload);
+    if (hasUpload) {
+        const mediasDirectory = path.resolve(process.cwd(), 'static/medias');
+        if (!existsSync(mediasDirectory)) {
+            mkdirSync(mediasDirectory, { recursive: true });
+        }
+    }
+}

package/dist/core/prototype/collection/upload/hooks/clean-up-files.server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook executed before deleting a document to clean up associated files from storage.
+ *
+ * This hook performs the following operations:
+ * 1. Retrieves the document ID from the deletion event
+ * 2. Locates and removes all files associated with the document from storage
+ * 3. Ensures no orphaned files remain after document deletion
+ *
+ */
+export declare const cleanUpFiles: import("../../../../pipeline/types").Hook<"raw", "delete", "before">;

package/dist/core/prototype/collection/upload/hooks/clean-up-files.server.js

@@ -0,0 +1,17 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { cleanUpDocumentFile } from '../disk/delete.server.js';
+/**
+ * Hook executed before deleting a document to clean up associated files from storage.
+ *
+ * This hook performs the following operations:
+ * 1. Retrieves the document ID from the deletion event
+ * 2. Locates and removes all files associated with the document from storage
+ * 3. Ensures no orphaned files remain after document deletion
+ *
+ */
+export const cleanUpFiles = Hooks.beforeDelete(async function cleanUpFiles(args) {
+    const config = args.config;
+    const id = args.context.params.id || '';
+    await cleanUpDocumentFile({ config, rime: args.event.locals.rime, id });
+    return args;
+});

package/dist/core/prototype/collection/upload/hooks/convert-base64.server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hook executed before save/update operations to convert base64 encoded files to File objects.
+ *
+ * @description
+ * This hook performs the following operations:
+ * 1. Checks if the incoming document contains a base64 encoded file
+ * 2. Converts it to a proper File object for disk storage
+ * 3. Preserves or generates metadata (filename, size, type)
+ *
+ * @param args Hook arguments containing the document to process
+ * @returns Updated args object with converted file data
+ */
+export declare const castBase64ToFile: import("../../../../pipeline/types").Hook<"upload", "create" | "update", "before">;

package/dist/core/prototype/collection/upload/hooks/convert-base64.server.js

@@ -0,0 +1,36 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { jsonFileToFile } from '../util/converter.server.js';
+import { RimeError } from '../../../../errors/index.js';
+import { isFile } from '../../../../../util/file.js';
+/**
+ * Hook executed before save/update operations to convert base64 encoded files to File objects.
+ *
+ * @description
+ * This hook performs the following operations:
+ * 1. Checks if the incoming document contains a base64 encoded file
+ * 2. Converts it to a proper File object for disk storage
+ * 3. Preserves or generates metadata (filename, size, type)
+ *
+ * @param args Hook arguments containing the document to process
+ * @returns Updated args object with converted file data
+ */
+export const castBase64ToFile = Hooks.beforeUpsert(async function castBase64ToFile(args) {
+    let data = args.data;
+    if (data?.file && !isFile(data.file)) {
+        try {
+            const { file, filename, filesize, mimeType } = jsonFileToFile(data.file);
+            data = {
+                ...data,
+                file,
+                filename: data.filename || filename,
+                filesize: data.filesize || filesize,
+                mimeType: data.mimeType || mimeType
+            };
+        }
+        catch (err) {
+            args.event.locals.rime.logger.error('Failed to convert base64 string to File object', err.message);
+            throw new RimeError(RimeError.UPLOAD, 'Unable to process file');
+        }
+    }
+    return { ...args, data };
+});

package/dist/core/prototype/collection/upload/hooks/extract-path.server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook executed before save/update operations on {uploadSlug}_directories collections
+ * the function normalize and validate path ({slug}_directories.id).
+ * Then extract parent, name from the given path.
+ */
+export declare const exctractPath: import("../../../../pipeline/types").Hook<"directory", "create" | "update", "before">;

package/dist/core/prototype/collection/upload/hooks/extract-path.server.js

@@ -0,0 +1,25 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { RimeError } from '../../../../errors/index.js';
+import { trycatchSync } from '../../../../../util/function.js';
+import { getSegments } from '../util/path.js';
+/**
+ * Hook executed before save/update operations on {uploadSlug}_directories collections
+ * the function normalize and validate path ({slug}_directories.id).
+ * Then extract parent, name from the given path.
+ */
+export const exctractPath = Hooks.beforeUpsert(async function exctractPath(args) {
+    let data = args.data;
+    if (data?.id) {
+        const [error, segments] = trycatchSync(() => getSegments(data.id));
+        if (error) {
+            throw new RimeError(RimeError.INVALID_DATA, error.message);
+        }
+        data = {
+            ...data,
+            id: segments.path,
+            name: segments.name,
+            parent: segments.parent
+        };
+    }
+    return { ...args, data };
+});

package/dist/core/prototype/collection/upload/hooks/handle-path-creation.server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook executed before save/update operations on an upload collections
+ * the function get the document _path and check if it exists,
+ * if it doesn't it create {upload_slug}_directories entries recursively
+ */
+export declare const handlePathCreation: import("../../../../pipeline/types").Hook<"upload", "create" | "update", "before">;

package/dist/core/prototype/collection/upload/hooks/handle-path-creation.server.js

@@ -0,0 +1,82 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { UPLOAD_PATH } from '../constant.js';
+import { logger } from '../../../../logger.server.js';
+import { directoriesOf } from '../naming.js';
+import { trycatch } from '../../../../../util/function.js';
+import { getSegments } from '../util/path.js';
+/**
+ * Hook executed before save/update operations on an upload collections
+ * the function get the document _path and check if it exists,
+ * if it doesn't it create {upload_slug}_directories entries recursively
+ */
+export const handlePathCreation = Hooks.beforeUpsert(async function handlePathCreation(args) {
+    const { rime } = args.event.locals;
+    const data = args.data;
+    /**
+     * An update that says nothing about the path leaves it alone; a create always has one.
+     *
+     * `getSegments` answers `root` for a missing *or null* path, which is what makes the second
+     * half true — and null is the case that matters, because the blank document a create is
+     * merged with puts `_path: null` in `data`. A test for `'_path' in data` therefore never
+     * fires on a create, which is why the **adapter** was the thing defaulting it.
+     */
+    if (args.operation !== 'create' && !args.data._path)
+        return args;
+    /**
+     * Normalise first — `getSegments` drops empty segments and trailing separators, and
+     * collapses a one-segment path to `root`. What is stored has to be the normalised form,
+     * because every directory row below is created under it and every lookup goes against it.
+     *
+     * The **adapter** did this, in `insertPrototype`, behind `'upload' in config` — a feature
+     * reaching into a write. It also re-created the directory row for the normalised path,
+     * which is what this hook already does and does properly: recursively, for every segment,
+     * through the public API. Only the assignment was missing here, and it had to move above
+     * the early return below to happen at all.
+     *
+     * `getSegments` throws `BAD_REQUEST` on an invalid path, which is the same rejection the
+     * adapter made, one layer earlier.
+     */
+    const pathInfo = getSegments(args.data._path);
+    args.data._path = pathInfo.path;
+    const directorySlug = directoriesOf(args.config);
+    const [, dir] = await trycatch(() => rime.collection(directorySlug).findById({
+        select: ['id'],
+        id: data._path
+    }));
+    if (dir)
+        return args;
+    // Split the path into segments
+    const segments = pathInfo.path.split(UPLOAD_PATH.SEPARATOR);
+    // Process all segments, including root
+    let currentPath = '';
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const parentPath = currentPath || null; // For root, parent is null
+        // Build the current path
+        currentPath = currentPath ? `${currentPath}${UPLOAD_PATH.SEPARATOR}${segment}` : segment;
+        // Check if this segment exists
+        const [, segExists] = await trycatch(() => rime.collection(directorySlug).findById({
+            select: ['id'],
+            id: currentPath
+        }));
+        // If the segment doesn't exist, create it
+        if (!segExists) {
+            const [createError] = await trycatch(() => rime.collection(directorySlug).create({
+                data: {
+                    id: currentPath,
+                    parent: parentPath,
+                    name: segment,
+                    createdAt: new Date(),
+                    updatedAt: new Date()
+                }
+            }));
+            if (createError) {
+                logger.error(`Failed to create directory segment ${currentPath}`, createError);
+                // If we can't create a segment, fall back to root
+                args.data._path = UPLOAD_PATH.ROOT_NAME;
+                return args;
+            }
+        }
+    }
+    return args;
+});

package/dist/core/prototype/collection/upload/hooks/index.server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `upload.someHook`.
+ *
+ * A barrel and nothing else — `module.server.ts` beside it is the pair half `$rime/modules:` resolves, and
+ * only files named exactly `module(.server).ts` are, so this one is invisible to that mechanism.
+ * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
+ * one import line per hook.
+ */
+export { castBase64ToFile } from './convert-base64.server.js';
+export { cleanUpFiles } from './clean-up-files.server.js';
+export { handlePathCreation } from './handle-path-creation.server.js';
+export { populateSizes } from './populate-sizes.server.js';
+export { processFileUpload } from './process-file-upload.server.js';

package/dist/core/prototype/collection/upload/hooks/index.server.js

@@ -0,0 +1,13 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `upload.someHook`.
+ *
+ * A barrel and nothing else — `module.server.ts` beside it is the pair half `$rime/modules:` resolves, and
+ * only files named exactly `module(.server).ts` are, so this one is invisible to that mechanism.
+ * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
+ * one import line per hook.
+ */
+export { castBase64ToFile } from './convert-base64.server.js';
+export { cleanUpFiles } from './clean-up-files.server.js';
+export { handlePathCreation } from './handle-path-creation.server.js';
+export { populateSizes } from './populate-sizes.server.js';
+export { processFileUpload } from './process-file-upload.server.js';