rimecms 0.31.4 → 0.32.0

package/dist/core/prototype/shared/versions/hooks/define-version-operation.server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Decides what this update does to the row it selected, and puts it on
+ * `context.versionOperation` — see `defineVersionUpdateOperation` for the table.
+ *
+ * Which row, is already decided: `getOriginalDocument` ran above and read the row `versionId`
+ * names, else the newest with `latest`, else the published one, exactly as a read would. Two
+ * groupings follow, and they are what the other hooks read (`VersionOperations`):
+ *
+ * - a **new-version** operation (`NEW_VERSION`, `NEW_AUTO_SAVE_FROM_VERSION`) is inserted by
+ *   `handleNewVersion` before the write plan is built, from the original plus the submission — so
+ *   the plan names no content row for it, and the row carries the `status` the body gave it,
+ *   `draft` by default; an auto-save carries the status of the row it branched from, which is
+ *   what it becomes when saved;
+ * - `UPDATE_VERSION` writes the row the original was read from. When that write is not an
+ *   auto-save it also clears `isAutoSave` on its row: that is how an auto-save is promoted.
+ *
+ * `demoteOtherVersions` runs for either group when the body says `published`.
+ */
+export declare const defineVersionOperation: import("../../../../pipeline/types").Hook<"raw", "update", "before">;

package/dist/core/prototype/shared/versions/hooks/define-version-operation.server.js

@@ -0,0 +1,37 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { defineVersionUpdateOperation } from '../strategy.js';
+/**
+ * Decides what this update does to the row it selected, and puts it on
+ * `context.versionOperation` — see `defineVersionUpdateOperation` for the table.
+ *
+ * Which row, is already decided: `getOriginalDocument` ran above and read the row `versionId`
+ * names, else the newest with `latest`, else the published one, exactly as a read would. Two
+ * groupings follow, and they are what the other hooks read (`VersionOperations`):
+ *
+ * - a **new-version** operation (`NEW_VERSION`, `NEW_AUTO_SAVE_FROM_VERSION`) is inserted by
+ *   `handleNewVersion` before the write plan is built, from the original plus the submission — so
+ *   the plan names no content row for it, and the row carries the `status` the body gave it,
+ *   `draft` by default; an auto-save carries the status of the row it branched from, which is
+ *   what it becomes when saved;
+ * - `UPDATE_VERSION` writes the row the original was read from. When that write is not an
+ *   auto-save it also clears `isAutoSave` on its row: that is how an auto-save is promoted.
+ *
+ * `demoteOtherVersions` runs for either group when the body says `published`.
+ */
+export const defineVersionOperation = Hooks.beforeUpdate(async function defineVersionOperation(args) {
+    const { config } = args;
+    const versionOperation = defineVersionUpdateOperation({
+        versionId: args.context.params.versionId,
+        fork: args.context.params.fork,
+        autoSave: args.context.params.autoSave,
+        originalIsAutoSave: !!args.context.originalDoc?.isAutoSave,
+        config
+    });
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            versionOperation
+        }
+    };
+});

package/dist/core/prototype/shared/versions/hooks/demote-other-versions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Exactly one version of a document is published at a time, so publishing one steps the others
+ * down first.
+ *
+ * Runs before the write, as every `beforeUpdate` hook does, and demotes every other version of
+ * the document. The one being published is `context.contentOwnerId` — the selected row, or the
+ * row `handleNewVersion` has just inserted for a fork, which the write plan will not touch again —
+ * and it is left alone. An auto-save carries the status of the row it branched from and
+ * publishes nothing, so it is left out.
+ *
+ * The two statements are not in a transaction (there are none in the adapter), so a reader
+ * between them sees the document with no published version.
+ *
+ * Isomorphic: it reaches the adapter through `event.locals`, so it imports nothing server-only
+ * and needs no `$rime/modules` pair — the feature can carry it directly.
+ */
+export declare const demoteOtherVersions: import("../../../../pipeline/types").Hook<"raw", "update", "before">;

package/dist/core/prototype/shared/versions/hooks/demote-other-versions.js

@@ -0,0 +1,37 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { VERSIONS_STATUS } from '../constant.js';
+import { VersionOperations } from '../strategy.js';
+/**
+ * Exactly one version of a document is published at a time, so publishing one steps the others
+ * down first.
+ *
+ * Runs before the write, as every `beforeUpdate` hook does, and demotes every other version of
+ * the document. The one being published is `context.contentOwnerId` — the selected row, or the
+ * row `handleNewVersion` has just inserted for a fork, which the write plan will not touch again —
+ * and it is left alone. An auto-save carries the status of the row it branched from and
+ * publishes nothing, so it is left out.
+ *
+ * The two statements are not in a transaction (there are none in the adapter), so a reader
+ * between them sees the document with no published version.
+ *
+ * Isomorphic: it reaches the adapter through `event.locals`, so it imports nothing server-only
+ * and needs no `$rime/modules` pair — the feature can carry it directly.
+ */
+export const demoteOtherVersions = Hooks.beforeUpdate(async function demoteOtherVersions(args) {
+    const { config, data, event, context } = args;
+    // Only a config with drafts has a published version to be the only one of.
+    if (!config.versions || !config.versions.draft)
+        return args;
+    if (context.params.autoSave)
+        return args;
+    if (VersionOperations.isAutoSaveCreation(context.versionOperation))
+        return args;
+    if (data.status !== VERSIONS_STATUS.PUBLISHED)
+        return args;
+    // On the versions table `id` is the row itself; `contentOwnerId` names it.
+    await event.locals.rime.adapter.contentOwner(config.slug).updateWhere({
+        query: `where[and][0][ownerId][equals]=${context.originalDoc.id}&where[and][1][id][not_equals]=${context.contentOwnerId}`,
+        data: { status: VERSIONS_STATUS.DRAFT }
+    });
+    return args;
+});

package/dist/core/prototype/shared/versions/hooks/discard-auto-saves-of.server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A staff member's auto-saved rows go with them.
+ *
+ * Runs on the staff collection's delete, before the row is gone: the foreign key would set
+ * `updatedBy` to null and leave a row nobody owns and nobody can resume. Every config that
+ * auto-saves is swept.
+ */
+export declare const discardAutoSavesOf: import("../../../../pipeline/types.js").Hook<"raw", "delete", "before">;

package/dist/core/prototype/shared/versions/hooks/discard-auto-saves-of.server.js

@@ -0,0 +1,17 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { retireAutoSaves } from '../retire-auto-saves.server.js';
+/**
+ * A staff member's auto-saved rows go with them.
+ *
+ * Runs on the staff collection's delete, before the row is gone: the foreign key would set
+ * `updatedBy` to null and leave a row nobody owns and nobody can resume. Every config that
+ * auto-saves is swept.
+ */
+export const discardAutoSavesOf = Hooks.beforeDelete(async function discardAutoSavesOf(args) {
+    const { event, doc } = args;
+    const { config } = event.locals.rime;
+    for (const prototype of [...Object.values(config.collections), ...Object.values(config.areas)]) {
+        await retireAutoSaves({ event, config: prototype, userId: doc.id });
+    }
+    return args;
+});

package/dist/core/prototype/shared/versions/hooks/expose-version-id.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Puts `versionId` on the document.
+ *
+ * The adapter folds a base row and its content row into one document and says which row the
+ * content came from — as `contentId`, its own word, the one `insert` returns and `find` takes.
+ * What that row *is* called on a versioned document is this feature's business, and it is the
+ * public property the panel, the REST params and every consumer already read.
+ *
+ * Additive — `contentId` stays, and the code that wants the row rather than the name reads that
+ * one, which is why `url` and `upload` need not run after this.
+ */
+export declare const exposeVersionId: import("../../../../pipeline/types").Hook<"raw", "read", "before">;

package/dist/core/prototype/shared/versions/hooks/expose-version-id.js

@@ -0,0 +1,17 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+/**
+ * Puts `versionId` on the document.
+ *
+ * The adapter folds a base row and its content row into one document and says which row the
+ * content came from — as `contentId`, its own word, the one `insert` returns and `find` takes.
+ * What that row *is* called on a versioned document is this feature's business, and it is the
+ * public property the panel, the REST params and every consumer already read.
+ *
+ * Additive — `contentId` stays, and the code that wants the row rather than the name reads that
+ * one, which is why `url` and `upload` need not run after this.
+ */
+export const exposeVersionId = Hooks.beforeRead(async function exposeVersionId(args) {
+    if (!args.doc.contentId)
+        return args;
+    return { ...args, doc: { ...args.doc, versionId: args.doc.contentId } };
+});

package/dist/core/prototype/shared/versions/hooks/fallback-data-from-original.d.ts

@@ -0,0 +1,9 @@
+import type { Dic } from '../../../../../util/types.js';
+import type { ConfigMap } from '../../../../pipeline/config-map/types.js';
+export declare const fallbackDataFromOriginal: <T extends Dic>(args: {
+    data: T;
+    original: T;
+    configMap: ConfigMap;
+    ignore: string[];
+    mode?: "required" | "all";
+}) => Promise<T>;

package/dist/core/prototype/shared/versions/hooks/fallback-data-from-original.js

@@ -0,0 +1,31 @@
+import { logger } from '../../../../logger.server.js';
+import { getValueAtPath, setValueAtPath } from '../../../../../util/object.js';
+export const fallbackDataFromOriginal = async (args) => {
+    //
+    const mode = args.mode || 'all';
+    const { original, configMap, ignore } = args;
+    let output = { ...args.data };
+    for (const [key, config] of Object.entries(configMap)) {
+        // skip keys in ignore list
+        if (ignore.includes(key))
+            continue;
+        // skip if not required and mode is 'required'
+        const shouldUpdate = (config.get.required && mode === 'required') || mode === 'all';
+        if (!shouldUpdate)
+            continue;
+        let value = getValueAtPath(key, output);
+        let isEmpty;
+        try {
+            isEmpty = config.use.isEmpty(value);
+        }
+        catch {
+            isEmpty = false;
+            logger.warn(`Error while checking if field ${key} is empty`);
+        }
+        if (isEmpty) {
+            value = await getValueAtPath(key, original);
+            output = setValueAtPath(key, output, value);
+        }
+    }
+    return output;
+};

package/dist/core/prototype/shared/versions/hooks/handle-new-version.server.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Where a versioned document's content lives for *this* update — overriding the default.
+ *
+ * `resolveContentOwner` has already said "the document's own row", which is right for every
+ * prototype with no versions. This runs after it, only on a config that enables `versions`, and
+ * answers again:
+ *
+ * - **a specific version** — that row.
+ * - **a new version** — the row this hook creates, through the public API, which is what makes
+ *   the write plan's third case ("already written") true.
+ *
+ * On a config that auto-saves it also says what the row is. An auto-save keeps its row
+ * auto-saved; any other write on a specific version clears the flag, which is how an auto-save
+ * becomes a version. A new auto-save replaces the caller's previous one on the document — one per
+ * user and document — and the flag is set on the row after the insert, because
+ * `stripAutoSaveFlag` takes it out of every submission, this create's included.
+ *
+ * An auto-saved row's `status` is what the row becomes when it is saved: the status of the row it
+ * branched from, kept as is afterwards, and never the body's. No read can return the row
+ * whatever it says — `versionsReadQuery` filters on `isAutoSave` first — so a row branched from
+ * the published version reads `published`, and saving it keeps the document published.
+ *
+ * **Two things pin where it sits in the list**, and both are silent if broken:
+ *
+ * - It runs after `buildOriginalDocConfigMap`, because `prepareDataForNewVersion` reads
+ *   `originalConfigMap` — the throw below says so.
+ * - It runs before `setDefaultValues`, because it reads the caller's submission *as sent*:
+ *   whatever was not sent, `fallbackDataFromOriginal` fills from the previous version. Let the
+ *   defaults land first and editing one field resets every unsent field to its default instead of
+ *   carrying it forward.
+ */
+export declare const handleNewVersion: import("../../../../pipeline/types.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/prototype/shared/versions/hooks/handle-new-version.server.js

@@ -0,0 +1,194 @@
+import { RimeError } from '../../../../errors/index.js';
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { copyLocales } from '../../../../locale/copy.server.js';
+import { moveEditLock } from '../../metas/lock.server.js';
+import { fileForDocument } from '../../../collection/upload/util/converter.server.js';
+import { VERSIONS_STATUS } from '../constant.js';
+import { withVersionsSuffix } from '../naming.js';
+import { VersionOperations } from '../strategy.js';
+import { omit, recursiveRemoveKeys } from '../../../../../util/object.js';
+import { retireAutoSaves } from '../retire-auto-saves.server.js';
+import { fallbackDataFromOriginal } from './fallback-data-from-original.js';
+/**
+ * Where a versioned document's content lives for *this* update — overriding the default.
+ *
+ * `resolveContentOwner` has already said "the document's own row", which is right for every
+ * prototype with no versions. This runs after it, only on a config that enables `versions`, and
+ * answers again:
+ *
+ * - **a specific version** — that row.
+ * - **a new version** — the row this hook creates, through the public API, which is what makes
+ *   the write plan's third case ("already written") true.
+ *
+ * On a config that auto-saves it also says what the row is. An auto-save keeps its row
+ * auto-saved; any other write on a specific version clears the flag, which is how an auto-save
+ * becomes a version. A new auto-save replaces the caller's previous one on the document — one per
+ * user and document — and the flag is set on the row after the insert, because
+ * `stripAutoSaveFlag` takes it out of every submission, this create's included.
+ *
+ * An auto-saved row's `status` is what the row becomes when it is saved: the status of the row it
+ * branched from, kept as is afterwards, and never the body's. No read can return the row
+ * whatever it says — `versionsReadQuery` filters on `isAutoSave` first — so a row branched from
+ * the published version reads `published`, and saving it keeps the document published.
+ *
+ * **Two things pin where it sits in the list**, and both are silent if broken:
+ *
+ * - It runs after `buildOriginalDocConfigMap`, because `prepareDataForNewVersion` reads
+ *   `originalConfigMap` — the throw below says so.
+ * - It runs before `setDefaultValues`, because it reads the caller's submission *as sent*:
+ *   whatever was not sent, `fallbackDataFromOriginal` fills from the previous version. Let the
+ *   defaults land first and editing one field resets every unsent field to its default instead of
+ *   carrying it forward.
+ */
+export const handleNewVersion = Hooks.beforeUpsert(async (args) => {
+    const { config, event } = args;
+    const { rime } = event.locals;
+    const { versionOperation, originalDoc, originalConfigMap, params } = args.context;
+    if (!originalConfigMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalConfigMap @handleNewVersion');
+    if (!originalDoc)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @handleNewVersion');
+    if (!versionOperation)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing versionOperation @handleNewVersion');
+    const autoSaves = !!config.versions?.autoSave;
+    if (VersionOperations.isSpecificVersionUpdate(versionOperation)) {
+        // A promoted auto-save states the status it inherited, so a published one is seen by
+        // `demoteOtherVersions` and stays the only published version. The body's own status wins.
+        const promoted = !!originalDoc.isAutoSave && !params.autoSave;
+        const inherited = promoted && originalDoc.status ? { status: originalDoc.status } : {};
+        const data = !autoSaves
+            ? args.data
+            : params.autoSave
+                ? { ...omit(['status'], args.data), isAutoSave: true }
+                : { ...inherited, ...args.data, isAutoSave: false };
+        return {
+            ...args,
+            data,
+            context: { ...args.context, contentOwnerId: originalDoc.versionId }
+        };
+    }
+    if (VersionOperations.isNewVersionCreation(versionOperation)) {
+        const isAutoSave = VersionOperations.isAutoSaveCreation(versionOperation);
+        const userId = event.locals.user?.id;
+        if (isAutoSave && !userId) {
+            throw new RimeError(RimeError.UNAUTHORIZED, 'an auto-save belongs to a user');
+        }
+        const data = await prepareDataForNewVersion({
+            data: args.data,
+            originalDoc,
+            config,
+            originalConfigMap
+        });
+        if (isAutoSave)
+            data.status = originalDoc.status;
+        const versionsSlug = withVersionsSuffix(config.slug);
+        if (isAutoSave) {
+            await retireAutoSaves({ event, config, docId: originalDoc.id, userId: userId });
+        }
+        const document = await rime.collection(versionsSlug).create({
+            data,
+            locale: params.locale
+        });
+        // The edit continues on the new row: the claim its maker holds on the original goes with it,
+        // so the panel has nothing to hand back or take.
+        if (userId) {
+            await moveEditLock({
+                event,
+                config,
+                doc: originalDoc,
+                to: { id: originalDoc.id, versionId: document.id },
+                userId
+            });
+        }
+        // The other locales come from the version this one branches from, raw: a translation the
+        // original has is carried over, one it has not stays unwritten and falls back on read. Before
+        // the auto-save flag below, since the copy is a write to the new row like any other.
+        const otherLocales = rime.config.getLocalesCodes().filter((code) => code !== params.locale);
+        if (params.locale && otherLocales.length) {
+            const created = config.type === 'collection'
+                ? await rime.collection(config.slug).findById({
+                    id: originalDoc.id,
+                    locale: params.locale,
+                    versionId: document.id,
+                    localeFallback: false
+                })
+                : await rime.area(config.slug).find({
+                    locale: params.locale,
+                    versionId: document.id,
+                    localeFallback: false
+                });
+            await copyLocales({
+                event,
+                config,
+                source: { id: originalDoc.id, versionId: originalDoc.versionId },
+                target: { id: originalDoc.id, versionId: document.id, doc: created },
+                locales: otherLocales
+            });
+        }
+        if (isAutoSave) {
+            await rime.adapter.contentOwner(config.slug).updateWhere({
+                query: `where[id][equals]=${document.id}`,
+                data: { isAutoSave: true }
+            });
+        }
+        else if (config.versions && config.versions.maxVersions) {
+            // The versions beyond `maxVersions`, oldest first, go. A published version stays, and an
+            // auto-save is not a version — each clause only where the config has the field, since a
+            // clause on a missing column matches nothing and the pruning would never happen.
+            const spared = [];
+            if (config.versions.draft)
+                spared.push({ status: { not_equals: VERSIONS_STATUS.PUBLISHED } });
+            if (autoSaves)
+                spared.push({ isAutoSave: { not_equals: true } });
+            // Bookkeeping, as rime itself: the editor writing a version need not hold `access.delete`.
+            await rime
+                .collection(versionsSlug)
+                .system()
+                .delete({
+                sort: '-updatedAt',
+                query: spared.length
+                    ? { where: spared.length === 1 ? spared[0] : { and: spared } }
+                    : undefined,
+                offset: config.versions.maxVersions
+            });
+        }
+        return { ...args, context: { ...args.context, contentOwnerId: document.id } };
+    }
+    // Versioned, but this update writes neither a named version nor a new one — the default
+    // `resolveContentOwner` set stands.
+    return args;
+});
+async function prepareDataForNewVersion(args) {
+    const { config, originalDoc, originalConfigMap } = args;
+    let data = { ...args.data };
+    /**
+     * A new version of an upload document inherits the file the old one had, unless the write brings
+     * a new one — the version row has its own `filename`, so without this a revision of a document
+     * nobody re-uploaded to comes out with no file.
+     *
+     * This asked `upload` for two things: where it keeps its files, and how to turn a path into a
+     * `File`. It asks for one now. The remaining import is the genuine cross-feature dependency
+     * what a new content row inherits is a question this feature
+     * has and only that one can answer — and it is one call rather than a copy of a convention.
+     */
+    if (config.type === 'collection' && config.upload && !data.file) {
+        data.file = (await fileForDocument(originalDoc)) ?? data.file;
+    }
+    // Use missing required data from original version
+    data = await fallbackDataFromOriginal({
+        data,
+        original: originalDoc,
+        configMap: originalConfigMap,
+        ignore: ['status'],
+        mode: 'all'
+    });
+    // Set default status to "draft" if no data.status
+    if (!data.status) {
+        data.status = VERSIONS_STATUS.DRAFT;
+    }
+    // Remove ownerId and id props from data this force new relation/blocks creations
+    data = recursiveRemoveKeys('ownerId', 'id').from(data);
+    data.ownerId = originalDoc.id;
+    delete data.id;
+    return data;
+}

package/dist/core/prototype/shared/versions/hooks/index.server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `versions.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 { defineVersionOperation } from './define-version-operation.server.js';
+export { demoteOtherVersions } from './demote-other-versions.js';
+export { discardAutoSavesOf } from './discard-auto-saves-of.server.js';
+export { exposeVersionId } from './expose-version-id.js';
+export { handleNewVersion } from './handle-new-version.server.js';
+export { preventLastVersionDeletion } from './prevent-last-version-deletion.server.js';
+export { stripAutoSaveFlag } from './strip-auto-save-flag.server.js';

package/dist/core/prototype/shared/versions/hooks/index.server.js

@@ -0,0 +1,15 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `versions.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 { defineVersionOperation } from './define-version-operation.server.js';
+export { demoteOtherVersions } from './demote-other-versions.js';
+export { discardAutoSavesOf } from './discard-auto-saves-of.server.js';
+export { exposeVersionId } from './expose-version-id.js';
+export { handleNewVersion } from './handle-new-version.server.js';
+export { preventLastVersionDeletion } from './prevent-last-version-deletion.server.js';
+export { stripAutoSaveFlag } from './strip-auto-save-flag.server.js';

package/dist/core/prototype/shared/versions/hooks/prevent-last-version-deletion.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A document keeps at least one version.
+ *
+ * Runs on the versions collection's delete. A base row with no content row reads as absent
+ * everywhere, so the last version goes with the document or not at all.
+ */
+export declare const preventLastVersionDeletion: import("../../../../pipeline/types").Hook<"raw", "delete", "before">;

package/dist/core/prototype/shared/versions/hooks/prevent-last-version-deletion.server.js

@@ -0,0 +1,21 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { RimeError } from '../../../../errors/index.js';
+/**
+ * A document keeps at least one version.
+ *
+ * Runs on the versions collection's delete. A base row with no content row reads as absent
+ * everywhere, so the last version goes with the document or not at all.
+ */
+export const preventLastVersionDeletion = Hooks.beforeDelete(async function preventLastVersionDeletion(args) {
+    const { config, doc, event } = args;
+    if (args.context.isSystemOperation)
+        return args;
+    const rows = await event.locals.rime.adapter.collection(config.slug).findMany({
+        query: { where: { ownerId: { equals: doc.ownerId } } },
+        select: ['id']
+    });
+    if (rows.length <= 1) {
+        throw new RimeError(RimeError.BAD_REQUEST, 'the last version of a document cannot be deleted, delete the document');
+    }
+    return args;
+});

package/dist/core/prototype/shared/versions/hooks/strip-auto-save-flag.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Drops `isAutoSave` from the submission. The server sets it; a request body cannot.
+ *
+ * `hidden()` is a panel concern only — any hidden field is writable through a request body, so
+ * a flag the server owns has to be taken out before anything reads the data.
+ */
+export declare const stripAutoSaveFlag: import("../../../../pipeline/types").Hook<"raw", "create" | "update", "before">;

package/dist/core/prototype/shared/versions/hooks/strip-auto-save-flag.server.js

@@ -0,0 +1,14 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+/**
+ * Drops `isAutoSave` from the submission. The server sets it; a request body cannot.
+ *
+ * `hidden()` is a panel concern only — any hidden field is writable through a request body, so
+ * a flag the server owns has to be taken out before anything reads the data.
+ */
+export const stripAutoSaveFlag = Hooks.beforeUpsert(async function stripAutoSaveFlag(args) {
+    if (!('isAutoSave' in args.data))
+        return args;
+    const data = { ...args.data };
+    delete data.isAutoSave;
+    return { ...args, data };
+});

package/dist/core/prototype/shared/versions/module.browser.js

@@ -0,0 +1 @@
+export const configureVersions = undefined;

package/dist/core/prototype/shared/versions/module.server.d.ts

@@ -0,0 +1 @@
+export { configureVersions } from './configure.server.js';

package/dist/core/prototype/shared/versions/module.server.js

@@ -0,0 +1,4 @@
+// Server half. The aliases are built from `collectionHooks`, which is server-only, so there is no
+// client half to pair this with — a client build resolves the name to `undefined` and the feature
+// simply carries no `configure` there. Same shape as `features/url`'s hooks.
+export { configureVersions } from './configure.server.js';

package/dist/core/prototype/shared/versions/naming.d.ts

@@ -0,0 +1,7 @@
+import type { CollectionSlug } from '../../../../types.js';
+/** `pages` -> `$pages__versions` */
+export declare const withVersionsSuffix: (name: string) => CollectionSlug;
+/** `$pages__versions` -> `pages`; anything else unchanged. */
+export declare const withoutVersionsSuffix: (name: string) => CollectionSlug;
+/** `$pages__versions` -> true */
+export declare const hasVersionsSuffix: (slug: string) => boolean;

package/dist/core/prototype/shared/versions/naming.js

@@ -0,0 +1,21 @@
+/**
+ * The versions table naming convention, in slug space.
+ *
+ * A derived slug is `$` + the base + `__` + the marker:
+ *
+ *   pages  ->  $pages__versions  ->  table pages__versions  ->  url pages--versions
+ *
+ * The `$` says rime made this, matching how `$hooks`/`$url`/`$adapter` already mark
+ * rime-owned config keys. The `__` says *versions of*, and it is a segment boundary rather than
+ * a word break — which is why every case conversion goes through mapSegments and why an author
+ * slug may not contain it (see core/config/validate.server.ts). Without that rule a
+ * collection named `pagesVersions` would snake-case onto the same table as this versions.
+ */
+const DERIVED = '$';
+const MARKER = '__versions';
+/** `pages` -> `$pages__versions` */
+export const withVersionsSuffix = (name) => `${DERIVED}${name.replace(/^\$/, '')}${MARKER}`;
+/** `$pages__versions` -> `pages`; anything else unchanged. */
+export const withoutVersionsSuffix = (name) => name.replace(/^\$/, '').replace(MARKER, '');
+/** `$pages__versions` -> true */
+export const hasVersionsSuffix = (slug) => slug.endsWith(MARKER);

package/dist/core/prototype/shared/versions/read-query.d.ts

@@ -0,0 +1,27 @@
+import type { OperationQuery } from '../../../pipeline/types.js';
+import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
+/**
+ * Which version a read means.
+ *
+ * ```
+ * versionId given          that row, whatever its status, auto-saved or not
+ * config auto-saves        never an auto-saved row — and, with drafts:
+ * config has no drafts     no narrowing — the adapter reads that as the newest row
+ * latest asked for         the newest row
+ * otherwise                the published one
+ * ```
+ *
+ * The same answer for a read and for the row an update starts from: `latest` and `versionId`
+ * select a row, and that is all they do. What an update then does to it, case by case, is tabled
+ * on `defineVersionUpdateOperation` in `strategy.ts`.
+ *
+ * `versionId` and not `id`, because on a versions table `id` means the document — see
+ * `normalizedForShadow` in the where builder.
+ */
+export declare const versionsReadQuery: (args: {
+    config: BuiltArea | BuiltCollection;
+    params: {
+        latest?: boolean;
+        versionId?: string;
+    };
+}) => OperationQuery | undefined;

package/dist/core/prototype/shared/versions/read-query.js

@@ -0,0 +1,35 @@
+import { VERSIONS_STATUS } from './constant.js';
+/**
+ * Which version a read means.
+ *
+ * ```
+ * versionId given          that row, whatever its status, auto-saved or not
+ * config auto-saves        never an auto-saved row — and, with drafts:
+ * config has no drafts     no narrowing — the adapter reads that as the newest row
+ * latest asked for         the newest row
+ * otherwise                the published one
+ * ```
+ *
+ * The same answer for a read and for the row an update starts from: `latest` and `versionId`
+ * select a row, and that is all they do. What an update then does to it, case by case, is tabled
+ * on `defineVersionUpdateOperation` in `strategy.ts`.
+ *
+ * `versionId` and not `id`, because on a versions table `id` means the document — see
+ * `normalizedForShadow` in the where builder.
+ */
+export const versionsReadQuery = (args) => {
+    const { config, params } = args;
+    if (params.versionId)
+        return { where: { versionId: { equals: params.versionId } } };
+    if (!config.versions)
+        return undefined;
+    const clauses = [];
+    if (config.versions.autoSave)
+        clauses.push({ isAutoSave: { not_equals: true } });
+    if (config.versions.draft && !params.latest) {
+        clauses.push({ status: { equals: VERSIONS_STATUS.PUBLISHED } });
+    }
+    if (clauses.length === 0)
+        return undefined;
+    return { where: clauses.length === 1 ? clauses[0] : { and: clauses } };
+};