buro26-strapi-graphql 0.1.0 → 0.2.0

package/dist/server/types.d.ts

@@ -1,6 +1,12 @@
 import type { ResolveContext } from './utils';
 import type { GraphQLResolveInfo } from 'graphql';
 export type Strapi = typeof strapi;
+/**
+ * A GraphQL extension as registered with Strapi's GraphQL plugin. Created by
+ * {@link createGraphQLExtension} or by building a field builder.
+ *
+ * @see https://docs.strapi.io/dev-docs/plugins/graphql#customization
+ */
 export interface GraphQLExtension {
     /**
      * Called when the extension is initialized, use this to perform any initialization logic
@@ -16,7 +22,7 @@ export interface GraphQLExtension {
      * Return array the types for the extension
      * Use Nexus to define types
      *
-     * @deprecated Use types() instead
+     * @deprecated Renamed to `types()`; same signature. Will be removed in the next major version.
      */
     getTypes?: () => any[];
     /**
@@ -43,7 +49,7 @@ export interface GraphQLExtension {
      * This is used to configure middlewares and other resolver options
      * @see https://docs.strapi.io/developer-docs/latest/plugins/graphql.html#extending-the-schema
      *
-     * @deprecated Use resolversConfig() instead
+     * @deprecated Renamed to `resolversConfig()`; same signature. Will be removed in the next major version.
      */
     getResolverConfig?: () => any;
     /**
@@ -53,8 +59,14 @@ export interface GraphQLExtension {
      */
     resolversConfig?: () => Record<string, ResolverConfigOption>;
 }
+/**
+ * Strapi resolver configuration for a `Type.field` path.
+ */
 export type ResolverConfigOption<TParent = any, TArgs = any, TOutput = any> = {
-    auth?: boolean | undefined;
+    /** `false` makes the field public; `{ scope }` requires these users-permissions actions */
+    auth?: boolean | {
+        scope: string[];
+    } | undefined;
     policies?: (string | PolicyFunction<TParent, TArgs>)[];
     middlewares?: MiddlewareFunction<TParent, TArgs, TOutput>[];
 };
@@ -72,4 +84,7 @@ export type PolicyFunctionOptions = {
 export type PolicyFunction<TParent = any, TArgs = any> = (context: PolicyFunctionContext<TParent, TArgs>, config: any, opts: PolicyFunctionOptions) => boolean | Promise<boolean>;
 export type MiddlewareFunction<TParent = any, TArgs = any, TOutput = any> = (next: MiddlewareNextFunction<TParent, TArgs, TOutput>, parent: TParent, args: TArgs, context: ResolveContext, info: GraphQLResolveInfo) => TOutput | Promise<TOutput>;
 export type MiddlewareNextFunction<TParent = any, TArgs = any, TOutput = any> = (parent: TParent, args: TArgs, context: ResolveContext, info: GraphQLResolveInfo) => Promise<TOutput>;
+/**
+ * A GraphQL resolver with Strapi's resolver context.
+ */
 export type ResolverFunction<TParent = any, TArgs = any, TOutput = any> = (parent: TParent, args: TArgs, context: ResolveContext, info: GraphQLResolveInfo) => TOutput | Promise<TOutput>;

package/dist/server/utils/collection-type.d.ts

@@ -8,14 +8,18 @@ import { type ResolveArgs } from './types';
  * Create a resolver for a collection of entities
  * Returns a resolver that resolves the entities based on the content type UID
  *
- * @param contentType The content type UID of the entities
+ * @param contentType - Content type UID of the entities.
+ * @returns A resolver taking `{ parent, args, context, info }` that applies Strapi's filters, sort and
+ *   pagination and returns an entity response collection.
  */
 export declare const createEntityCollectionResolver: <ContentType extends Object>(contentType: string) => (resolveArgs: ResolveArgs<ContentType>) => Promise<EntityResponseCollection<ContentType>>;
 /**
  * Create a resolver for a collection of entities related to a parent entity
  * Returns a resolver that resolves the related entities based on the relation field name
  *
- * @param contentType The content type UID of the related entities
+ * @param contentType - Content type UID of the **parent** (owner of the relation).
+ * @deprecated Prefer {@link FieldExtensionBuilder.relation}, which also keeps the `find` permission scope
+ *   and works on Strapi v5.
  */
 export declare function createEntityRelationCollectionResolver<Parent extends object>(contentType: string): <K extends keyof Parent>(relationFieldName: K, resolveArgs: ResolveArgs<Parent>) => Promise<EntityResponseCollection<ExtractRelation<Parent, K>>>;
 type EntityResponseCollection<T extends Object> = {
@@ -26,6 +30,13 @@ type EntityResponseCollection<T extends Object> = {
     };
 };
 type ExtractRelation<Parent, K extends keyof Parent> = Parent[K] extends Array<infer U> ? U extends object ? U : never : Parent[K] extends object ? Parent[K] : never;
+/**
+ * Wrap entities in Strapi's response collection (`{ nodes, info }`), the return shape of
+ * `XEntityResponseCollection` fields.
+ *
+ * @param args - The (transformed) field arguments, used for pagination info.
+ * @param resourceUID - Content type UID of the items.
+ */
 export declare function toEntityResponseCollection<T extends Object>(items: T[], { args, resourceUID }: {
     args: Record<string, any>;
     resourceUID: string;

package/dist/server/utils/collection-type.js

@@ -10,7 +10,9 @@ exports.toEntityResponseCollection = exports.createEntityRelationCollectionResol
  * Create a resolver for a collection of entities
  * Returns a resolver that resolves the entities based on the content type UID
  *
- * @param contentType The content type UID of the entities
+ * @param contentType - Content type UID of the entities.
+ * @returns A resolver taking `{ parent, args, context, info }` that applies Strapi's filters, sort and
+ *   pagination and returns an entity response collection.
  */
 const createEntityCollectionResolver = (contentType) => {
     const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
@@ -36,7 +38,9 @@ exports.createEntityCollectionResolver = createEntityCollectionResolver;
  * Create a resolver for a collection of entities related to a parent entity
  * Returns a resolver that resolves the related entities based on the relation field name
  *
- * @param contentType The content type UID of the related entities
+ * @param contentType - Content type UID of the **parent** (owner of the relation).
+ * @deprecated Prefer {@link FieldExtensionBuilder.relation}, which also keeps the `find` permission scope
+ *   and works on Strapi v5.
  */
 function createEntityRelationCollectionResolver(contentType) {
     return async (relationFieldName, resolveArgs) => {
@@ -52,6 +56,13 @@ function createEntityRelationCollectionResolver(contentType) {
     };
 }
 exports.createEntityRelationCollectionResolver = createEntityRelationCollectionResolver;
+/**
+ * Wrap entities in Strapi's response collection (`{ nodes, info }`), the return shape of
+ * `XEntityResponseCollection` fields.
+ *
+ * @param args - The (transformed) field arguments, used for pagination info.
+ * @param resourceUID - Content type UID of the items.
+ */
 async function toEntityResponseCollection(items, { args, resourceUID }) {
     const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
     return toEntityResponseCollection(items, {

package/dist/server/utils/field-builder/builder.d.ts

@@ -14,11 +14,20 @@ type BuilderState<Type = any, TArgs = any, TOutput = any> = {
     built: boolean;
 };
 /**
- * Creates a fluent, deeply immutable builder to extend a root field in the GraphQL schema.
- * Each method returns a new builder instance with its own state.
+ * Create a field builder: the recommended way to add or replace a GraphQL field.
  *
- * @param rootType - Either 'Query' or 'Mutation' or any other Type to extend.
- * @param _state
+ * See {@link FieldExtensionBuilder} for all methods and the execution order.
+ *
+ * @param rootType - Shorthand for `.rootType(...)`. Prefer calling `.rootType()` so presets can be applied
+ *   before the type is known.
+ * @param _state - Internal; do not pass.
+ *
+ * @example
+ * export default createGraphQLFieldBuilder()
+ *   .rootType('Customer')
+ *   .fieldName('fullName')
+ *   .outputType('String')
+ *   .resolver((customer) => [customer?.firstName, customer?.lastName].filter(Boolean).join(' '))
  */
 export declare const createGraphQLFieldBuilder: <Type = any, TArgs = any, TOutput = Type>(rootType?: string, _state?: BuilderState<Type, TArgs, TOutput>) => FieldExtensionBuilder<Type, TArgs, TOutput>;
 export {};

package/dist/server/utils/field-builder/builder.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGraphQLFieldBuilder = void 0;
+exports.resetBuiltFields = exports.createGraphQLFieldBuilder = void 0;
 const nexus_1 = require("nexus");
 const utils_1 = require("@strapi/utils");
 const immer_1 = require("immer");
 const zod_1 = require("zod");
 const graphql_extension_1 = require("../graphql-extension");
 const helpers_1 = require("./helpers");
-const registry_1 = require("../registry");
+const resolve_field_1 = require("../registry/resolve-field");
+const field_authorize_plugin_1 = require("../../nexus/plugins/field-authorize.plugin");
+const strapi_compat_1 = require("../strapi-compat");
+const loaders_1 = require("../loaders");
 /**
  * Helper to update builder state immutably using Immer.
  */
@@ -20,15 +23,6 @@ function updateState(state, updater) {
 function composeMiddlewares(resolver, middlewares) {
     return middlewares.reduceRight((next, mw) => mw(next), resolver);
 }
-/**
- * Compose all authorize functions into a single function.
- */
-async function runAuthorizes(authorizes, parent, args, ctx, info) {
-    if (!authorizes.length)
-        return true;
-    const results = await Promise.all(authorizes.map(fn => fn(parent, args, ctx, info)));
-    return results.every(Boolean);
-}
 /**
  * Wrap resolver with Zod validation if schema is provided.
  */
@@ -101,11 +95,20 @@ async function runHooks(hooks, when, ...args) {
     }
 }
 /**
- * Creates a fluent, deeply immutable builder to extend a root field in the GraphQL schema.
- * Each method returns a new builder instance with its own state.
+ * Create a field builder: the recommended way to add or replace a GraphQL field.
+ *
+ * See {@link FieldExtensionBuilder} for all methods and the execution order.
  *
- * @param rootType - Either 'Query' or 'Mutation' or any other Type to extend.
- * @param _state
+ * @param rootType - Shorthand for `.rootType(...)`. Prefer calling `.rootType()` so presets can be applied
+ *   before the type is known.
+ * @param _state - Internal; do not pass.
+ *
+ * @example
+ * export default createGraphQLFieldBuilder()
+ *   .rootType('Customer')
+ *   .fieldName('fullName')
+ *   .outputType('String')
+ *   .resolver((customer) => [customer?.firstName, customer?.lastName].filter(Boolean).join(' '))
  */
 const createGraphQLFieldBuilder = (rootType, _state) => {
     const initialState = _state !== null && _state !== void 0 ? _state : {
@@ -134,9 +137,6 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
         }
     }
     const builder = {
-        /**
-         * Set the root type to extend (e.g., 'Query', 'Mutation').
-         */
         rootType(type) {
             ensureNotBuilt(initialState);
             if (initialState.options.rootType) {
@@ -146,9 +146,6 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.options.rootType = type;
             }));
         },
-        /**
-         * Set the name of the field to add/extend.
-         */
         fieldName(name) {
             ensureNotBuilt(initialState);
             if (initialState.options.fieldName) {
@@ -158,6 +155,19 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.options.fieldName = name;
             }));
         },
+        relation(contentType, attribute, relationOptions = {}) {
+            ensureNotBuilt(initialState);
+            if (initialState.options.relation) {
+                throw new Error('Relation has already been set.');
+            }
+            if (initialState.options.fieldName && initialState.options.fieldName !== attribute) {
+                throw new Error(`Field name "${initialState.options.fieldName}" does not match relation attribute "${attribute}".`);
+            }
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.fieldName = attribute;
+                draft.options.relation = { contentType, attribute, batch: Boolean(relationOptions.batch) };
+            }));
+        },
         description(text) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
@@ -170,18 +180,12 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.options.deprecationReason = reason;
             }));
         },
-        /**
-         * Register a function to be called when the extension is initialized.
-         */
         init(fn) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
                 draft.initFunctions.push(fn);
             }));
         },
-        /**
-         * Set the resolver function for the field.
-         */
         resolver(fn) {
             ensureNotBuilt(initialState);
             if (initialState.options.resolver) {
@@ -191,19 +195,12 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.options.resolver = fn;
             }));
         },
-        /**
-         * Add a middleware function for the field.
-         */
         middleware(middleware) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
                 draft.middlewareFunctions.push(middleware);
             }));
         },
-        /**
-         * Set resolver config (policies, middlewares, etc).
-         * Only supported for Query and Mutation root types.
-         */
         resolverConfig(config) {
             ensureNotBuilt(initialState);
             const resolverConfig = typeof config === 'function' ? config() : config;
@@ -223,22 +220,16 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                     })
                 };
                 if (resolverConfig.auth !== undefined) {
-                    draft.options.auth = resolverConfig.auth;
+                    draft.options.auth = resolverConfig.auth !== false;
                 }
             }));
         },
-        /**
-         * Add SDL type definitions for the field.
-         */
         typeDefs(sdl) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
                 draft.options.typeDefs = `${draft.options.typeDefs}\n${sdl}`;
             }));
         },
-        /**
-         * Add additional Nexus types if needed.
-         */
         types(typesFn) {
             ensureNotBuilt(initialState);
             const fn = typeof typesFn === 'function' ? typesFn : () => typesFn;
@@ -246,9 +237,6 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.typeFunctions.push(fn);
             }));
         },
-        /**
-         * Set the arguments for the field.
-         */
         args(a) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
@@ -261,18 +249,12 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.options.validateArgsSchema = schema;
             }));
         },
-        /**
-         * Set the output type for the field.
-         */
         outputType(type) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
                 draft.options.outputType = type;
             }));
         },
-        /**
-         * Make authentication mandatory/optional for the field.
-         */
         withAuth(auth) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
@@ -283,9 +265,6 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 };
             }));
         },
-        /**
-         * Add additional authorization logic to the field.
-         */
         authorize(authorizeFn) {
             ensureNotBuilt(initialState);
             return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
@@ -305,7 +284,6 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
             }));
         },
         use(preset) {
-            // Just call the preset with this builder and return the result
             return preset(this);
         },
         hook(hook) {
@@ -323,10 +301,10 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
             if (!options.fieldName) {
                 throw new utils_1.errors.ApplicationError('Field name must be provided via fieldName()');
             }
-            if (!options.outputType) {
+            if (!options.outputType && !options.relation) {
                 throw new utils_1.errors.ApplicationError(`Output type must be provided for field "${options.fieldName}" via outputType()`);
             }
-            if (!options.resolver) {
+            if (!options.resolver && !options.relation) {
                 throw new utils_1.errors.ApplicationError(`Resolver function must be provided for field "${options.fieldName}" via resolver()`);
             }
             const isRootType = ['Query', 'Mutation'].includes(options.rootType);
@@ -350,25 +328,23 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
         },
         test({ parent, args, context, info, skipMiddleware = false, skipAuth = false } = {}) {
             this.validate();
-            const { options, middlewareFunctions, authorizeFunctions } = initialState;
-            // Compose middleware chain
-            let resolver = options.resolver;
-            if (!skipMiddleware && middlewareFunctions.length > 0) {
-                resolver = middlewareFunctions.reduceRight((next, mw) => mw(next), resolver);
+            const { options } = initialState;
+            if (!options.resolver) {
+                throw new utils_1.errors.ApplicationError(`test() needs a resolver; relation fields without a custom resolver need a running Strapi instance`);
             }
-            // Compose auth chain
-            const runAuth = async () => {
-                if (skipAuth || authorizeFunctions.length === 0)
-                    return true;
-                const results = await Promise.all(authorizeFunctions.map(fn => fn(parent, args, context, info)));
-                return results.every(Boolean);
-            };
+            // Same pipeline as in production: globals, withAuth, authorize, middlewares, validation, tracing, hooks
+            const pipeline = (0, resolve_field_1.resolveFieldPipeline)(options.rootType, options.fieldName, fieldExtensions(initialState));
+            const testInfo = (info !== null && info !== void 0 ? info : {
+                fieldName: options.fieldName,
+                parentType: { name: options.rootType },
+            });
+            const resolver = composeResolver(initialState, options.resolver);
+            const withMiddlewares = skipMiddleware ? resolver : composeMiddlewares(resolver, pipeline.middlewares);
             return (async () => {
-                const isAuthorized = await runAuth();
-                if (!isAuthorized) {
-                    throw new Error('Not authorized');
+                if (!skipAuth) {
+                    await (0, field_authorize_plugin_1.runAuthorization)(pipeline, parent, args, context, testInfo);
                 }
-                return resolver(parent, args, context, info);
+                return withMiddlewares(parent, args, context, testInfo);
             })();
         },
         trace(handler) {
@@ -381,59 +357,42 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                 draft.options.traceHandlers.push(handler !== null && handler !== void 0 ? handler : defaultTraceHandler);
             }));
         },
-        /**
-         * Build the extension for registration.
-         */
         build() {
-            var _a;
             ensureNotBuilt(initialState);
             this.validate();
-            const { options, initFunctions, typeFunctions, middlewareFunctions, authorizeFunctions, hooks } = initialState;
+            const { options, initFunctions, typeFunctions } = initialState;
+            registerBuiltField(options.rootType, options.fieldName);
             const isRootType = ['Query', 'Mutation'].includes(options.rootType);
-            const fieldInfo = {
-                type: options.rootType,
-                fieldName: options.fieldName,
-                tags: options.tags || []
-            };
-            // Compose all middleware and authorize functions
-            const allMiddlewares = [
-                ...(0, registry_1.getGlobalMiddlewares)(fieldInfo),
-                ...middlewareFunctions
-            ];
-            const allAuthorizes = [
-                ...(0, registry_1.getGlobalAuthorizes)(fieldInfo),
-                ...authorizeFunctions
-            ];
-            // Compose resolver pipeline
-            let resolver = options.resolver;
-            resolver = withArgValidation(resolver, options.validateArgsSchema);
-            resolver = composeMiddlewares(resolver, allMiddlewares);
-            resolver = withTracing(resolver, (_a = options.traceHandlers) !== null && _a !== void 0 ? _a : []);
+            // Authorization and middlewares (own + global + protectFields) are applied by the package's Nexus
+            // plugins when the schema is built, so they are not composed into the resolver here.
+            const extensions = fieldExtensions(initialState);
             const nexusExtension = (0, nexus_1.extendType)({
                 type: options.rootType,
                 definition(t) {
+                    var _a, _b;
                     const nexusArgs = options.args ? (0, helpers_1.parseArgs)(options.args) : {};
+                    if (options.relation) {
+                        const { contentType, attribute } = options.relation;
+                        const customResolver = (_a = options.resolver) !== null && _a !== void 0 ? _a : (options.relation.batch ? batchedRelationResolver(options.relation) : undefined);
+                        for (const spec of (0, strapi_compat_1.relationFieldSpecs)(contentType, attribute, customResolver)) {
+                            t.field(spec.name, {
+                                type: spec.type,
+                                args: { ...((_b = spec.args) !== null && _b !== void 0 ? _b : {}), ...nexusArgs },
+                                description: options.description,
+                                deprecation: options.deprecationReason,
+                                extensions: extensions,
+                                resolve: composeResolver(initialState, spec.resolve)
+                            });
+                        }
+                        return;
+                    }
                     t.field(options.fieldName, {
                         type: options.outputType,
                         args: nexusArgs,
                         description: options.description,
                         deprecation: options.deprecationReason,
-                        extensions: {
-                            middlewares: [
-                                ...(options.auth ? [(0, helpers_1.makeAuthMiddleware)()] : []),
-                                ...allMiddlewares
-                            ],
-                            // @ts-ignore
-                            authorize: async (parent, args, ctx, info) => {
-                                return runAuthorizes(allAuthorizes, parent, args, ctx, info);
-                            },
-                        },
-                        async resolve(parent, args, context, info) {
-                            await runHooks(hooks, 'beforeResolve', parent, args, context, info);
-                            const result = await resolver(parent, args, context, info);
-                            await runHooks(hooks, 'afterResolve', result, parent, args, context, info);
-                            return result;
-                        }
+                        extensions: extensions,
+                        resolve: composeResolver(initialState, options.resolver)
                     });
                 }
             });
@@ -448,19 +407,102 @@ const createGraphQLFieldBuilder = (rootType, _state) => {
                     nexusExtension,
                     ...typeFunctions.flatMap((fn) => fn())
                 ],
-                resolversConfig: isRootType
-                    ? () => ({
-                        [options.rootType]: {
-                            [options.fieldName]: options.resolverConfig || {}
-                        }
-                    })
-                    : undefined
+                resolversConfig: () => ({
+                    // Keep Strapi's `<target>.find` permission scope on (re)defined relation fields
+                    ...(options.relation
+                        ? (0, strapi_compat_1.relationResolversConfig)(options.relation.contentType, options.relation.attribute)
+                        : {}),
+                    ...(isRootType
+                        ? { [options.rootType]: { [options.fieldName]: options.resolverConfig || {} } }
+                        : {})
+                })
             }));
         }
     };
+    // The implementation is untyped internally; the public generics are enforced by the interface
     return Object.freeze(builder);
 };
 exports.createGraphQLFieldBuilder = createGraphQLFieldBuilder;
+const builtFields = new Set();
+/**
+ * Warn when two builders define the same `Type.field`: only one of them ends up in the schema, which is
+ * almost always a mistake (e.g. a copied file). Replacing a field Strapi generates is not reported.
+ */
+function registerBuiltField(type, fieldName) {
+    var _a, _b, _c;
+    const key = `${type}.${fieldName}`;
+    if (builtFields.has(key)) {
+        const warn = (_c = (_b = (_a = globalThis.strapi) === null || _a === void 0 ? void 0 : _a.log) === null || _b === void 0 ? void 0 : _b.warn) !== null && _c !== void 0 ? _c : console.warn;
+        warn(`[buro26-strapi-graphql] Field "${key}" is defined by more than one field builder; only one definition is used.`);
+    }
+    builtFields.add(key);
+}
+/** @internal Only for tests. */
+function resetBuiltFields() {
+    builtFields.clear();
+}
+exports.resetBuiltFields = resetBuiltFields;
+/**
+ * Field extensions read by the Nexus authorize/middleware plugins.
+ */
+function fieldExtensions(state) {
+    var _a;
+    const { options, authorizeFunctions, middlewareFunctions } = state;
+    return {
+        ...(authorizeFunctions.length > 0 && {
+            authorize: async (parent, args, ctx, info) => {
+                for (const authorize of authorizeFunctions) {
+                    const result = await authorize(parent, args, ctx, info);
+                    if (result !== true)
+                        return result instanceof Error ? result : false;
+                }
+                return true;
+            }
+        }),
+        middlewares: [...middlewareFunctions],
+        builder: {
+            tags: [...((_a = options.tags) !== null && _a !== void 0 ? _a : [])],
+            requireAuth: Boolean(options.auth)
+        }
+    };
+}
+/**
+ * The resolver as executed inside the middlewares: argument validation, hooks and tracing.
+ */
+function composeResolver(state, baseResolver) {
+    var _a;
+    const { options, hooks } = state;
+    const validated = withArgValidation(baseResolver, options.validateArgsSchema);
+    const withHooks = async (parent, args, context, info) => {
+        await runHooks(hooks, 'beforeResolve', parent, args, context, info);
+        const result = await validated(parent, args, context, info);
+        await runHooks(hooks, 'afterResolve', result, parent, args, context, info);
+        return result;
+    };
+    return withTracing(withHooks, (_a = options.traceHandlers) !== null && _a !== void 0 ? _a : []);
+}
+/**
+ * Resolver for `.relation(..., { batch: true })`: loads the related entity of all parents in the request
+ * with one query, sanitizes it like Strapi does and returns the shape the relation field expects.
+ */
+function batchedRelationResolver({ contentType, attribute }) {
+    var _a, _b;
+    const attr = (_b = (_a = strapi.getModel(contentType)) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b[attribute];
+    if (!attr || attr.type !== 'relation') {
+        throw new utils_1.errors.ApplicationError(`"${contentType}.${attribute}" is not a relation`);
+    }
+    if (String(attr.relation).endsWith('Many')) {
+        throw new utils_1.errors.ApplicationError(`relation(..., { batch: true }) is only supported for to-one relations ("${contentType}.${attribute}" is to-many)`);
+    }
+    // Returns Strapi's response wrapper (`{ value, info }`), like `buildAssociationResolver`; the relation
+    // field spec unwraps it on Strapi v5.
+    const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+    return async (parent, _args, context) => {
+        const related = (parent === null || parent === void 0 ? void 0 : parent.id) ? await (0, loaders_1.loaders)(context).relation(contentType, attribute).load(parent.id) : null;
+        const sanitized = related ? await (0, strapi_compat_1.sanitizeOutput)(related, attr.target, context) : null;
+        return toEntityResponse(sanitized, { args: {}, resourceUID: attr.target });
+    };
+}
 function defaultTraceHandler({ type, fieldName, durationMs, args, error }) {
     // Colors
     const green = '\x1b[32m';

package/dist/server/utils/field-builder/helpers.d.ts

@@ -1,19 +1,34 @@
 import type { FieldExtensionBuilder, FieldGroupPreset, GraphQLFieldPreset } from './types';
 import type { Middleware } from '../../nexus';
 /**
- * Parse argument definitions into Nexus-compatible args.
+ * Middleware that throws a `ForbiddenError` ("Not authenticated") when there is no `ctx.state.user`.
+ *
+ * @deprecated Use `.withAuth(true)` on the field builder; it is checked before authorization runs.
  */
-export declare function parseArgs(args: Record<string, string | unknown>): Record<string, unknown>;
+export declare function makeAuthMiddleware(): Middleware;
 /**
- * Middleware that throws if the user is not authenticated.
+ * Define a reusable preset for `.use()`. Identity function that exists for typing and readability.
+ *
+ * @example
+ * export const adminOnly = createGraphQLFieldPreset((builder) =>
+ *   builder.withAuth(true).authorize((_p, _a, ctx) => ctx.state.user?.role?.type === 'admin')
+ * )
+ *
+ * createGraphQLFieldBuilder().use(adminOnly).rootType('Query') // ...
  */
-export declare function makeAuthMiddleware(): Middleware;
 export declare function createGraphQLFieldPreset(preset: GraphQLFieldPreset): GraphQLFieldPreset;
 /**
- * Combine multiple field builders into a single GraphQL extension.
+ * Export several fields from one file. Builds each builder and returns the extensions.
+ *
+ * @example
+ * export default registerFields(fieldA, fieldB)
  */
 export declare function registerFields(...fields: FieldExtensionBuilder[]): import("../..").GraphQLExtension[];
 /**
- * Apply one or more presets to a group of fields.
+ * Apply presets to every field in a group (e.g. one auth rule for all fields of a feature).
+ * Presets are applied in order. Returns unbuilt builders; export them with {@link registerFields}.
+ *
+ * @example
+ * export default registerFields(...createFieldGroup([fieldA, fieldB], requireUser))
  */
 export declare function createFieldGroup(fields: FieldExtensionBuilder[], ...presets: FieldGroupPreset[]): FieldExtensionBuilder[];