buro26-strapi-graphql 0.0.21 → 0.0.23

package/README.md

@@ -43,10 +43,13 @@ extensions with Strapi.
 From each file create a default export that uses th `createGraphQLExtension` factory function. This function takes a
 function as an argument that will receive the Strapi instance and should return an object with the following methods:
 
-- init: Called when the extension is initialized
-- getTypes: Returns an array of GraphQL types
-- resolvers: Returns an object with resolvers
-- getResolverConfig: Returns an object with resolver configuration
+| Method          | Description                                      |
+|-----------------|--------------------------------------------------|
+| init            | Called when the extension is initialized         |
+| types           | Returns an array of GraphQL types                |
+| typeDefs        | Returns a string with the type definition in SDL |
+| resolvers       | Returns an object with resolvers                 |
+| resolversConfig | Returns an object with resolver configuration    |
 
 The functions you can implement follow the pattern of the Strapi customization
 options: https://docs.strapi.io/dev-docs/plugins/graphql#customization. The return values here will be registered as-is
@@ -54,7 +57,7 @@ with Strapi in the register hook.
 
 ```typescript
 import { createGraphQLExtension } from 'buro26-strapi-graphql';
-import { extendType, stringArg, nonNull } from 'nexus'
+import { extendType, nonNull, stringArg } from 'nexus';
 
 export default createGraphQLExtension(strapi => ({
 
@@ -67,6 +70,14 @@ export default createGraphQLExtension(strapi => ({
       .disableActions(['find', 'findOne', 'create', 'update', 'delete']);
   },
 
+  typeDefs() {
+    return `
+      type HelloWorldResponse {
+        greeting: String!
+      }
+    `;
+  },
+
   types() {
     return [
       // Extend an existing type
@@ -124,7 +135,7 @@ export default createGraphQLExtension(strapi => ({
     };
   },
 
-  resolverConfig() {
+  resolversConfig() {
     return {
       'Query.helloWorld': {
         policies: [
@@ -224,6 +235,68 @@ export default createGraphQLExtension(strapi => ({
 }));
 ```
 
+### Field middleware
+
+You can add middleware to a specific field, similarly to adding authorization. Each field can have multiple middlewares.
+
+This can be useful when you want to add some logic before or after the field is resolved. E.g. logging, caching,
+response parsing, etc.
+
+```typescript
+import { createGraphQLExtension, overrideField } from 'buro26-strapi-graphql';
+import { extendType } from 'nexus';
+
+export default createGraphQLExtension(strapi => ({
+  types() {
+    return [
+      // Extend an existing type
+      extendType({
+        type: 'MyType',
+        definition(t) {
+          t.field('myField', {
+            type: 'MyFieldType',
+            extensions: {
+              middlewares: [
+                next => async (root, args, context, info) => {
+                  // Do something before the field is resolved
+
+                  const res = await next(root, args, context, info);
+
+                  // Do something after the field is resolved
+
+                  return res;
+                }
+              ]
+            },
+            resolve: async (root) => {
+              // Resolver is optional
+            }
+          })
+          overrideField<MyContentType>(t, {
+            contentTypeName: 'api::my-type.my-type',
+            fieldName: 'myField',
+            extensions: {
+              middlewares: [
+                next => async (root, args, context, info) => {
+                  // Do something before the field is resolved
+
+                  const res = await next(root, args, context, info);
+
+                  // Do something after the field is resolved
+
+                  return res;
+                }
+              ]
+            }
+          });
+        }
+      })
+
+    ];
+  }
+}));
+```
+
 ### Utility functions
 
 The plugin also provides utility functions to help you resolve entities and collections. These functions are useful when
@@ -283,6 +356,58 @@ export default createGraphQLExtension(strapi => ({
 }));
 ```
 
+#### resolveEntityRelation
+
+The `resolveEntityRelation` function can be used to resolve an entity by id. The function takes the content type name and an
+object with all the resolve args passed the resolver function. The function will return the resolved entity as
+EntityResponse.
+
+```typescript
+import { createGraphQLExtension, overrideField, resolveEntityRelation } from 'buro26-strapi-graphql';
+import { extendType } from 'nexus';
+
+export default createGraphQLExtension(strapi => ({
+  types() {
+    return [
+      // Extend an existing type
+      extendType({
+        type: 'MyType',
+        definition(t) {
+          t.field('myFields', {
+            type: 'MyFieldEntityResponse',
+            resolve: async (parent, args, context, info) => {
+              // Do something, and resolve the entit
+              return resolveEntityRelation<MyContentType>('api::my-content-type.my-content-type', {
+                args: {
+                  id: 'the id here',
+                },
+                parent,
+                context,
+                info,
+              })
+            }
+          });
+          overrideField<MyContentType>(t, {
+            contentTypeName: 'api::my-type.my-type',
+            fieldName: 'myOtherField',
+            resolve: async (parent, args, context, info) => {
+              // Do something, and resolve the entit
+              return resolveEntityRelation<MyContentType>('api::my-content-type.my-content-type', 'myRelationField', {
+                args,
+                parent, // needs to have the id field populated
+                context,
+                info,
+              })
+            }
+          });
+        }
+      })
+
+    ];
+  }
+}));
+```
+
 #### resolveEntityCollection
 
 The `resolveEntityCollection` function can be used to resolve a collection of entities. The function takes the content
@@ -290,7 +415,7 @@ type name and an object with all the resolve args passed the resolver function.
 collection as EntityCollectionResponse.
 
 ```typescript
-import { createGraphQLExtension, overrideField, resolveEntityCollection } from 'buro26-strapi-graphql';
+import { createGraphQLExtension, overrideField, createEntityCollectionResolver } from 'buro26-strapi-graphql';
 import { extendType } from 'nexus';
 
 export default createGraphQLExtension(strapi => ({
@@ -303,8 +428,9 @@ export default createGraphQLExtension(strapi => ({
           t.field('myFields', {
             type: 'MyFieldEntityResponseCollection',
             resolve: async (parent, args, context, info) => {
-              // Do something, and resolve the entit
-              return resolveEntityCollection<MyContentType>('api::my-content-type.my-content-type', {
+              // Do something, and resolve the entity
+              const resolver = createEntityCollectionResolver<MyContentType>('api::my-content-type.my-content-type');
+              return resolver({
                 args,
                 parent,
                 context,
@@ -316,8 +442,9 @@ export default createGraphQLExtension(strapi => ({
             contentTypeName: 'api::my-type.my-type',
             fieldName: 'myOtherField',
             resolve: async (parent, args, context, info) => {
-              // Do something, and resolve the entit
-              return resolveEntityCollection<MyContentType>('api::my-content-type.my-content-type', {
+              // Do something, and resolve the entity
+              const resolver = createEntityCollectionResolver<MyContentType>('api::my-content-type.my-content-type');
+              return resolver({
                 args,
                 parent,
                 context,
@@ -335,8 +462,8 @@ export default createGraphQLExtension(strapi => ({
 
 #### resolveEntityRelationCollection
 
-This function has the same API as `resolveEntityCollection` but is used to resolve a collection of entities from a
-relational field on the provided content type.
+This function has a similar API as `createEntityRelationCollectionResolver` but is used to resolve a collection of entities from a
+relational field on the provided content type. The only difference is that the resolvers first argument is the relation field name that should be resolved.
 
 #### toEntityResponse
 
@@ -354,7 +481,8 @@ This function is re-exported from the Strapi GraphQL plugin.
 
 #### resolveArgs
 
-This function is a typesafe utility function to resolve the args passed to the resolver function. It will transform the graphql
+This function is a typesafe utility function to resolve the args passed to the resolver function. It will transform the
+graphql
 args into args that can be passed to the entityManager.
 
 This function is re-exported from the Strapi GraphQL plugin.

package/dist/server/index.d.ts

@@ -1,5 +1,8 @@
-import { type Strapi } from '@strapi/strapi';
-import { type GraphQLExtension } from './types';
+import type { Strapi } from '@strapi/strapi';
+import type { GraphQLExtension } from './types';
+import type { Middleware, ResolveContext } from './utils';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { GraphQLFieldConfig } from 'graphql/type';
 declare const _default: {
     register: ({ strapi }: {
         strapi: Strapi;
@@ -43,3 +46,31 @@ declare module '@strapi/strapi' {
         createGraphQLExtension: (factory: (strapi: Strapi) => GraphQLExtension) => GraphQLExtension;
     }
 }
+/**
+ * Extend Nexus's field definition to include a middleware array.
+ */
+declare module 'nexus/dist/core' {
+    /**
+     * Extends Nexus's OutputFieldConfig to include a `middleware` property.
+     */
+    interface NexusOutputFieldConfig<TypeName extends string, FieldName extends string> {
+        extensions?: {
+            middlewares?: Middleware[];
+        } & GraphQLFieldConfig<any, any>['extensions'];
+        /**
+         * A function that determines if the current user is authorized to access this field.
+         *
+         * @param parent The parent object.
+         * @param args The arguments passed to the field.
+         * @param context The context object.
+         * @param info The GraphQLResolveInfo object.
+         */
+        authorize?: <Parent extends Object, Args extends Object, Context = ResolveContext>(parent: Parent, args: Args, context: Context, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+    }
+    interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs> {
+        /**
+         * An array of middleware functions to apply to this field.
+         */
+        middleware?: Middleware[];
+    }
+}

package/dist/server/register.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const nexus_1 = require("nexus");
+const utils_1 = require("./utils");
 exports.default = async ({ strapi }) => {
     const fileService = strapi
         .plugin('burotwosix-graphql-plugin')
@@ -13,7 +14,8 @@ exports.default = async ({ strapi }) => {
     ];
     graphQlExtensionService.use(() => ({
         plugins: [
-            (0, nexus_1.fieldAuthorizePlugin)()
+            (0, nexus_1.fieldAuthorizePlugin)(),
+            (0, utils_1.nexusMiddlewarePlugin)(),
         ]
     }));
     for (const extension of extensions) {
@@ -30,7 +32,7 @@ exports.default = async ({ strapi }) => {
                 resolvers: (_k = (_j = extension === null || extension === void 0 ? void 0 : extension.resolvers) === null || _j === void 0 ? void 0 : _j.call(extension)) !== null && _k !== void 0 ? _k : { Query: {}, Mutation: {} },
                 resolversConfig: {
                     ...(_m = (_l = extension === null || extension === void 0 ? void 0 : extension.getResolverConfig) === null || _l === void 0 ? void 0 : _l.call(extension)) !== null && _m !== void 0 ? _m : {},
-                    ...(_p = (_o = extension === null || extension === void 0 ? void 0 : extension.resolverConfig) === null || _o === void 0 ? void 0 : _o.call(extension)) !== null && _p !== void 0 ? _p : {},
+                    ...(_p = (_o = extension === null || extension === void 0 ? void 0 : extension.resolversConfig) === null || _o === void 0 ? void 0 : _o.call(extension)) !== null && _p !== void 0 ? _p : {},
                 },
             });
         });

package/dist/server/types.d.ts

@@ -43,7 +43,7 @@ export interface GraphQLExtension {
      * This is used to configure middlewares and other resolver options
      * @see https://docs.strapi.io/developer-docs/latest/plugins/graphql.html#extending-the-schema
      *
-     * @deprecated Use resolverConfig() instead
+     * @deprecated Use resolversConfig() instead
      */
     getResolverConfig?: () => any;
     /**
@@ -51,7 +51,7 @@ export interface GraphQLExtension {
      * This is used to configure middlewares and other resolver options
      * @see https://docs.strapi.io/developer-docs/latest/plugins/graphql.html#extending-the-schema
      */
-    resolverConfig?: () => Record<string, ResolverConfigOption>;
+    resolversConfig?: () => Record<string, ResolverConfigOption>;
 }
 type ResolverConfigOption = {
     auth?: boolean | undefined;

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

@@ -3,18 +3,31 @@
  *
  * Based on node_modules/@strapi/plugin-graphql/server/services/builders/resolvers/association.js
  */
-import { Entity, type ResolveArgs } from './types';
-export declare const resolveEntityCollection: <T extends Object>(contentType: string, resolveArgs: ResolveArgs) => Promise<Entity<T>[]>;
-export declare const resolveEntityRelationCollection: <T extends Object>(contentType: string, relationFieldName: keyof T, resolveArgs: ResolveArgs) => Promise<Entity<T>[]>;
-type EntityResponse<T extends Object> = {
-    value: Entity<T> | null;
+import { type ResolveArgs } from './types';
+/**
+ * Create a resolver for a collection of entities
+ * Returns a resolver that resolves the entities based on the content type UID
+ *
+ * @param contentType The content type UID of the entities
+ */
+export declare const createEntityCollectionResolver: <ContentType extends Object>(contentType: string) => (resolveArgs: ResolveArgs<ContentType>) => Promise<EntityResponseCollection<ContentType>>;
+/**
+ * Create a resolver for a collection of entities related to a parent entity
+ * Returns a resolver that resolves the related entities based on the relation field name
+ *
+ * @param contentType The content type UID of the related entities
+ */
+export declare function createEntityRelationCollectionResolver<Parent extends object>(contentType: string): <K extends keyof Parent>(relationFieldName: K, resolveArgs: ResolveArgs<Parent>) => Promise<EntityResponseCollection<ExtractRelation<Parent, K>>>;
+type EntityResponseCollection<T extends Object> = {
+    nodes: T[];
     info: {
         args: Record<string, any>;
         resourceUID: string;
     };
 };
+type ExtractRelation<Parent, K extends keyof Parent> = Parent[K] extends Array<infer U> ? U extends object ? U : never : Parent[K] extends object ? Parent[K] : never;
 export default function toEntityResponseCollection<T extends Object>(items: T[], { args, resourceUID }: {
     args: Record<string, any>;
     resourceUID: string;
-}): EntityResponse<T>[];
+}): EntityResponseCollection<T>;
 export {};

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

@@ -5,34 +5,53 @@
  * Based on node_modules/@strapi/plugin-graphql/server/services/builders/resolvers/association.js
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEntityRelationCollection = exports.resolveEntityCollection = void 0;
-const resolveEntityCollection = async (contentType, resolveArgs) => {
+exports.createEntityRelationCollectionResolver = exports.createEntityCollectionResolver = void 0;
+/**
+ * Create a resolver for a collection of entities
+ * Returns a resolver that resolves the entities based on the content type UID
+ *
+ * @param contentType The content type UID of the entities
+ */
+const createEntityCollectionResolver = (contentType) => {
     const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
     const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
     const { buildQueriesResolvers } = strapi.plugin('graphql').service('builders').get('content-api');
-    const transformedArgs = transformArgs(resolveArgs.args, {
-        contentType: strapi.contentTypes[contentType],
-        usePagination: true
-    });
     const { find } = buildQueriesResolvers({
         contentType: strapi.contentTypes[contentType]
     });
-    const items = await find(resolveArgs.parent, transformedArgs, resolveArgs.context);
-    return toEntityResponseCollection(items, {
-        args: transformedArgs,
-        resourceUID: contentType
-    });
+    return async (resolveArgs) => {
+        const transformedArgs = transformArgs(resolveArgs.args, {
+            contentType: strapi.contentTypes[contentType],
+            usePagination: true
+        });
+        const items = await find(resolveArgs.parent, transformedArgs, resolveArgs.context);
+        return toEntityResponseCollection(items, {
+            args: transformedArgs,
+            resourceUID: contentType
+        });
+    };
 };
-exports.resolveEntityCollection = resolveEntityCollection;
-const resolveEntityRelationCollection = async (contentType, relationFieldName, resolveArgs) => {
-    const { buildAssociationResolver } = strapi.plugin('graphql').service('builders').get('content-api');
-    const find = buildAssociationResolver({
-        contentTypeUID: contentType,
-        attributeName: relationFieldName
-    });
-    return find(resolveArgs.parent, resolveArgs.args, resolveArgs.context);
-};
-exports.resolveEntityRelationCollection = resolveEntityRelationCollection;
+exports.createEntityCollectionResolver = createEntityCollectionResolver;
+/**
+ * Create a resolver for a collection of entities related to a parent entity
+ * Returns a resolver that resolves the related entities based on the relation field name
+ *
+ * @param contentType The content type UID of the related entities
+ */
+function createEntityRelationCollectionResolver(contentType) {
+    return async (relationFieldName, resolveArgs) => {
+        const { buildAssociationResolver } = strapi
+            .plugin('graphql')
+            .service('builders')
+            .get('content-api');
+        const find = buildAssociationResolver({
+            contentTypeUID: contentType,
+            attributeName: relationFieldName
+        });
+        return find(resolveArgs.parent, resolveArgs.args, resolveArgs.context);
+    };
+}
+exports.createEntityRelationCollectionResolver = createEntityRelationCollectionResolver;
 function toEntityResponseCollection(items, { args, resourceUID }) {
     const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
     return toEntityResponseCollection(items, {

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

@@ -1,5 +1,6 @@
 export * from './types';
 export * from './single-type';
 export * from './collection-type';
+export * from './middleware';
 export * from './misc';
 export * from './override';

package/dist/server/utils/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./single-type"), exports);
 __exportStar(require("./collection-type"), exports);
+__exportStar(require("./middleware"), exports);
 __exportStar(require("./misc"), exports);
 __exportStar(require("./override"), exports);

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

@@ -0,0 +1,17 @@
+import 'nexus';
+import { GraphQLResolveInfo } from 'graphql';
+import { ResolveContext } from './types';
+/**
+ * The Resolver type represents a GraphQL resolver function.
+ */
+export type Resolver = <Parent extends Object, Args extends Object, Context = ResolveContext>(parent: Parent, args: Args, context: Context, info: GraphQLResolveInfo) => any | Promise<any>;
+/**
+ * Middleware is a function that takes a resolver and returns a new resolver.
+ */
+export type Middleware = (resolver: Resolver) => Resolver;
+export declare const nexusMiddlewarePlugin: () => import("nexus/dist/plugin").NexusPlugin;
+/**
+ * Logging Middleware
+ * Logs the execution of the resolver.
+ */
+export declare const loggingMiddleware: Middleware;

package/dist/server/utils/middleware.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggingMiddleware = exports.nexusMiddlewarePlugin = void 0;
+require("nexus");
+const nexus_1 = require("nexus");
+const utils_1 = require("nexus/dist/utils");
+const fieldDefTypes = (0, utils_1.printedGenTyping)({
+    optional: true,
+    name: 'middlewares',
+    description: `
+    Authorization for an individual field. Returning "true"
+    or "Promise<true>" means the field can be accessed.
+    Returning "false" or "Promise<false>" will respond
+    with a "Not Authorized" error for the field.
+    Returning or throwing an error will also prevent the
+    resolver from executing.
+  `,
+    type: 'any',
+});
+const nexusMiddlewarePlugin = () => (0, nexus_1.plugin)({
+    name: 'NexusMiddlewarePlugin',
+    description: 'The middleware plugin allows attaching middleware functions to individual fields.',
+    /**
+     * Defines the field definition types for the plugin.
+     */
+    fieldDefTypes: fieldDefTypes,
+    /**
+     * Hook into field resolver creation to apply middleware.
+     */
+    onCreateFieldResolver(config) {
+        var _a;
+        const { fieldConfig } = config;
+        // @ts-ignore
+        const middlewares = ((_a = fieldConfig.extensions) === null || _a === void 0 ? void 0 : _a.middlewares) || [];
+        if (middlewares.length === 0) {
+            return undefined; // No middleware to apply
+        }
+        // Convert Middleware[] to MiddlewareFn[]
+        const middlewareFns = middlewares.map(middleware => {
+            return async (source, args, context, info, next) => {
+                const newResolver = middleware(next);
+                return newResolver(source, args, context, info);
+            };
+        });
+        // Compose the middleware functions into a single MiddlewareFn
+        return async (source, args, context, info, next) => {
+            let index = -1;
+            const dispatch = async (i) => {
+                if (i <= index)
+                    throw new Error('next() called multiple times');
+                index = i;
+                const middlewareFn = middlewareFns[i];
+                if (middlewareFn) {
+                    return middlewareFn(source, args, context, info, () => dispatch(i + 1));
+                }
+                else {
+                    return next(source, args, context, info);
+                }
+            };
+            return dispatch(0);
+        };
+    },
+});
+exports.nexusMiddlewarePlugin = nexusMiddlewarePlugin;
+/**
+ * Logging Middleware
+ * Logs the execution of the resolver.
+ */
+const loggingMiddleware = (resolver) => {
+    return async (parent, args, context, info) => {
+        console.log(`Resolving field ${info.parentType.name}.${info.fieldName}`);
+        const result = await resolver(parent, args, context, info);
+        console.log(`Resolved field ${info.parentType.name}.${info.fieldName} with result:`, result);
+        return result;
+    };
+};
+exports.loggingMiddleware = loggingMiddleware;

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

@@ -3,14 +3,18 @@
  *
  * Based on node_modules/@strapi/plugin-graphql/server/services/builders/type.js
  */
-import { type GraphQLResolveInfo } from 'graphql';
-import { ResolveContext } from './types';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { ResolveContext } from './types';
+import type { Middleware } from './middleware';
 type OverrideFieldOptions<Type extends Object, Args = unknown, Context = ResolveContext, Info = GraphQLResolveInfo> = {
     contentTypeName: string;
     fieldName: keyof Type;
     type?: string;
     authorize?: (parent: Type, args: Args, context: Context, info: Info) => boolean | Promise<boolean>;
     resolve?: (parent: Type, args: Args, context: Context, info: Info) => unknown;
+    extensions?: {
+        middlewares?: Middleware[];
+    };
 };
 export declare const overrideField: <T extends Object>(t: any, overrideOptions: OverrideFieldOptions<T, unknown, ResolveContext, GraphQLResolveInfo>) => void;
 export {};

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

@@ -10,6 +10,7 @@ type ResolveEntityArgs = Omit<ResolveArgs, 'args'> & {
     };
 };
 export declare function resolveEntity<T extends Object>(contentType: string, resolveArgs: ResolveEntityArgs): Promise<Entity<T> | null>;
+export declare const resolveEntityRelation: <T extends Object>(contentType: string, relationFieldName: keyof T, resolveArgs: ResolveArgs) => Promise<Entity<T>[]>;
 type EntityResponse<T extends Object> = {
     value: Entity<T> | null;
     info: {

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

@@ -5,7 +5,7 @@
  * Based on node_modules/@strapi/plugin-graphql/server/services/builders/type.js
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toEntityResponse = exports.resolveEntity = void 0;
+exports.toEntityResponse = exports.resolveEntityRelation = exports.resolveEntity = void 0;
 async function resolveEntity(contentType, resolveArgs) {
     const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
     const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
@@ -19,6 +19,15 @@ async function resolveEntity(contentType, resolveArgs) {
     });
 }
 exports.resolveEntity = resolveEntity;
+const resolveEntityRelation = async (contentType, relationFieldName, resolveArgs) => {
+    const { buildAssociationResolver } = strapi.plugin('graphql').service('builders').get('content-api');
+    const find = buildAssociationResolver({
+        contentTypeUID: contentType,
+        attributeName: relationFieldName
+    });
+    return find(resolveArgs.parent, resolveArgs.args, resolveArgs.context);
+};
+exports.resolveEntityRelation = resolveEntityRelation;
 async function toEntityResponse(item, { args, resourceUID }) {
     const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
     return toEntityResponse(item, {