rimecms 0.31.4 → 0.32.0

package/dist/core/prototype/collection/upload/hooks/populate-sizes.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Puts `sizes` on an upload document — the URL of each generated image size, keyed by its name.
+ */
+export declare const populateSizes: import("../../../../pipeline/types").Hook<"raw", "read", "before">;

package/dist/core/prototype/collection/upload/hooks/populate-sizes.server.js

@@ -0,0 +1,48 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+/**
+ * Puts `sizes` on an upload document — the URL of each generated image size, keyed by its name.
+ */
+export const populateSizes = Hooks.beforeRead(async function populateSizes(args) {
+    const config = args.config;
+    const doc = args.doc;
+    if ('imageSizes' in config.upload && config.upload.imageSizes && doc.filename) {
+        doc.sizes = {};
+        for (const size of config.upload.imageSizes) {
+            if (doc[size.name]) {
+                // Handle multiple formats
+                const formats = doc[size.name].split('|');
+                // Multiple formats
+                if (formats.length > 1) {
+                    formats.forEach((format) => {
+                        const extension = format.split('.').pop();
+                        doc.sizes[`${size.name}_${extension}`] = `/medias/${format}`;
+                    });
+                    // Single format
+                }
+                else {
+                    doc.sizes[size.name] = `/medias/${formats[0]}`;
+                }
+                delete doc[size.name];
+            }
+            else {
+                // Default case: use original file as string
+                doc.sizes[size.name] = `/medias/${doc.filename}`;
+            }
+        }
+        // Add the _thumbnail prop
+        if ('thumbnail' in doc.sizes) {
+            doc._thumbnail = doc.sizes.thumbnail;
+        }
+        else {
+            const thumbnailKey = Object.keys(doc.sizes).find((sizeName) => sizeName.startsWith('thumbnail'));
+            if (thumbnailKey) {
+                doc._thumbnail = doc.sizes[thumbnailKey];
+            }
+            else {
+                doc._thumbnail = `/medias/${doc.filename}`;
+            }
+        }
+    }
+    doc.url = doc.filename ? `/medias/${doc.filename}` : null;
+    return { ...args, doc };
+});

package/dist/core/prototype/collection/upload/hooks/process-file-upload.server.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Hook that handles file upload processing and image resizing operations.
+ *
+ * @description
+ * This hook performs the following operations:
+ * 1. For new files:
+ *    - Saves the uploaded file to storage
+ *    - Generates different image sizes if configured
+ *    - Updates document with file metadata and image variations
+ *
+ * 2. For file updates:
+ *    - Removes old files from storage
+ *    - Processes new file as above
+ *
+ * 3. For file deletions:
+ *    - Removes files from storage
+ *    - Cleans up image variations
+ *    - Nullifies related document fields
+ */
+export declare const processFileUpload: import("../../../../pipeline/types").Hook<"upload", "create" | "update", "before">;

package/dist/core/prototype/collection/upload/hooks/process-file-upload.server.js

@@ -0,0 +1,60 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { cleanUpDocumentFile } from '../disk/delete.server.js';
+import { saveFile } from '../disk/save.server.js';
+import { omit } from '../../../../../util/object.js';
+import { toCamelCase } from '../../../../../util/string.js';
+import { isUploadConfig } from '../util/config.js';
+/**
+ * Hook that handles file upload processing and image resizing operations.
+ *
+ * @description
+ * This hook performs the following operations:
+ * 1. For new files:
+ *    - Saves the uploaded file to storage
+ *    - Generates different image sizes if configured
+ *    - Updates document with file metadata and image variations
+ *
+ * 2. For file updates:
+ *    - Removes old files from storage
+ *    - Processes new file as above
+ *
+ * 3. For file deletions:
+ *    - Removes files from storage
+ *    - Cleans up image variations
+ *    - Nullifies related document fields
+ */
+export const processFileUpload = Hooks.beforeUpsert(async function processFileUpload(args) {
+    const { operation, config, event } = args;
+    const { rime } = event.locals;
+    if (!isUploadConfig(config))
+        throw new Error('Should never throw');
+    let data = args.data || {};
+    const hasSizeConfig = 'imageSizes' in config.upload && Array.isArray(config.upload.imageSizes);
+    const sizesConfig = hasSizeConfig ? config.upload.imageSizes : [];
+    if (data.file) {
+        if (operation === 'update' && args.context.originalDoc) {
+            await cleanUpDocumentFile({ config, rime, id: args.context.originalDoc.id });
+        }
+        const { filename, imageSizes } = await saveFile(data.file, sizesConfig);
+        data = {
+            ...omit(['file'], data),
+            filename,
+            ...imageSizes
+        };
+    }
+    // If data.file is explicitly set to null : delete file
+    if (data.file === null) {
+        // delete files
+        if (operation === 'update' && args.context.originalDoc) {
+            await cleanUpDocumentFile({ config, rime, id: args.context.originalDoc.id });
+        }
+        // update data for DB update
+        for (const size of sizesConfig) {
+            data = {
+                ...data,
+                [toCamelCase(size.name)]: null
+            };
+        }
+    }
+    return { ...args, data };
+});

package/dist/core/prototype/collection/upload/hooks/update-directory-children.server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @TODO explain — reads the directory's children before the write, for `updateDirectoryChildren`
+ * below to re-parent afterwards.
+ */
+export declare const prepareDirectoryChildren: import("../../../../pipeline/types").Hook<"directory", "update", "before">;
+/**
+ * @TODO explain — re-parents what `prepareDirectoryChildren` collected, once the directory's own
+ * row has been written.
+ */
+export declare const updateDirectoryChildren: import("../../../../pipeline/types").Hook<"directory", "update", "after">;

package/dist/core/prototype/collection/upload/hooks/update-directory-children.server.js

@@ -0,0 +1,47 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { RimeError } from '../../../../errors/index.js';
+import { trycatch } from '../../../../../util/function.js';
+/**
+ * @TODO explain — reads the directory's children before the write, for `updateDirectoryChildren`
+ * below to re-parent afterwards.
+ */
+export const prepareDirectoryChildren = Hooks.beforeUpdate(async function prepareDirectoryChildren(args) {
+    const data = args.data;
+    const { event, config, context } = args;
+    const originalDoc = context.originalDoc;
+    if (!originalDoc)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @prepareDirectoryChildren');
+    if (data.id) {
+        // `parent` is an ordinary field on the directories collection, which is never versioned —
+        // so the normal query path answers this and no drizzle handle is needed.
+        const children = await event.locals.rime.adapter.collection(config.slug).findMany({
+            query: { where: { parent: { equals: `${originalDoc.id}` } } }
+        });
+        const updates = children.map((childDir) => {
+            return {
+                id: childDir.id,
+                data: {
+                    id: `${childDir.parent.replace(originalDoc.id, data.id)}:${childDir.name}`
+                }
+            };
+        });
+        args.context.directoriesUpdates = updates;
+    }
+    return args;
+});
+/**
+ * @TODO explain — re-parents what `prepareDirectoryChildren` collected, once the directory's own
+ * row has been written.
+ */
+export const updateDirectoryChildren = Hooks.afterUpdate(async function updateDirectoryChildren(args) {
+    const { event, config } = args;
+    const collection = event.locals.rime.collection(config.slug);
+    const updates = args.context.directoriesUpdates || [];
+    for (const update of updates) {
+        const [error] = await trycatch(() => collection.updateById(update));
+        if (error) {
+            throw new RimeError(RimeError.OPERATION_ERROR, 'Error when updating child directories');
+        }
+    }
+    return args;
+});

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

@@ -0,0 +1,15 @@
+import type { Collection } from '../../../config/types.js';
+import type { WithNormalizedUpload } from './types.js';
+/**
+ * Normalize config.upload and imagesSizes
+ * add corresponding fields with validation if config.upload.accept is defined
+ */
+export declare const augmentUpload: <T extends Collection<any>>(config: T) => WithNormalizedUpload<T>;
+/**
+ * The derived `<slug>Directories` collections, re-exported so `$rime/modules` collects them.
+ *
+ * They live in `directories/configure.ts` — the file says the phase — and only a file named
+ * `module.ts` or `module.server.ts` is a pair half, so this one re-exports rather than holding
+ * the code.
+ */
+export { configureUploadDirectories } from './directories/configure.js';

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

@@ -0,0 +1,92 @@
+import { text } from '../../../../fields/text/index.js';
+import { toCamelCase } from '../../../../util/string.js';
+import { validatePath } from './util/path.js';
+/**
+ * The upload feature's client half — the augment as it runs on both sides.
+ *
+ * `$rime/modules` resolves this file on a client build and `module.server.ts` on a server one, so
+ * the two halves share the export name `augmentUpload` and only the file differs. The server half
+ * adds a foreign key the client config must not carry; everything else is here.
+ *
+ * A name only has to be unique within this pair — `$rime/modules:core/prototype/collection/upload`
+ * names the folder. The type still lives in types.ts: a type exported here would be stubbed as a
+ * value on the client.
+ */
+const withNormalizedUpload = (config) => {
+    // Create a new object without the auth property
+    const { upload, ...rest } = config;
+    // Determine the normalized upload value
+    let normalizedUpload;
+    if (typeof upload === 'boolean') {
+        normalizedUpload = upload === true ? {} : undefined;
+    }
+    else {
+        normalizedUpload = upload;
+    }
+    // Return the new object with the normalized upload
+    return {
+        ...rest,
+        upload: normalizedUpload
+    };
+};
+/**
+ * Normalize config.upload and imagesSizes
+ * add corresponding fields with validation if config.upload.accept is defined
+ */
+export const augmentUpload = (config) => {
+    const normalizedUploadConfig = withNormalizedUpload(config);
+    if (!normalizedUploadConfig.upload)
+        return normalizedUploadConfig;
+    const { upload } = normalizedUploadConfig;
+    let fields = [...(config.fields || [])];
+    if (upload) {
+        // Add panel thumbnail size if not already present
+        const isPanelThumbnailInSizes = upload.imageSizes &&
+            upload.imageSizes.some((size) => size.name === 'thumbnail');
+        if (!isPanelThumbnailInSizes) {
+            const thumbnailSize = { name: 'thumbnail', width: 400, compression: 60 };
+            upload.imageSizes = [thumbnailSize, ...(upload.imageSizes || [])];
+        }
+        // Add image size fields
+        if ('imageSizes' in upload && upload.imageSizes?.length) {
+            const sizesFields = upload.imageSizes.map((size) => text(toCamelCase(size.name)).hidden());
+            fields = [...fields, ...sizesFields];
+        }
+        // Add mimeType field
+        const mimeType = text('mimeType').table({ sort: true, position: 99 }).hidden();
+        // Add validation if accept is defined
+        if ('accept' in upload && Array.isArray(upload.accept)) {
+            const allowedMimeTypes = upload.accept;
+            mimeType.validate((value) => {
+                return ((typeof value === 'string' && allowedMimeTypes.includes(value)) ||
+                    `File should be the type of ${allowedMimeTypes.toString()}`);
+            });
+        }
+        const _pathField = text('_path').$root().hidden().validate(validatePath);
+        // Add hidden fields
+        fields.push(mimeType, text('filename').hidden(), text('filesize').hidden(), _pathField);
+    }
+    // What an upload document is called, overriding the prototype's fallback. Overrides rather than
+    // defers, so upload wins for the rare config carrying both — registry order puts this after
+    // auth's.
+    //
+    // `_dashboardLayout` is the same kind of statement: a collection of files reads better as
+    // thumbnails than as rows. Offered, not imposed — the dashboard falls back to `'rows'` and an
+    // author's `panel.dashboard.layout` wins over both. Before this, the *collection prototype*
+    // tested `config.upload` to decide it.
+    return {
+        ...config,
+        upload: upload || false,
+        fields,
+        _titleFallback: 'filename',
+        _dashboardLayout: 'grid'
+    };
+};
+/**
+ * The derived `<slug>Directories` collections, re-exported so `$rime/modules` collects them.
+ *
+ * They live in `directories/configure.ts` — the file says the phase — and only a file named
+ * `module.ts` or `module.server.ts` is a pair half, so this one re-exports rather than holding
+ * the code.
+ */
+export { configureUploadDirectories } from './directories/configure.js';

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

@@ -0,0 +1,24 @@
+import type { Collection } from '../../../config/types.js';
+import type { WithNormalizedUpload } from './types.js';
+/**
+ * The upload feature's server half.
+ *
+ * Same export name as `module.ts` for the augment, because `$rime/modules` picks the file, not the
+ * name — the `…Server` suffix this replaces was doing the resolver's job by hand. `uploadHooks`
+ * has no client half at all, so the resolver stubs it to `undefined` there.
+ */
+/**
+ * The client augment, plus the one thing a client config must not carry: `_path` points at the
+ * collection's directories table, and that foreign key is what makes the schema's cascade work.
+ * Get this half onto the wrong build and the FK silently vanishes — which is why the golden
+ * schema diff is the check that matters for this feature.
+ */
+export declare const augmentUpload: <T extends Collection<any>>(config: T) => WithNormalizedUpload<T>;
+/**
+ * The derived `<slug>Directories` collections, re-exported so `$rime/modules` collects them.
+ *
+ * They live in `directories/configure.server.ts` — the file says the phase — and only a file named
+ * `module.ts` or `module.server.ts` is a pair half, so this one re-exports rather than holding
+ * the code.
+ */
+export { configureUploadDirectories } from './directories/configure.server.js';

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

@@ -0,0 +1,36 @@
+import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import { directoriesOf } from './naming.js';
+import { augmentUpload as augmentUploadBase } from './module.js';
+/**
+ * The upload feature's server half.
+ *
+ * Same export name as `module.ts` for the augment, because `$rime/modules` picks the file, not the
+ * name — the `…Server` suffix this replaces was doing the resolver's job by hand. `uploadHooks`
+ * has no client half at all, so the resolver stubs it to `undefined` there.
+ */
+/**
+ * The client augment, plus the one thing a client config must not carry: `_path` points at the
+ * collection's directories table, and that foreign key is what makes the schema's cascade work.
+ * Get this half onto the wrong build and the FK silently vanishes — which is why the golden
+ * schema diff is the check that matters for this feature.
+ */
+export const augmentUpload = (config) => {
+    const collection = augmentUploadBase(config);
+    (collection.fields || []).forEach((field) => {
+        if (field instanceof FormFieldBuilder && field.name === '_path') {
+            field.$references(directoriesOf(config), {
+                onDelete: 'cascade',
+                onUpdate: 'cascade'
+            });
+        }
+    });
+    return collection;
+};
+/**
+ * The derived `<slug>Directories` collections, re-exported so `$rime/modules` collects them.
+ *
+ * They live in `directories/configure.server.ts` — the file says the phase — and only a file named
+ * `module.ts` or `module.server.ts` is a pair half, so this one re-exports rather than holding
+ * the code.
+ */
+export { configureUploadDirectories } from './directories/configure.server.js';

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

@@ -0,0 +1,23 @@
+import type { CollectionSlug } from '../../../../types.js';
+/** `medias` -> `$mediasDirectories`. A slug in, a slug out; it strips nothing. */
+export declare const withDirectoriesSuffix: (slug: string) => CollectionSlug;
+/**
+ * The directories collection a config's files live under — its own, or its owner's when it is a
+ * versions.
+ *
+ * The one call site that has a config rather than a bare slug should use this. `_shadowOf` is
+ * core's answer to "whose content is this", set by whichever feature derived the versions table.
+ */
+export declare const directoriesOf: (config: {
+    slug: string;
+    _shadowOf?: string;
+}) => never;
+/**
+ * The URL form of a collection's directories sibling: `medias` -> `medias-directories`.
+ *
+ * Takes the **slug**, never the kebab. Three panel call sites did
+ * `apiUrl(withDirectoriesSuffix(config.kebab))`, which was right only while a slug and its
+ * kebab were the same string — it now builds `/api/$mediasDirectories`, and for a multi-word
+ * collection it corrupts the name twice over (`my-medias` -> `$my-mediasDirectories`).
+ */
+export declare const directoriesKebab: (slug: string) => string;

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

@@ -0,0 +1,37 @@
+import { prototypeKebab } from '../../naming.js';
+/**
+ * The upload directories naming convention, in slug space.
+ *
+ *   medias  ->  $mediasDirectories  ->  table medias_directories  ->  url medias-directories
+ *
+ * `$` marks it rime-derived, but there is deliberately **no `__`**: a directories collection is
+ * a sibling, not a versions table or a child, and holds no schema relationship to its parent. So its
+ * table name carries no relationship marker and stays exactly what it is today. Telling a
+ * directories collection apart is the upload feature's job — by this convention — not something
+ * the table name can answer.
+ *
+ * A folder tree belongs to the **document**, not to a revision of it, so a versions table's
+ * directories are its owner's. `directoriesOf` below asks the config whose content it holds,
+ * rather than reading it off how the slug is spelled.
+ */
+const DERIVED = '$';
+const MARKER = 'Directories';
+/** `medias` -> `$mediasDirectories`. A slug in, a slug out; it strips nothing. */
+export const withDirectoriesSuffix = (slug) => `${DERIVED}${slug}${MARKER}`;
+/**
+ * The directories collection a config's files live under — its own, or its owner's when it is a
+ * versions.
+ *
+ * The one call site that has a config rather than a bare slug should use this. `_shadowOf` is
+ * core's answer to "whose content is this", set by whichever feature derived the versions table.
+ */
+export const directoriesOf = (config) => withDirectoriesSuffix(config._shadowOf ?? config.slug);
+/**
+ * The URL form of a collection's directories sibling: `medias` -> `medias-directories`.
+ *
+ * Takes the **slug**, never the kebab. Three panel call sites did
+ * `apiUrl(withDirectoriesSuffix(config.kebab))`, which was right only while a slug and its
+ * kebab were the same string — it now builds `/api/$mediasDirectories`, and for a multi-word
+ * collection it corrupts the name twice over (`my-medias` -> `$my-mediasDirectories`).
+ */
+export const directoriesKebab = (slug) => prototypeKebab(withDirectoriesSuffix(slug));

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

@@ -0,0 +1,102 @@
+import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
+import type { Field } from '../../../../fields/types.js';
+import type { Access } from '../../../config/types.js';
+import type { CollectionHooks } from '../../../config/types.js';
+import type { BaseDoc, GenericDoc } from '../../types.js';
+import type { Dic } from '../../../../util/types.js';
+import type { UploadPath } from './util/path.js';
+/**
+ * What a document of an upload collection carries beyond a plain one.
+ *
+ * Was in `core/prototype/types.ts`, in the `Docs` registry, which is what made that file import
+ * `UploadPath` out of this feature to describe its own type.
+ */
+export type UploadDoc = BaseDoc & {
+    mimeType: string;
+    filesize: string;
+    filename: string;
+    url: string;
+    sizes: {
+        [key: string]: string;
+    };
+} & Dic;
+/** A row of the directories tree this feature derives per upload collection. */
+export type DirectoryDoc = {
+    id: UploadPath;
+    parent: string | null;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+declare module '$lib/core/prototype/types.js' {
+    interface FeatureDocTypes {
+        upload: UploadDoc;
+        directory: DirectoryDoc;
+    }
+}
+/** A config whose `upload` has been normalised from `true` to an object by the upload augment. */
+export type WithNormalizedUpload<T> = Omit<T, 'upload'> & {
+    upload?: UploadConfig;
+};
+export type JsonFile = {
+    base64: string;
+    filename?: string;
+    mimeType?: string;
+    filesize?: number;
+    lastModified?: number;
+};
+export type Directory = GenericDoc & {
+    id: UploadPath;
+    name: string;
+    parent: UploadPath | null;
+};
+import type { AtLeastOne } from '../../../../util/types.js';
+/** What an author writes under `upload`, and the image sizes it may ask for. */
+export type UploadConfig = {
+    /**
+     * Define image sizes that will be generated when an image is uploaded.
+     * A 'thumbnail' size will be added, if none provided with this name.
+     * @example
+     * ```typescript
+     * imageSizes: [
+     *   {
+     *     name: 'thumbnail',
+     *     width: 200,
+     *     height: 200,
+     *     out: ['jpg', 'webp'],
+     *     compression: 80
+     *   },
+     *   {
+     *     name: 'medium',
+     *     width: 800,
+     *     compression: 85
+     *   }
+     * ]
+     * ```
+     */
+    imageSizes?: ImageSizesConfig[];
+    /**
+     * Allowed mimeTypes
+     * @example
+     * ```typescript
+     * accept: ['image/jpeg', 'image/svg']
+     * ```
+     */
+    accept?: string[];
+    /** Directories */
+    directories?: {
+        fields: FieldBuilder<Field>[];
+        access?: Access;
+        $hooks?: CollectionHooks<any>;
+    };
+};
+export type ImageSizesConfig = {
+    name: string;
+    /** If none provided, will fallback to original file extesion */
+    out?: Array<'jpg' | 'webp'>;
+    /** Default compression: 60 */
+    compression?: number;
+} & AtLeastOne<{
+    width: number;
+    height: number;
+}>;

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

@@ -0,0 +1 @@
+export {};

package/dist/core/prototype/collection/upload/util/config.d.ts

@@ -0,0 +1,16 @@
+import type { UploadConfig } from '../types.js';
+export type WithUpload<T extends {
+    upload?: boolean | UploadConfig;
+}> = T & {
+    upload: UploadConfig;
+};
+/**
+ * Type guard to check if a configuration has upload capabilities
+ * @example
+ * if (isUploadConfig(collection)) {
+ *   // Handle upload-specific functionality
+ * }
+ */
+export declare function isUploadConfig<C extends {
+    upload?: UploadConfig;
+}>(config: C): config is WithUpload<C>;

package/dist/core/prototype/collection/upload/util/converter.server.d.ts

@@ -0,0 +1,29 @@
+import type { JsonFile } from '../types.js';
+export declare const jsonFileToFile: (jsonFile: JsonFile) => {
+    filename: string;
+    mimeType: string;
+    filesize: string;
+    file: File;
+};
+/** Used by the e2e suites — each fixture's `api.test.ts` — to post an upload as base64. */
+export declare function filePathToBase64(filePath: string): Promise<string>;
+/**
+ * Convert a filepath to a File like object
+ * @param filePath - Absolute path to the file
+ * @returns A File-like object with necessary properties and methods
+ * @example
+ * const file = await filePathToFile('/path/to/image.jpg');
+ */
+export declare function filePathToFile(filePath: string): Promise<File>;
+/**
+ * The file a stored document already has, as a `File`.
+ *
+ * One call, so a caller never spells out where upload keeps its files —
+ * `disk/save.server.ts` and `disk/delete.server.ts` own that convention.
+ *
+ * `undefined` when the document has no file, so a caller asking "does it have one?" and "give it
+ * to me" makes one call, not two.
+ */
+export declare function fileForDocument(doc: {
+    filename?: unknown;
+}): Promise<File | undefined>;