rimecms 0.31.5 → 0.32.0

package/dist/core/prototype/collection/rest/get.server.js

@@ -0,0 +1,38 @@
+import { isStaff } from '../../../auth/access.js';
+import { normalizeQuery } from '../../../pipeline/query.js';
+import { selectWithTitle } from '../../shared/title/select.js';
+import { PARAMS } from '../../../constants.js';
+import { handleError } from '../../../errors/handler.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * GET handler for the collection API endpoint.
+ */
+export const restGet = endpoint(async ({ event, collection }) => {
+    //
+    const { rime } = event.locals;
+    const params = event.url.searchParams;
+    const hasQueryParams = !!params
+        .keys()
+        .filter((key) => key.startsWith('where'))
+        .toArray().length;
+    const query = hasQueryParams ? normalizeQuery(event.url.search.substring(1)) : undefined;
+    // A row other than the published one is staff's to see: from anyone else, `latest` reads as absent.
+    const staff = isStaff(event.locals.user);
+    const apiParams = {
+        locale: rime.getLocale(),
+        sort: params.get(PARAMS.SORT) || undefined,
+        depth: params.get(PARAMS.DEPTH) ? parseInt(params.get(PARAMS.DEPTH)) : 0,
+        limit: params.get(PARAMS.LIMIT) ? parseInt(params.get(PARAMS.LIMIT)) : undefined,
+        offset: params.get(PARAMS.OFFSET) ? parseInt(params.get(PARAMS.OFFSET)) : undefined,
+        latest: staff && params.get(PARAMS.LATEST) ? params.get(PARAMS.LATEST) === 'true' : undefined,
+        query,
+        select: selectWithTitle(params.get(PARAMS.SELECT), collection.config.asTitle)
+    };
+    const [error, docs] = await trycatch(() => collection.find(apiParams));
+    if (error) {
+        return handleError(error, { context: 'api' });
+    }
+    return json({ docs }, { status: 200 });
+});

package/dist/core/prototype/collection/rest/index.server.d.ts

@@ -0,0 +1,12 @@
+import type { RouteConfig } from '../../../config/types.js';
+/**
+ * The REST surface a collection provides.
+ *
+ * Declared the way every other route in rime is declared — `RouteConfig` per path, the shape
+ * `config.$routes` and `plugin.routes` use — so codegen writes the `+server.ts` files from this
+ * and nothing else needs to know a collection has three tiers.
+ *
+ * Keys are sub-paths under `/api/[slug=collection]`, not absolute pathnames as a plugin's are:
+ * a collection has no URL of its own to name, only slugs the user's config supplies.
+ */
+export declare const rest: Record<string, RouteConfig>;

package/dist/core/prototype/collection/rest/index.server.js

@@ -0,0 +1,24 @@
+import { restCreate } from './create.server.js';
+import { restDelete } from './delete.server.js';
+import { restDeleteById } from './delete-by-id.server.js';
+import { restDuplicate } from './duplicate.server.js';
+import { restGet } from './get.server.js';
+import { restGetById } from './get-by-id.server.js';
+import { restLock, restUnlock } from './lock.server.js';
+import { restUpdateById } from './update-by-id.server.js';
+/**
+ * The REST surface a collection provides.
+ *
+ * Declared the way every other route in rime is declared — `RouteConfig` per path, the shape
+ * `config.$routes` and `plugin.routes` use — so codegen writes the `+server.ts` files from this
+ * and nothing else needs to know a collection has three tiers.
+ *
+ * Keys are sub-paths under `/api/[slug=collection]`, not absolute pathnames as a plugin's are:
+ * a collection has no URL of its own to name, only slugs the user's config supplies.
+ */
+export const rest = {
+    '': { GET: restGet, POST: restCreate, DELETE: restDelete },
+    '[id]': { GET: restGetById, PATCH: restUpdateById, DELETE: restDeleteById },
+    '[id]/duplicate': { POST: restDuplicate },
+    '[id]/lock': { POST: restLock, DELETE: restUnlock }
+};

package/dist/core/prototype/collection/rest/lock.server.d.ts

@@ -0,0 +1,2 @@
+export declare const restLock: import("@sveltejs/kit").RequestHandler;
+export declare const restUnlock: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/lock.server.js

@@ -0,0 +1,59 @@
+import { PARAMS } from '../../../constants.js';
+import { handleError } from '../../../errors/handler.server.js';
+import { RimeError } from '../../../errors/index.js';
+import { claimEditLock, releaseEditLock } from '../../shared/metas/lock.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * The edit lock on one document: POST to take it, DELETE to give it back.
+ *
+ * A route rather than a panel form action, because a prototype adds a route by declaring it in
+ * `rest` and codegen writes the file — while a form action has to be listed by name in the
+ * generated `+page.server.ts`, so one that is not listed answers 404 and every claim quietly does
+ * nothing.
+ *
+ * Neither method goes near the write pipeline: `claimEditLock`/`releaseEditLock` set the two lock
+ * columns through the adapter's `updateWhere`, so holding a document leaves `updatedAt` and
+ * `updatedBy` alone and cuts no version. The fields' own `.access({ update })` decides who may
+ * call this at all; the update access below decides which documents.
+ */
+const run = (intent) => endpoint(async ({ event, collection }) => {
+    const { user } = event.locals;
+    const id = event.params.id;
+    if (!user)
+        return handleError(new RimeError(RimeError.UNAUTHORIZED), { context: 'api' });
+    if (!id)
+        return handleError(new RimeError(RimeError.NOT_FOUND), { context: 'api' });
+    if (!collection.config.access.update(user, { id })) {
+        return handleError(new RimeError(RimeError.UNAUTHORIZED), { context: 'api' });
+    }
+    // Past the access check above, so `system()`: the lock sits on a document this caller may
+    // write, and reading it back is not a second permission question.
+    //
+    // The row on the caller's screen when they name one, else the newest: a lock is held on the
+    // version being edited, and an auto-saved row is only ever reached by its `versionId`.
+    const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+    const [readError, doc] = await trycatch(() => collection.system().findById({ id, versionId, latest: true }));
+    if (readError)
+        return handleError(readError, { context: 'api' });
+    // A `pagehide` beacon can only POST, so a release arriving that way says so in the query.
+    // DELETE stays the method for every release that has time to pick one.
+    const releasing = intent === 'release' || event.url.searchParams.get('release') === 'true';
+    const force = !releasing && event.url.searchParams.get('force') === 'true';
+    const args = { event, config: collection.config, doc, userId: user.id, force };
+    const [error, held] = await trycatch(async () => {
+        if (releasing) {
+            await releaseEditLock(args);
+            return false;
+        }
+        return claimEditLock(args);
+    });
+    if (error)
+        return handleError(error, { context: 'api' });
+    // `held` is the answer, not a failure: a heartbeat that lost the document has to render that,
+    // so somebody else holding it is an ordinary 200.
+    return json({ held: !!held });
+});
+export const restLock = run('claim');
+export const restUnlock = run('release');

package/dist/core/prototype/collection/rest/update-by-id.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * PATCH handler for the collection API endpoint to update a document by its ID.
+ */
+export declare const restUpdateById: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/update-by-id.server.js

@@ -0,0 +1,44 @@
+import { PARAMS } from '../../../constants.js';
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { RimeError } from '../../../errors/index.js';
+import { extractData } from '../../../pipeline/extract-data.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * PATCH handler for the collection API endpoint to update a document by its ID.
+ */
+export const restUpdateById = endpoint(async ({ event, collection }) => {
+    //
+    const { rime } = event.locals;
+    const id = event.params.id;
+    if (!id) {
+        return handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+    }
+    // Which row: `versionId`, else the newest with `latest`, else the published one. `fork` makes
+    // a new version from it instead of writing it.
+    const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+    const latest = event.url.searchParams.get(PARAMS.LATEST) === 'true' || undefined;
+    const fork = event.url.searchParams.get(PARAMS.FORK) === 'true' || undefined;
+    // Extract data from the request body
+    const [extractError, data] = await trycatch(() => extractData(event.request));
+    if (extractError) {
+        return handleError(extractError, { context: ERROR_CONTEXT.API });
+    }
+    // Set the locale if provided in the data
+    if (data.locale) {
+        rime.setLocale(data.locale);
+    }
+    const [error, document] = await trycatch(() => collection.updateById({
+        id,
+        data,
+        locale: rime.getLocale(),
+        versionId,
+        latest,
+        fork
+    }));
+    if (error) {
+        return handleError(error, { context: ERROR_CONTEXT.API });
+    }
+    return json({ doc: document });
+});

package/dist/core/prototype/collection/thumbnail/augment.d.ts

@@ -0,0 +1,13 @@
+import type { Collection } from '../../../config/types.js';
+type Input = {
+    fields?: Collection<any>['fields'];
+};
+type WithAsThumbnail<T> = T & {
+    asThumbnail: string | null;
+};
+/**
+ * Resolves `asThumbnail`: the relation field that stands in for a document visually, or `null`
+ * when the config marks none.
+ */
+export declare const augmentThumbnail: <T extends Input>(config: T) => WithAsThumbnail<T>;
+export {};

package/dist/core/prototype/collection/thumbnail/augment.js

@@ -0,0 +1,15 @@
+import { findThumbnailField } from './find-thumbnail.js';
+/**
+ * Resolves `asThumbnail`: the relation field that stands in for a document visually, or `null`
+ * when the config marks none.
+ */
+export const augmentThumbnail = (config) => {
+    const addAsThumbnail = () => {
+        const thumbnailField = findThumbnailField(config.fields);
+        return thumbnailField?.path || null;
+    };
+    return {
+        ...config,
+        asThumbnail: addAsThumbnail()
+    };
+};

package/dist/core/prototype/collection/thumbnail/find-thumbnail.d.ts

@@ -0,0 +1,9 @@
+import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
+import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import type { Field, FormField } from '../../../../fields/types.js';
+interface ThumbnailFieldResult {
+    field: FormFieldBuilder<FormField>;
+    path: string;
+}
+export declare function findThumbnailField(fields?: FieldBuilder<Field>[], basePath?: string): ThumbnailFieldResult | null;
+export {};

package/dist/core/prototype/collection/thumbnail/find-thumbnail.js

@@ -0,0 +1,34 @@
+import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import { GroupFieldBuilder } from '../../../../fields/group/index.js';
+import { RelationFieldBuilder } from '../../../../fields/relation/index.js';
+import { TabsBuilder } from '../../../../fields/tabs/index.js';
+export function findThumbnailField(fields = [], basePath = '') {
+    for (const field of fields) {
+        // Direct check for isThumbnail
+        if (field instanceof RelationFieldBuilder &&
+            'isThumbnail' in field.get &&
+            field.get.isThumbnail === true) {
+            const path = basePath ? `${basePath}.${field.name}` : field.name;
+            return { field, path };
+        }
+        // Check in group
+        if (field instanceof GroupFieldBuilder && field.get.fields) {
+            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
+            const found = findThumbnailField(field.get.fields, groupPath);
+            if (found)
+                return found;
+        }
+        // Check in tabs
+        if (field instanceof TabsBuilder && field.get.tabs) {
+            for (const tab of field.get.tabs) {
+                if (tab.get.fields) {
+                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
+                    const found = findThumbnailField(tab.get.fields, tabPath);
+                    if (found)
+                        return found;
+                }
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `thumbnail.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 { setDocumentThumbnail } from './set-document-thumbnail.server.js';

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

@@ -0,0 +1,9 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `thumbnail.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 { setDocumentThumbnail } from './set-document-thumbnail.server.js';

package/dist/core/prototype/collection/thumbnail/hooks/set-document-thumbnail.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Puts `_thumbnail` on the document — the URL the panel shows for it in a list.
+ *
+ * Runs after `populateSizes`, so it can take the thumbnail size an upload collection generated
+ * rather than the original file.
+ */
+export declare const setDocumentThumbnail: import("../../../../pipeline/types").Hook<"raw", "read", "before">;

package/dist/core/prototype/collection/thumbnail/hooks/set-document-thumbnail.server.js

@@ -0,0 +1,40 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { isRelationResolved } from '../../../../../fields/relation/index.js';
+import {} from '../../../../../types.js';
+import { getValueAtPath } from '../../../../../util/object.js';
+/**
+ * Puts `_thumbnail` on the document — the URL the panel shows for it in a list.
+ *
+ * Runs after `populateSizes`, so it can take the thumbnail size an upload collection generated
+ * rather than the original file.
+ */
+export const setDocumentThumbnail = Hooks.beforeRead(async (args) => {
+    const config = args.config;
+    let doc = args.doc;
+    const hasThumbnail = (c) => {
+        return c.type === 'collection' && !!c.asThumbnail;
+    };
+    const paramSelect = args.context.params.select;
+    const hasSelect = Array.isArray(paramSelect) && paramSelect.length;
+    const shouldSetThumbnail = hasThumbnail(config) &&
+        !doc._thumbnail &&
+        (!hasSelect || (hasSelect && paramSelect.includes('_thumbnail')));
+    if (shouldSetThumbnail) {
+        const relationValue = getValueAtPath(config.asThumbnail, doc);
+        if (!relationValue || (Array.isArray(relationValue) && relationValue.length === 0))
+            return args;
+        const unwraped = Array.isArray(relationValue) ? relationValue[0] : relationValue;
+        if (typeof unwraped === 'string')
+            return args;
+        const relationResolved = isRelationResolved(unwraped)
+            ? unwraped
+            : await args.event.locals.rime
+                .collection(unwraped.relationTo)
+                .findById({ id: unwraped.documentId });
+        doc = {
+            _thumbnail: relationResolved._thumbnail,
+            ...doc
+        };
+    }
+    return { ...args, doc };
+});

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

@@ -0,0 +1,14 @@
+import type { Collection } from '../../config/types.js';
+import type { OmitPreservingDiscrimination } from '../../../util/types.js';
+export type CollectionWithoutSlug<S> = OmitPreservingDiscrimination<Collection<S>, 'slug'>;
+/** What a collection is called, in the panel and in a form. */
+export type CollectionLabel = {
+    singular: string;
+    plural: string;
+    /** Label to search document, ex: Search for pages... */
+    search?: string;
+    /** Label for creation ex: New page */
+    create?: string;
+    /** Label when no document found, ex: No pages found */
+    none?: string;
+};

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

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

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

@@ -0,0 +1,13 @@
+import type { BuiltCollection } from '../../../../config/types.js';
+/**
+ * Upload's boot step, in a module of its own **with no `module.ts` beside it**.
+ *
+ * That placement is the whole point. `features/upload/module.server.ts` has a client half, and a
+ * name only the server half declares is *not exported* on a client build rather than `undefined`
+ * — which fails at link time with "does not provide an export named" the moment `index.ts`, which
+ * is client-reachable, imports it. Boot rejected this file's first home for exactly that reason.
+ * See `core/dev/codegen/runtime/index.server.ts`.
+ */
+export declare const bootUpload: (config: {
+    collections?: BuiltCollection[];
+}) => void;

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

@@ -0,0 +1,11 @@
+import { ensureMedias } from '../ensure.server.js';
+/**
+ * Upload's boot step, in a module of its own **with no `module.ts` beside it**.
+ *
+ * That placement is the whole point. `features/upload/module.server.ts` has a client half, and a
+ * name only the server half declares is *not exported* on a client build rather than `undefined`
+ * — which fails at link time with "does not provide an export named" the moment `index.ts`, which
+ * is client-reachable, imports it. Boot rejected this file's first home for exactly that reason.
+ * See `core/dev/codegen/runtime/index.server.ts`.
+ */
+export const bootUpload = (config) => ensureMedias(config);

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

@@ -0,0 +1,10 @@
+/**
+ * How an upload path is spelled: `root:folder:sub`.
+ *
+ * Lived in `core/constants.ts`. The separator and the root's name are this feature's format, and
+ * nothing outside it — bar the panel, which renders the folders — has any reason to know either.
+ */
+export declare const UPLOAD_PATH: {
+    readonly SEPARATOR: ":";
+    readonly ROOT_NAME: "root";
+};

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

@@ -0,0 +1,10 @@
+/**
+ * How an upload path is spelled: `root:folder:sub`.
+ *
+ * Lived in `core/constants.ts`. The separator and the root's name are this feature's format, and
+ * nothing outside it — bar the panel, which renders the folders — has any reason to know either.
+ */
+export const UPLOAD_PATH = {
+    SEPARATOR: ':',
+    ROOT_NAME: 'root'
+};

package/dist/core/prototype/collection/upload/directories/configure.d.ts

@@ -0,0 +1,14 @@
+import type { BuiltCollection } from '../../../../config/types.js';
+/**
+ * Derives a `<slug>Directories` collection for every upload collection in the config.
+ *
+ * Upload's `configure`, in a module pair of its own rather than beside the augment — the server
+ * half needs the collection pipeline, which imports the feature registry, which imports
+ * this feature. Keeping that import out of `../module.server.ts` is what lets the augment and the
+ * hooks be read normally; only this one is read lazily. See features/upload/index.ts.
+ */
+export declare const configureUploadDirectories: <T extends {
+    collections?: BuiltCollection[];
+}>(config: T) => T & {
+    collections: BuiltCollection[];
+};

package/dist/core/prototype/collection/upload/directories/configure.js

@@ -0,0 +1,19 @@
+import { isUploadConfig } from '../util/config.js';
+import { makeUploadDirectoriesCollectionClient } from './derive.js';
+/**
+ * Derives a `<slug>Directories` collection for every upload collection in the config.
+ *
+ * Upload's `configure`, in a module pair of its own rather than beside the augment — the server
+ * half needs the collection pipeline, which imports the feature registry, which imports
+ * this feature. Keeping that import out of `../module.server.ts` is what lets the augment and the
+ * hooks be read normally; only this one is read lazily. See features/upload/index.ts.
+ */
+export const configureUploadDirectories = (config) => {
+    const directoriesCollections = config.collections
+        ?.filter(isUploadConfig)
+        .map(makeUploadDirectoriesCollectionClient);
+    return {
+        ...config,
+        collections: [...(config.collections || []), ...(directoriesCollections || [])]
+    };
+};

package/dist/core/prototype/collection/upload/directories/configure.server.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltCollection } from '../../../../config/types.js';
+/**
+ * The server half of the derivation: a `<slug>Directories` collection per upload collection.
+ *
+ * They land before the config chain resolves any pipeline, so each one is resolved by the same
+ * step that resolves an authored collection — nothing here builds one.
+ */
+export declare const configureUploadDirectories: <T extends {
+    collections?: BuiltCollection[];
+}>(config: T) => T & {
+    collections: BuiltCollection[];
+};

package/dist/core/prototype/collection/upload/directories/configure.server.js

@@ -0,0 +1,35 @@
+import { isUploadConfig } from '../util/config.js';
+import { makeUploadDirectoriesCollectionClient } from './derive.js';
+import { directoriesPipeline } from './pipeline.server.js';
+/**
+ * The return is annotated, not inferred: the collection's feature list holds `upload` — this
+ * feature, whose `configure` is this function — so inferring it would put the list in its own type
+ * graph. Same rule as `Rime` and the registries.
+ */
+const makeUploadDirectoriesCollection = (collection) => {
+    const collectionClient = makeUploadDirectoriesCollectionClient(collection);
+    // Hook order for a directories collection sits beside this file, in ./pipeline.server.ts —
+    // upload's own derived collection, so upload owns its order.
+    const directoriesCollection = {
+        ...collectionClient,
+        $hooks: directoriesPipeline(collection.upload.directories)
+    };
+    // Its pipeline is resolved after this runs, by the step that resolves every prototype config —
+    // see prototype/pipelines.server.ts. Nothing to build here.
+    return directoriesCollection;
+};
+/**
+ * The server half of the derivation: a `<slug>Directories` collection per upload collection.
+ *
+ * They land before the config chain resolves any pipeline, so each one is resolved by the same
+ * step that resolves an authored collection — nothing here builds one.
+ */
+export const configureUploadDirectories = (config) => {
+    const directoriesCollections = config.collections
+        ?.filter(isUploadConfig)
+        .map(makeUploadDirectoriesCollection);
+    return {
+        ...config,
+        collections: [...(config.collections || []), ...(directoriesCollections || [])]
+    };
+};

package/dist/core/prototype/collection/upload/directories/derive.d.ts

@@ -0,0 +1,7 @@
+import type { BuiltCollection } from '../../../../config/types.js';
+import type { WithUpload } from '../util/config.js';
+/**
+ * Creates an upload directories collection for collections with upload enabled
+ * Eg. for medias this will create a collection medias_directories
+ */
+export declare function makeUploadDirectoriesCollectionClient<C extends WithUpload<BuiltCollection>>(collection: C): BuiltCollection;

package/dist/core/prototype/collection/upload/directories/derive.js

@@ -0,0 +1,56 @@
+import { prototypeKebab } from '../../../naming.js';
+import { date } from '../../../../../fields/date/index.js';
+import { text } from '../../../../../fields/text/index.js';
+import { withDirectoriesSuffix } from '../naming.js';
+import { validatePath } from '../util/path.js';
+/**
+ * Creates an upload directories collection for collections with upload enabled
+ * Eg. for medias this will create a collection medias_directories
+ */
+export function makeUploadDirectoriesCollectionClient(collection) {
+    const slug = withDirectoriesSuffix(collection.slug);
+    const directoriesConfig = collection.upload.directories;
+    // else create the directory collection
+    const directoriesCollection = {
+        slug: slug,
+        kebab: prototypeKebab(slug),
+        versions: undefined,
+        access: {
+            read: directoriesConfig?.access?.read || collection.access.read,
+            create: directoriesConfig?.access?.create || collection.access.create,
+            update: directoriesConfig?.access?.update || collection.access.update,
+            delete: directoriesConfig?.access?.delete || collection.access.delete
+        },
+        fields: [
+            text('id').validate(validatePath).unique().required().hidden(),
+            text('name')
+                .validate((value) => {
+                const pattern = /^[a-zA-Z0-9-_ ]+$/;
+                if (typeof value !== 'string' || !pattern.test(value)) {
+                    return 'Incorrect folder name';
+                }
+                return true;
+            })
+                .onChange((value, { useField }) => {
+                const id = useField('id');
+                const parent = useField('parent');
+                const newPath = `${parent.value}:${value}`;
+                id.value = newPath;
+            }),
+            text('parent').hidden(),
+            ...(directoriesConfig?.fields || []),
+            date('createdAt').hidden(),
+            date('updatedAt').hidden()
+        ],
+        type: 'collection',
+        label: {
+            singular: `${collection.slug} directory`,
+            plural: `${collection.slug} directories`
+        },
+        icon: collection.icon,
+        asTitle: 'name',
+        asThumbnail: collection.asThumbnail,
+        panel: false
+    };
+    return directoriesCollection;
+}

package/dist/core/prototype/collection/upload/directories/pipeline.server.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionHooks } from '../../../../../types.js';
+/**
+ * The hooks for an upload collection's derived `<slug>_directories` collection.
+ *
+ * Upload's own derived collection, so its pipeline belongs to upload — the same rule that puts
+ * `uploadHooks` here. The result goes through `augmentHooks` like an author-written collection.
+ */
+export declare const directoriesPipeline: (directoriesConfig: {
+    $hooks?: CollectionHooks<any>;
+} | undefined) => CollectionHooks<any>;

package/dist/core/prototype/collection/upload/directories/pipeline.server.js

@@ -0,0 +1,22 @@
+import { exctractPath } from '../hooks/extract-path.server.js';
+import { prepareDirectoryChildren, updateDirectoryChildren } from '../hooks/update-directory-children.server.js';
+/**
+ * The hooks for an upload collection's derived `<slug>_directories` collection.
+ *
+ * Upload's own derived collection, so its pipeline belongs to upload — the same rule that puts
+ * `uploadHooks` here. The result goes through `augmentHooks` like an author-written collection.
+ */
+export const directoriesPipeline = (directoriesConfig) => ({
+    beforeOperation: directoriesConfig?.$hooks?.beforeOperation || [],
+    beforeCreate: [exctractPath, ...(directoriesConfig?.$hooks?.beforeCreate || [])],
+    beforeRead: directoriesConfig?.$hooks?.beforeRead || [],
+    beforeUpdate: [
+        exctractPath,
+        prepareDirectoryChildren,
+        ...(directoriesConfig?.$hooks?.beforeUpdate || [])
+    ],
+    beforeDelete: directoriesConfig?.$hooks?.beforeDelete || [],
+    afterCreate: directoriesConfig?.$hooks?.afterCreate || [],
+    afterUpdate: [updateDirectoryChildren, ...(directoriesConfig?.$hooks?.afterUpdate || [])],
+    afterDelete: directoriesConfig?.$hooks?.afterDelete || []
+});

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

@@ -0,0 +1,9 @@
+import type { BuiltCollection, Config } from '../../../../config/types.js';
+import type { GenericDoc } from '../../../types.js';
+import type { RimeContext } from '../../../../rime.server.js';
+import type { WithUpload } from '../util/config.js';
+export declare const cleanUpDocumentFile: <C extends Config>(args: {
+    config: WithUpload<BuiltCollection>;
+    rime: RimeContext<C>;
+    id: string;
+}) => Promise<GenericDoc>;