feat(slugification): add compound references (#22)

* feat(sugification): add compound reference support

resolves #17

* chore(ReADME): update references data type to String or Array

* chore(README): add new `skipUndefinedReferences` setting

Author: ComfortablyCoding

README.md

@@ -67,8 +67,9 @@ This will listen for any record created or updated in the article content type a
 | contentTypes | The Content Types to add auto slugification and search findOne by slug search utility to | Object | {} | No |
 | contentTypes[modelName] | The model name of the content type (it is the `singularName` in the [model schema](https://docs.strapi.io/developer-docs/latest/development/backend-customization/models.html#model-schema)) | String | N/A | Yes |
 | contentTypes[modelName]field | The name of the field to add the slug  | String | N/A | Yes |
-| contentTypes[modelName]references | The name of the field that is used to build the slug | String | N/A | Yes |
+| contentTypes[modelName]references | The name(s) of the field(s) used to build the slug. If an array of fields is set it will result in a compound slug | String or Array | N/A | Yes |
 | SlugifyWithCount | Duplicate strings will have their occurrence appended to the end of the slug | Boolean | false | No |
+| skipUndefinedReferences | Skip reference fields that have no data. Mostly applicable to compound slug | Boolean | false | No |
 | slugifyOptions | The options to pass the the slugify function. All options can be found in the [slugify docs](https://github.com/sindresorhus/slugify#api) | Object | {} | No |
 
 ## Usage

server/config/index.js

@@ -8,6 +8,7 @@ module.exports = {
 			contentTypes: {},
 			slugifyOptions: {},
 			slugifyWithCount: false,
+			skipUndefinedReferences: false,
 		};
 	},
 	async validator(config) {

server/config/schema.js

@@ -10,12 +10,15 @@ const pluginConfigSchema = yup.object().shape({
 		_.each(obj, (_value, key) => {
 			shape[key] = yup.object().shape({
 				field: yup.string().required(),
-				references: yup.string().required(),
+				references: yup.lazy((v) =>
+					_.isArray(v) ? yup.array().of(yup.string()).required() : yup.string().required()
+				),
 			});
 		});
 		return yup.object().shape(shape);
 	}),
 	slugifyWithCount: yup.bool(),
+	skipUndefinedReferences: yup.bool(),
 });
 
 module.exports = {

server/services/settings-service.js

@@ -14,18 +14,26 @@ module.exports = ({ strapi }) => ({
 	build(settings) {
 		// build models
 		settings.models = {};
-		_.filter(strapi.contentTypes, (contentType, uid) => {
+		_.each(strapi.contentTypes, (contentType, uid) => {
 			const model = settings.contentTypes[contentType.modelName];
 			if (!model) {
 				return;
 			}
 
 			// ensure provided fields are present on the model
-			const hasField = isValidModelField(model, model.field);
-			const hasReference = isValidModelField(model, model.references);
-			if (!hasField || !hasReference) {
+			const hasField = isValidModelField(contentType, model.field);
+			if (!hasField) {
 				strapi.log.warn(
-					`[slugify] skipping ${contentType.info.singularName} registration, invalid field and/or reference provided.`
+					`[slugify] skipping ${contentType.info.singularName} registration, invalid field provided.`
+				);
+				return;
+			}
+
+			let references = _.isArray(model.references) ? model.references : [model.references];
+			const hasReferences = references.every((r) => isValidModelField(contentType, r));
+			if (!hasReferences) {
+				strapi.log.warn(
+					`[slugify] skipping ${contentType.info.singularName} registration, invalid reference field provided.`
 				);
 				return;
 			}
@@ -34,6 +42,7 @@ module.exports = ({ strapi }) => ({
 				uid,
 				...model,
 				contentType,
+				references,
 			};
 			settings.models[uid] = data;
 			settings.models[contentType.modelName] = data;

server/services/slug-service.js

@@ -17,19 +17,24 @@ module.exports = ({ strapi }) => ({
 		}
 
 		const { field, references } = model;
-		const referenceFieldValue = data[references];
 
 		// ensure the reference field has data
-		if (typeof referenceFieldValue === 'undefined') {
+		let referenceFieldValues = references
+			.filter((r) => typeof data[r] !== 'undefined' && data[r].length)
+			.map((r) => data[r]);
+
+		const hasUndefinedFields = referenceFieldValues.length < references.length;
+		if ((!settings.skipUndefinedReferences && hasUndefinedFields) || !referenceFieldValues.length) {
 			return;
 		}
 
+		referenceFieldValues = referenceFieldValues.join(' ');
 		if (settings.slugifyWithCount) {
-			data[field] = toSlugWithCount(referenceFieldValue, settings.slugifyOptions);
+			data[field] = toSlugWithCount(referenceFieldValues, settings.slugifyOptions);
 			return;
 		}
 
-		data[field] = toSlug(referenceFieldValue, settings.slugifyOptions);
+		data[field] = toSlug(referenceFieldValues, settings.slugifyOptions);
 	},
 
 	async findOne(uid, query) {