feat: add graphql support (#8)

* feat(getPluginService): add support for any plugin

* refactor(settings): add uid model veersion to models for unified resource access

* feat: add graphql support

* chore(README): add graphql examples

* chore(strapi meta): add displayName

* chore(FindSlugResponse): update description

* fix(graphql types): ensure model exists before processing

* chore(README): incorrect title in graphql response

Author: ComfortablyCoding

README.md

@@ -86,33 +86,62 @@ Hitting the `/api/slugify/slugs/:modelName/:slug` endpoint for any configured co
 
 Like all other created API endpoints the `findSlug` route must be allowed under `User & Permissions -> Roles -> Public/Authenticated` for the user to be able to access the route.
 
-#### Example Request
+## Examples
+
+### Example Request
 
 Making the following request with the sample configuration will look as follows
 
+#### REST
+
 ```js
 await fetch(`${API_URL}/api/slugify/slugs/article/lorem-ipsum-dolor`);
 // GET /api/slugify/slugs/article/lorem-ipsum-dolor
 ```
 
-#### Example Response
+#### GraphQL
+
+```graphql
+{
+  findSlug(modelName:"article",slug:"lorem-ipsum-dolor"){
+    ... on ArticleEntityResponse{
+      data{
+        id
+        attributes{
+          title
+        }
+      }
+    }
+  }
+}
+```
+
+### Example Response
+
+If an article with the slug of `lorem-ipsum-dolor` exists the response will look the same as a single entity response
+
+#### REST
 
-If an article with the slug of `lorem-ipsum-dolor` exists the reponse will look the same as a single entity response
+##### Successful Response
 
 ```json
 {
 	"data": {
 		"id": 1,
-		"title": "lorem ipsum dolor",
-		"slug": "lorem-ipsum-dolor",
-		"createdAt": "2022-02-17T01:49:31.961Z",
-		"updatedAt": "2022-02-17T03:47:09.950Z",
-		"publishedAt": null
+		"attributes":{
+			"title": "lorem ipsum dolor",
+			"slug": "lorem-ipsum-dolor",
+			"createdAt": "2022-02-17T01:49:31.961Z",
+			"updatedAt": "2022-02-17T03:47:09.950Z",
+			"publishedAt": null
+		}
 	}
 }
 ```
 
-**IMPORTANT NOTE** To be inline with Strapi's default behavior for single types if an article with the slug of `lorem-ipsum-dolor` does not exist a 404 error will be returned.
+##### Error Response
+
+To be inline with Strapi's default behavior for single types if an article with the slug of `lorem-ipsum-dolor` does not exist a 404 error will be returned.
 
 ```json
 {
@@ -121,6 +150,38 @@ If an article with the slug of `lorem-ipsum-dolor` exists the reponse will look
 }
 ```
 
+#### GraphQL
+
+##### Successful Response
+
+```json
+{
+  "data": {
+    "findSlug": {
+      "data": {
+        "id": "1",
+        "attributes": {
+          "title": "lorem ipsum dolor"
+        }
+      }
+    }
+  }
+}
+```
+
+##### Error Response
+To be inline with Strapi's default behavior for single types if an article with the slug of `lorem-ipsum-dolor` does not exist the data will be null.
+
+```json
+{
+  "data": {
+    "findSlug": {
+      "data": null
+    }
+  }
+}
+```
+
 ## Bugs
 
 If any bugs are found please report them as a [Github Issue](https://github.com/ComfortablyCoding/strapi-plugin-slugify/issues)

package.json

@@ -40,6 +40,7 @@
 		"yup": "^0.32.9"
 	},
 	"strapi": {
+		"displayName": "Slugify",
 		"name": "slugify",
 		"description": "A plugin for Strapi Headless CMS that provides the ability to auto slugify a field for any content type.",
 		"kind": "plugin"

server/bootstrap.js

@@ -10,23 +10,22 @@ module.exports = ({ strapi }) => {
 	const { contentTypes, slugifyOptions } = settings;
 
 	// build settings structure
-	const uids = {};
 	const models = {};
 	_.forEach(strapi.contentTypes, (value, key) => {
 		if (contentTypes[value.modelName]) {
 			const data = {
 				uid: value.uid,
 				...contentTypes[value.modelName],
+				contentType: value,
 			};
-			uids[key] = data;
+			models[key] = data;
 			models[value.modelName] = data;
 		}
 	});
 
 	// reset plugin settings
 	getPluginService(strapi, 'settingsService').set({
 		models,
-		uids,
 		slugifyOptions,
 	});
 

server/graphql/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { getCustomTypes } = require('./types');
+const { getResolversConfig } = require('./resolversConfig');
+const { getPluginService } = require('../utils/getPluginService');
+
+const registerGraphlQLQuery = (strapi) => {
+	// build plugins schema extension
+	const extension = ({ nexus }) => ({
+		types: getCustomTypes(strapi, nexus),
+		resolversConfig: getResolversConfig(),
+	});
+
+	getPluginService(strapi, 'extension', 'graphql').use(extension);
+};
+
+module.exports = {
+	registerGraphlQLQuery,
+};

server/graphql/resolversConfig.js

@@ -0,0 +1,13 @@
+const getResolversConfig = () => ({
+	Query: {
+		findSlug: {
+			auth: {
+				scope: 'plugin::slugify.slugController.findSlug',
+			},
+		},
+	},
+});
+
+module.exports = {
+	getResolversConfig,
+};

server/graphql/types.js

@@ -0,0 +1,77 @@
+const _ = require('lodash');
+const { getPluginService } = require('../utils/getPluginService');
+
+const getCustomTypes = (strapi, nexus) => {
+	const { naming } = getPluginService(strapi, 'utils', 'graphql');
+	const { toEntityResponse } = getPluginService(strapi, 'format', 'graphql').returnTypes;
+	const { models } = getPluginService(strapi, 'settingsService').get();
+	const { getEntityResponseName } = naming;
+
+	// get all types required for findSlug query
+	let findSlugTypes = {
+		response: [],
+	};
+	_.forEach(strapi.contentTypes, (value, key) => {
+		if (models[key]) {
+			findSlugTypes.response.push(getEntityResponseName(value));
+		}
+	});
+
+	// ensure we have at least one type before attempting to register
+	if (!findSlugTypes.response.length) {
+		return [];
+	}
+
+	// build custom union type based on defined models
+	const FindSlugResponse = nexus.unionType({
+		name: 'FindSlugResponse',
+		description: 'Union Type of all registered slug content types',
+		definition(t) {
+			t.members(...findSlugTypes.response);
+		},
+		resolveType: (ctx) => {
+			return getEntityResponseName(models[ctx.info.resourceUID].contentType);
+		},
+	});
+
+	return [
+		FindSlugResponse,
+		nexus.extendType({
+			type: 'Query',
+			definition: (t) => {
+				t.field('findSlug', {
+					type: FindSlugResponse,
+					args: {
+						modelName: nexus.stringArg('The model name of the content type'),
+						slug: nexus.stringArg('The slug to query for'),
+					},
+					resolve: async (_, args) => {
+						const { models } = getPluginService(strapi, 'settingsService').get();
+						const { modelName, slug } = args;
+
+						const model = models[modelName];
+
+						// ensure valid model is passed
+						if (!model) {
+							return toEntityResponse(null, { resourceUID: uid });
+						}
+
+						const { uid, field } = model;
+						let query = {
+							filters: {
+								[field]: slug,
+							},
+						};
+
+						const data = await getPluginService(strapi, 'slugService').findOne(uid, query);
+						return toEntityResponse(data, { resourceUID: uid });
+					},
+				});
+			},
+		}),
+	];
+};
+
+module.exports = {
+	getCustomTypes,
+};

server/index.js

@@ -1,13 +1,15 @@
 'use strict';
 
 const bootstrap = require('./bootstrap');
+const register = require('./register');
 const config = require('./config');
 const controllers = require('./controllers');
 const routes = require('./routes');
 const services = require('./services');
 
 module.exports = {
 	bootstrap,
+	register,
 	config,
 	controllers,
 	routes,

server/register.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { registerGraphlQLQuery } = require('./graphql');
+
+module.exports = ({ strapi }) => {
+	// add graphql query if present
+	if (strapi.plugin('graphql')) {
+		strapi.log.info('[slugify] graphql detected, registering queries');
+		registerGraphlQLQuery(strapi);
+	}
+};

server/services/slug-service.js

@@ -5,10 +5,10 @@ const { stringToSlug } = require('../utils/stringToSlug');
 
 module.exports = ({ strapi }) => ({
 	slugify(ctx) {
-		const { uids, slugifyOptions } = getPluginService(strapi, 'settingsService').get();
+		const { models, slugifyOptions } = getPluginService(strapi, 'settingsService').get();
 
 		const { params, model: entityModel } = ctx;
-		const model = uids[entityModel.uid];
+		const model = models[entityModel.uid];
 		const { data } = params;
 
 		if (!data) {
@@ -19,7 +19,7 @@ module.exports = ({ strapi }) => ({
 		const references = data[model.references];
 
 		// for empty values they are null, undefined means they are not on the model.
-		if (!field || typeof references === 'undefined') {
+		if (!field || typeof data[model.field] === 'undefined' || typeof references === 'undefined') {
 			return;
 		}
 

server/utils/getPluginService.js

@@ -7,7 +7,7 @@ const { pluginId } = require('./pluginId');
  *
  * @return service
  */
-const getPluginService = (strapi, name) => strapi.plugin(pluginId).service(name);
+const getPluginService = (strapi, name, plugin = pluginId) => strapi.plugin(plugin).service(name);
 
 module.exports = {
 	getPluginService,