buro26-strapi-graphql 0.0.26 → 0.2.0

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

@@ -0,0 +1,33 @@
+import type { FieldExtensionBuilder, FieldExtensionOptions, GraphQLFieldHook } from './types';
+import type { ResolverFunction } from '../../types';
+import type { Middleware } from '../../nexus';
+/**
+ * Internal state for the builder.
+ */
+type BuilderState<Type = any, TArgs = any, TOutput = any> = {
+    options: FieldExtensionOptions<Type, TArgs, TOutput>;
+    initFunctions: Array<() => void>;
+    typeFunctions: Array<() => unknown[]>;
+    middlewareFunctions: Middleware[];
+    authorizeFunctions: ResolverFunction<Partial<Type> | null, TArgs, boolean>[];
+    hooks: GraphQLFieldHook[];
+    built: boolean;
+};
+/**
+ * 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 - 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

@@ -0,0 +1,552 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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.
+ */
+function updateState(state, updater) {
+    return (0, immer_1.produce)(state, updater);
+}
+/**
+ * Compose all middleware functions into a single resolver.
+ */
+function composeMiddlewares(resolver, middlewares) {
+    return middlewares.reduceRight((next, mw) => mw(next), resolver);
+}
+/**
+ * Wrap resolver with Zod validation if schema is provided.
+ */
+function withArgValidation(resolver, schema) {
+    if (!schema)
+        return resolver;
+    return async (parent, args, ctx, info) => {
+        try {
+            const parsedArgs = schema.parse(args);
+            return resolver(parent, parsedArgs, ctx, info);
+        }
+        catch (err) {
+            if (err instanceof zod_1.ZodError) {
+                throw new utils_1.errors.ValidationError('Invalid arguments', { cause: err });
+            }
+            throw err;
+        }
+    };
+}
+/**
+ * Wrap resolver with tracing handlers.
+ */
+function withTracing(resolver, traceHandlers) {
+    if (!traceHandlers.length)
+        return resolver;
+    return async (parent, args, ctx, info) => {
+        const start = Date.now();
+        let result, error;
+        try {
+            result = await resolver(parent, args, ctx, info);
+            return result;
+        }
+        catch (err) {
+            error = err;
+            throw err;
+        }
+        finally {
+            const durationMs = Date.now() - start;
+            for (const handler of traceHandlers) {
+                Promise.resolve()
+                    .then(() => {
+                    var _a;
+                    return handler({
+                        type: (_a = info === null || info === void 0 ? void 0 : info.parentType) === null || _a === void 0 ? void 0 : _a.name,
+                        fieldName: info === null || info === void 0 ? void 0 : info.fieldName,
+                        durationMs,
+                        args,
+                        context: ctx,
+                        result,
+                        error
+                    });
+                })
+                    .catch((err) => {
+                    // Swallow errors in trace handlers
+                    console.error('[TRACE HANDLER ERROR]', err);
+                });
+            }
+        }
+    };
+}
+/**
+ * Run before/after resolve hooks.
+ */
+async function runHooks(hooks, when, ...args) {
+    for (const hook of hooks) {
+        if (hook[when]) {
+            // @ts-ignore
+            await hook[when](...args);
+        }
+    }
+}
+/**
+ * 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 - 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 : {
+        options: {
+            rootType: rootType !== null && rootType !== void 0 ? rootType : '',
+            fieldName: undefined,
+            resolver: undefined,
+            resolverConfig: { policies: [], middlewares: [] },
+            typeDefs: '',
+            types: () => [],
+            args: {},
+            outputType: undefined,
+            tags: [],
+            traceHandlers: []
+        },
+        initFunctions: [],
+        typeFunctions: [],
+        middlewareFunctions: [],
+        authorizeFunctions: [],
+        hooks: [],
+        built: false
+    };
+    function ensureNotBuilt(state) {
+        if (state.built) {
+            throw new utils_1.errors.ApplicationError('Builder has already been built.');
+        }
+    }
+    const builder = {
+        rootType(type) {
+            ensureNotBuilt(initialState);
+            if (initialState.options.rootType) {
+                throw new Error('Root type has already been set.');
+            }
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.rootType = type;
+            }));
+        },
+        fieldName(name) {
+            ensureNotBuilt(initialState);
+            if (initialState.options.fieldName) {
+                throw new Error('Field name has already been set.');
+            }
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                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) => {
+                draft.options.description = text;
+            }));
+        },
+        deprecate(reason) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.deprecationReason = reason;
+            }));
+        },
+        init(fn) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.initFunctions.push(fn);
+            }));
+        },
+        resolver(fn) {
+            ensureNotBuilt(initialState);
+            if (initialState.options.resolver) {
+                throw new Error('Resolver function has already been set.');
+            }
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.resolver = fn;
+            }));
+        },
+        middleware(middleware) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.middlewareFunctions.push(middleware);
+            }));
+        },
+        resolverConfig(config) {
+            ensureNotBuilt(initialState);
+            const resolverConfig = typeof config === 'function' ? config() : config;
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                var _a, _b;
+                draft.options.resolverConfig = {
+                    policies: [
+                        ...(((_a = draft.options.resolverConfig) === null || _a === void 0 ? void 0 : _a.policies) || []),
+                        ...(resolverConfig.policies || [])
+                    ],
+                    middlewares: [
+                        ...(((_b = draft.options.resolverConfig) === null || _b === void 0 ? void 0 : _b.middlewares) || []),
+                        ...(resolverConfig.middlewares || [])
+                    ],
+                    ...(resolverConfig.auth !== undefined && {
+                        auth: resolverConfig.auth
+                    })
+                };
+                if (resolverConfig.auth !== undefined) {
+                    draft.options.auth = resolverConfig.auth !== false;
+                }
+            }));
+        },
+        typeDefs(sdl) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.typeDefs = `${draft.options.typeDefs}\n${sdl}`;
+            }));
+        },
+        types(typesFn) {
+            ensureNotBuilt(initialState);
+            const fn = typeof typesFn === 'function' ? typesFn : () => typesFn;
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.typeFunctions.push(fn);
+            }));
+        },
+        args(a) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.args = a;
+            }));
+        },
+        validateArgs(schema) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.validateArgsSchema = schema;
+            }));
+        },
+        outputType(type) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.outputType = type;
+            }));
+        },
+        withAuth(auth) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.auth = auth;
+                draft.options.resolverConfig = {
+                    ...draft.options.resolverConfig,
+                    auth
+                };
+            }));
+        },
+        authorize(authorizeFn) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.authorizeFunctions.push(authorizeFn);
+            }));
+        },
+        tag(tag) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.tags = [...(draft.options.tags || []), tag];
+            }));
+        },
+        tags(tags) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.options.tags = [...(draft.options.tags || []), ...tags];
+            }));
+        },
+        use(preset) {
+            return preset(this);
+        },
+        hook(hook) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                draft.hooks.push(hook);
+            }));
+        },
+        validate() {
+            var _a, _b, _c, _d;
+            const { options } = initialState;
+            if (!options.rootType) {
+                throw new utils_1.errors.ApplicationError('Root type must be provided via rootType()');
+            }
+            if (!options.fieldName) {
+                throw new utils_1.errors.ApplicationError('Field name must be provided via fieldName()');
+            }
+            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 && !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);
+            if (!isRootType &&
+                (!!((_b = (_a = options.resolverConfig) === null || _a === void 0 ? void 0 : _a.middlewares) === null || _b === void 0 ? void 0 : _b.length) ||
+                    !!((_d = (_c = options.resolverConfig) === null || _c === void 0 ? void 0 : _c.policies) === null || _d === void 0 ? void 0 : _d.length))) {
+                throw new utils_1.errors.ApplicationError(`Resolver config is only supported for Query and Mutation root types.`);
+            }
+        },
+        describe() {
+            // Return a snapshot of the current config for debugging/docs
+            const { options, initFunctions, typeFunctions, middlewareFunctions, authorizeFunctions, hooks } = initialState;
+            return {
+                options,
+                initFunctions: initFunctions.map(fn => fn.name || 'anonymous'),
+                typeFunctions: typeFunctions.length,
+                middlewareFunctions: middlewareFunctions.length,
+                authorizeFunctions: authorizeFunctions.length,
+                hooks: hooks.length
+            };
+        },
+        test({ parent, args, context, info, skipMiddleware = false, skipAuth = false } = {}) {
+            this.validate();
+            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`);
+            }
+            // 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 () => {
+                if (!skipAuth) {
+                    await (0, field_authorize_plugin_1.runAuthorization)(pipeline, parent, args, context, testInfo);
+                }
+                return withMiddlewares(parent, args, context, testInfo);
+            })();
+        },
+        trace(handler) {
+            ensureNotBuilt(initialState);
+            return (0, exports.createGraphQLFieldBuilder)(undefined, updateState(initialState, (draft) => {
+                if (!draft.options.traceHandlers) {
+                    draft.options.traceHandlers = [];
+                }
+                // If no handler is provided, use the default
+                draft.options.traceHandlers.push(handler !== null && handler !== void 0 ? handler : defaultTraceHandler);
+            }));
+        },
+        build() {
+            ensureNotBuilt(initialState);
+            this.validate();
+            const { options, initFunctions, typeFunctions } = initialState;
+            registerBuiltField(options.rootType, options.fieldName);
+            const isRootType = ['Query', 'Mutation'].includes(options.rootType);
+            // 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: extensions,
+                        resolve: composeResolver(initialState, options.resolver)
+                    });
+                }
+            });
+            return (0, graphql_extension_1.createGraphQLExtension)((_) => ({
+                init: () => {
+                    for (const initFn of initFunctions) {
+                        initFn();
+                    }
+                },
+                typeDefs: () => options.typeDefs || '',
+                types: () => [
+                    nexusExtension,
+                    ...typeFunctions.flatMap((fn) => fn())
+                ],
+                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';
+    const yellow = '\x1b[33m';
+    const red = '\x1b[31m';
+    const cyan = '\x1b[36m';
+    const reset = '\x1b[0m';
+    // Status
+    const status = error ? `${red}❌ ERROR${reset}` : `${green}✅ OK${reset}`;
+    // Timing color
+    let timingColor = green;
+    if (durationMs > 1000)
+        timingColor = red;
+    else if (durationMs > 300)
+        timingColor = yellow;
+    // Args preview, with proper table formatting for multi-line
+    let argsPreview = '';
+    try {
+        argsPreview = JSON.stringify(args, null, 2);
+        if (argsPreview.length > 120)
+            argsPreview = argsPreview.slice(0, 117) + '...';
+    }
+    catch {
+        argsPreview = '[unserializable]';
+    }
+    const argsLines = argsPreview.split('\n');
+    const argsTableLines = argsLines.map((line, idx) => idx === 0
+        ? `${cyan}│${reset} ${'Args:'.padEnd(12)}${line}`
+        : `${cyan}│${reset} ${' '.repeat(12)}${line}`);
+    // Table-style output
+    const lines = [
+        `${cyan}┌─────────────────────────────[GraphQL Field Trace]─────────────────────────────┐${reset}`,
+        `${cyan}│${reset} ${'Type:'.padEnd(12)}${type}`,
+        `${cyan}│${reset} ${'Field:'.padEnd(12)}${fieldName}`,
+        `${cyan}│${reset} ${'Status:'.padEnd(12)}${status}`,
+        `${cyan}│${reset} ${'Duration:'.padEnd(12)}${timingColor}${durationMs}ms${reset}`,
+        ...argsTableLines,
+        `${cyan}└───────────────────────────────────────────────────────────────────────────────┘${reset}`
+    ];
+    if (error) {
+        lines.push(`${red}[Trace Error]${reset} ${error instanceof Error ? error.stack : error}`);
+        console.error(lines.join('\n'));
+    }
+    else {
+        console.log(lines.join('\n'));
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { FieldExtensionBuilder, FieldGroupPreset, GraphQLFieldPreset } from './types';
+import type { Middleware } from '../../nexus';
+/**
+ * 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 makeAuthMiddleware(): Middleware;
+/**
+ * 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 createGraphQLFieldPreset(preset: GraphQLFieldPreset): GraphQLFieldPreset;
+/**
+ * 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 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[];