buro26-strapi-graphql 0.0.26 → 0.2.0

package/dist/server/utils/strapi-compat.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRelationValue = exports.sanitizeOutput = exports.relationResolversConfig = exports.relationFieldSpecs = exports.resetTypeNameCache = exports.uidOfTypeName = exports.typeNameOf = exports.isV4CompatibilityMode = exports.isStrapiV5 = void 0;
+/**
+ * Small compatibility layer over the parts of `@strapi/plugin-graphql` that differ between Strapi v4 and v5.
+ *
+ * Everything that needs to know "which Strapi is this?" should go through here, so the rest of the
+ * package can stay version-agnostic.
+ */
+const nexus_1 = require("nexus");
+const getGraphQLService = (name) => strapi.plugin('graphql').service(name);
+/**
+ * True when running on Strapi v5. The document service (`strapi.documents`) only exists in v5.
+ */
+const isStrapiV5 = () => typeof strapi.documents === 'function';
+exports.isStrapiV5 = isStrapiV5;
+/**
+ * Whether the GraphQL plugin runs in v4 compatibility mode (only relevant on v5).
+ */
+const isV4CompatibilityMode = () => (0, exports.isStrapiV5)() && Boolean(strapi.plugin('graphql').config('v4CompatibilityMode', false));
+exports.isV4CompatibilityMode = isV4CompatibilityMode;
+const getModel = (uid) => {
+    const model = strapi.getModel(uid);
+    if (!model) {
+        throw new Error(`[buro26-strapi-graphql] Unknown content type "${uid}"`);
+    }
+    return model;
+};
+/**
+ * GraphQL object type name Strapi generates for a content type, e.g. `api::customer.customer` → `Customer`.
+ */
+const typeNameOf = (uid) => getGraphQLService('utils').naming.getTypeName(getModel(uid));
+exports.typeNameOf = typeNameOf;
+let typeNameToUidCache = null;
+/**
+ * Reverse lookup of {@link typeNameOf}: the content type UID behind a generated GraphQL type name.
+ * Built lazily (content types do not change at runtime).
+ */
+const uidOfTypeName = (typeName) => {
+    var _a;
+    if (!typeNameToUidCache) {
+        typeNameToUidCache = new Map();
+        const { naming } = getGraphQLService('utils');
+        for (const contentType of Object.values((_a = strapi.contentTypes) !== null && _a !== void 0 ? _a : {})) {
+            try {
+                typeNameToUidCache.set(naming.getTypeName(contentType), contentType.uid);
+            }
+            catch {
+                // Content types that are not exposed in GraphQL can be ignored
+            }
+        }
+    }
+    return typeNameToUidCache.get(typeName);
+};
+exports.uidOfTypeName = uidOfTypeName;
+/** @internal Only for tests. */
+const resetTypeNameCache = () => {
+    typeNameToUidCache = null;
+};
+exports.resetTypeNameCache = resetTypeNameCache;
+/**
+ * Describes the GraphQL field(s) Strapi itself generates for a regular (non-morph) relation, so we can
+ * (re)define them with exactly the same type, arguments, resolver and permission scope.
+ *
+ * - v4: to-one → `XEntityResponse`, to-many → `XRelationResponseCollection` (with filters/pagination args).
+ * - v5: to-one → `X` (unwrapped), to-many → `[X]!` (unwrapped `nodes`) **and** `<field>_connection`
+ *   returning `XRelationResponseCollection`.
+ *
+ * All variants use Strapi's own `buildAssociationResolver`, so query validation, output sanitizing and
+ * draft/publish handling stay identical to the generated field.
+ *
+ * Low-level building block for {@link FieldExtensionBuilder.relation} and `overrideField`; prefer those.
+ *
+ * @param resolveOverride - Replaces Strapi's association resolver. It must return Strapi's response
+ *   wrapper (`{ value }` / `{ nodes }`); v5 unwrapping is applied on top.
+ * @throws Error when the content type is unknown or the attribute is not a regular relation.
+ */
+const relationFieldSpecs = (contentTypeUID, attributeName, resolveOverride) => {
+    var _a;
+    const contentType = getModel(contentTypeUID);
+    const attribute = (_a = contentType.attributes) === null || _a === void 0 ? void 0 : _a[attributeName];
+    if (!attribute || attribute.type !== 'relation' || !attribute.target) {
+        throw new Error(`[buro26-strapi-graphql] "${contentTypeUID}.${attributeName}" is not a regular relation attribute`);
+    }
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const targetContentType = getModel(attribute.target);
+    const isToMany = String(attribute.relation).endsWith('Many');
+    const parentTypeName = naming.getTypeName(contentType);
+    const associationResolver = resolveOverride !== null && resolveOverride !== void 0 ? resolveOverride : buildAssociationResolver({ contentTypeUID, attributeName, strapi });
+    if (!(0, exports.isStrapiV5)()) {
+        return [
+            {
+                name: attributeName,
+                type: isToMany
+                    ? naming.getRelationResponseCollectionName(targetContentType)
+                    : naming.getEntityResponseName(targetContentType),
+                args: isToMany ? getContentTypeArgs(targetContentType) : undefined,
+                resolve: associationResolver,
+                resolverConfigPaths: [`${parentTypeName}.${attributeName}`],
+            },
+        ];
+    }
+    const typeName = naming.getTypeName(targetContentType);
+    if (!isToMany) {
+        return [
+            {
+                name: attributeName,
+                type: typeName,
+                resolve: async (...resolveArgs) => {
+                    var _a;
+                    const response = (await associationResolver(...resolveArgs));
+                    return (_a = response === null || response === void 0 ? void 0 : response.value) !== null && _a !== void 0 ? _a : null;
+                },
+                resolverConfigPaths: [`${parentTypeName}.${attributeName}`],
+            },
+        ];
+    }
+    const args = getContentTypeArgs(targetContentType, { isNested: true });
+    return [
+        {
+            name: `${attributeName}_connection`,
+            type: naming.getRelationResponseCollectionName(targetContentType),
+            args,
+            resolve: associationResolver,
+            resolverConfigPaths: [`${parentTypeName}.${attributeName}_connection`],
+        },
+        {
+            name: attributeName,
+            type: (0, nexus_1.nonNull)((0, nexus_1.list)(typeName)),
+            args,
+            resolve: async (...resolveArgs) => {
+                var _a;
+                const response = (await associationResolver(...resolveArgs));
+                return (_a = response === null || response === void 0 ? void 0 : response.nodes) !== null && _a !== void 0 ? _a : [];
+            },
+            resolverConfigPaths: [`${parentTypeName}.${attributeName}`],
+        },
+    ];
+};
+exports.relationFieldSpecs = relationFieldSpecs;
+/**
+ * Resolver config that applies Strapi's own permission scope (`<target>.find`) to relation fields,
+ * exactly like the generated relation fields do. Pass it to an extension's `resolversConfig` when you
+ * define relation fields yourself.
+ *
+ * @returns A map of `Type.field` paths to `{ auth: { scope } }`.
+ */
+const relationResolversConfig = (contentTypeUID, attributeName) => {
+    var _a;
+    const attribute = (_a = getModel(contentTypeUID).attributes) === null || _a === void 0 ? void 0 : _a[attributeName];
+    const scope = [`${attribute.target}.find`];
+    return Object.fromEntries((0, exports.relationFieldSpecs)(contentTypeUID, attributeName).flatMap((spec) => spec.resolverConfigPaths.map((path) => [path, { auth: { scope } }])));
+};
+exports.relationResolversConfig = relationResolversConfig;
+/**
+ * Sanitize raw database output for the content API (removes private/password fields and fields the
+ * current auth may not read). v4: `@strapi/utils` sanitize, v5: `strapi.contentAPI.sanitize`.
+ *
+ * Use it on data from {@link loaders} or `strapi.db.query()` before returning it from a resolver.
+ *
+ * @param uid - Content type of `data`.
+ * @param context - The resolver context; its `state.auth` decides what may be read.
+ */
+const sanitizeOutput = async (data, uid, context) => {
+    var _a;
+    if (data == null)
+        return data;
+    const schema = getModel(uid);
+    const auth = (_a = context === null || context === void 0 ? void 0 : context.state) === null || _a === void 0 ? void 0 : _a.auth;
+    if ((0, exports.isStrapiV5)()) {
+        return strapi.contentAPI.sanitize.output(data, schema, { auth });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { sanitize } = require('@strapi/utils');
+    return sanitize.contentAPI.output(data, schema, { auth });
+};
+exports.sanitizeOutput = sanitizeOutput;
+/**
+ * Wrap a single entity the way the given relation field expects: an entity response in v4, the bare
+ * entity in v5.
+ *
+ * @param targetUID - Content type of `entity`.
+ */
+const toRelationValue = (entity, targetUID) => {
+    if (entity == null)
+        return null;
+    if ((0, exports.isStrapiV5)())
+        return entity;
+    const { toEntityResponse } = getGraphQLService('format').returnTypes;
+    return toEntityResponse(entity, { args: {}, resourceUID: targetUID });
+};
+exports.toRelationValue = toRelationValue;

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

@@ -20,7 +20,31 @@ export type BaseUser = {
         updatedAt: string;
     };
 };
-export type ResolveContext<UserType = BaseUser> = {
+/**
+ * Project-wide type registration. Augment it once in your project:
+ *
+ * @example
+ * declare module 'buro26-strapi-graphql' {
+ *   interface Register {
+ *     user: User
+ *     // GraphQL type name → entity type, used to type `parent` in `.rootType('Customer')`
+ *     types: { Customer: Customer; Order: Order }
+ *   }
+ * }
+ */
+export interface Register {
+}
+/** The user type registered via {@link Register}, or {@link BaseUser}. */
+export type RegisteredUser = Register extends {
+    user: infer U;
+} ? U : BaseUser;
+/** GraphQL type name → entity type map registered via {@link Register}. */
+export type RegisteredTypes = Register extends {
+    types: infer T;
+} ? T : {};
+/** Parent type for fields on GraphQL type `N`, when registered. */
+export type ParentOf<N extends string, Fallback = any> = N extends keyof RegisteredTypes ? RegisteredTypes[N] : Fallback;
+export type ResolveContext<UserType = RegisteredUser> = {
     state: {
         route: {
             info: {