fix (findSlug query): default live publication state (#9)

* fix(findSlug query): only return published records by default

* refactor(settingsService): add build util

* refactor(slugService): remove unnecessary validation

Author: ComfortablyCoding

server/bootstrap.js

@@ -5,26 +5,16 @@ const { SUPPORTED_LIFECYCLES } = require('./utils/constants');
 const { getPluginService } = require('./utils/getPluginService');
 
 module.exports = ({ strapi }) => {
-	const settings = getPluginService(strapi, 'settingsService').get();
+	const settingsService = getPluginService(strapi, 'settingsService');
+	const settings = settingsService.get();
 
 	const { contentTypes, slugifyOptions } = settings;
 
 	// build settings structure
-	const models = {};
-	_.forEach(strapi.contentTypes, (value, key) => {
-		if (contentTypes[value.modelName]) {
-			const data = {
-				uid: value.uid,
-				...contentTypes[value.modelName],
-				contentType: value,
-			};
-			models[key] = data;
-			models[value.modelName] = data;
-		}
-	});
+	const models = settingsService.build(contentTypes);
 
 	// reset plugin settings
-	getPluginService(strapi, 'settingsService').set({
+	settingsService.set({
 		models,
 		slugifyOptions,
 	});

server/controllers/slug-controller.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { getPluginService } = require('../utils/getPluginService');
+const _ = require('lodash');
 
 module.exports = ({ strapi }) => ({
 	async findSlug(ctx) {
@@ -24,15 +25,20 @@ module.exports = ({ strapi }) => ({
 				);
 			}
 
-			const { uid, field } = model;
+			const { uid, field, contentType } = model;
 
 			// add slug filter to any already existing query restrictions
-			let query = ctx.query;
+			let query = ctx.query || {};
 			if (!query.filters) {
 				query.filters = {};
 			}
 			query.filters[field] = slug;
 
+			// only return published entries by default if content type has draftAndPublish enabled
+			if (_.get(contentType, ['options', 'draftAndPublish'], false) && !query.publicationState) {
+				query.publicationState = 'live';
+			}
+
 			const data = await getPluginService(strapi, 'slugService').findOne(uid, query);
 
 			if (data) {

server/graphql/types.js

@@ -56,13 +56,18 @@ const getCustomTypes = (strapi, nexus) => {
 							return toEntityResponse(null, { resourceUID: uid });
 						}
 
-						const { uid, field } = model;
+						const { uid, field, contentType } = model;
 						let query = {
 							filters: {
 								[field]: slug,
 							},
 						};
 
+						// only return published entries
+						if (_.get(contentType, ['options', 'draftAndPublish'], false)) {
+							query.publicationState = 'live';
+						}
+
 						const data = await getPluginService(strapi, 'slugService').findOne(uid, query);
 						return toEntityResponse(data, { resourceUID: uid });
 					},

server/services/settings-service.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const _ = require('lodash');
 const { pluginId } = require('../utils/pluginId');
 
 module.exports = ({ strapi }) => ({
@@ -9,4 +10,34 @@ module.exports = ({ strapi }) => ({
 	set(settings) {
 		return strapi.config.set(`plugin.${pluginId}`, settings);
 	},
+	build(contentTypes) {
+		let models = {};
+
+		_.filter(strapi.contentTypes, (value, uid) => {
+			const model = contentTypes[value.modelName];
+			if (!model) {
+				return;
+			}
+
+			// ensure provided fields are present on the model
+			const hasField = _.get(value, ['attributes', model.field], false);
+			const hasReference = _.get(value, ['attributes', model.references], false);
+			if (!hasField || !hasReference) {
+				strapi.log.warn(
+					`[slugify] skipping ${value.info.singularName} registration, invalid field and/or reference provided.`
+				);
+				return;
+			}
+
+			const data = {
+				uid,
+				...contentTypes[value.modelName],
+				contentType: value,
+			};
+			models[uid] = data;
+			models[value.modelName] = data;
+		});
+
+		return models;
+	},
 });

server/services/slug-service.js

@@ -15,15 +15,15 @@ module.exports = ({ strapi }) => ({
 			return;
 		}
 
-		const field = model.field;
-		const references = data[model.references];
+		const { field, references } = model;
+		const referenceFieldValue = data[references];
 
-		// for empty values they are null, undefined means they are not on the model.
-		if (!field || typeof data[model.field] === 'undefined' || typeof references === 'undefined') {
+		// ensure the reference field has data
+		if (typeof referenceFieldValue === 'undefined') {
 			return;
 		}
 
-		data[field] = stringToSlug(references, slugifyOptions);
+		data[field] = stringToSlug(referenceFieldValue, slugifyOptions);
 	},
 
 	async findOne(uid, query) {