buro26-strapi-graphql 0.0.24 → 0.0.26

package/README.md

@@ -6,6 +6,8 @@ as co-location of GraphQL schema and resolvers, field overriding, and field auth
 This let's you define your GraphQL schema and resolvers in the content-type directory, making it easier to manage and
 maintain your GraphQL API.
 
+This plugin is compatible with both Strapi v4 and Strapi v5.
+
 ## Getting started
 
 ```bash
@@ -21,7 +23,7 @@ the [Strapi GraphQL plugin](https://docs.strapi.io/dev-docs/plugins/graphql).
 
 ### Enable plugin
 
-Add plugin in `./config/plugins.js/ts` in your Strapi project.
+Add plugin in `./config/plugins.[js/ts]` in your Strapi project.
 
 ```typescript
 export default () => ({
@@ -156,6 +158,54 @@ export default createGraphQLExtension(strapi => ({
 }));
 ```
 
+### Fluent Builder Pattern
+The plugin also supports a builder pattern so that you can configure your extension using a fluent API. This is achieved by calling createGraphQLExtension() with no arguments. For example, you can write:
+
+```typescript
+export default createGraphQLExtension()
+  .init(() => {
+    // Initialization logic here...
+  })
+  .typeDefs(`
+    extend type Query {
+      hello: String
+    }
+  `)
+  .resolvers({
+    Query: {
+      hello: () => 'Hello from builder!'
+    }
+  });
+```
+
+In this pattern, `createGraphQLExtension()` detects that no argument was passed and returns a builder. The builder exposes methods like `.init()`, `.typeDefs()`, `.types()`, `.plugins()`, `.resolvers()`, and `.resolversConfig()` so you can chain calls and define your extension inline.
+
+### Shorter way to define a new field
+
+The `createGraphQLFieldBuilder()` function provides a fluent builder API to create a single GraphQL field extension using Nexus. It simplifies the process of extending the GraphQL schema by letting you define the field's name, arguments, output type, resolver, and resolver configuration in a chainable way.
+
+The builder pattern ensures that you only need to specify the necessary parts, and the extension is automatically registered using the provided settings. This approach minimizes boilerplate code while ensuring consistency across your GraphQL extensions.
+
+Below is an example of how to define a new field using the builder pattern. This example creates a new query field called `helloWorld` that takes a non-null `name` argument and returns a non-null `String`.
+
+```typescript
+import { createGraphQLFieldBuilder } from "buro26-strapi-graphql";
+import { nonNull, stringArg } from 'nexus';
+
+export default createGraphQLFieldBuilder('Query')
+  .fieldName('helloWorld')
+  .args({
+    name: nonNull(stringArg()),
+  })
+  .outputType(nonNull('String'))
+  .resolver(async (parent, args, ctx) => {
+    return `Hello World ${args.name}`;
+  })
+  .resolverConfig({
+    auth: false,
+  });
+```
+
 ### Overriding a field
 
 Sometimes you will need to override a field in an existing type. You can do this by extending the type and adding the
@@ -487,6 +537,27 @@ args into args that can be passed to the entityManager.
 
 This function is re-exported from the Strapi GraphQL plugin.
 
+#### shadowCRUD
+
+This function is a typesafe utility function to create shadow CRUD operations for a content type. It will create the CRUD operations for the content type and return the shadow CRUD object.
+
+```typescript
+import { createGraphQLExtension, shadowCRUD } from 'buro26-strapi-graphql';
+
+export default createGraphQLExtension((strapi) => ({
+
+  init() {
+    shadowCRUD('api::article.article')
+      .disableActions(['create', 'update', 'delete']);
+
+    shadowCRUD('api::category.category')
+      .field('title')
+      .disable();
+  }
+
+}));
+```
+
 ## Test and Deploy
 
 ### Running tests

package/dist/server/bootstrap.d.ts

@@ -1,4 +1,4 @@
-import { type Strapi } from '@strapi/strapi';
+import { type Strapi } from './types';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => void;

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

@@ -1,6 +1,6 @@
 declare const _default: {
     myController: ({ strapi }: {
-        strapi: import("@strapi/types").Strapi;
+        strapi: Required<import("@strapi/types").Strapi>;
     }) => {};
 };
 export default _default;

package/dist/server/controllers/my-controller.d.ts

@@ -1,4 +1,4 @@
-import { Strapi } from '@strapi/strapi';
+import type { Strapi } from '../types';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => {};

package/dist/server/destroy.d.ts

@@ -1,4 +1,4 @@
-import { type Strapi } from '@strapi/strapi';
+import { type Strapi } from './types';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => void;

package/dist/server/index.d.ts

@@ -1,17 +1,16 @@
-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;
+        strapi: import("@strapi/types").Strapi;
     }) => Promise<void>;
     bootstrap: ({ strapi }: {
-        strapi: Strapi;
+        strapi: Required<import("@strapi/types").Strapi>;
     }) => void;
     destroy: ({ strapi }: {
-        strapi: Strapi;
+        strapi: Required<import("@strapi/types").Strapi>;
     }) => void;
     config: {
         default: {};
@@ -19,18 +18,18 @@ declare const _default: {
     };
     controllers: {
         myController: ({ strapi }: {
-            strapi: Strapi;
+            strapi: Required<import("@strapi/types").Strapi>;
         }) => {};
     };
     routes: any[];
     services: {
         fileService: ({ strapi }: {
-            strapi: Strapi;
+            strapi: Required<import("@strapi/types").Strapi>;
         }) => {
             getAllFilesInGraphQlDirectory(directoryPath: string, collectedExtensions?: GraphQLExtension[]): Promise<GraphQLExtension[]>;
         };
         graphQlService: ({ strapi }: {
-            strapi: Strapi;
+            strapi: Required<import("@strapi/types").Strapi>;
         }) => {};
     };
     contentTypes: {};
@@ -40,12 +39,16 @@ declare const _default: {
 export default _default;
 export * from './types';
 export * from './utils';
-export declare const createGraphQLExtension: (factory: (strapi: Strapi) => GraphQLExtension) => GraphQLExtension;
 declare module '@strapi/strapi' {
     interface Strapi {
         createGraphQLExtension: (factory: (strapi: Strapi) => GraphQLExtension) => GraphQLExtension;
     }
 }
+declare module '@strapi/types' {
+    interface Strapi {
+        createGraphQLExtension: (factory: (strapi: Strapi) => GraphQLExtension) => GraphQLExtension;
+    }
+}
 /**
  * Extend Nexus's field definition to include a middleware array.
  */

package/dist/server/index.js

@@ -17,7 +17,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGraphQLExtension = void 0;
 const register_1 = __importDefault(require("./register"));
 const bootstrap_1 = __importDefault(require("./bootstrap"));
 const destroy_1 = __importDefault(require("./destroy"));
@@ -42,5 +41,3 @@ exports.default = {
 };
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
-const createGraphQLExtension = (factory) => factory(strapi);
-exports.createGraphQLExtension = createGraphQLExtension;

package/dist/server/services/file-service.d.ts

@@ -1,5 +1,4 @@
-import type { Strapi } from '@strapi/strapi';
-import type { GraphQLExtension } from '../types';
+import type { GraphQLExtension, Strapi } from '../types';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => {

package/dist/server/services/file-service.js

@@ -53,10 +53,13 @@ exports.default = ({ strapi }) => ({
             if (!graphqlModule) {
                 return;
             }
-            collectedExtensions.push({
-                ...graphqlModule,
-                ...(graphqlModule.default || {})
-            });
+            // Support both ES module default export and CommonJS exports
+            let extension = graphqlModule.default || graphqlModule;
+            // If the extension is a builder (has a build function), call build() automatically
+            if (extension && typeof extension.build === 'function') {
+                extension = extension.build();
+            }
+            collectedExtensions.push(extension);
         });
         // Wait for all the promises to resolve
         await Promise.all(filePromises);

package/dist/server/services/graphql-service.d.ts

@@ -1,4 +1,4 @@
-import { type Strapi } from '@strapi/strapi';
+import { type Strapi } from '../types';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => {};

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

@@ -1,11 +1,11 @@
 declare const _default: {
     fileService: ({ strapi }: {
-        strapi: import("@strapi/types").Strapi;
+        strapi: Required<import("@strapi/types").Strapi>;
     }) => {
         getAllFilesInGraphQlDirectory(directoryPath: string, collectedExtensions?: import("..").GraphQLExtension[]): Promise<import("..").GraphQLExtension[]>;
     };
     graphQlService: ({ strapi }: {
-        strapi: import("@strapi/types").Strapi;
+        strapi: Required<import("@strapi/types").Strapi>;
     }) => {};
 };
 export default _default;

package/dist/server/types.d.ts

@@ -1,6 +1,6 @@
 import type { ResolveContext } from './utils';
 import type { GraphQLResolveInfo } from 'graphql';
-import type { Strapi } from '@strapi/strapi';
+export type Strapi = typeof strapi;
 export interface GraphQLExtension {
     /**
      * Called when the extension is initialized, use this to perform any initialization logic
@@ -53,12 +53,12 @@ export interface GraphQLExtension {
      */
     resolversConfig?: () => Record<string, ResolverConfigOption>;
 }
-type ResolverConfigOption = {
+export type ResolverConfigOption = {
     auth?: boolean | undefined;
     policies?: (string | PolicyFunction)[];
     middlewares?: MiddlewareFunction[];
 };
-type PolicyFunctionContext = {
+export type PolicyFunctionContext = {
     parent: any;
     args: any;
     context: ResolveContext;
@@ -66,11 +66,10 @@ type PolicyFunctionContext = {
     state: ResolveContext['state'];
     http: any;
 };
-type PolicyFunctionOptions = {
+export type PolicyFunctionOptions = {
     strapi: Strapi;
 };
-type PolicyFunction = (context: PolicyFunctionContext, config: any, opts: PolicyFunctionOptions) => boolean | Promise<boolean>;
-type MiddlewareFunction = (next: MiddlewareNextFunction, parent: any, args: any, context: ResolveContext, info: GraphQLResolveInfo) => any | Promise<any>;
-type MiddlewareNextFunction = (parent: any, args: any, context: ResolveContext, info: GraphQLResolveInfo) => Promise<any>;
-type ResolverFunction = (parent: any, args: any, context: ResolveContext, info: GraphQLResolveInfo) => any | Promise<any>;
-export {};
+export type PolicyFunction = (context: PolicyFunctionContext, config: any, opts: PolicyFunctionOptions) => boolean | Promise<boolean>;
+export type MiddlewareFunction = (next: MiddlewareNextFunction, parent: any, args: any, context: ResolveContext, info: GraphQLResolveInfo) => any | Promise<any>;
+export type MiddlewareNextFunction = (parent: any, args: any, context: ResolveContext, info: GraphQLResolveInfo) => Promise<any>;
+export type ResolverFunction = (parent: any, args: any, context: ResolveContext, info: GraphQLResolveInfo) => any | Promise<any>;

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

@@ -0,0 +1,31 @@
+import type { GraphQLExtension, ResolverConfigOption, ResolverFunction } from '../types';
+export type FieldExtensionOptions = {
+    rootType: string;
+    fieldName?: string;
+    resolver: ResolverFunction;
+    resolverConfig?: ResolverConfigOption;
+    typeDefs?: string;
+    types?: () => any[];
+    plugins?: () => any[];
+    args?: Record<string, string | any>;
+    outputType?: string | any;
+};
+export interface FieldExtensionBuilder {
+    fieldName(name: string): FieldExtensionBuilder;
+    resolver(fn: ResolverFunction): FieldExtensionBuilder;
+    resolverConfig(config: ResolverConfigOption): FieldExtensionBuilder;
+    typeDefs(sdl: string): FieldExtensionBuilder;
+    types(typesFn: () => any[]): FieldExtensionBuilder;
+    plugins(pluginsFn: () => any[]): FieldExtensionBuilder;
+    args(a: Record<string, string | any>): FieldExtensionBuilder;
+    outputType(type: string | any): FieldExtensionBuilder;
+    build(): GraphQLExtension;
+}
+/**
+ * Creates a fluent builder to extend a root field in the GraphQL schema.
+ * The field is automatically registered using Nexus. The output type must be defined
+ * using the outputType callback.
+ *
+ * @param rootType - Either 'Query' or 'Mutation'
+ */
+export declare const createGraphQLFieldBuilder: (rootType: string) => FieldExtensionBuilder;

package/dist/server/utils/field-builder.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLFieldBuilder = void 0;
+const nexus_1 = require("nexus");
+const graphql_extension_1 = require("./graphql-extension");
+/**
+ * Creates a fluent builder to extend a root field in the GraphQL schema.
+ * The field is automatically registered using Nexus. The output type must be defined
+ * using the outputType callback.
+ *
+ * @param rootType - Either 'Query' or 'Mutation'
+ */
+const createGraphQLFieldBuilder = (rootType) => {
+    const options = {
+        rootType,
+        fieldName: undefined,
+        resolver: () => {
+            throw new Error('Resolver function must be provided via .resolver()');
+        },
+        resolverConfig: {},
+        typeDefs: '',
+        types: () => [],
+        plugins: () => [],
+        args: {},
+        outputType: undefined
+    };
+    return {
+        fieldName(name) {
+            options.fieldName = name;
+            return this;
+        },
+        resolver(fn) {
+            options.resolver = fn;
+            return this;
+        },
+        resolverConfig(config) {
+            options.resolverConfig = config;
+            return this;
+        },
+        typeDefs(sdl) {
+            options.typeDefs = sdl;
+            return this;
+        },
+        types(typesFn) {
+            options.types = typesFn;
+            return this;
+        },
+        plugins(pluginsFn) {
+            options.plugins = pluginsFn;
+            return this;
+        },
+        args(a) {
+            options.args = a;
+            return this;
+        },
+        outputType(type) {
+            options.outputType = type;
+            return this;
+        },
+        build() {
+            if (!options.fieldName) {
+                throw new Error('Field name must be provided via fieldName()');
+            }
+            if (!options.outputType) {
+                throw new Error(`Output type must be provided for field "${options.fieldName}" via outputType()`);
+            }
+            const nexusExtension = (0, nexus_1.extendType)({
+                type: options.rootType,
+                definition(t) {
+                    // Build Nexus arguments if provided
+                    let nexusArgs = {};
+                    if (options.args) {
+                        for (const [argName, argType] of Object.entries(options.args)) {
+                            if (typeof argType !== 'string') {
+                                nexusArgs[argName] = argType;
+                                continue;
+                            }
+                            const isNonNull = argType.endsWith('!');
+                            const baseType = isNonNull ? argType.slice(0, -1) : argType;
+                            nexusArgs[argName] = isNonNull
+                                ? (0, nexus_1.nonNull)((0, nexus_1.arg)({ type: baseType }))
+                                : (0, nexus_1.arg)({ type: baseType });
+                        }
+                    }
+                    t.field(options.fieldName, {
+                        type: options.outputType,
+                        args: nexusArgs,
+                        resolve: options.resolver
+                    });
+                }
+            });
+            // Merge the auto-generated Nexus extension with any additional Nexus types
+            const autoTypes = [nexusExtension, ...(options.types ? options.types() : [])];
+            return (0, graphql_extension_1.createGraphQLExtension)((strapi) => ({
+                // Provided typeDefs are optional; Nexus types take precedence.
+                typeDefs: () => options.typeDefs || '',
+                types: () => autoTypes,
+                plugins: () => (options.plugins ? options.plugins() : []),
+                resolvers: () => ({
+                    [options.rootType]: {
+                        [options.fieldName]: options.resolver
+                    }
+                }),
+                resolversConfig: () => ({
+                    [options.rootType]: {
+                        [options.fieldName]: options.resolverConfig || {}
+                    }
+                })
+            }));
+        }
+    };
+};
+exports.createGraphQLFieldBuilder = createGraphQLFieldBuilder;

package/dist/server/utils/graphql-extension.d.ts

@@ -0,0 +1,25 @@
+import type { GraphQLExtension, ResolverConfigOption, ResolverFunction, Strapi } from '../types';
+type ResolversObject = {
+    Query?: Record<string, ResolverFunction>;
+    Mutation?: Record<string, ResolverFunction>;
+};
+/**
+ * Builder interface for configuring a GraphQLExtension.
+ */
+interface GraphQLExtensionBuilder {
+    init(fn: () => void): GraphQLExtensionBuilder;
+    typeDefs(sdl: string | (() => string)): GraphQLExtensionBuilder;
+    types(typesFn: (() => any[]) | any[]): GraphQLExtensionBuilder;
+    plugins(pluginsFn: (() => any[]) | any[]): GraphQLExtensionBuilder;
+    resolvers(resolversObj: (() => ResolversObject) | ResolversObject): GraphQLExtensionBuilder;
+    resolversConfig(config: (() => Record<string, ResolverConfigOption>) | Record<string, ResolverConfigOption>): GraphQLExtensionBuilder;
+    build(): GraphQLExtension;
+}
+/**
+ * Overloaded createGraphQLExtension:
+ * - When called with no arguments, returns a new builder.
+ * - When called with a factory function returns a GraphQLExtension.
+ */
+export declare function createGraphQLExtension(): GraphQLExtensionBuilder;
+export declare function createGraphQLExtension(extension: ((strapi: Strapi) => GraphQLExtension)): GraphQLExtension;
+export {};

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLExtension = void 0;
+/**
+ * Internal function that creates a new builder instance.
+ */
+function graphQLExtensionBuilder() {
+    // Options to store configuration.
+    const options = {};
+    return {
+        init(fn) {
+            options.init = fn;
+            return this;
+        },
+        typeDefs(sdl) {
+            options.typeDefs = typeof sdl === 'string' ? () => sdl : sdl;
+            return this;
+        },
+        types(typesFn) {
+            options.types = typeof typesFn === 'function' ? typesFn : () => typesFn;
+            return this;
+        },
+        plugins(pluginsFn) {
+            options.plugins = typeof pluginsFn === 'function' ? pluginsFn : () => pluginsFn;
+            return this;
+        },
+        resolvers(resolversObj) {
+            options.resolvers = typeof resolversObj === 'function' ? resolversObj : () => resolversObj;
+            return this;
+        },
+        resolversConfig(configObj) {
+            options.resolversConfig = typeof configObj === 'function' ? configObj : () => configObj;
+            return this;
+        },
+        build() {
+            // Create the extension using the options collected.
+            return {
+                init: options.init,
+                typeDefs: options.typeDefs,
+                types: options.types,
+                plugins: options.plugins,
+                resolvers: options.resolvers,
+                resolversConfig: options.resolversConfig,
+            };
+        },
+    };
+}
+function createGraphQLExtension(extension) {
+    if (!extension) {
+        // No argument passed: return a new builder.
+        return graphQLExtensionBuilder();
+    }
+    return extension(strapi);
+}
+exports.createGraphQLExtension = createGraphQLExtension;

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

@@ -1,6 +1,9 @@
 export * from './types';
 export * from './single-type';
 export * from './collection-type';
+export * from './field-builder';
+export * from './graphql-extension';
 export * from './middleware';
 export * from './misc';
 export * from './override';
+export * from './shadow-crud';

package/dist/server/utils/index.js

@@ -17,6 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __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("./override"), exports);
+__exportStar(require("./shadow-crud"), exports);

package/dist/server/utils/shadow-crud.d.ts

@@ -0,0 +1,30 @@
+type Action = 'create' | 'update' | 'delete' | 'findOne' | 'find';
+interface FieldOperations<T> {
+    disable(): this;
+    disableInput(): this;
+    disableOutput(): this;
+    disableFilters(): this;
+    isEnabled(): boolean;
+    isDisabled(): boolean;
+    hasInputEnabled(): boolean;
+    hasOutputEnabled(): boolean;
+    hasFiltersEnabled(): boolean;
+}
+interface ShadowCRUD<T> {
+    disable(): this;
+    disableActions(actions: Action[]): this;
+    disableAction(action: Action): this;
+    disableQueries(): this;
+    disableMutations(): this;
+    field<K extends keyof T>(name: K): FieldOperations<T[K]>;
+    isEnabled(): boolean;
+    isDisabled(): boolean;
+    areQueriesEnabled(): boolean;
+    areQueriesDisabled(): boolean;
+    areMutationsEnabled(): boolean;
+    areMutationsDisabled(): boolean;
+    isActionEnabled(action: Action): boolean;
+    isActionDisabled(action: Action): boolean;
+}
+export declare const shadowCRUD: <Type extends unknown = null>(contentTypeUID: string) => ShadowCRUD<Type>;
+export {};

package/dist/server/utils/shadow-crud.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shadowCRUD = void 0;
+const shadowCRUD = (contentTypeUID) => {
+    const extensionService = strapi.plugin('graphql').service('extension');
+    return extensionService.shadowCRUD(contentTypeUID);
+};
+exports.shadowCRUD = shadowCRUD;