buro26-strapi-graphql 0.1.0 → 0.3.0

package/dist/server/utils/graphql-extension.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGraphQLExtension = void 0;
+exports.mapFieldPresetToExtension = exports.createGraphQLExtension = void 0;
+const field_builder_1 = require("./field-builder");
 /**
  * Internal function that creates a new builder instance.
  */
@@ -12,31 +13,31 @@ function graphQLExtensionBuilder(options = {}) {
         typeDefs(sdl) {
             return graphQLExtensionBuilder({
                 ...options,
-                typeDefs: typeof sdl === 'string' ? () => sdl : sdl,
+                typeDefs: typeof sdl === 'string' ? () => sdl : sdl
             });
         },
         types(typesFn) {
             return graphQLExtensionBuilder({
                 ...options,
-                types: typeof typesFn === 'function' ? typesFn : () => typesFn,
+                types: typeof typesFn === 'function' ? typesFn : () => typesFn
             });
         },
         plugins(pluginsFn) {
             return graphQLExtensionBuilder({
                 ...options,
-                plugins: typeof pluginsFn === 'function' ? pluginsFn : () => pluginsFn,
+                plugins: typeof pluginsFn === 'function' ? pluginsFn : () => pluginsFn
             });
         },
         resolvers(resolversObj) {
             return graphQLExtensionBuilder({
                 ...options,
-                resolvers: typeof resolversObj === 'function' ? resolversObj : () => resolversObj,
+                resolvers: typeof resolversObj === 'function' ? resolversObj : () => resolversObj
             });
         },
         resolversConfig(configObj) {
             return graphQLExtensionBuilder({
                 ...options,
-                resolversConfig: typeof configObj === 'function' ? configObj : () => configObj,
+                resolversConfig: typeof configObj === 'function' ? configObj : () => configObj
             });
         },
         use(preset) {
@@ -44,7 +45,7 @@ function graphQLExtensionBuilder(options = {}) {
         },
         build() {
             return { ...options };
-        },
+        }
     };
 }
 function createGraphQLExtension(extension) {
@@ -55,3 +56,68 @@ function createGraphQLExtension(extension) {
     return extension(strapi);
 }
 exports.createGraphQLExtension = createGraphQLExtension;
+/**
+ * Maps a field-level preset to all (or matching) fields in a GraphQLExtension.
+ * Throws if a field is not a function (i.e., not a resolver).
+ *
+ * @param fieldPreset - a GraphQLFieldPreset (FieldExtensionBuilder => FieldExtensionBuilder)
+ * @param matcher - a function (type, fieldName) => boolean or an array of field names
+ * @returns a function that takes a GraphQLExtension and returns a new one with wrapped resolvers
+ */
+function mapFieldPresetToExtension(fieldPreset, matcher = () => true) {
+    return (extension) => {
+        var _a, _b, _c;
+        const originalResolvers = ((_a = extension.resolvers) === null || _a === void 0 ? void 0 : _a.call(extension)) || {};
+        const newResolvers = {};
+        for (const type of Object.keys(originalResolvers)) {
+            newResolvers[type] = {};
+            // @ts-ignore
+            for (const fieldName of Object.keys(originalResolvers[type] || {})) {
+                const shouldApply = typeof matcher === 'function'
+                    ? matcher(type, fieldName)
+                    : matcher.includes(fieldName);
+                // @ts-ignore
+                const originalResolver = originalResolvers[type][fieldName];
+                if (typeof originalResolver !== 'function') {
+                    throw new Error(`Cannot apply field preset: ${type}.${fieldName} is not a resolver function`);
+                }
+                if (shouldApply) {
+                    // Build a field builder for this resolver
+                    let fieldBuilder = (0, field_builder_1.createGraphQLFieldBuilder)(type)
+                        .fieldName(fieldName)
+                        .resolver(originalResolver);
+                    // Apply the preset
+                    fieldBuilder = fieldPreset(fieldBuilder);
+                    // Build the field and extract the resolver
+                    const builtExtension = fieldBuilder.build();
+                    const builtType = (_c = (_b = builtExtension === null || builtExtension === void 0 ? void 0 : builtExtension.types) === null || _b === void 0 ? void 0 : _b.call(builtExtension)) === null || _c === void 0 ? void 0 : _c.find((t) => t.name === type);
+                    if (!builtType || !builtType.definition) {
+                        throw new Error(`Cannot extract wrapped resolver for ${type}.${fieldName}`);
+                    }
+                    // Extract the resolver from the field definition
+                    let wrappedResolver = null;
+                    builtType.definition({
+                        field: (name, config) => {
+                            if (name === fieldName) {
+                                wrappedResolver = config.resolve;
+                            }
+                        },
+                    });
+                    if (typeof wrappedResolver !== 'function') {
+                        throw new Error(`Preset did not produce a valid resolver for ${type}.${fieldName}`);
+                    }
+                    newResolvers[type][fieldName] = wrappedResolver;
+                }
+                else {
+                    newResolvers[type][fieldName] = originalResolver;
+                }
+            }
+        }
+        // Return a new extension with the updated resolvers
+        return {
+            ...extension,
+            resolvers: () => newResolvers,
+        };
+    };
+}
+exports.mapFieldPresetToExtension = mapFieldPresetToExtension;

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

@@ -7,3 +7,5 @@ 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,6 +14,7 @@ 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);
@@ -23,3 +24,13 @@ __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,110 @@
+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.
+ *
+ * Options are compared by value, not by reference: key order does not matter and `select` is treated
+ * as a set. Loaders with a different `populate` never share a batch, because the rows they load differ.
+ */
+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';
+    /**
+     * Pass every loaded row through {@link sanitizeOutput} before resolving it, so private fields and
+     * fields the current auth may not read are removed.
+     *
+     * Sanitizing needs the content type schema, so this throws for an unknown `uid`.
+     *
+     * @default false
+     */
+    sanitize?: boolean;
+};
+/**
+ * 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 and fields the current auth may not read.**
+     * Pass `{ sanitize: true }` to run every row through {@link sanitizeOutput} first, or sanitize the
+     * rows yourself before returning them to clients.
+     */
+    entity<T = AnyRecord>(uid: string, options?: EntityLoaderOptions): Loader<number | string, T | null>;
+    /**
+     * Load a relation or media attribute of many parents with one query on the parent content type.
+     * Resolves to the related entity or `null` (to-one, single media), or an array (to-many, multiple
+     * media; empty when there is none).
+     *
+     * **Returns raw database rows, including private fields and fields the current auth may not read.**
+     * Pass `{ sanitize: true }` to run every related row through {@link sanitizeOutput} first, or
+     * sanitize the rows yourself before returning them to clients.
+     *
+     * @throws Error when `attribute` is not a relation or media attribute 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. Add
+ * `{ sanitize: true }` to return rows that are safe for the content API.
+ *
+ * Loaders are cached per request and per options value: options are compared by value (key order and
+ * `select` order do not matter), and loaders with a different `populate` do not share batches.
+ *
+ * @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)
+ * const safeOrder = await loaders(ctx).entity(ORDER, { sanitize: true }).load(parent.id)
+ */
+export declare function loaders(context: object): RequestLoaders;
+export {};

package/dist/server/utils/loaders.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loaders = exports.createLoader = void 0;
+/**
+ * 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.
+ */
+const strapi_compat_1 = require("./strapi-compat");
+/**
+ * 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();
+/**
+ * Normalize a value for a cache key: object keys are sorted recursively, `select` arrays are sorted,
+ * and `undefined` properties are dropped.
+ */
+const normalizeCacheValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(normalizeCacheValue);
+    if (!value || typeof value !== 'object')
+        return value;
+    const entries = Object.entries(value)
+        .filter(([, entryValue]) => entryValue !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, entryValue]) => [
+        key,
+        key === 'select' && Array.isArray(entryValue)
+            ? [...entryValue].sort()
+            : normalizeCacheValue(entryValue)
+    ]);
+    return Object.fromEntries(entries);
+};
+/**
+ * Stable cache key for loader options, so equivalent options share one loader regardless of property
+ * order (`{ status: 'draft', populate: {...} }` and `{ populate: {...}, status: 'draft' }`) or column
+ * order in `select`.
+ */
+const optionsCacheKey = (options) => JSON.stringify(normalizeCacheValue(options));
+/** Sanitize one related value: an array for to-many, a single row for to-one, or `null`. */
+const sanitizeRelationValue = async (value, targetUID, context) => {
+    if (value == null)
+        return value;
+    if (Array.isArray(value)) {
+        return Promise.all(value.map((row) => (0, strapi_compat_1.sanitizeOutput)(row, targetUID, context)));
+    }
+    return (0, strapi_compat_1.sanitizeOutput)(value, targetUID, context);
+};
+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. Add
+ * `{ sanitize: true }` to return rows that are safe for the content API.
+ *
+ * Loaders are cached per request and per options value: options are compared by value (key order and
+ * `select` order do not matter), and loaders with a different `populate` do not share batches.
+ *
+ * @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)
+ * const safeOrder = await loaders(ctx).entity(ORDER, { sanitize: true }).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}:${optionsCacheKey(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]));
+                const resolved = ids.map((id) => { var _a; return (_a = byId.get(String(id))) !== null && _a !== void 0 ? _a : null; });
+                if (!options.sanitize)
+                    return resolved;
+                return Promise.all(resolved.map((row) => (row ? (0, strapi_compat_1.sanitizeOutput)(row, uid, context) : row)));
+            }));
+        },
+        relation(uid, attribute, options = {}) {
+            return getOrCreate(`relation:${uid}:${attribute}:${optionsCacheKey(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];
+                const isMedia = (attr === null || attr === void 0 ? void 0 : attr.type) === 'media';
+                if (!attr || (!isMedia && attr.type !== 'relation')) {
+                    throw new Error(`[buro26-strapi-graphql] "${uid}.${attribute}" is not a relation or media attribute`);
+                }
+                // Media are stored as a morph relation to the upload plugin's file content type. Their
+                // target lives there, not on the attribute, and draft & publish never applies to files.
+                const targetUID = isMedia ? 'plugin::upload.file' : attr.target;
+                const isToMany = isMedia ? Boolean(attr.multiple) : String(attr.relation).endsWith('Many');
+                const nestedPopulate = options.populate && typeof options.populate === 'object' && !Array.isArray(options.populate)
+                    ? { populate: options.populate }
+                    : {};
+                // Media always need `true`/a nested populate; their file rows have no draft & publish status.
+                const populate = isMedia
+                    ? Object.keys(nestedPopulate).length > 0
+                        ? nestedPopulate
+                        : true
+                    : {
+                        ...nestedPopulate,
+                        ...(hasDraftAndPublish(targetUID) && { where: statusWhere(targetUID, options.status) }),
+                    };
+                const rows = await strapi.db.query(uid).findMany({
+                    where: { id: { $in: ids } },
+                    select: ['id'],
+                    populate: { [attribute]: populate },
+                });
+                const byId = new Map(rows.map((row) => [String(row.id), row[attribute]]));
+                const resolved = ids.map((id) => { var _a; return (_a = byId.get(String(id))) !== null && _a !== void 0 ? _a : (isToMany ? [] : null); });
+                if (!options.sanitize)
+                    return resolved;
+                return Promise.all(resolved.map((value) => sanitizeRelationValue(value, targetUID, context)));
+            }));
+        },
+        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

@@ -6,16 +6,48 @@
 import type { GraphQLResolveInfo } from 'graphql';
 import type { ResolveContext } from './types';
 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 {};