@abinnovision/payloadcms-mcpx 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/schema/pointer.mjs

@@ -1,4 +1,4 @@
-import { blockOf, blockSlugsOf, collectionOf, describeFields, findBlocksField, joinPath, splitPath } from "./walk.mjs";
+import { blockOf, blockSlugsOf, describeFields, findBlocksField, joinPath, splitPath, targetOf } from "./walk.mjs";
 //#region src/schema/pointer.ts
 const isIndexSegment = (segment) => segment === "-" || /^\d+$/.test(segment);
 const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isIndexSegment(segment) : part === segment);
@@ -32,7 +32,7 @@ const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isI
 * can only be resolved by reading `blockType` off `sections[3]`, since a blocks
 * field admits many shapes at the same index.
 */ const resolveDataPointer = (config, target) => {
-	let fields = collectionOf(config, target.collection).flattenedFields;
+	let fields = targetOf(config, target.ref).flattenedFields;
 	let data = target.doc;
 	let blockType;
 	let segments = splitPath(target.pointer);

package/dist/schema/shape.mjs

@@ -1,4 +1,5 @@
-import { blockOf, blockSlugsOf, describeFields, findBlocksField, splitPath } from "./walk.mjs";
+import { lexicalSubSchema } from "./lexical.mjs";
+import { blockOf, blockSlugsOf, describeFields, findBlocksField, findRichTextField, splitPath } from "./walk.mjs";
 //#region src/schema/shape.ts
 /**
 * Keys Payload manages on a row that a client may echo back harmlessly.
@@ -9,30 +10,79 @@ import { blockOf, blockSlugsOf, describeFields, findBlocksField, splitPath } fro
 ]);
 const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
-* Checks every node type in an editor state against what the field's editor
-* can actually produce.
+* Checks the fields a single Lexical node carries against the schema its
+* feature declares for that node type.
+*
+* A node with nothing to declare, and one whose sub-fields cannot be named at
+* a position, are both left alone.
+*/ const checkNodeFields = (scope, field, node) => {
+	const sub = lexicalSubSchema(field, node.type);
+	if (!sub) return;
+	const data = node.fields;
+	if (!isPlainObject(data)) {
+		scope.problems.push(`${scope.pointer}: a "${node.type}" node carries a "fields" object.`);
+		return;
+	}
+	const nested = {
+		...scope,
+		pointer: `${scope.pointer}/fields`,
+		prefix: []
+	};
+	if (sub.kind === "fields") {
+		checkValue({
+			...nested,
+			fields: sub.fields
+		}, data);
+		return;
+	}
+	const slug = data["blockType"];
+	const block = typeof slug === "string" ? blockOf(scope.config, sub.blocksField, slug) : void 0;
+	if (!block) {
+		scope.problems.push(`${scope.pointer}/fields: "${String(slug)}" is not allowed here. Allowed: ${blockSlugsOf(sub.blocksField).join(", ")}`);
+		return;
+	}
+	checkValue({
+		...nested,
+		fields: block.flattenedFields
+	}, data);
+};
+/**
+* Checks an editor state against what the field's editor can actually
+* produce: every node type, and the fields each node carries.
 *
 * Payload does not: the Lexical validator runs node validations only for the
 * few node types that register one, so a `heading` inside a field whose
 * editor has no heading feature is stored without complaint and only fails
-* later, at render or when the document is reopened in the admin editor.
-*/ const checkRichText = (scope, allowed, value) => {
+* later, at render or when the document is reopened in the admin editor. A key
+* a node's fields do not declare is dropped just as silently.
+*/ const checkRichText = (scope, editor, value) => {
 	if (!isPlainObject(value) || !isPlainObject(value["root"])) {
 		scope.problems.push(`${scope.pointer}: expected a Lexical editor state with a "root".`);
 		return;
 	}
-	const walk = (nodes) => {
+	const walk = (nodes, pointer) => {
 		if (!Array.isArray(nodes)) return;
-		for (const node of nodes) {
+		nodes.forEach((node, index) => {
+			const at = `${pointer}/${String(index)}`;
 			if (!isPlainObject(node) || typeof node["type"] !== "string") {
-				scope.problems.push(`${scope.pointer}: every node needs a "type".`);
-				continue;
+				scope.problems.push(`${at}: every node needs a "type".`);
+				return;
 			}
-			if (!allowed.includes(node["type"])) scope.problems.push(`${scope.pointer}: "${node["type"]}" is not available in this field's editor. Allowed: ${allowed.join(", ")}`);
-			walk(node["children"]);
-		}
+			if (!editor.allowed.includes(node["type"])) {
+				scope.problems.push(`${at}: "${node["type"]}" is not available in this field's editor. Allowed: ${editor.allowed.join(", ")}`);
+				return;
+			}
+			if (editor.field) checkNodeFields({
+				...scope,
+				pointer: at
+			}, editor.field, {
+				fields: node["fields"],
+				type: node["type"]
+			});
+			walk(node["children"], `${at}/children`);
+		});
 	};
-	walk(value["root"]["children"]);
+	walk(value["root"]["children"], `${scope.pointer}/root/children`);
 };
 const checkLeafValue = (scope, descriptor, value) => {
 	if (descriptor.readOnly) {
@@ -40,7 +90,10 @@ const checkLeafValue = (scope, descriptor, value) => {
 		return;
 	}
 	if (descriptor.type === "richText") {
-		checkRichText(scope, descriptor.nodes ?? [], value);
+		checkRichText(scope, {
+			allowed: descriptor.nodes ?? [],
+			field: findRichTextField(scope.fields, splitPath(descriptor.path))
+		}, value);
 		return;
 	}
 	if (descriptor.type !== "blocks") return;

package/dist/schema/walk.d.mts

@@ -0,0 +1 @@
+import "payload";

package/dist/schema/walk.mjs

@@ -109,10 +109,21 @@ const withRows = (descriptor, field) => ({
 		if (field.type === "array" && path[1] === "*") return findBlocksField(field.flattenedFields, path.slice(2));
 	}
 };
-const collectionOf = (config, collection) => {
-	const found = config.collections.find((candidate) => candidate.slug === collection);
-	if (!found) throw new Error(`Unknown collection "${collection}".`);
+/**
+* Locates the rich text field that a resolved descriptor path refers to, so
+* its editor can be introspected for the fields its nodes carry.
+*/ const findRichTextField = (fields, path) => {
+	for (const field of fields) {
+		if (!("name" in field) || field.name !== path[0]) continue;
+		if (field.type === "richText" && path.length === 1) return field;
+		if (field.type === "tab" || field.type === "group") return findRichTextField(field.flattenedFields, path.slice(1));
+		if (field.type === "array" && path[1] === "*") return findRichTextField(field.flattenedFields, path.slice(2));
+	}
+};
+const targetOf = (config, ref) => {
+	const found = ref.kind === "collection" ? config.collections.find((candidate) => candidate.slug === ref.slug) : config.globals.find((candidate) => candidate.slug === ref.slug);
+	if (!found) throw new Error(`Unknown ${ref.kind} "${ref.slug}".`);
 	return found;
 };
 //#endregion
-export { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, blockOf, blockSlugsOf, collectionOf, describeFields, findBlocksField, joinPath, pointerFromPayloadPath, splitPath, staticDescription };
+export { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, blockOf, blockSlugsOf, describeFields, findBlocksField, findRichTextField, joinPath, pointerFromPayloadPath, splitPath, staticDescription, targetOf };

package/dist/tools/create-document.mjs

@@ -1,5 +1,6 @@
 import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, ensureAllowed, localeOf, localeShape, readDraft } from "./shared.mjs";
+import { localeOf, localeShape, readTarget, slugEnum } from "./shared.mjs";
+import { resolveTarget } from "./target.mjs";
 import { validateWriteValue } from "../schema/shape.mjs";
 import { stripRowIds } from "../write/patch.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
@@ -16,7 +17,7 @@ const createDocument = {
 	},
 	isEnabled: (scope) => scope.writable.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.writable).describe("Collection to create the document in."),
+		collection: slugEnum(scope.writable).describe("Collection to create the document in."),
 		...localeShape(scope, {
 			required: true,
 			description: "Locale the localized fields of the seed belong to."
@@ -24,14 +25,14 @@ const createDocument = {
 		data: z.record(z.string(), z.unknown()).describe("Initial field values, as describeSchema lists them.")
 	}),
 	handler: async (args, scope) => {
-		const collection = ensureAllowed(scope, args.collection, "write");
+		const target = resolveTarget(scope, { collection: args.collection }, "write");
 		const { payload } = scope.req;
 		const locale = localeOf(scope, args.locale);
 		const { id: _ignored, ...seed } = args.data;
 		const problems = validateWriteValue(payload.config, {
 			pointer: "",
 			resolution: {
-				fields: collection.flattenedFields,
+				fields: target.config.flattenedFields,
 				prefix: []
 			}
 		}, seed);
@@ -45,15 +46,15 @@ const createDocument = {
 			req: scope.req,
 			...locale === void 0 ? {} : { locale }
 		});
-		const saved = await readDraft(scope, {
-			collection: args.collection,
+		const saved = await readTarget(scope, {
+			target,
 			id: created["id"],
 			locale,
 			privileged: true
 		});
 		const publishBlockers = await collectPublishBlockers(scope.req, {
-			collection,
-			doc: saved
+			doc: saved,
+			entity: target
 		});
 		return jsonResult({
 			id: saved["id"],

package/dist/tools/describe-schema.mjs

@@ -1,5 +1,6 @@
 import { jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, ensureAllowed } from "./shared.mjs";
+import { targetShape } from "./shared.mjs";
+import { refOf, resolveTarget } from "./target.mjs";
 import { describeNode, reachableSchemaPaths } from "../schema/describe.mjs";
 import { z } from "zod";
 //#region src/tools/describe-schema.ts
@@ -7,8 +8,12 @@ const describeSchema = {
 	name: "describeSchema",
 	description: `Describes the writable shape of a document, one node at a time.
 
+Pass exactly one of "collection" and "global". A global is a singleton: it has no id, is not listed by findDocuments and cannot be created.
+
 Call it with no "paths" to get a collection's own fields. Every "blocks" field stops there and lists the block slugs it accepts instead of nesting them; each node's "next" lists the ready-to-use paths for those blocks, so pass any entry of "next" as a "paths" element to descend, e.g. "/layout/sections/sectionWrapper" and then "/layout/sections/sectionWrapper/modules/hero". A block is described as it exists at that position, because the same block can accept different children elsewhere.
 
+A "richText" field stops there too. It lists the Lexical node types it accepts in "nodes", and "next" carries a path for every node type that holds fields of its own: "/content/link" for a link node, "/content/block/callout" and "/content/inlineBlock/badge" for the block nodes. Descend to get the real field list instead of guessing what a node carries. Upload nodes are not addressable, because their fields depend on the collection the node points at.
+
 Paths here use the same JSON Pointer syntax as getDocument and patchDocument, and are already resolved through anything that does not nest in the stored document. The difference is only what stands in an element position: a path names an array element "*" and a block by its slug, where a pointer into a document carries a 0-based index. So "/items/*/title" is written at "/items/0/title", and "/layout/sections/hero" at "/layout/sections/0".
 
 Fields Payload maintains (id, _status, createdAt, updatedAt) are never listed and cannot be written. Fields marked readOnly are listed but refused on write.`,
@@ -16,19 +21,22 @@ Fields Payload maintains (id, _status, createdAt, updatedAt) are never listed an
 		readOnlyHint: true,
 		openWorldHint: false
 	},
-	isEnabled: (scope) => scope.readable.length > 0,
+	isEnabled: (scope) => scope.readable.length + scope.readableGlobals.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.readable).describe("Collection to describe."),
+		...targetShape(scope, "read", {
+			collection: "Collection to describe.",
+			global: "Global to describe."
+		}),
 		paths: z.array(z.string()).optional().describe("Schema paths to describe, e.g. \"/layout/sections/sectionWrapper\". Omit for the collection root."),
 		expand: z.boolean().optional().describe("Return every node reachable from the root in one response. Ignores paths.")
 	}),
 	handler: (args, scope) => {
-		ensureAllowed(scope, args.collection, "read");
+		const ref = refOf(resolveTarget(scope, args, "read"));
 		const { config } = scope.req.payload;
-		const expanded = args.expand === true ? reachableSchemaPaths(config, args.collection) : void 0;
+		const expanded = args.expand === true ? reachableSchemaPaths(config, ref) : void 0;
 		const nodes = (expanded?.paths ?? (args.paths && args.paths.length > 0 ? args.paths : [""])).map((schemaPath) => {
 			try {
-				return describeNode(config, args.collection, schemaPath);
+				return describeNode(config, ref, schemaPath);
 			} catch (error) {
 				return {
 					error: error instanceof Error ? error.message : "Unknown error",

package/dist/tools/find-documents.mjs

@@ -1,5 +1,6 @@
 import { jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, depthShape, ensureAllowed, localeOf, localeShape } from "./shared.mjs";
+import { depthShape, localeOf, localeShape, slugEnum } from "./shared.mjs";
+import { resolveTarget } from "./target.mjs";
 import { z } from "zod";
 //#region src/tools/find-documents.ts
 const findDocuments = {
@@ -11,7 +12,7 @@ const findDocuments = {
 	},
 	isEnabled: (scope) => scope.readable.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.readable).describe("Collection to search."),
+		collection: slugEnum(scope.readable).describe("Collection to search."),
 		where: z.record(z.string(), z.unknown()).optional().describe("Payload where query."),
 		sort: z.string().optional().describe("Sort field, prefix with \"-\" for descending."),
 		limit: z.number().int().min(1).max(scope.options.limits.maxLimit).optional().describe(`Documents per page. Default 10, at most ${String(scope.options.limits.maxLimit)}.`),
@@ -25,7 +26,7 @@ const findDocuments = {
 		draft: z.boolean().optional().describe("Include the latest drafts. Default true.")
 	}),
 	handler: async (args, scope) => {
-		ensureAllowed(scope, args.collection, "read");
+		resolveTarget(scope, { collection: args.collection }, "read");
 		const locale = localeOf(scope, args.locale);
 		const result = await scope.req.payload.find({
 			collection: args.collection,

package/dist/tools/get-document.mjs

@@ -1,20 +1,26 @@
 import { JSON_POINTER_PATTERN } from "../schema/walk.mjs";
 import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, depthShape, ensureAllowed, idSchema, localeOf, localeShape } from "./shared.mjs";
+import { depthShape, idShape, localeOf, localeShape, targetShape } from "./shared.mjs";
+import { requireIdFor, resolveTarget } from "./target.mjs";
 import { z } from "zod";
 import { Pointer } from "rfc6902";
 //#region src/tools/get-document.ts
 const getDocument = {
 	name: "getDocument",
-	description: `Reads one document, or one subtree of it when "path" is given as a JSON pointer such as "/layout/sections/2". Returns the latest draft by default. Read before patching: the response carries "updatedAt" for expectedUpdatedAt and the indices pointers need.`,
+	description: `Reads one document, or one subtree of it when "path" is given as a JSON pointer such as "/layout/sections/2". Returns the latest draft by default. Read before patching: the response carries "updatedAt" for expectedUpdatedAt and the indices pointers need.
+
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.`,
 	annotations: {
 		readOnlyHint: true,
 		openWorldHint: false
 	},
-	isEnabled: (scope) => scope.readable.length > 0,
+	isEnabled: (scope) => scope.readable.length + scope.readableGlobals.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.readable).describe("Collection holding the document."),
-		id: idSchema,
+		...targetShape(scope, "read", {
+			collection: "Collection holding the document.",
+			global: "Global to read."
+		}),
+		...idShape(scope, "read"),
 		path: z.string().regex(JSON_POINTER_PATTERN).optional().describe("JSON pointer to return only a subtree, e.g. \"/layout/sections/0\"."),
 		...depthShape(scope),
 		...localeShape(scope, {
@@ -24,17 +30,24 @@ const getDocument = {
 		draft: z.boolean().optional().describe("Return the latest draft. Default true.")
 	}),
 	handler: async (args, scope) => {
-		ensureAllowed(scope, args.collection, "read");
+		const target = resolveTarget(scope, args, "read");
+		const id = requireIdFor(target, args.id);
 		const locale = localeOf(scope, args.locale);
-		const doc = await scope.req.payload.findByID({
-			collection: args.collection,
-			id: args.id,
+		const shared = {
 			depth: args.depth ?? 0,
 			draft: args.draft ?? true,
 			overrideAccess: false,
 			req: scope.req,
 			...locale === void 0 ? {} : { locale }
-		});
+		};
+		const doc = await (target.kind === "collection" ? scope.req.payload.findByID({
+			...shared,
+			collection: target.slug,
+			id
+		}) : scope.req.payload.findGlobal({
+			...shared,
+			slug: target.slug
+		}));
 		if (args.path === void 0 || args.path === "") return jsonResult(doc);
 		let value;
 		try {
@@ -43,7 +56,7 @@ const getDocument = {
 			return errorResult(`"${args.path}" is not a valid JSON pointer.`);
 		}
 		return jsonResult({
-			id: doc["id"],
+			...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
 			status: doc["_status"],
 			updatedAt: doc["updatedAt"],
 			path: args.path,

package/dist/tools/list-capabilities.mjs

@@ -5,7 +5,9 @@ import { hasDraftValidationEnabled } from "payload/shared";
 //#region src/tools/list-capabilities.ts
 const listCapabilities = {
 	name: "listCapabilities",
-	description: `Lists what this key may do: the collections it can read or write, their draft behaviour and id type, the configured locales, the limits in force and the custom tools available. Call it first to orient; nothing here changes with the content model.`,
+	description: `Lists what this key may do: the collections and globals it can read or write, their draft behaviour and id type, the configured locales, the limits in force and the custom tools available. Call it first to orient; nothing here changes with the content model.
+
+A global is a singleton: it has no id, is not listed by findDocuments and cannot be created. Address one with the "global" argument where a collection document would take "collection" and "id".`,
 	annotations: {
 		readOnlyHint: true,
 		openWorldHint: false
@@ -34,8 +36,24 @@ const listCapabilities = {
 				idType: collection.customIDType ?? payload.db.defaultIDType
 			}];
 		});
+		const globals = scope.options.globals.flatMap((entry) => {
+			const capability = scope.capabilities.globals[entry.slug];
+			const config = payload.globals.config.find((candidate) => candidate.slug === entry.slug);
+			if (!capability || !config || !(capability.read || capability.write)) return [];
+			const description = staticDescription(config.admin.description);
+			return [{
+				slug: entry.slug,
+				label: translateLabel(scope, config.label, entry.slug),
+				...description === void 0 ? {} : { description },
+				read: capability.read,
+				write: capability.write,
+				drafts: entry.hasDrafts,
+				draftValidation: hasDraftValidationEnabled(config)
+			}];
+		});
 		return Promise.resolve(jsonResult({
 			collections,
+			...globals.length > 0 ? { globals } : {},
 			locales: scope.locales ? {
 				codes: scope.locales,
 				default: scope.defaultLocale

package/dist/tools/patch-document.mjs

@@ -1,5 +1,6 @@
 import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, ensureAllowed, idSchema, localeOf, localeShape, readDraft } from "./shared.mjs";
+import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
+import { refOf, requireIdFor, resolveTarget } from "./target.mjs";
 import { PATCH_OPERATION_SCHEMA, applyPatchToCopy, buildWriteData, findPatchProblems, isElementPointer } from "../write/patch.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
 import { withTransaction } from "../write/transaction.mjs";
@@ -8,6 +9,8 @@ import { Pointer } from "rfc6902";
 //#region src/tools/patch-document.ts
 const DESCRIPTION = `Applies RFC 6902 JSON Patch operations to one document.
 
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.
+
 The write always lands as a draft and is never published, whatever it contains; publishing stays a human action in the admin panel.
 
 Only the fields describeSchema lists can be addressed. A pointer that does not resolve is refused with the fields that are valid at that point, and nothing is applied unless every operation in the batch validates first. describeSchema reports field paths in this same pointer syntax; a path becomes a pointer into a document by replacing each "*" and each block slug with its 0-based index.
@@ -48,10 +51,13 @@ const patchDocument = {
 		idempotentHint: false,
 		openWorldHint: false
 	},
-	isEnabled: (scope) => scope.writable.length > 0,
+	isEnabled: (scope) => scope.writable.length + scope.writableGlobals.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.writable).describe("Collection holding the document."),
-		id: idSchema,
+		...targetShape(scope, "write", {
+			collection: "Collection holding the document.",
+			global: "Global to patch."
+		}),
+		...idShape(scope, "write"),
 		...localeShape(scope, {
 			required: true,
 			description: "Locale the patch applies to. Localized fields write here only."
@@ -60,47 +66,55 @@ const patchDocument = {
 		expectedUpdatedAt: z.string().optional().describe("The updatedAt read before patching. The write is refused if the document has changed since.")
 	}),
 	handler: async (args, scope) => {
-		const collection = ensureAllowed(scope, args.collection, "write");
+		const target = resolveTarget(scope, args, "write");
+		const id = requireIdFor(target, args.id);
 		const { payload } = scope.req;
 		const locale = localeOf(scope, args.locale);
 		return await withTransaction(scope.req, async () => {
-			const doc = await readDraft(scope, {
-				collection: args.collection,
-				id: args.id,
+			const doc = await readTarget(scope, {
+				target,
+				id,
 				locale
 			});
 			if (args.expectedUpdatedAt !== void 0 && !sameInstant(doc["updatedAt"], args.expectedUpdatedAt)) return errorResult("The document changed since you read it. Read it again and re-apply the patch.", { updatedAt: doc["updatedAt"] });
 			const problems = findPatchProblems(payload.config, {
-				collection: args.collection,
 				doc,
-				patches: args.patches
+				patches: args.patches,
+				ref: refOf(target)
 			});
 			if (problems.length > 0) return errorResult("No operation was applied.", { problems });
 			const applied = applyPatchToCopy(doc, args.patches);
 			if ("problems" in applied) return errorResult("No operation was applied.", { problems: applied.problems });
-			await payload.update({
-				collection: args.collection,
-				id: args.id,
-				data: buildWriteData(payload.config, collection, applied.next),
+			const write = {
+				data: buildWriteData(payload.config, target.config, applied.next),
 				depth: 0,
 				draft: true,
 				overrideAccess: false,
 				req: scope.req,
 				...locale === void 0 ? {} : { locale }
+			};
+			if (target.kind === "collection") await payload.update({
+				...write,
+				collection: target.slug,
+				id
+			});
+			else await payload.updateGlobal({
+				...write,
+				slug: target.slug
 			});
-			const saved = await readDraft(scope, {
-				collection: args.collection,
-				id: args.id,
+			const saved = await readTarget(scope, {
+				target,
+				id,
 				locale,
 				privileged: true
 			});
 			const notApplied = notAppliedPointers(args.patches, applied.next, saved);
 			const publishBlockers = await collectPublishBlockers(scope.req, {
-				collection,
-				doc: saved
+				doc: saved,
+				entity: target
 			});
 			return jsonResult({
-				id: saved["id"],
+				...target.kind === "collection" ? { id: saved["id"] } : { global: target.slug },
 				status: saved["_status"],
 				updatedAt: saved["updatedAt"],
 				...publishBlockers.length > 0 ? { publishBlockers } : {},

package/dist/tools/shared.mjs

@@ -1,8 +1,39 @@
-import { Forbidden, NotFound } from "payload";
+import { NotFound } from "payload";
 import { z } from "zod";
 //#region src/tools/shared.ts
-const collectionEnum = (slugs) => z.enum(slugs);
+const slugEnum = (slugs) => z.enum(slugs);
 const idSchema = z.union([z.string(), z.number()]).describe("Document id.");
+const slugsFor = (scope, operation) => ({
+	collections: operation === "read" ? scope.readable : scope.writable,
+	globals: operation === "read" ? scope.readableGlobals : scope.writableGlobals
+});
+/**
+* The `collection` and `global` arguments.
+*
+* When the key can reach no global, `global` is left out of the shape entirely
+* and `collection` stays required, mirroring how {@link localeShape} omits
+* `locale` when localization is off. A deployment without globals therefore
+* sees exactly the schema it saw before. Only the mixed case makes either
+* argument optional, and the handler enforces the exclusivity there.
+*/ const targetShape = (scope, operation, descriptions) => {
+	const { collections, globals } = slugsFor(scope, operation);
+	if (globals.length === 0) return { collection: slugEnum(collections).describe(descriptions.collection) };
+	if (collections.length === 0) return { global: slugEnum(globals).describe(descriptions.global) };
+	return {
+		collection: slugEnum(collections).optional().describe(descriptions.collection),
+		global: slugEnum(globals).optional().describe(descriptions.global)
+	};
+};
+/**
+* The `id` argument, which only a collection document has. Omitted when the key
+* can reach no collection, required when it can reach no global, and optional
+* in between, where `requireIdFor` enforces the dependency.
+*/ const idShape = (scope, operation) => {
+	const { collections, globals } = slugsFor(scope, operation);
+	if (collections.length === 0) return {};
+	if (globals.length === 0) return { id: idSchema };
+	return { id: idSchema.optional().describe("Document id. Required with \"collection\"; must be omitted with \"global\".") };
+};
 /**
 * The `locale` argument, present only when localization is configured.
 */ const localeShape = (scope, options) => {
@@ -12,15 +43,6 @@ const idSchema = z.union([z.string(), z.number()]).describe("Document id.");
 };
 const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.options.limits.maxDepth).optional().describe(`Relationship population depth. Default 0, at most ${String(scope.options.limits.maxDepth)}.`) });
 /**
-* Throws unless the key may perform `operation` on `slug`. The input schema
-* already limits the enum, so this only guards against a stale tool list.
-*/ const ensureAllowed = (scope, slug, operation) => {
-	const allowed = operation === "read" ? scope.readable : scope.writable;
-	const collection = scope.req.payload.collections[slug];
-	if (!allowed.includes(slug) || !collection) throw new Forbidden(scope.req.t);
-	return collection.config;
-};
-/**
 * The locale to operate on: the explicit argument, else the request's, else
 * the default. `undefined` when localization is off.
 */ const localeOf = (scope, locale) => {
@@ -31,23 +53,34 @@ const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.option
 /**
 * Reads the current draft in a fixed locale with no fallback, which is the
 * shape that may be written back or validated without mixing locales.
-*/ const readDraft = async (scope, args) => {
-	const doc = await scope.req.payload.findByID({
-		collection: args.collection,
-		id: args.id,
+*/ const readTarget = async (scope, args) => {
+	const { payload } = scope.req;
+	const privileged = args.privileged === true;
+	const shared = {
 		depth: 0,
 		draft: true,
 		...args.locale === void 0 ? {} : {
 			locale: args.locale,
 			fallbackLocale: false
 		},
-		overrideAccess: args.privileged === true,
-		showHiddenFields: args.privileged === true,
-		disableErrors: true,
+		overrideAccess: privileged,
+		showHiddenFields: privileged,
 		req: scope.req
+	};
+	if (args.target.kind === "collection") {
+		const doc = await payload.findByID({
+			...shared,
+			collection: args.target.slug,
+			id: args.id,
+			disableErrors: true
+		});
+		if (!doc) throw new NotFound(scope.req.t);
+		return doc;
+	}
+	return await payload.findGlobal({
+		...shared,
+		slug: args.target.slug
 	});
-	if (!doc) throw new NotFound(scope.req.t);
-	return doc;
 };
 /**
 * Resolves a collection label for the request's language.
@@ -62,4 +95,4 @@ const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.option
 	return fallback;
 };
 //#endregion
-export { collectionEnum, depthShape, ensureAllowed, idSchema, localeOf, localeShape, readDraft, translateLabel };
+export { depthShape, idSchema, idShape, localeOf, localeShape, readTarget, slugEnum, targetShape, translateLabel };

package/dist/tools/target.d.mts

@@ -0,0 +1,3 @@
+import "./types.mjs";
+import "../schema/walk.mjs";
+import "payload";