rimecms 0.31.4 → 0.32.0

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

@@ -0,0 +1,74 @@
+import { augmentAuth } from 'rimecms/core/auth/module';
+import { isAuth } from '../../auth/enabled.js';
+import { augmentMetas } from 'rimecms/core/prototype/shared/metas/module';
+import { augmentNested } from 'rimecms/core/prototype/collection/nested/module';
+import { isNested } from './nested/enabled.js';
+import { augmentThumbnail } from './thumbnail/augment.js';
+import { augmentTitle } from '../shared/title/augment.js';
+import { augmentUpload } from 'rimecms/core/prototype/collection/upload/module';
+import { isUpload } from './upload/enabled.js';
+import { augmentUrl } from '../shared/url/augment.js';
+import { hasUrl } from '../shared/url/enabled.js';
+import { augmentVersions } from '../shared/versions/augment.js';
+import { when } from '../when.js';
+import { definePrototype } from '../define.js';
+import { augmentLabel } from './augment-label.js';
+/**
+ * A collection: many documents, addressed by id, with the full set of operations.
+ *
+ * The client half of the pair. It carries everything a client build needs — what a collection
+ * *is* — and none of what only a server can do: `api` and `rest` are declared in
+ * `definition.server.ts`, which re-exports this with those added.
+ *
+ * That split is what lets the definition hold `features` and `augments`: `create` runs them on
+ * both sides, so both lists have to be reachable from a client build, which a `.server.ts`
+ * definition never was.
+ */
+export const collection = definePrototype({
+    /** The name it is exported under, and the `type` every collection config carries. */
+    name: 'collection',
+    /**
+     * **Everything that shapes a collection config, in the order it runs** — which is the order the
+     * fields land in, and therefore column order (CONTRIBUTING rule 2).
+     *
+     * This was two declarations: `augments: [augmentLabel]` for the prototype's own, and
+     * `features: [auth, panel, upload, …]` for the rest, folded by `applyAugments`, each entry
+     * gated by a `FeatureDefinition.enabled` predicate declared in its own file. Reading the chain
+     * meant opening ten of them. It is one list now, and the guard is beside the step.
+     *
+     * `auth` is first because `title` resolves `asTitle` from the fallback `auth` and `upload` each
+     * offer, so both have to have run before it. `metas` is last because metas close the table.
+     * `augmentVersions` carries its own guard on its first line; the four `when`s are the rest of
+     * what `enabled` used to answer, and the unguarded steps are the six that answered `() => true`.
+     *
+     * `panel` and `cors` are not here: neither has an augment. They shape the whole config and are
+     * called by the config chain — see `config/build.ts`.
+     */
+    augments: () => [
+        augmentLabel,
+        when(isAuth, augmentAuth),
+        when(isUpload, augmentUpload),
+        when(isNested, augmentNested),
+        augmentVersions,
+        when(hasUrl, augmentUrl),
+        augmentTitle,
+        augmentThumbnail,
+        augmentMetas
+    ]
+});
+/**
+ * The public authoring API: `Collection.create('pages', {…})`.
+ *
+ * One line over `collection.create`, and it exists for the one thing a definition prop cannot
+ * state: the authoring type is generic in the slug — `Collection<S>` types `$hooks` and `$url`
+ * from it — and no type parameter can carry a generic type. So the composition lives in
+ * `definePrototype` and the signature lives here, next to the kind it belongs to.
+ *
+ * Isomorphic on purpose. A feature that derives a collection (`auth`'s `staff`) imports this file
+ * and not `definition.server.ts` — see rule 3 in CONTRIBUTING.md.
+ */
+export const create = (slug, config) => 
+// The same erasure the registry casts through: a definition's `create` is typed by the kind the
+// definition is, and the client half is written against `BuiltPrototype` so that the registry
+// can hold both in one list.
+collection.create(slug, config);

package/dist/core/prototype/collection/definition.server.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltCollection } from '../../config/types.js';
+/**
+ * The server half: the same collection, plus what only a server can provide.
+ *
+ * Same export name as `module.js` — that is what makes the pair resolve — and it takes the
+ * client half whole rather than restating it, so the features and hooks are declared once.
+ */
+export declare const collection: import("../define.js").PrototypeDefinition<BuiltCollection>;

package/dist/core/prototype/collection/definition.server.js

@@ -0,0 +1,24 @@
+import { definePrototype } from '../define.js';
+import { collection as base } from './definition.js';
+import { collectionHooks } from './hooks.server.js';
+import { rest } from './rest/index.server.js';
+/**
+ * The server half: the same collection, plus what only a server can provide.
+ *
+ * Same export name as `module.js` — that is what makes the pair resolve — and it takes the
+ * client half whole rather than restating it, so the features and hooks are declared once.
+ */
+export const collection = definePrototype({
+    ...base,
+    rest,
+    /**
+     * The prototype's own document hooks, listed in `hooks.server.ts` beside this file.
+     *
+     * On the **server half**, and that is a constraint rather than tidiness. The config factory runs
+     * on both sides and needs `features`, so it imports the client half — and a hook is typed through
+     * `HookContext → event.locals.rime`, which resolves through the config the factory is building.
+     * Putting hooks on the client half therefore made every one of them reference itself.
+     * They are server-only code regardless; nothing client-side runs a document hook.
+     */
+    hooks: collectionHooks
+});

package/dist/core/prototype/collection/hooks/merge-with-blank.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Merges the incoming data onto a blank document, so a create starts from every field the config
+ * declares rather than only the ones the caller sent.
+ */
+export declare const mergeWithBlankDocument: import("../../../pipeline/types").Hook<"raw", "create", "before">;

package/dist/core/prototype/collection/hooks/merge-with-blank.server.js

@@ -0,0 +1,28 @@
+import { Hooks } from '../../../pipeline/define-hook.js';
+import { createBlankDocument } from '../../doc.js';
+import { omit, pick } from '../../../../util/object.js';
+import deepmerge from 'deepmerge';
+/**
+ * Merges the incoming data onto a blank document, so a create starts from every field the config
+ * declares rather than only the ones the caller sent.
+ */
+export const mergeWithBlankDocument = Hooks.beforeCreate(async function mergeWithBlankDocument(args) {
+    const blank = createBlankDocument(args.config, args.event);
+    const known = Object.keys(blank);
+    const data = args.data;
+    /**
+     * The blank is built from the config's fields, so only the keys it has are keys there is
+     * anything to merge *with*. Everything else is carried across rather than through.
+     *
+     * That is what keeps a `File` a `File`. `deepmerge` clones every plain object it walks, so an
+     * upload payload passed through it would come out with none of a `File`'s methods — and `file`
+     * is not a field on any config, so the blank has no key for it and nothing to merge it into.
+     */
+    return {
+        ...args,
+        data: {
+            ...deepmerge(blank, pick(known, data), { arrayMerge: (_, incoming) => incoming }),
+            ...omit(known, data)
+        }
+    };
+});

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

@@ -0,0 +1,28 @@
+import type { AnyHook, HookTiming } from '../../pipeline/types.js';
+/**
+ * Every hook a collection can run, in the order it runs them.
+ *
+ * **The order is written here, not computed**, and in `beforeUpdate` that is a security question:
+ * `preventUserMutations` rejects on `'name' in args.data`, so a default filled in above it turns
+ * an ordinary update into a 401. Two adjacent lines you can read.
+ *
+ * ```ts
+ * when(isAuth, auth.removePrivateFields)   // runs only on a collection that declares `auth`
+ * processDocumentFields                    // runs always
+ * ```
+ *
+ * A feature owns its hooks; this says when they run and what they run on.
+ *
+ * A hook a feature owns and this list does not place never runs, and nothing throws: placing it
+ * here is what runs it.
+ *
+ * A consumer's hooks are appended after these, per timing, and before the finaliser.
+ *
+ * **In its own file rather than in `definition.server.ts`, and that is load-bearing.** A derived
+ * collection needs the same list — `upload` derives a `<slug>Directories`, `versions` one per
+ * versioned area, and both must run authorize, validation and the rest as an authored collection
+ * does. This file depends on nothing, so anything can import it; `definition.server.ts` spreads
+ * `{ ...base }` at module scope, so importing *that* makes the importer's correctness depend on
+ * evaluation order, and the spread can come out without `features`.
+ */
+export declare const collectionHooks: Partial<Record<HookTiming, AnyHook[]>>;

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

@@ -0,0 +1,133 @@
+import { isAuth, isStaffCollection } from '../../auth/enabled.js';
+import * as auth from '../../auth/hooks/index.server.js';
+import { authorize } from '../../pipeline/hooks/authorize.server.js';
+import { buildDataConfigMap } from '../../pipeline/hooks/data-config-map.server.js';
+import { getOriginalDocument } from '../../pipeline/hooks/get-original-document.server.js';
+import { normalizeResolvedReferences } from '../../pipeline/hooks/normalize-resolved-references.server.js';
+import { buildOriginalDocConfigMap } from '../../pipeline/hooks/original-config-map.server.js';
+import { processDocumentFields } from '../../pipeline/hooks/process-document-fields.server.js';
+import { resolveContentOwner } from '../../pipeline/hooks/resolve-content-owner.server.js';
+import { setDefaultValues } from '../../pipeline/hooks/set-default-values.server.js';
+import { setDocumentLocale } from '../../pipeline/hooks/set-document-locale.server.js';
+import { setDocumentType } from '../../pipeline/hooks/set-document-type.server.js';
+import { validateFields } from '../../pipeline/hooks/validate-fields.server.js';
+import { isNested } from './nested/enabled.js';
+import * as nested from './nested/hooks/index.server.js';
+import * as thumbnail from './thumbnail/hooks/index.server.js';
+import { isUpload } from './upload/enabled.js';
+import * as upload from './upload/hooks/index.server.js';
+import * as metas from '../shared/metas/hooks/index.server.js';
+import * as title from '../shared/title/hooks/index.server.js';
+import { hasUrl } from '../shared/url/enabled.js';
+import * as url from '../shared/url/hooks/index.server.js';
+import { isVersioned, isVersionsCollection } from '../shared/versions/enabled.js';
+import * as versions from '../shared/versions/hooks/index.server.js';
+import { when } from '../when.js';
+import { mergeWithBlankDocument } from './hooks/merge-with-blank.server.js';
+/**
+ * Every hook a collection can run, in the order it runs them.
+ *
+ * **The order is written here, not computed**, and in `beforeUpdate` that is a security question:
+ * `preventUserMutations` rejects on `'name' in args.data`, so a default filled in above it turns
+ * an ordinary update into a 401. Two adjacent lines you can read.
+ *
+ * ```ts
+ * when(isAuth, auth.removePrivateFields)   // runs only on a collection that declares `auth`
+ * processDocumentFields                    // runs always
+ * ```
+ *
+ * A feature owns its hooks; this says when they run and what they run on.
+ *
+ * A hook a feature owns and this list does not place never runs, and nothing throws: placing it
+ * here is what runs it.
+ *
+ * A consumer's hooks are appended after these, per timing, and before the finaliser.
+ *
+ * **In its own file rather than in `definition.server.ts`, and that is load-bearing.** A derived
+ * collection needs the same list — `upload` derives a `<slug>Directories`, `versions` one per
+ * versioned area, and both must run authorize, validation and the rest as an authored collection
+ * does. This file depends on nothing, so anything can import it; `definition.server.ts` spreads
+ * `{ ...base }` at module scope, so importing *that* makes the importer's correctness depend on
+ * evaluation order, and the spread can come out without `features`.
+ */
+export const collectionHooks = {
+    beforeOperation: [authorize],
+    beforeRead: [
+        // First, so nothing deriving from the document can copy a private value into derived data.
+        when(isAuth, auth.removePrivateFields),
+        processDocumentFields,
+        setDocumentLocale,
+        setDocumentType,
+        when(isUpload, upload.populateSizes),
+        when(isNested, nested.addChildrenProperty),
+        when(isVersioned, versions.exposeVersionId),
+        title.setDocumentTitle,
+        // After the title: `config.$url(document)` is the author's own function, and a slug built
+        // from the title is the ordinary case.
+        when(hasUrl, url.populateURL),
+        // After the sizes: it takes the thumbnail `upload.populateSizes` derived when there is one.
+        thumbnail.setDocumentThumbnail,
+        metas.deletePanelLockMetas
+    ],
+    beforeCreate: [
+        // First, on the submission as sent. Unconditional: the derived versions collection carries
+        // the flag and is not itself versioned.
+        versions.stripAutoSaveFlag,
+        mergeWithBlankDocument,
+        // After the merge: it appends the password field, and the config map below has to see it.
+        when(isAuth, auth.augmentFieldsPassword),
+        // Above `buildDataConfigMap`: that map is what the write turns into `incomingPaths`, the set
+        // of paths the request may touch, so a field added to `data` below it is dropped in silence.
+        metas.stampCreatedBy,
+        buildDataConfigMap,
+        setDefaultValues,
+        // Above validation, which reads an id where a read handed back the document.
+        normalizeResolvedReferences,
+        validateFields,
+        when(isAuth, auth.createBetterAuthUser),
+        when(isUpload, upload.handlePathCreation),
+        when(isUpload, upload.castBase64ToFile),
+        when(isUpload, upload.processFileUpload)
+    ],
+    afterCreate: [when(isAuth, auth.populateAPIKey), when(isAuth, auth.signInNewUser)],
+    beforeUpdate: [
+        versions.stripAutoSaveFlag,
+        getOriginalDocument,
+        buildOriginalDocConfigMap,
+        resolveContentOwner,
+        when(isAuth, auth.augmentFieldsPassword),
+        // The three guards read the caller's submission *as sent*, so they run before anything adds
+        // to it. `auth.preventUserMutations` rejects on `'name' in args.data` and
+        // `auth.preventSuperAdminMutation` on `'isSuperAdmin' in args.data` — a default filled in above
+        // either of them turns an ordinary update into a 401.
+        when(isAuth, auth.preventSuperAdminMutation),
+        when(isAuth, auth.preventUserMutations),
+        when(isAuth, auth.forwardRolesToBetterAuth),
+        // Also reads the submission as sent, and overrides the content row core resolved above.
+        when(isVersioned, versions.defineVersionOperation),
+        when(isVersioned, versions.handleNewVersion),
+        // Between the two: below `handleNewVersion`, which reads the submission *as sent* to work out
+        // what the previous version did not carry, and above `buildDataConfigMap`, whose keys are the
+        // paths the write may touch — a stamp below that is dropped in silence.
+        metas.stampUpdatedBy,
+        buildDataConfigMap,
+        setDefaultValues,
+        normalizeResolvedReferences,
+        validateFields,
+        when(isUpload, upload.handlePathCreation),
+        when(isUpload, upload.castBase64ToFile),
+        when(isUpload, upload.processFileUpload),
+        // Last: it demotes the other versions once this one is known to be valid and published.
+        when(isVersioned, versions.demoteOtherVersions)
+    ],
+    beforeDelete: [
+        // On the versions collection only, where the document *is* the row. On the base collection
+        // a delete means the whole document, whichever row was read for it.
+        when(isVersionsCollection, versions.preventLastVersionDeletion),
+        when(isAuth, auth.preventSupperAdminDeletion),
+        // After the refusal above: a user who cannot be deleted keeps their auto-saves.
+        when(isStaffCollection, versions.discardAutoSavesOf),
+        when(isUpload, upload.cleanUpFiles)
+    ],
+    afterDelete: [when(isAuth, auth.deleteBetterAuthUser)]
+};

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

@@ -0,0 +1 @@
+export { collection, create } from './definition.js';

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

@@ -0,0 +1 @@
+export { collection, create } from './definition.js';

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

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

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

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

package/dist/core/prototype/collection/nested/hooks/add-children.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook to populate _children property on document from a nested collection
+ */
+export declare const addChildrenProperty: import("../../../../pipeline/types").Hook<"raw", "read", "before">;

package/dist/core/prototype/collection/nested/hooks/add-children.server.js

@@ -0,0 +1,40 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+/**
+ * Hook to populate _children property on document from a nested collection
+ */
+export const addChildrenProperty = Hooks.beforeRead(async function addChildrenProperty(args) {
+    // No `config.nested` check: the feature's `enabled` decides that, and the pipeline only asks
+    // for this hook on a collection. See features/nested/index.ts.
+    const select = args.context.params.select && Array.isArray(args.context.params.select)
+        ? args.context.params.select
+        : [];
+    const emptySelect = select.length === 0;
+    // If there is a select param do not populate _children just return args
+    if (!emptySelect && !select.includes('_children'))
+        return args;
+    // Else populate _children
+    const { rime } = args.event.locals;
+    /**
+     * A filter and an order, both over columns this
+     * feature put on the row. The adapter had a method named after the question.
+     *
+     * The ordinary document read, projected to ids — not a raw-row primitive. Everything on
+     * `adapter.collection(slug)` returns documents, and a second read verb that returned ids
+     * instead was a worse trade than the one join `select: ['id']` still costs. It needed
+     * `buildOrderByParam` to resolve base-row columns on a versioned prototype, which it did not
+     * do until 4b9db413 — `sort: '_position'` here would have silently ordered by `createdAt`.
+     *
+     * No `draft`/content narrowing: a parent lists every document parented to it, published or
+     * not, which is what the flat query did.
+     */
+    const children = await rime.adapter.collection(args.config.slug).findMany({
+        query: { where: { _parent: { equals: args.doc.id } } },
+        sort: '_position',
+        select: ['id']
+    });
+    args.doc = {
+        ...args.doc,
+        _children: children.map((child) => child.id)
+    };
+    return args;
+});

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { Collection } from '../../../config/types.js';
+type IncomingConfig = {
+    slug: string;
+    nested?: boolean;
+    fields?: Collection<any>['fields'];
+};
+/**
+ * Adds the root-table fields a nested collection is addressed by: who its parent is, and where it
+ * sits among its siblings.
+ *
+ * The client half. `module.server.ts` adds the self-referencing foreign key on `_parent`; whether
+ * a config uses this at all is the feature's `enabled`, so there is no condition here.
+ */
+export declare const augmentNested: <T extends IncomingConfig>(config: T) => T;
+export {};

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

@@ -0,0 +1,17 @@
+import { number } from '../../../../fields/number/index.js';
+import { text } from '../../../../fields/text/index.js';
+/**
+ * Adds the root-table fields a nested collection is addressed by: who its parent is, and where it
+ * sits among its siblings.
+ *
+ * The client half. `module.server.ts` adds the self-referencing foreign key on `_parent`; whether
+ * a config uses this at all is the feature's `enabled`, so there is no condition here.
+ */
+export const augmentNested = (config) => ({
+    ...config,
+    fields: [
+        ...(config.fields || []),
+        text('_parent').hidden().$root(),
+        number('_position').defaultValue(0).hidden().$root()
+    ]
+});

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

@@ -0,0 +1,16 @@
+import type { Collection } from '../../../config/types.js';
+type IncomingConfig = {
+    slug: string;
+    nested?: boolean;
+    fields?: Collection<any>['fields'];
+};
+/**
+ * The nested feature's server half.
+ *
+ * Same shape as the client augment, plus the one thing that cannot cross to the browser:
+ * `_parent` is a self-referencing foreign key, which is what lets a parent's deletion null its
+ * children rather than orphan them. Written out rather than wrapping the client half, because the
+ * reference has to be on the builder at construction, not bolted on afterwards.
+ */
+export declare const augmentNested: <T extends IncomingConfig>(config: T) => T;
+export {};

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

@@ -0,0 +1,21 @@
+import { number } from '../../../../fields/number/index.js';
+import { text } from '../../../../fields/text/index.js';
+/**
+ * The nested feature's server half.
+ *
+ * Same shape as the client augment, plus the one thing that cannot cross to the browser:
+ * `_parent` is a self-referencing foreign key, which is what lets a parent's deletion null its
+ * children rather than orphan them. Written out rather than wrapping the client half, because the
+ * reference has to be on the builder at construction, not bolted on afterwards.
+ */
+export const augmentNested = (config) => ({
+    ...config,
+    fields: [
+        ...(config.fields || []),
+        text('_parent')
+            .$references(config.slug, { onDelete: 'set null', selfReferencing: true })
+            .hidden()
+            .$root(),
+        number('_position').defaultValue(0).hidden().$root()
+    ]
+});

package/dist/core/prototype/collection/operations/create.d.ts

@@ -0,0 +1,18 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+import type { CollectionSlug } from '../../types.js';
+import type { RegisterCollection } from '../../../../index.js';
+import type { DeepPartial } from '../../../../util/types.js';
+/**
+ * What a caller passes. Exported, and free of the context, so the API surface a prototype
+ * declares never mentions the request — see the note on `CollectionApi`.
+ */
+export type CreateArgs<T> = {
+    data: DeepPartial<T>;
+    locale?: string | undefined;
+};
+type Args<T> = CreateArgs<T> & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+export declare const create: <T extends RegisterCollection[CollectionSlug]>(args: Args<T>) => Promise<T>;
+export {};

package/dist/core/prototype/collection/operations/create.js

@@ -0,0 +1,68 @@
+import { versionsWritePlan } from '../../shared/versions/write-plan.js';
+import { assertUpsertContext, persistRelational, runBeforeOperation, runDataHooks, runDocHooks } from '../../../pipeline/run.server.js';
+export const create = async (args) => {
+    const { ctx, locale } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    let context = { params: { locale }, isSystemOperation };
+    context = await runBeforeOperation({
+        config,
+        event,
+        operation: 'create',
+        context
+    });
+    const before = await runDataHooks({
+        hooks: config.$hooks?.beforeCreate,
+        data: args.data,
+        config,
+        event,
+        operation: 'create',
+        context
+    });
+    const data = before.data;
+    context = before.context;
+    assertUpsertContext(context, 'create', ['configMap']);
+    const incomingPaths = Object.keys(context.configMap);
+    /**
+     * Which rows this create writes, decided here rather than in the adapter.
+     *
+     * The same call `runUpdate` makes at its step 3.5, and for the same reason: whether a document's
+     * content lands on its own row or a second one is versions' statement, not the database layer's.
+     * `operation: 'create'` is what lets it answer differently — an insert names no content row,
+     * because there is none yet.
+     */
+    const plan = versionsWritePlan({ data: data }, { config, context, operation: 'create' });
+    const created = await rime.adapter.collection(config.slug).insert({
+        data: plan.data,
+        content: plan.content && { data: plan.content.data },
+        locale
+    });
+    // Blocks, trees and relations hang off the row the content landed on, which is the document's
+    // own row unless it is versioned.
+    await persistRelational({
+        context,
+        ownerId: created.contentId,
+        data,
+        incomingPaths,
+        adapter: rime.adapter,
+        config,
+        locale
+    });
+    // The created document, in the one locale this create wrote. The other locales are not
+    // written: a read in one of them falls back field by field until it is translated.
+    let document = (await rime
+        .collection(config.slug)
+        .findById({ id: created.id, locale, versionId: created.contentId }));
+    // Unlike afterUpdate, afterCreate's returned doc IS propagated — preserved as-is.
+    const after = await runDocHooks({
+        hooks: config.$hooks?.afterCreate,
+        doc: document,
+        data,
+        config,
+        event,
+        operation: 'create',
+        context
+    });
+    document = after.doc;
+    return document;
+};

package/dist/core/prototype/collection/operations/delete-by-id.d.ts

@@ -0,0 +1,11 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+import type { GenericDoc } from '../../types.js';
+export type DeleteByIdArgs = {
+    id: string;
+};
+type Args = DeleteByIdArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+export declare const deleteById: <T extends GenericDoc>(args: Args) => Promise<string>;
+export {};

package/dist/core/prototype/collection/operations/delete-by-id.js

@@ -0,0 +1,44 @@
+import { RimeError } from '../../../errors/index.js';
+import { runBeforeOperation, runDocHooks } from '../../../pipeline/run.server.js';
+export const deleteById = async (args) => {
+    const { ctx, id } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    let context = {
+        params: { id },
+        isSystemOperation
+    };
+    context = await runBeforeOperation({
+        config,
+        event,
+        operation: 'delete',
+        context
+    });
+    // No `content`: a delete means the document, so it reads whichever row is newest. That is what
+    // `latest: true` said here before there was a way to say "no narrowing".
+    const document = (await rime.adapter.collection(config.slug).find({ id }));
+    if (!document) {
+        throw new RimeError(RimeError.NOT_FOUND);
+    }
+    const before = await runDocHooks({
+        hooks: config.$hooks?.beforeDelete,
+        doc: document,
+        config,
+        event,
+        operation: 'delete',
+        context
+    });
+    context = before.context;
+    await rime.adapter.collection(config.slug).delete({ id });
+    // Deliberately the pre-hook document, matching the previous implementation: beforeDelete's
+    // returned doc was never carried into afterDelete.
+    await runDocHooks({
+        hooks: config.$hooks?.afterDelete,
+        doc: document,
+        config,
+        event,
+        operation: 'delete',
+        context
+    });
+    return id;
+};

package/dist/core/prototype/collection/operations/delete.d.ts

@@ -0,0 +1,15 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { OperationQuery } from '../../../pipeline/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+export type DeleteArgs = {
+    query?: OperationQuery;
+    locale?: string | undefined;
+    sort?: string;
+    limit?: number;
+    offset?: number;
+};
+type Args = DeleteArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+export declare const deleteDocs: (args: Args) => Promise<string[]>;
+export {};