@abinnovision/payloadcms-mcpx 2.0.0-beta.9 → 2.0.0

package/dist/tools/delete-document.mjs

@@ -0,0 +1,154 @@
+import { defineMcpxTool } from "../define-tool.mjs";
+import { errorResult, jsonResult } from "../result.mjs";
+import { translateStatic } from "../i18n.mjs";
+import { expectedUpdatedAtShape, idSchema, slugsFor, stringEnum } from "./shared.mjs";
+import { readDraft, resolveCollection, staleReadResult } from "./document.mjs";
+import { withTrashIntent } from "../write/publish-intent.mjs";
+import { withTransaction } from "../write/transaction.mjs";
+import { z } from "zod";
+import { Forbidden, combineQueries, executeAccess } from "payload";
+import { formatAdminURL } from "payload/shared";
+//#region src/tools/delete-document.ts
+const DESCRIPTION = `Asks to delete one document. This call deletes nothing: it returns a "confirmation" with an "id" and a "url". Give the url to the user, who approves or rejects in the admin panel, then pass the id to runConfirmed, which deletes. Refused when the document is unknown, already in trash, changed since "expectedUpdatedAt" or not deletable by the user.`;
+const permanenceSentence = (scope) => {
+	const permanent = slugsFor(scope, "delete").collections.filter((slug) => scope.req.payload.collections[slug]?.config.trash !== true);
+	if (permanent.length === 0) return " Documents move to trash.";
+	const sentence = ` Deletes in ${permanent.join(", ")} are permanent.`;
+	return permanent.length === slugsFor(scope, "delete").collections.length ? sentence : `${sentence} Other documents move to trash.`;
+};
+const unattendedSentence = (scope) => {
+	const unattended = slugsFor(scope, "delete").collections.filter((slug) => scope.capabilities.collections[slug]?.deleteUnattended === true);
+	return unattended.length === 0 ? "" : ` Exception: in ${unattended.join(", ")} this call moves the document to trash at once and returns the delete result, with no confirmation.`;
+};
+const mayDelete = async (req, target) => {
+	const { config } = target;
+	const data = config.trash ? { deletedAt: (/* @__PURE__ */ new Date()).toISOString() } : {};
+	const rules = config.trash ? [config.access.delete, config.access.update] : [config.access.delete];
+	let where = { id: { equals: target.id } };
+	for (const rule of rules) {
+		const result = await executeAccess({
+			id: target.id,
+			data,
+			disableErrors: true,
+			req
+		}, rule);
+		if (result === false) return false;
+		if (typeof result === "object") where = combineQueries(where, result);
+	}
+	const { totalDocs } = await req.payload.count({
+		collection: target.slug,
+		where,
+		overrideAccess: true,
+		trash: true,
+		req
+	});
+	return totalDocs > 0;
+};
+/**
+* Deletes one collection document once the key's user approved the call. The
+* first call only checks and stores it; `runConfirmed` runs it again with the
+* stored arguments, pinned to the `updatedAt` read here. Available where the
+* config exposes `delete` and the key has the `delete` checkbox.
+*/ const deleteDocument = defineMcpxTool({
+	name: "deleteDocument",
+	description: (scope) => `${DESCRIPTION}${permanenceSentence(scope)}${unattendedSentence(scope)}`,
+	annotations: {
+		destructiveHint: true,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => scope.uploads && scope.collections.deletable.length > 0,
+	inputSchema: (scope) => ({
+		collection: stringEnum(scope.collections.deletable),
+		id: idSchema,
+		...expectedUpdatedAtShape,
+		reason: z.string().max(500).optional().describe("Why, shown to the user who approves.")
+	}),
+	confirm: {
+		label: "Delete documents",
+		summarize: async ({ args }, req) => {
+			const slug = String(args["collection"]);
+			const id = args["id"];
+			const config = req.payload.collections[slug]?.config;
+			const titleField = config?.admin.useAsTitle;
+			const read = async (draft) => config ? await req.payload.findByID({
+				collection: slug,
+				id,
+				depth: 0,
+				draft,
+				overrideAccess: false,
+				disableErrors: true,
+				req
+			}) : null;
+			const titleOf = (doc) => {
+				const value = titleField === void 0 ? void 0 : doc?.[titleField];
+				return typeof value === "string" && value !== "" ? value : void 0;
+			};
+			const published = await read(false);
+			const live = titleOf(published);
+			const latest = titleOf(await read(true));
+			const title = live === void 0 ? latest : latest !== void 0 && latest !== live ? `${live} (draft: ${latest})` : live;
+			const status = published?.["_status"];
+			return {
+				label: (typeof config?.labels.singular === "function" ? void 0 : translateStatic(config?.labels.singular, req.i18n)) ?? slug,
+				...title === void 0 ? {} : { title },
+				...typeof status === "string" ? { status } : {},
+				id: String(id),
+				href: formatAdminURL({
+					adminRoute: req.payload.config.routes.admin,
+					path: `/collections/${slug}/${String(id)}`
+				}),
+				permanent: config?.trash !== true,
+				...typeof args["reason"] === "string" ? { reason: args["reason"] } : {}
+			};
+		}
+	},
+	handler: async ({ args, scope, confirmation }) => {
+		const target = {
+			...resolveCollection(scope, args.collection, "delete"),
+			id: args.id
+		};
+		const { req } = scope;
+		const { payload } = req;
+		const trash = target.config.trash ?? false;
+		return await withTransaction(req, async () => {
+			const doc = await readDraft(scope, {
+				target,
+				locale: void 0,
+				trash: true
+			});
+			if (doc["deletedAt"]) return errorResult("The document is already in the trash. Emptying the trash is not available.");
+			const stale = staleReadResult(doc, args.expectedUpdatedAt, "The document changed since you read it. Read it again before deleting.");
+			if (stale) return stale;
+			if (!await mayDelete(req, target)) throw new Forbidden(req.t);
+			const unattended = trash && scope.capabilities.collections[target.slug]?.deleteUnattended === true;
+			if (!confirmation.confirmed && !unattended) return await confirmation.request({
+				...args,
+				expectedUpdatedAt: new Date(doc["updatedAt"]).toISOString()
+			});
+			if (trash) await payload.update({
+				collection: target.slug,
+				id: target.id,
+				data: withTrashIntent({ deletedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+				depth: 0,
+				overrideAccess: false,
+				overrideLock: false,
+				req
+			});
+			else await payload.delete({
+				collection: target.slug,
+				id: target.id,
+				depth: 0,
+				overrideAccess: false,
+				overrideLock: false,
+				req
+			});
+			return jsonResult({
+				collection: target.slug,
+				id: target.id,
+				movedToTrash: trash
+			});
+		});
+	}
+});
+//#endregion
+export { deleteDocument };

package/dist/tools/describe-schema.mjs

@@ -1,11 +1,11 @@
 import { defineMcpxTool } from "../define-tool.mjs";
 import { jsonResult } from "../result.mjs";
+import { SchemaError } from "../schema/errors.mjs";
 import { nodePropertiesFor } from "../schema/lexical.mjs";
 import { translatorFor } from "../i18n.mjs";
-import { SchemaError } from "../schema/errors.mjs";
 import { nodeDescriber, reachableSchemaPaths } from "../schema/describe.mjs";
 import "../schema/index.mjs";
-import { entityShape } from "./shared.mjs";
+import { entityShape, reaches } from "./shared.mjs";
 import { resolveEntity } from "./document.mjs";
 import { z } from "zod";
 //#region src/tools/describe-schema.ts
@@ -30,7 +30,7 @@ const PATHS_LIMIT = 400;
 		readOnlyHint: true,
 		openWorldHint: false
 	},
-	isEnabled: (scope) => scope.collections.readable.length + scope.globals.readable.length > 0,
+	isEnabled: (scope) => reaches(scope, "read"),
 	inputSchema: (scope) => ({
 		...entityShape(scope, "read", "Instead of \"collection\"."),
 		paths: z.array(z.string()).max(PATHS_LIMIT).optional().describe("Schema paths from \"next\". Omit for the top-level node."),
@@ -43,9 +43,12 @@ const PATHS_LIMIT = 400;
 		const expanded = args.expand === true ? reachableSchemaPaths(config, ref) : void 0;
 		const requested = expanded?.paths ?? (args.paths && args.paths.length > 0 ? args.paths : [""]);
 		const failures = [];
+		const nodeTypes = [];
 		const nodes = requested.map((schemaPath) => {
 			try {
-				return describeNode(config, ref, schemaPath);
+				const node = describeNode(config, ref, schemaPath);
+				nodeTypes.push(...node.fields.flatMap((field) => field.nodes ?? []));
+				return node;
 			} catch (error) {
 				if (error instanceof SchemaError) return {
 					error: error.message,
@@ -62,7 +65,6 @@ const PATHS_LIMIT = 400;
 			err: failures[0],
 			msg: `[payloadcms-mcpx] Describing ${String(failures.length)} schema paths failed.`
 		});
-		const nodeTypes = nodes.flatMap((node) => (node.fields ?? []).flatMap((field) => field.nodes ?? []));
 		if (nodeTypes.length > 0) nodes.push({ nodeProperties: nodePropertiesFor(nodeTypes) });
 		if (expanded?.truncated) nodes.push({ error: `Result truncated after ${String(400)} nodes. Request explicit paths instead.` });
 		return jsonResult(nodes);

package/dist/tools/document.mjs

@@ -1,34 +1,44 @@
-import { errorResult } from "../result.mjs";
-import { slugsFor } from "./shared.mjs";
+import { definedProps } from "../guards.mjs";
+import { errorResult, jsonResult } from "../result.mjs";
+import { documentLinks } from "./links.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
+import { slugsFor } from "./shared.mjs";
 import { APIError, Forbidden, NotFound } from "payload";
 //#region src/tools/document.ts
 /**
+* `payload.globals` is `{ config: SanitizedGlobalConfig[] }`, an array, not the
+* slug-keyed map `payload.collections` is.
+*/ const globalConfig = (payload, slug) => payload.globals.config.find((candidate) => candidate.slug === slug);
+/**
+* For a tool that takes a collection and no global, so the result needs no
+* check for one.
+*/ const resolveCollection = (scope, slug, operation) => {
+	const found = scope.req.payload.collections[slug]?.config;
+	if (!slugsFor(scope, operation).collections.includes(slug) || !found) throw new Forbidden(scope.req.t);
+	return {
+		kind: "collection",
+		slug,
+		config: found
+	};
+};
+/**
 * A raw input shape leaves no top-level `.refine` to express "exactly one of
 * collection and global", so the rule is enforced here, with a message naming
 * the offending arguments.
 */ const resolveEntity = (scope, args, operation) => {
 	const { collection, global } = args;
-	const allowedSlugs = slugsFor(scope, operation);
 	if (collection !== void 0 && global !== void 0) throw new APIError("Pass either \"collection\" or \"global\", not both.", 400);
-	if (collection === void 0 && global === void 0) throw new APIError("One of \"collection\" or \"global\" is required. Call listCapabilities to see which slugs are available.", 400);
-	if (collection !== void 0) {
-		const found = scope.req.payload.collections[collection];
-		if (!allowedSlugs.collections.includes(collection) || !found) throw new Forbidden(scope.req.t);
+	if (collection !== void 0) return resolveCollection(scope, collection, operation);
+	if (global !== void 0) {
+		const found = globalConfig(scope.req.payload, global);
+		if (!slugsFor(scope, operation).globals.includes(global) || !found) throw new Forbidden(scope.req.t);
 		return {
-			kind: "collection",
-			slug: collection,
-			config: found.config
+			kind: "global",
+			slug: global,
+			config: found
 		};
 	}
-	const slug = global;
-	const found = scope.req.payload.globals.config.find((candidate) => candidate.slug === slug);
-	if (!allowedSlugs.globals.includes(slug) || !found) throw new Forbidden(scope.req.t);
-	return {
-		kind: "global",
-		slug,
-		config: found
-	};
+	throw new APIError("One of \"collection\" or \"global\" is required. Call listCapabilities to see which slugs are available.", 400);
 };
 /**
 * Resolves the entity and checks `id` against it. A collection document needs
@@ -48,7 +58,45 @@ import { APIError, Forbidden, NotFound } from "payload";
 };
 /**
 * What a response names its subject by: a document's id, or a global's slug.
-*/ const identityOf = (target, id) => target.kind === "collection" ? { id } : { global: target.slug };
+*/ const identityOf = (target) => target.kind === "collection" ? { id: target.id } : { global: target.slug };
+/**
+* The fields every write result starts with, read from the saved `doc`.
+*/ const documentSummary = (target, doc) => ({
+	...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
+	status: doc["_status"],
+	updatedAt: doc["updatedAt"]
+});
+/**
+* Names the blockers of a check, and whether the check itself failed.
+*/ const blockerFields = (result, key) => ({
+	...result.blockers.length > 0 ? { [key]: result.blockers } : {},
+	...result.unavailable ? { [`${key}Unavailable`]: true } : {}
+});
+/**
+* What a tool that wrote a document returns: the document, re-read privileged
+* in `locale`, with its links and publish blockers. `extra` follows them.
+*/ const writtenResult = async (scope, args) => {
+	const { target, locale } = args;
+	const saved = await readDraft(scope, {
+		target,
+		locale,
+		privileged: true
+	});
+	const validation = await collectPublishBlockers(scope.req, {
+		doc: saved,
+		entity: target
+	});
+	return jsonResult({
+		...documentSummary(target, saved),
+		...await documentLinks(scope.req, {
+			target,
+			doc: saved,
+			locale
+		}),
+		...blockerFields(validation, "publishBlockers"),
+		...args.extra
+	});
+};
 const sameInstant = (left, right) => (typeof left === "string" || left instanceof Date) && new Date(left).getTime() === new Date(right).getTime();
 /**
 * Refuses a write when the document changed since the client read it.
@@ -75,7 +123,8 @@ const sameInstant = (left, right) => (typeof left === "string" || left instanceo
 			...shared,
 			collection: args.target.slug,
 			id: args.target.id,
-			disableErrors: true
+			disableErrors: true,
+			...args.trash ? { trash: true } : {}
 		});
 		if (!doc) throw new NotFound(scope.req.t);
 		return doc;
@@ -86,39 +135,76 @@ const sameInstant = (left, right) => (typeof left === "string" || left instanceo
 	});
 };
 /**
+* Updates a collection document or a global with no fallback locale, so a value
+* missing in the written locale is not backfilled from another and persisted.
+*/ const updateTarget = async (scope, target, write) => {
+	const { payload } = scope.req;
+	const { data, draft, file, ...optional } = write;
+	const shared = {
+		data,
+		depth: 0,
+		draft,
+		fallbackLocale: false,
+		overrideAccess: false,
+		req: scope.req,
+		...definedProps(optional)
+	};
+	if (target.kind === "collection") await payload.update({
+		...shared,
+		...definedProps({ file }),
+		collection: target.slug,
+		id: target.id
+	});
+	else await payload.updateGlobal({
+		...shared,
+		slug: target.slug
+	});
+};
+/**
+* Runs `run`, then puts back the request's locale and fallback locale, which
+* Payload's local API assigns in place.
+*/ const withRequestLocale = async (req, run) => {
+	const { fallbackLocale, locale } = req;
+	try {
+		return await run();
+	} finally {
+		if (locale !== void 0) req.locale = locale;
+		if (fallbackLocale !== void 0) req.fallbackLocale = fallbackLocale;
+	}
+};
+/**
 * {@link collectPublishBlockers} over the draft of each locale, each blocker
 * tagged with its locale. Locales run in turn because hooks share `req`, and
 * the request's locale and fallback locale are restored afterwards.
 */ const collectLocaleBlockers = async (scope, target, locales) => {
 	const { req } = scope;
-	const { fallbackLocale, locale: requestLocale } = req;
 	const blockers = [];
-	let unavailable = false;
-	for (const locale of locales) try {
-		const doc = await readDraft(scope, {
-			target,
-			locale,
-			privileged: true
-		});
-		const result = await collectPublishBlockers(req, {
-			doc,
-			entity: target
-		});
-		unavailable ||= result.unavailable === true;
-		blockers.push(...result.blockers.map((entry) => ({
-			...entry,
-			locale
-		})));
-	} catch (error) {
-		req.payload.logger.warn(`[payloadcms-mcpx] Could not read the ${target.slug} draft in ${locale}: ${error instanceof Error ? error.message : "unknown error"}`);
-		unavailable = true;
-	}
-	if (requestLocale !== void 0) req.locale = requestLocale;
-	if (fallbackLocale !== void 0) req.fallbackLocale = fallbackLocale;
 	return {
 		blockers,
-		...unavailable ? { unavailable: true } : {}
+		...await withRequestLocale(req, async () => {
+			let failed = false;
+			for (const locale of locales) try {
+				const doc = await readDraft(scope, {
+					target,
+					locale,
+					privileged: true
+				});
+				const result = await collectPublishBlockers(req, {
+					doc,
+					entity: target
+				});
+				failed ||= result.unavailable === true;
+				blockers.push(...result.blockers.map((entry) => ({
+					...entry,
+					locale
+				})));
+			} catch (error) {
+				req.payload.logger.warn(`[payloadcms-mcpx] Could not read the ${target.slug} draft in ${locale}: ${error instanceof Error ? error.message : "unknown error"}`);
+				failed = true;
+			}
+			return failed;
+		}) ? { unavailable: true } : {}
 	};
 };
 //#endregion
-export { collectLocaleBlockers, identityOf, readDraft, resolveDocument, resolveEntity, staleReadResult };
+export { blockerFields, collectLocaleBlockers, documentSummary, globalConfig, identityOf, readDraft, resolveCollection, resolveDocument, resolveEntity, staleReadResult, updateTarget, withRequestLocale, writtenResult };

package/dist/tools/duplicate-document.mjs

@@ -0,0 +1,50 @@
+import { defineMcpxTool } from "../define-tool.mjs";
+import { idSchema, liveWriteSentence, localeOf, slugsFor, stringEnum } from "./shared.mjs";
+import { resolveCollection, writtenResult } from "./document.mjs";
+import { withDuplicateIntent } from "../write/publish-intent.mjs";
+import { Forbidden } from "payload";
+//#region src/tools/duplicate-document.ts
+const duplicableSlugs = (scope) => slugsFor(scope, "create").collections.filter((slug) => scope.req.payload.collections[slug]?.config.disableDuplicate !== true && !scope.exposure.collections.some((entity) => entity.slug === slug && entity.isUpload));
+const DESCRIPTION = (scope) => `Copies a document into a new one in the same collection. Use it instead of getDocument and createDocument to copy a document. It copies the latest version, the draft if there is one, in every locale. Unique text fields get " - Copy" appended. Returns the same fields as createDocument. To rename the copy, call patchDocument with the returned "updatedAt".
+
+${liveWriteSentence(scope, "create")}`;
+/**
+* Wraps Payload's duplicate, which checks read access on the source and create
+* access on the copy, and runs the fields' `beforeDuplicate` hooks.
+*/ const duplicateDocument = defineMcpxTool({
+	name: "duplicateDocument",
+	description: DESCRIPTION,
+	annotations: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	},
+	isEnabled: (scope) => duplicableSlugs(scope).length > 0,
+	inputSchema: (scope) => ({
+		collection: stringEnum(duplicableSlugs(scope)),
+		id: idSchema
+	}),
+	handler: async ({ args, scope }) => {
+		const target = resolveCollection(scope, args.collection, "create");
+		if (!duplicableSlugs(scope).includes(target.slug)) throw new Forbidden(scope.req.t);
+		const created = await scope.req.payload.duplicate({
+			collection: target.slug,
+			id: args.id,
+			data: withDuplicateIntent({}),
+			depth: 0,
+			draft: true,
+			overrideAccess: false,
+			req: scope.req
+		});
+		return await writtenResult(scope, {
+			target: {
+				...target,
+				id: created["id"]
+			},
+			locale: localeOf(scope, void 0)
+		});
+	}
+});
+//#endregion
+export { duplicateDocument };

package/dist/tools/find-documents.mjs

@@ -1,9 +1,10 @@
 import { defineMcpxTool } from "../define-tool.mjs";
+import { definedProps } from "../guards.mjs";
 import { jsonResult } from "../result.mjs";
 import { stripAdminHidden } from "../schema/admin-hidden.mjs";
 import "../schema/index.mjs";
-import { READ_LOCALE_DESCRIPTION, depthShape, localeOf, localeShape, slugEnum } from "./shared.mjs";
-import { resolveEntity } from "./document.mjs";
+import { READ_LOCALE_DESCRIPTION, depthShape, localeOf, localeShape, pageFields, pageShape, stringEnum } from "./shared.mjs";
+import { resolveCollection } from "./document.mjs";
 import { assertQueryable } from "./query-paths.mjs";
 import { mcpxReadRequest } from "./read-request.mjs";
 import { z } from "zod";
@@ -23,11 +24,10 @@ import { z } from "zod";
 	},
 	isEnabled: (scope) => scope.collections.readable.length > 0,
 	inputSchema: (scope) => ({
-		collection: slugEnum(scope.collections.readable),
+		collection: stringEnum(scope.collections.readable),
 		where: z.record(z.string(), z.unknown()).optional(),
 		sort: z.string().optional().describe("e.g. \"-updatedAt\" for descending."),
-		limit: z.number().int().min(1).max(scope.limits.maxLimit).optional().describe("Default 10."),
-		page: z.number().int().min(1).optional(),
+		...pageShape(scope),
 		...depthShape(scope),
 		select: z.record(z.string(), z.unknown()).optional().describe("Fields to return, e.g. {\"title\":true}."),
 		...localeShape(scope, {
@@ -37,7 +37,7 @@ import { z } from "zod";
 		draft: z.boolean().optional().describe("Default true: latest drafts.")
 	}),
 	handler: async ({ args, scope }) => {
-		resolveEntity(scope, { collection: args.collection }, "read");
+		const target = resolveCollection(scope, args.collection, "read");
 		const locale = localeOf(scope, args.locale);
 		assertQueryable(scope, {
 			collection: args.collection,
@@ -52,22 +52,17 @@ import { z } from "zod";
 			limit: args.limit ?? 10,
 			overrideAccess: false,
 			req: mcpxReadRequest(scope),
-			...args.page === void 0 ? {} : { page: args.page },
-			...args.sort === void 0 ? {} : { sort: args.sort },
-			...args.where === void 0 ? {} : { where: args.where },
-			...args.select === void 0 ? {} : { select: args.select },
-			...locale === void 0 ? {} : { locale }
+			...definedProps({
+				page: args.page,
+				sort: args.sort,
+				where: args.where,
+				select: args.select,
+				locale
+			})
 		});
 		return jsonResult({
-			docs: result.docs.map((doc) => stripAdminHidden(scope.req.payload.config, {
-				kind: "collection",
-				slug: args.collection
-			}, doc)),
-			totalDocs: result.totalDocs,
-			page: result.page,
-			totalPages: result.totalPages,
-			limit: result.limit,
-			hasNextPage: result.hasNextPage
+			docs: result.docs.map((doc) => stripAdminHidden(scope.req.payload.config, target, doc)),
+			...pageFields(result)
 		});
 	}
 });

package/dist/tools/find-versions.mjs

@@ -1,15 +1,16 @@
 import { defineMcpxTool } from "../define-tool.mjs";
+import { definedProps } from "../guards.mjs";
 import { jsonResult } from "../result.mjs";
-import { draftVersionSlugs, entityShape, idShape, localeOf, localeShape, slugsFor, widen } from "./shared.mjs";
+import { entityShape, idShape, localeOf, localeShape, pageFields, pageShape, reaches, slugsFor, slugsWhere, widen } from "./shared.mjs";
 import { resolveDocument } from "./document.mjs";
 import { queryVersions } from "./versions.mjs";
+import { z } from "zod";
 import { APIError } from "payload";
 import { hasDraftsEnabled } from "payload/shared";
-import { z } from "zod";
 //#region src/tools/find-versions.ts
 const DESCRIPTION = `Lists the versions of one document or global, newest first, autosaves included. Returns per version "versionId", "createdAt", "updatedAt", "status", "latest", "autosave" and, where set, "publishedLocale", without the content. Read a version with getDocument "versionId", or compare it with "diffFrom".`;
 const statusShape = (scope) => {
-	const { collections, globals } = draftVersionSlugs(scope);
+	const { collections, globals } = slugsWhere(scope, (entity) => entity.hasDrafts, slugsFor(scope, "versions"));
 	if (collections.length + globals.length === 0) return widen({});
 	return widen({ status: z.enum(["published", "draft"]).optional() });
 };
@@ -25,15 +26,11 @@ const statusShape = (scope) => {
 		readOnlyHint: true,
 		openWorldHint: false
 	},
-	isEnabled: (scope) => {
-		const { collections, globals } = slugsFor(scope, "versions");
-		return collections.length + globals.length > 0;
-	},
+	isEnabled: (scope) => reaches(scope, "versions"),
 	inputSchema: (scope) => ({
 		...entityShape(scope, "versions"),
 		...idShape(scope, "versions"),
-		limit: z.number().int().min(1).max(scope.limits.maxLimit).optional().describe("Default 10."),
-		page: z.number().int().min(1).optional(),
+		...pageShape(scope),
 		...statusShape(scope),
 		...localeShape(scope, {
 			required: false,
@@ -49,8 +46,10 @@ const statusShape = (scope) => {
 			locale: localeOf(scope, args.locale)
 		}, {
 			limit: args.limit ?? 10,
-			...args.page === void 0 ? {} : { page: args.page },
-			...args.status === void 0 ? {} : { status: args.status }
+			...definedProps({
+				page: args.page,
+				status: args.status
+			})
 		});
 		const versions = result.docs.map((doc) => ({
 			versionId: doc.id,
@@ -63,10 +62,7 @@ const statusShape = (scope) => {
 		}));
 		return jsonResult({
 			versions,
-			totalDocs: result.totalDocs,
-			page: result.page,
-			totalPages: result.totalPages,
-			hasNextPage: result.hasNextPage
+			...pageFields(result)
 		});
 	}
 });