buro26-strapi-graphql 0.0.26 → 0.2.0

package/dist/server/utils/index.d.ts

@@ -3,7 +3,9 @@ export * from './single-type';
 export * from './collection-type';
 export * from './field-builder';
 export * from './graphql-extension';
-export * from './middleware';
 export * from './misc';
+export * from './registry';
 export * from './override';
 export * from './shadow-crud';
+export * from './loaders';
+export { isStrapiV5, isV4CompatibilityMode, typeNameOf, uidOfTypeName, relationFieldSpecs, relationResolversConfig, sanitizeOutput, toRelationValue, } from './strapi-compat';

package/dist/server/utils/index.js

@@ -14,12 +14,23 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRelationValue = exports.sanitizeOutput = exports.relationResolversConfig = exports.relationFieldSpecs = exports.uidOfTypeName = exports.typeNameOf = exports.isV4CompatibilityMode = exports.isStrapiV5 = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./single-type"), exports);
 __exportStar(require("./collection-type"), exports);
 __exportStar(require("./field-builder"), exports);
 __exportStar(require("./graphql-extension"), exports);
-__exportStar(require("./middleware"), exports);
 __exportStar(require("./misc"), exports);
+__exportStar(require("./registry"), exports);
 __exportStar(require("./override"), exports);
 __exportStar(require("./shadow-crud"), exports);
+__exportStar(require("./loaders"), exports);
+var strapi_compat_1 = require("./strapi-compat");
+Object.defineProperty(exports, "isStrapiV5", { enumerable: true, get: function () { return strapi_compat_1.isStrapiV5; } });
+Object.defineProperty(exports, "isV4CompatibilityMode", { enumerable: true, get: function () { return strapi_compat_1.isV4CompatibilityMode; } });
+Object.defineProperty(exports, "typeNameOf", { enumerable: true, get: function () { return strapi_compat_1.typeNameOf; } });
+Object.defineProperty(exports, "uidOfTypeName", { enumerable: true, get: function () { return strapi_compat_1.uidOfTypeName; } });
+Object.defineProperty(exports, "relationFieldSpecs", { enumerable: true, get: function () { return strapi_compat_1.relationFieldSpecs; } });
+Object.defineProperty(exports, "relationResolversConfig", { enumerable: true, get: function () { return strapi_compat_1.relationResolversConfig; } });
+Object.defineProperty(exports, "sanitizeOutput", { enumerable: true, get: function () { return strapi_compat_1.sanitizeOutput; } });
+Object.defineProperty(exports, "toRelationValue", { enumerable: true, get: function () { return strapi_compat_1.toRelationValue; } });

package/dist/server/utils/loaders.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Per-request batching and caching for GraphQL resolvers (DataLoader-style, without the dependency).
+ *
+ * Loads requested in the same tick are combined into one batch call; results are cached for the rest
+ * of the request. The cache lives on the GraphQL context object, which Strapi creates per request in
+ * both v4 and v5, so nothing leaks between requests or users.
+ */
+type AnyRecord = Record<string, any>;
+/**
+ * Loads values for many keys at once. Must return one result per key, **in the same order**; return an
+ * `Error` at a position to reject only that key.
+ */
+export type BatchFunction<K, V> = (keys: readonly K[]) => Promise<ReadonlyArray<V | Error>>;
+/**
+ * A batching, caching loader created by {@link createLoader} or {@link loaders}.
+ */
+export interface Loader<K, V> {
+    /** Load one key. Calls in the same tick are batched; repeated keys come from the cache. */
+    load(key: K): Promise<V>;
+    /** Load several keys; rejects if any key fails. */
+    loadMany(keys: readonly K[]): Promise<V[]>;
+    /** Remove a key from the cache, e.g. after a mutation changed it. */
+    clear(key: K): void;
+    /** Put a known value in the cache. Does nothing when the key is already cached. */
+    prime(key: K, value: V): void;
+}
+/**
+ * Create a batching loader. Keys are compared by `String(key)`, so `1` and `'1'` share a cache entry.
+ * Failed batches are not cached, so a later `load` retries.
+ *
+ * Usually you want {@link loaders}, which scopes loaders to the request; a loader created with this
+ * function caches for as long as you keep it.
+ *
+ * @param batch - See {@link BatchFunction}.
+ * @param options.maxBatchSize - Larger batches are split into several calls. @default 500
+ * @throws Error (per key) when `batch` returns a different number of results than keys.
+ */
+export declare function createLoader<K, V>(batch: BatchFunction<K, V>, { maxBatchSize }?: {
+    maxBatchSize?: number;
+}): Loader<K, V>;
+/**
+ * Options for {@link RequestLoaders.entity}. Loaders with different options are cached separately.
+ */
+export type EntityLoaderOptions = {
+    /** Columns to select (default: all) */
+    select?: string[];
+    /** Strapi query engine populate */
+    populate?: AnyRecord | string[] | true;
+    /**
+     * Only for draft & publish content types: which version to load. Ignored for other content types.
+     * @default 'published'
+     */
+    status?: 'published' | 'draft';
+};
+/**
+ * Loaders scoped to one GraphQL request, returned by {@link loaders}.
+ */
+export interface RequestLoaders {
+    /**
+     * Load entities of a content type by database id, batched into one `findMany` per tick.
+     * Resolves to `null` for ids that do not exist.
+     *
+     * Returns raw database rows (including private fields): sanitize before returning them to clients,
+     * see {@link sanitizeOutput}.
+     */
+    entity<T = AnyRecord>(uid: string, options?: EntityLoaderOptions): Loader<number | string, T | null>;
+    /**
+     * Load a relation of many parents with one query on the parent content type.
+     * Resolves to the related entity or `null` (to-one), or an array (to-many), as raw database rows.
+     *
+     * @throws Error when `attribute` is not a relation of `uid`.
+     */
+    relation<T = AnyRecord>(uid: string, attribute: string, options?: Omit<EntityLoaderOptions, 'select'>): Loader<number | string, T>;
+    /**
+     * A loader with your own batch function, e.g. for an external API. Cached per request under `name`:
+     * the first call's `batch` function is used for the rest of the request.
+     */
+    custom<K, V>(name: string, batch: BatchFunction<K, V>): Loader<K, V>;
+}
+/**
+ * Loaders scoped to the current GraphQL request.
+ *
+ * Uses `strapi.db.query()` (same API in v4 and v5). That is the query engine, not the entity/document
+ * service: lifecycle-free and unsanitized, so it is meant for reading data inside resolvers.
+ *
+ * @param context - The resolver's third argument (`ctx`).
+ * @throws Error when `context` is not an object.
+ *
+ * @example
+ * const order = await loaders(ctx).entity(ORDER, { populate: { customer: true } }).load(parent.id)
+ * const customer = await loaders(ctx).relation(ORDER, 'customer').load(parent.id)
+ */
+export declare function loaders(context: object): RequestLoaders;
+export {};

package/dist/server/utils/loaders.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Per-request batching and caching for GraphQL resolvers (DataLoader-style, without the dependency).
+ *
+ * Loads requested in the same tick are combined into one batch call; results are cached for the rest
+ * of the request. The cache lives on the GraphQL context object, which Strapi creates per request in
+ * both v4 and v5, so nothing leaks between requests or users.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loaders = exports.createLoader = void 0;
+/**
+ * Create a batching loader. Keys are compared by `String(key)`, so `1` and `'1'` share a cache entry.
+ * Failed batches are not cached, so a later `load` retries.
+ *
+ * Usually you want {@link loaders}, which scopes loaders to the request; a loader created with this
+ * function caches for as long as you keep it.
+ *
+ * @param batch - See {@link BatchFunction}.
+ * @param options.maxBatchSize - Larger batches are split into several calls. @default 500
+ * @throws Error (per key) when `batch` returns a different number of results than keys.
+ */
+function createLoader(batch, { maxBatchSize = 500 } = {}) {
+    const cache = new Map();
+    let queue = [];
+    let scheduled = false;
+    const dispatch = async () => {
+        scheduled = false;
+        const current = queue;
+        queue = [];
+        for (let i = 0; i < current.length; i += maxBatchSize) {
+            const chunk = current.slice(i, i + maxBatchSize);
+            try {
+                const results = await batch(chunk.map((item) => item.key));
+                if (results.length !== chunk.length) {
+                    throw new Error(`[buro26-strapi-graphql] Batch function returned ${results.length} results for ${chunk.length} keys`);
+                }
+                chunk.forEach((item, index) => {
+                    const result = results[index];
+                    if (result instanceof Error)
+                        item.reject(result);
+                    else
+                        item.resolve(result);
+                });
+            }
+            catch (error) {
+                chunk.forEach((item) => {
+                    cache.delete(String(item.key));
+                    item.reject(error);
+                });
+            }
+        }
+    };
+    const loader = {
+        load(key) {
+            const cacheKey = String(key);
+            const cached = cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const promise = new Promise((resolve, reject) => {
+                queue.push({ key, resolve, reject });
+                if (!scheduled) {
+                    scheduled = true;
+                    // Wait until all resolvers of the current tick have asked for their keys
+                    process.nextTick(() => {
+                        void dispatch();
+                    });
+                }
+            });
+            cache.set(cacheKey, promise);
+            return promise;
+        },
+        loadMany(keys) {
+            return Promise.all(keys.map((key) => loader.load(key)));
+        },
+        clear(key) {
+            cache.delete(String(key));
+        },
+        prime(key, value) {
+            const cacheKey = String(key);
+            if (!cache.has(cacheKey))
+                cache.set(cacheKey, Promise.resolve(value));
+        },
+    };
+    return loader;
+}
+exports.createLoader = createLoader;
+const requestLoaders = new WeakMap();
+const hasDraftAndPublish = (uid) => { var _a, _b; return Boolean((_b = (_a = strapi.getModel(uid)) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.draftAndPublish); };
+const statusWhere = (uid, status) => {
+    if (!hasDraftAndPublish(uid))
+        return {};
+    return { publishedAt: (status !== null && status !== void 0 ? status : 'published') === 'published' ? { $notNull: true } : { $null: true } };
+};
+/**
+ * Loaders scoped to the current GraphQL request.
+ *
+ * Uses `strapi.db.query()` (same API in v4 and v5). That is the query engine, not the entity/document
+ * service: lifecycle-free and unsanitized, so it is meant for reading data inside resolvers.
+ *
+ * @param context - The resolver's third argument (`ctx`).
+ * @throws Error when `context` is not an object.
+ *
+ * @example
+ * const order = await loaders(ctx).entity(ORDER, { populate: { customer: true } }).load(parent.id)
+ * const customer = await loaders(ctx).relation(ORDER, 'customer').load(parent.id)
+ */
+function loaders(context) {
+    if (!context || typeof context !== 'object') {
+        throw new Error('[buro26-strapi-graphql] loaders(context) needs the GraphQL resolver context');
+    }
+    let registry = requestLoaders.get(context);
+    if (!registry) {
+        registry = new Map();
+        requestLoaders.set(context, registry);
+    }
+    const getOrCreate = (key, create) => {
+        let loader = registry.get(key);
+        if (!loader) {
+            loader = create();
+            registry.set(key, loader);
+        }
+        return loader;
+    };
+    return {
+        entity(uid, options = {}) {
+            return getOrCreate(`entity:${uid}:${JSON.stringify(options)}`, () => createLoader(async (ids) => {
+                const select = options.select ? Array.from(new Set(['id', ...options.select])) : undefined;
+                const rows = await strapi.db.query(uid).findMany({
+                    where: { id: { $in: ids }, ...statusWhere(uid, options.status) },
+                    ...(select && { select }),
+                    ...(options.populate && { populate: options.populate }),
+                });
+                const byId = new Map(rows.map((row) => [String(row.id), row]));
+                return ids.map((id) => { var _a; return (_a = byId.get(String(id))) !== null && _a !== void 0 ? _a : null; });
+            }));
+        },
+        relation(uid, attribute, options = {}) {
+            return getOrCreate(`relation:${uid}:${attribute}:${JSON.stringify(options)}`, () => createLoader(async (ids) => {
+                var _a, _b;
+                const attr = (_b = (_a = strapi.getModel(uid)) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b[attribute];
+                if (!attr || attr.type !== 'relation') {
+                    throw new Error(`[buro26-strapi-graphql] "${uid}.${attribute}" is not a relation`);
+                }
+                const isToMany = String(attr.relation).endsWith('Many');
+                const rows = await strapi.db.query(uid).findMany({
+                    where: { id: { $in: ids } },
+                    select: ['id'],
+                    populate: {
+                        [attribute]: {
+                            ...(options.populate && typeof options.populate === 'object' && !Array.isArray(options.populate)
+                                ? { populate: options.populate }
+                                : {}),
+                            ...(hasDraftAndPublish(attr.target) && { where: statusWhere(attr.target, options.status) }),
+                        },
+                    },
+                });
+                const byId = new Map(rows.map((row) => [String(row.id), row[attribute]]));
+                return ids.map((id) => { var _a; return (_a = byId.get(String(id))) !== null && _a !== void 0 ? _a : (isToMany ? [] : null); });
+            }));
+        },
+        custom(name, batch) {
+            return getOrCreate(`custom:${name}`, () => createLoader(batch));
+        },
+    };
+}
+exports.loaders = loaders;

package/dist/server/utils/misc.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Convert GraphQL arguments (filters, pagination, sort) into Strapi query parameters, using the GraphQL
+ * plugin's own transformer.
+ *
+ * @param options.usePagination - Translate `pagination` into `start`/`limit`. @default true
+ */
 export declare function transformArgs(args: Record<string, any>, { contentType, usePagination }: {
     contentType: string;
     usePagination?: boolean;

package/dist/server/utils/misc.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformArgs = void 0;
+/**
+ * Convert GraphQL arguments (filters, pagination, sort) into Strapi query parameters, using the GraphQL
+ * plugin's own transformer.
+ *
+ * @param options.usePagination - Translate `pagination` into `start`/`limit`. @default true
+ */
 function transformArgs(args, { contentType, usePagination }) {
     const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
     return transformArgs(args, {

package/dist/server/utils/override.d.ts

@@ -5,16 +5,49 @@
  */
 import type { GraphQLResolveInfo } from 'graphql';
 import type { ResolveContext } from './types';
-import type { Middleware } from './middleware';
+import type { Middleware } from '../nexus';
+/**
+ * Options for {@link overrideField}.
+ */
 type OverrideFieldOptions<Type extends Object, Args = unknown, Context = ResolveContext, Info = GraphQLResolveInfo> = {
+    /** Content type UID the field belongs to */
     contentTypeName: string;
+    /** Attribute name to (re)define */
     fieldName: keyof Type;
+    /** Override the GraphQL output type. Defaults to the type Strapi generates. */
     type?: string;
+    /**
+     * Authorization check; return `true` to allow.
+     * Same as `extensions.authorize` (which wins when both are set).
+     */
     authorize?: (parent: Type, args: Args, context: Context, info: Info) => boolean | Promise<boolean>;
+    /** Replace the resolver. Defaults to Strapi's resolver for the attribute. */
     resolve?: (parent: Type, args: Args, context: Context, info: Info) => unknown;
     extensions?: {
         middlewares?: Middleware[];
+        authorize?: (parent: Type, args: Args, context: Context, info: Info) => boolean | Promise<boolean>;
     };
 };
+/**
+ * Redefine a field Strapi generates for a content type attribute, inside a Nexus `extendType`, with the
+ * same type, arguments and resolver as Strapi uses (v4 and v5), plus your own `authorize`, `resolve` or
+ * middlewares.
+ *
+ * Private attributes and attributes disabled for output via shadow CRUD are skipped.
+ *
+ * @param t - The Nexus definition block (`definition(t)`).
+ * @throws Error when the attribute does not exist on the content type.
+ *
+ * @remarks To only restrict access use {@link protectFields}; for relations prefer
+ *   {@link FieldExtensionBuilder.relation}. Both work without an extension and without redefining fields.
+ *
+ * @example
+ * extendType({
+ *   type: 'Article',
+ *   definition(t) {
+ *     overrideField(t, { contentTypeName: ARTICLE, fieldName: 'titel', resolve: (plan) => plan.titel ?? '' })
+ *   },
+ * })
+ */
 export declare const overrideField: <T extends Object>(t: any, overrideOptions: OverrideFieldOptions<T, unknown, ResolveContext, GraphQLResolveInfo>) => void;
 export {};

package/dist/server/utils/override.js

@@ -6,6 +6,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.overrideField = void 0;
+const strapi_compat_1 = require("./strapi-compat");
 const fp_1 = require("lodash/fp");
 const utils_1 = require("@strapi/utils");
 const getGraphQLService = (name) => strapi.plugin('graphql').service(name);
@@ -142,35 +143,27 @@ const addPolymorphicRelationalAttribute = (options) => {
     }
 };
 /**
- * Add a regular relational attribute to the type definition
+ * Add a regular relational attribute to the type definition.
+ *
+ * Uses the same field specs as Strapi itself (see `relationFieldSpecs`), so this works for both
+ * Strapi v4 (entity response types) and v5 (unwrapped types + `<field>_connection`).
  */
 const addRegularRelationalAttribute = (options) => {
-    const { naming } = getGraphQLService('utils');
-    const { getContentTypeArgs } = getGraphQLService('builders').utils;
-    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
     const extension = getGraphQLService('extension');
-    const { builder } = options;
-    const { attributeName, attribute, contentType } = options;
+    const { builder, attributeName, attribute, contentType, resolve, extensions } = options;
+    // @ts-ignore
     if (extension.shadowCRUD(attribute.target).isDisabled()) {
         return;
     }
-    // @ts-ignore
-    const isToManyRelation = attribute.relation.endsWith('Many');
-    const resolve = buildAssociationResolver({
-        contentTypeUID: contentType.uid,
-        attributeName,
-        strapi,
-    });
-    // @ts-ignore
-    const targetContentType = strapi.getModel(attribute.target);
-    const type = isToManyRelation
-        ? naming.getRelationResponseCollectionName(targetContentType)
-        : naming.getEntityResponseName(targetContentType);
-    const args = isToManyRelation ? getContentTypeArgs(targetContentType) : undefined;
-    const resolverPath = `${naming.getTypeName(contentType)}.${attributeName}`;
-    const resolverScope = `${targetContentType.uid}.find`;
-    extension.use({ resolversConfig: { [resolverPath]: { auth: { scope: [resolverScope] } } } });
-    builder.field(attributeName, { type, resolve, args, ...options });
+    for (const spec of (0, strapi_compat_1.relationFieldSpecs)(contentType.uid, attributeName, resolve)) {
+        builder.field(spec.name, {
+            type: spec.type,
+            args: spec.args,
+            resolve: spec.resolve,
+            ...(extensions && { extensions }),
+        });
+    }
+    extension.use({ resolversConfig: (0, strapi_compat_1.relationResolversConfig)(contentType.uid, attributeName) });
 };
 const isPrivate = (contentType) => (attributeName) => {
     return utils_1.contentTypes.isPrivateAttribute(contentType, attributeName);
@@ -179,7 +172,29 @@ const isDisabled = (contentType) => (attributeName) => {
     const extension = getGraphQLService('extension');
     return !extension.shadowCRUD(contentType.uid).field(attributeName).hasOutputEnabled();
 };
+/**
+ * Redefine a field Strapi generates for a content type attribute, inside a Nexus `extendType`, with the
+ * same type, arguments and resolver as Strapi uses (v4 and v5), plus your own `authorize`, `resolve` or
+ * middlewares.
+ *
+ * Private attributes and attributes disabled for output via shadow CRUD are skipped.
+ *
+ * @param t - The Nexus definition block (`definition(t)`).
+ * @throws Error when the attribute does not exist on the content type.
+ *
+ * @remarks To only restrict access use {@link protectFields}; for relations prefer
+ *   {@link FieldExtensionBuilder.relation}. Both work without an extension and without redefining fields.
+ *
+ * @example
+ * extendType({
+ *   type: 'Article',
+ *   definition(t) {
+ *     overrideField(t, { contentTypeName: ARTICLE, fieldName: 'titel', resolve: (plan) => plan.titel ?? '' })
+ *   },
+ * })
+ */
 const overrideField = (t, overrideOptions) => {
+    var _a;
     const utils = getGraphQLService('utils');
     const { contentTypeName, fieldName } = overrideOptions;
     const { isStrapiScalar, isComponent, isDynamicZone, isEnumeration, isMedia, isMorphRelation, isRelation, } = utils.attributes;
@@ -187,10 +202,13 @@ const overrideField = (t, overrideOptions) => {
     const { attributes } = contentType;
     // @ts-ignore
     const attribute = attributes[fieldName];
-    if (isPrivate(contentType)(attribute)) {
+    if (!attribute) {
+        throw new Error(`[buro26-strapi-graphql] overrideField: "${contentTypeName}.${String(fieldName)}" does not exist`);
+    }
+    if (isPrivate(contentType)(fieldName)) {
         return;
     }
-    if (isDisabled(contentType)(attribute)) {
+    if (isDisabled(contentType)(fieldName)) {
         return;
     }
     // We create a copy of the builder (t) to apply custom
@@ -199,12 +217,22 @@ const overrideField = (t, overrideOptions) => {
     if (attribute.required) {
         builder = builder.nonNull;
     }
+    // `authorize` (deprecated, top-level) is only enforced when it ends up in `extensions.authorize`,
+    // which is what the package's Nexus authorize plugin reads.
+    const { authorize, extensions, resolve, type, contentTypeName: _ct, fieldName: _fn, ...rest } = overrideOptions;
+    const authorizeFn = (_a = extensions === null || extensions === void 0 ? void 0 : extensions.authorize) !== null && _a !== void 0 ? _a : authorize;
     const options = {
+        ...rest,
         builder,
         attributeName: fieldName,
         attribute,
         contentType,
-        ...overrideOptions,
+        ...(type && { type }),
+        ...(resolve && { resolve }),
+        extensions: {
+            ...extensions,
+            ...(authorizeFn && { authorize: authorizeFn }),
+        },
     };
     // Enums
     if (isEnumeration(attribute)) {

package/dist/server/utils/registry/field-protection.d.ts

@@ -0,0 +1,43 @@
+import type { ResolverFunction } from '../../types';
+import type { Middleware } from '../../nexus';
+/**
+ * Returned by {@link protectFields}; add checks and middlewares. Mutates the registration, so calls
+ * can be chained or made later on the same builder.
+ */
+export interface FieldProtectionBuilder<T = any> {
+    /**
+     * Add an authorization check. Runs after global and field checks; all must return `true`.
+     * Return `false` for "Not authorized" or an `Error` to send that error.
+     */
+    authorize(fn: ResolverFunction<T>): FieldProtectionBuilder<T>;
+    /** Add a middleware that wraps the field resolver (innermost, after global and field middlewares). */
+    middleware(fn: Middleware<T>): FieldProtectionBuilder<T>;
+}
+/**
+ * Protect fields of a content type, including the fields Strapi generates (scalars, enums, media,
+ * components and relations), without redefining them.
+ *
+ * The authorization and middleware are attached by the package's Nexus plugins when the schema is built,
+ * so Strapi's own types, arguments, filters, pagination and resolvers stay untouched. For to-many relations
+ * on Strapi v5 the matching `<field>_connection` field is protected as well.
+ *
+ * Call it at module level in a file inside a `graphql` folder; the file does not need to export anything.
+ *
+ * **Non-null fields:** when a check denies a non-null field, GraphQL nulls the nearest nullable parent
+ * instead of only the field (standard GraphQL error propagation). Strapi generates required attributes and,
+ * on v5, to-many relations (`[X]!`) as non-null; a warning is logged for those. Protect the
+ * `<field>_connection` field only, or check access in the parent query, when that is not acceptable.
+ * Several `protectFields` calls for the same field are combined.
+ *
+ * @typeParam T - Entity type, so `fields` is checked against its keys.
+ * @param contentType - Content type UID, e.g. `api::customer.customer`.
+ * @param fields - Attribute names to protect.
+ * @returns A {@link FieldProtectionBuilder} to add checks and middlewares.
+ *
+ * @example
+ * protectFields<Customer>('api::customer.customer', ['street', 'iban', 'orders'])
+ *   .authorize((customer, _args, ctx) => isOwner(customer, ctx.state.user))
+ *
+ * @see {@link FieldExtensionBuilder.relation} to redefine a relation instead.
+ */
+export declare function protectFields<T = any>(contentType: string, fields: ReadonlyArray<keyof T & string>): FieldProtectionBuilder<T>;

package/dist/server/utils/registry/field-protection.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetFieldProtections = exports.getFieldProtections = exports.protectFields = void 0;
+const protections = [];
+/**
+ * Protect fields of a content type, including the fields Strapi generates (scalars, enums, media,
+ * components and relations), without redefining them.
+ *
+ * The authorization and middleware are attached by the package's Nexus plugins when the schema is built,
+ * so Strapi's own types, arguments, filters, pagination and resolvers stay untouched. For to-many relations
+ * on Strapi v5 the matching `<field>_connection` field is protected as well.
+ *
+ * Call it at module level in a file inside a `graphql` folder; the file does not need to export anything.
+ *
+ * **Non-null fields:** when a check denies a non-null field, GraphQL nulls the nearest nullable parent
+ * instead of only the field (standard GraphQL error propagation). Strapi generates required attributes and,
+ * on v5, to-many relations (`[X]!`) as non-null; a warning is logged for those. Protect the
+ * `<field>_connection` field only, or check access in the parent query, when that is not acceptable.
+ * Several `protectFields` calls for the same field are combined.
+ *
+ * @typeParam T - Entity type, so `fields` is checked against its keys.
+ * @param contentType - Content type UID, e.g. `api::customer.customer`.
+ * @param fields - Attribute names to protect.
+ * @returns A {@link FieldProtectionBuilder} to add checks and middlewares.
+ *
+ * @example
+ * protectFields<Customer>('api::customer.customer', ['street', 'iban', 'orders'])
+ *   .authorize((customer, _args, ctx) => isOwner(customer, ctx.state.user))
+ *
+ * @see {@link FieldExtensionBuilder.relation} to redefine a relation instead.
+ */
+function protectFields(contentType, fields) {
+    const protection = { contentType, fields: [...fields], authorizes: [], middlewares: [] };
+    protections.push(protection);
+    const builder = {
+        authorize(fn) {
+            protection.authorizes.push(fn);
+            return builder;
+        },
+        middleware(fn) {
+            protection.middlewares.push(fn);
+            return builder;
+        },
+    };
+    return builder;
+}
+exports.protectFields = protectFields;
+const stripConnectionSuffix = (fieldName) => fieldName.replace(/_connection$/, '');
+/**
+ * All protections that apply to `contentType.fieldName` (also matches `<field>_connection`).
+ *
+ * @internal Used by the Nexus plugins.
+ */
+function getFieldProtections(contentType, fieldName) {
+    if (!contentType)
+        return [];
+    const baseName = stripConnectionSuffix(fieldName);
+    return protections.filter((p) => p.contentType === contentType && p.fields.includes(baseName));
+}
+exports.getFieldProtections = getFieldProtections;
+/** @internal Only for tests. */
+function resetFieldProtections() {
+    protections.length = 0;
+}
+exports.resetFieldProtections = resetFieldProtections;