rimecms 0.31.4 → 0.32.0

package/dist/core/prototype/area/operations/update.js

@@ -0,0 +1,44 @@
+import { runUpdate } from '../../../pipeline/run.server.js';
+/**
+ * Updates an area's single document.
+ *
+ * The pipeline itself lives in operations/run.server.ts — shared with a collection's
+ * updateById. Only the two prototype-specific pieces are here: which adapter method writes the
+ * root row, and how the saved document is read back.
+ */
+export const update = async (args) => {
+    const { ctx, locale, latest, fork, versionId, autoSave, isLocaleCopy } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    const context = {
+        params: {
+            locale,
+            versionId,
+            latest,
+            fork,
+            autoSave
+        },
+        isSystemOperation,
+        isLocaleCopy
+    };
+    return runUpdate({
+        data: args.data,
+        config,
+        event,
+        context,
+        locale,
+        where: 'update',
+        // No `id`: an area's handle resolves its single row. See the collection's for the plan.
+        write: ({ plan, config }) => rime.adapter.area(config.slug).update({ ...plan, locale }),
+        /**
+         * Read back **the row the write went to** — see the collection's `reread` for the full note.
+         *
+         * Not `versionId`, the caller's parameter: the hooks answer "which row holds the content" on
+         * `context.contentOwnerId`, and on a new-version update that is a row the caller never named.
+         */
+        reread: ({ config, context }) => rime.area(config.slug).find({
+            locale,
+            versionId: context.contentOwnerId
+        })
+    });
+};

package/dist/core/prototype/area/rest/endpoint.server.d.ts

@@ -0,0 +1,14 @@
+import type { RequestEvent, RequestHandler } from '@sveltejs/kit';
+/** See the collection wrapper for why this comes from the accessor and not from `../index`. */
+type AreaApi = ReturnType<App.Locals['rime']['area']>;
+type Run = (args: {
+    event: RequestEvent;
+    area: AreaApi;
+}) => Promise<Response>;
+/**
+ * The area counterpart of the collection wrapper — see the note there for why the check stays
+ * per-prototype rather than being folded into one shared helper: `isArea` narrows the slug, and
+ * that narrowing is what the accessor needs.
+ */
+export declare const endpoint: (run: Run) => RequestHandler;
+export {};

package/dist/core/prototype/area/rest/endpoint.server.js

@@ -0,0 +1,15 @@
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { RimeError } from '../../../errors/index.js';
+/**
+ * The area counterpart of the collection wrapper — see the note there for why the check stays
+ * per-prototype rather than being folded into one shared helper: `isArea` narrows the slug, and
+ * that narrowing is what the accessor needs.
+ */
+export const endpoint = (run) => (event) => {
+    const { rime } = event.locals;
+    const slug = event.params.slug;
+    if (!rime.config.isArea(slug)) {
+        return handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+    }
+    return run({ event, area: rime.area(slug) });
+};

package/dist/core/prototype/area/rest/get.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * GET handler for the area API endpoint.
+ */
+export declare const restGet: import("@sveltejs/kit").RequestHandler;

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

@@ -0,0 +1,31 @@
+import { isStaff } from '../../../auth/access.js';
+import { PARAMS } from '../../../constants.js';
+import { handleError } from '../../../errors/handler.server.js';
+import { selectWithTitle } from '../../shared/title/select.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * GET handler for the area API endpoint.
+ */
+export const restGet = endpoint(async ({ event, area }) => {
+    //
+    const { rime } = event.locals;
+    const params = event.url.searchParams;
+    // A row other than the published one is staff's to see: from anyone else, `latest` and
+    // `versionId` read as absent.
+    const staff = isStaff(event.locals.user);
+    const apiParams = {
+        locale: rime.getLocale(),
+        latest: staff && params.get(PARAMS.LATEST) ? params.get(PARAMS.LATEST) === 'true' : undefined,
+        versionId: staff ? params.get(PARAMS.VERSION_ID) || undefined : undefined,
+        depth: params.get(PARAMS.DEPTH) ? parseInt(params.get(PARAMS.DEPTH)) : 0,
+        select: selectWithTitle(params.get(PARAMS.SELECT), area.config.asTitle)
+    };
+    // Call the area API to find the document based on the prepared parameters
+    const [error, doc] = await trycatch(() => area.find(apiParams));
+    if (error) {
+        return handleError(error, { context: 'api' });
+    }
+    return json({ doc });
+});

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

@@ -0,0 +1,9 @@
+import type { RouteConfig } from '../../../config/types.js';
+/**
+ * The REST surface an area provides: one path, two methods.
+ *
+ * No `[id]` tier — a singleton has one document, so there is nothing to address. Its `''` path
+ * carries no POST or DELETE for the same reason: nothing to create, nothing to remove. That is not
+ * a switch turned off somewhere; it is simply what this prototype declares.
+ */
+export declare const rest: Record<string, RouteConfig>;

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

@@ -0,0 +1,14 @@
+import { restGet } from './get.server.js';
+import { restLock, restUnlock } from './lock.server.js';
+import { restUpdate } from './update.server.js';
+/**
+ * The REST surface an area provides: one path, two methods.
+ *
+ * No `[id]` tier — a singleton has one document, so there is nothing to address. Its `''` path
+ * carries no POST or DELETE for the same reason: nothing to create, nothing to remove. That is not
+ * a switch turned off somewhere; it is simply what this prototype declares.
+ */
+export const rest = {
+    '': { GET: restGet, PATCH: restUpdate },
+    lock: { POST: restLock, DELETE: restUnlock }
+};

package/dist/core/prototype/area/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/area/rest/lock.server.js

@@ -0,0 +1,38 @@
+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 an area — see the collection's, which this mirrors without the `[id]` tier. */
+const run = (intent) => endpoint(async ({ event, area }) => {
+    const { user } = event.locals;
+    if (!user)
+        return handleError(new RimeError(RimeError.UNAUTHORIZED), { context: 'api' });
+    if (!area.config.access.update(user, {})) {
+        return handleError(new RimeError(RimeError.UNAUTHORIZED), { context: 'api' });
+    }
+    // The row on the caller's screen when they name one, else the newest — see the collection's.
+    const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+    const [readError, doc] = await trycatch(() => area.system().find({ 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: area.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' });
+    return json({ held: !!held });
+});
+export const restLock = run('claim');
+export const restUnlock = run('release');

package/dist/core/prototype/area/rest/update.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * PATCH handler for the area API endpoint.
+ */
+export declare const restUpdate: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/area/rest/update.server.js

@@ -0,0 +1,38 @@
+import { PARAMS } from '../../../constants.js';
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.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 area API endpoint.
+ */
+export const restUpdate = endpoint(async ({ event, area }) => {
+    //
+    const { rime } = event.locals;
+    // 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, doc] = await trycatch(() => area.update({
+        data,
+        versionId,
+        latest,
+        fork,
+        locale: rime.getLocale()
+    }));
+    if (error) {
+        return handleError(error, { context: ERROR_CONTEXT.API });
+    }
+    return json({ doc });
+});

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

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

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

@@ -0,0 +1,173 @@
+import type { BuiltCollection } from '../../config/types.js';
+import type { RegisterCollection } from '../../../index.js';
+import type { PrototypeApiContext } from '../define.js';
+import type { RequestEvent } from '@sveltejs/kit';
+import type { Dic } from '../../../util/types.js';
+import type { CollectionSlug } from '../types.js';
+import type { OperationQuery } from '../../pipeline/types.js';
+import { type CreateArgs } from './operations/create.js';
+import { type DeleteByIdArgs } from './operations/delete-by-id.js';
+import { type DeleteArgs } from './operations/delete.js';
+import { type DuplicateArgs } from './operations/duplicate.js';
+import { type FindByIdArgs } from './operations/find-by-id.js';
+import { type FindArgs } from './operations/find.js';
+import { type UpdateByIdArgs } from './operations/update-by-id.js';
+/** What building a collection's API for one request needs. */
+export type CollectionApiArgs = {
+    config: BuiltCollection;
+    event: RequestEvent;
+    defaultLocale: string | undefined;
+};
+/**
+ * Everything `rime.collection('pages')` can do, in the collection's own folder, beside the
+ * operations that implement it.
+ *
+ * A class, and the operations are handed `this`. It was a `context()` building a plumbing object,
+ * a `shape(ctx)` returning the verbs, a `build()` wiring `system` around them and a
+ * `collectionApi()` calling that — four functions to hand back one object, and a
+ * `ReturnType<typeof shape>` to name it afterwards.
+ *
+ * The plumbing members below `system` are what the operations reach for; `CollectionApi` at the
+ * foot of this file is the list a caller sees.
+ */
+declare class CollectionAPI<Doc extends RegisterCollection[CollectionSlug]> implements PrototypeApiContext<BuiltCollection> {
+    private readonly args;
+    readonly config: BuiltCollection;
+    readonly event: RequestEvent;
+    readonly defaultLocale: string | undefined;
+    /** True when rime itself is the caller: access checks and some hooks stand down. */
+    readonly isSystemOperation: boolean;
+    constructor(args: CollectionApiArgs, isSystemOperation?: boolean);
+    /**
+     * The same API, telling the pipeline that rime is the caller.
+     *
+     * A new instance rather than a flag, so a system call cannot leak back into the one it was
+     * escalated from. `system(false)` hands this one back, which is what lets `system(someBoolean)`
+     * read as "escalate if needed".
+     */
+    system(isSystem?: boolean): CollectionAPI<Doc>;
+    /**
+     * A document of this collection's shape with every default applied, and no id.
+     *
+     * An auth collection hands back nothing private — the password, the better-auth link. Only a
+     * collection signs in, which is why this step is here and not on the area's.
+     */
+    blank(): Doc;
+    /** The locale to act in: the one asked for, else the request's, else the config's default. */
+    fallbackLocale(locale?: string): string | undefined;
+    /** Which version row a read means — see `versionsReadQuery`. */
+    versionQuery(params: {
+        latest?: boolean;
+        versionId?: string;
+    }): OperationQuery | undefined;
+    /** Read through the API cache when it is on and this is not a system call. */
+    cached<T>(operation: string, key: Dic, read: () => Promise<T>): Promise<T>;
+    /**
+     * Creates a new document in the collection
+     *
+     * @example
+     * const post = await rime.collection('posts').create({
+     *   data: { title: 'Hello World', content: 'My first post' },
+     *   locale: 'en'
+     * });
+     */
+    create(args: CreateArgs<Doc>): Promise<Doc>;
+    /**
+     * Duplicate a document in the collection
+     *
+     * @example
+     * const post = await rime.collection('posts').duplicate({ id: '1234' });
+     * // A given row rather than the newest real version
+     * const copy = await rime.collection('posts').duplicate({ id: '1234', versionId: 'abcd' });
+     */
+    duplicate(args: DuplicateArgs): Promise<string>;
+    /**
+     * Finds documents in the collection matching the query
+     *
+     * @example
+     * // Find published posts sorted by creation date
+     * const posts = await rime.collection('posts').find({
+     *   query: { published: true },
+     *   sort: '-createdAt',
+     *   limit: 10
+     * });
+     */
+    find(args?: FindArgs): Promise<Doc[]>;
+    /**
+     * Finds a document in the collection by ID
+     *
+     * For collections with versioning:
+     * - If versionId is provided: Retrieves that specific version
+     * - If no versionId and latest=true: Retrieves the newest version, whatever its status
+     * - If no versionId and draft=false: Retrieves the published version
+     *
+     * @example
+     * // Get published version
+     * const post = await rime.collection('posts').findById({ id: '12345' });
+     *
+     * // Get specific version
+     * const post = await rime.collection('posts').findById({
+     *   id: '12345',
+     *   versionId: 'v2',
+     *   locale: 'en'
+     * });
+     *
+     * // Get latest draft version
+     * const post = await rime.collection('posts').findById({
+     *   id: '12345',
+     *   latest: true
+     * });
+     */
+    findById(args: FindByIdArgs): Promise<Doc>;
+    /**
+     * Updates a document in the collection by ID.
+     *
+     * `versionId`, else `latest`, else the published version selects the row; `fork` makes a new
+     * version from it instead of writing it. A config with versions and no drafts keeps a version
+     * per save, so an update that names no row is a fork there.
+     *
+     * @example
+     * // Write the published version
+     * await rime.collection('posts').updateById({ id, data: { title: 'New title' } });
+     *
+     * // Write the newest version, draft or not
+     * await rime.collection('posts').updateById({ id, data, latest: true });
+     *
+     * // A new draft from the published version
+     * await rime.collection('posts').updateById({ id, data, fork: true });
+     */
+    updateById(args: UpdateByIdArgs<Doc>): Promise<Doc>;
+    /**
+     * Deletes a document in the collection by ID
+     *
+     * @example
+     * const post = await rime.collection('posts').deleteById({ id: '12345' });
+     */
+    deleteById(args: DeleteByIdArgs): Promise<string>;
+    /**
+     * Deletes multiple documents in the collection. No query means no filter —
+     * `delete()` with no args deletes every document in the collection.
+     *
+     * @example
+     * const posts = await rime.collection('posts').delete({
+     *   query: { published: true },
+     *   limit: 10
+     * });
+     */
+    delete(args?: DeleteArgs): Promise<string[]>;
+}
+/** Builds a collection's API for one request. What `rime.collection(slug)` calls. */
+export declare const collectionApi: <Doc extends RegisterCollection[CollectionSlug]>(args: CollectionApiArgs) => CollectionApi<Doc>;
+/**
+ * What `rime.collection(slug)` hands back — **written out**, not read off the class.
+ *
+ * The class also carries the plumbing its operations reach for (`event`, `cached`,
+ * `versionQuery`, `fallbackLocale`, `isSystemOperation`); none of that is a caller's business, and
+ * naming `RequestEvent` in this type would be worse than untidy. `event.locals.rime` is typed as
+ * this accessor's owner, so a surface that reached `RequestEvent` would be defined in terms of
+ * itself and every `rime.collection(...)` in the repo would resolve to `never`. Each operation
+ * exports its caller-facing arguments separately for the same reason.
+ */
+export type CollectionApi<Doc extends RegisterCollection[CollectionSlug] = RegisterCollection[CollectionSlug]> = Pick<CollectionAPI<Doc>, 'config' | 'blank' | 'create' | 'duplicate' | 'find' | 'findById' | 'updateById' | 'deleteById' | 'delete' | 'system'>;
+export type CollectionAccessor = <Slug extends keyof RegisterCollection>(slug: Slug) => CollectionApi<RegisterCollection[Slug]>;
+export {};

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

@@ -0,0 +1,224 @@
+import { RimeError } from '../../errors/index.js';
+import { withoutPrivateFields } from '../../auth/constant.server.js';
+import { isAuth } from '../../auth/enabled.js';
+import { createBlankDocument } from '../doc.js';
+import { versionsReadQuery } from '../shared/versions/read-query.js';
+import { create } from './operations/create.js';
+import { deleteById } from './operations/delete-by-id.js';
+import { deleteDocs } from './operations/delete.js';
+import { duplicate } from './operations/duplicate.js';
+import { findById } from './operations/find-by-id.js';
+import { find } from './operations/find.js';
+import { updateById } from './operations/update-by-id.js';
+/**
+ * Everything `rime.collection('pages')` can do, in the collection's own folder, beside the
+ * operations that implement it.
+ *
+ * A class, and the operations are handed `this`. It was a `context()` building a plumbing object,
+ * a `shape(ctx)` returning the verbs, a `build()` wiring `system` around them and a
+ * `collectionApi()` calling that — four functions to hand back one object, and a
+ * `ReturnType<typeof shape>` to name it afterwards.
+ *
+ * The plumbing members below `system` are what the operations reach for; `CollectionApi` at the
+ * foot of this file is the list a caller sees.
+ */
+class CollectionAPI {
+    args;
+    config;
+    event;
+    defaultLocale;
+    /** True when rime itself is the caller: access checks and some hooks stand down. */
+    isSystemOperation;
+    constructor(args, isSystemOperation = false) {
+        this.args = args;
+        this.config = args.config;
+        this.event = args.event;
+        this.defaultLocale = args.defaultLocale;
+        this.isSystemOperation = isSystemOperation;
+    }
+    /**
+     * The same API, telling the pipeline that rime is the caller.
+     *
+     * A new instance rather than a flag, so a system call cannot leak back into the one it was
+     * escalated from. `system(false)` hands this one back, which is what lets `system(someBoolean)`
+     * read as "escalate if needed".
+     */
+    system(isSystem = true) {
+        return isSystem ? new CollectionAPI(this.args, true) : this;
+    }
+    /**
+     * A document of this collection's shape with every default applied, and no id.
+     *
+     * An auth collection hands back nothing private — the password, the better-auth link. Only a
+     * collection signs in, which is why this step is here and not on the area's.
+     */
+    blank() {
+        const doc = createBlankDocument(this.config, this.event);
+        return (isAuth(this.config) ? withoutPrivateFields(doc) : doc);
+    }
+    /** The locale to act in: the one asked for, else the request's, else the config's default. */
+    fallbackLocale(locale) {
+        return locale || this.event.locals.locale || this.defaultLocale;
+    }
+    /** Which version row a read means — see `versionsReadQuery`. */
+    versionQuery(params) {
+        return versionsReadQuery({ config: this.config, params });
+    }
+    /** Read through the API cache when it is on and this is not a system call. */
+    cached(operation, key, read) {
+        if (!this.event.locals.cacheEnabled || this.isSystemOperation)
+            return read();
+        const cacheKey = this.event.locals.rime.cache.createKey(operation, {
+            slug: this.config.slug,
+            userEmail: this.event.locals.user?.email,
+            userRoles: this.event.locals.user?.roles,
+            ...key
+        });
+        return this.event.locals.rime.cache.get(cacheKey, read);
+    }
+    /**
+     * Creates a new document in the collection
+     *
+     * @example
+     * const post = await rime.collection('posts').create({
+     *   data: { title: 'Hello World', content: 'My first post' },
+     *   locale: 'en'
+     * });
+     */
+    create(args) {
+        return create({
+            ctx: this,
+            data: args.data,
+            locale: this.fallbackLocale(args.locale)
+        });
+    }
+    /**
+     * Duplicate a document in the collection
+     *
+     * @example
+     * const post = await rime.collection('posts').duplicate({ id: '1234' });
+     * // A given row rather than the newest real version
+     * const copy = await rime.collection('posts').duplicate({ id: '1234', versionId: 'abcd' });
+     */
+    duplicate(args) {
+        return duplicate({ ctx: this, id: args.id, versionId: args.versionId });
+    }
+    /**
+     * Finds documents in the collection matching the query
+     *
+     * @example
+     * // Find published posts sorted by creation date
+     * const posts = await rime.collection('posts').find({
+     *   query: { published: true },
+     *   sort: '-createdAt',
+     *   limit: 10
+     * });
+     */
+    find(args = {}) {
+        const { query, locale, sort = '-updatedAt', depth = 0, limit, offset, latest, select, localeFallback } = args;
+        // The key holds the locale as the *caller* gave it, not the resolved one — preserved from
+        // the class this replaces. Reachable only from a local-API call that omits `locale` while
+        // the API cache is on, which the REST layer never does: it always passes rime.getLocale().
+        return this.cached('collection.find', { select, sort, depth, limit, offset, locale, latest, query, localeFallback }, () => find({
+            ctx: this,
+            select,
+            query,
+            sort,
+            depth,
+            limit,
+            offset,
+            latest,
+            localeFallback,
+            locale: this.fallbackLocale(locale)
+        }));
+    }
+    /**
+     * Finds a document in the collection by ID
+     *
+     * For collections with versioning:
+     * - If versionId is provided: Retrieves that specific version
+     * - If no versionId and latest=true: Retrieves the newest version, whatever its status
+     * - If no versionId and draft=false: Retrieves the published version
+     *
+     * @example
+     * // Get published version
+     * const post = await rime.collection('posts').findById({ id: '12345' });
+     *
+     * // Get specific version
+     * const post = await rime.collection('posts').findById({
+     *   id: '12345',
+     *   versionId: 'v2',
+     *   locale: 'en'
+     * });
+     *
+     * // Get latest draft version
+     * const post = await rime.collection('posts').findById({
+     *   id: '12345',
+     *   latest: true
+     * });
+     */
+    findById(args) {
+        const { id, versionId, locale, select, latest, depth = 0, localeFallback } = args;
+        if (!id) {
+            throw new RimeError(RimeError.NOT_FOUND);
+        }
+        return this.cached('collection.findById', { id, versionId, select, depth, latest, locale, localeFallback }, () => findById({
+            ctx: this,
+            id,
+            versionId,
+            select,
+            depth,
+            latest,
+            localeFallback,
+            locale: this.fallbackLocale(locale)
+        }));
+    }
+    /**
+     * Updates a document in the collection by ID.
+     *
+     * `versionId`, else `latest`, else the published version selects the row; `fork` makes a new
+     * version from it instead of writing it. A config with versions and no drafts keeps a version
+     * per save, so an update that names no row is a fork there.
+     *
+     * @example
+     * // Write the published version
+     * await rime.collection('posts').updateById({ id, data: { title: 'New title' } });
+     *
+     * // Write the newest version, draft or not
+     * await rime.collection('posts').updateById({ id, data, latest: true });
+     *
+     * // A new draft from the published version
+     * await rime.collection('posts').updateById({ id, data, fork: true });
+     */
+    updateById(args) {
+        return updateById({
+            ...args,
+            ctx: this,
+            locale: this.fallbackLocale(args.locale)
+        });
+    }
+    /**
+     * Deletes a document in the collection by ID
+     *
+     * @example
+     * const post = await rime.collection('posts').deleteById({ id: '12345' });
+     */
+    deleteById(args) {
+        return deleteById({ ctx: this, id: args.id });
+    }
+    /**
+     * Deletes multiple documents in the collection. No query means no filter —
+     * `delete()` with no args deletes every document in the collection.
+     *
+     * @example
+     * const posts = await rime.collection('posts').delete({
+     *   query: { published: true },
+     *   limit: 10
+     * });
+     */
+    delete(args = {}) {
+        return deleteDocs({ ctx: this, ...args });
+    }
+}
+/** Builds a collection's API for one request. What `rime.collection(slug)` calls. */
+export const collectionApi = (args) => new CollectionAPI(args);

package/dist/core/prototype/collection/augment-label.d.ts

@@ -0,0 +1,6 @@
+import type { CollectionLabel } from './types.js';
+import type { Collection } from '../../../types.js';
+export type WithNormalizedLabel<T> = Omit<T, 'label'> & {
+    label: CollectionLabel;
+};
+export declare const augmentLabel: <T extends Collection<any>>(config: T) => WithNormalizedLabel<T>;

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

@@ -0,0 +1,26 @@
+import type { BuiltCollection } from '../../config/types.js';
+import type { CollectionWithoutSlug } from './types.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 declare const collection: import("../define.js").PrototypeDefinition<import("../define.js").BuiltPrototype>;
+/**
+ * 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 declare const create: <S extends string>(slug: S, config: CollectionWithoutSlug<S>) => BuiltCollection;