refactor(slugService): move updateSlug check and get reference fields to separate files

Author: ComfortablyCoding

server/services/slug-service.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const getReferenceFieldValues = (ctx, data, references) => {
+	return references
+		.filter((referenceField) => {
+			// check action specific fields
+			if (
+				referenceField === 'id' &&
+				(ctx.action === 'afterCreate' || ctx.action === 'beforeUpdate')
+			) {
+				return true;
+			}
+
+			// check general data fields
+			if (typeof data[referenceField] === 'undefined') {
+				return false;
+			}
+
+			if (data[referenceField] === null) {
+				return false;
+			}
+
+			if (typeof data[referenceField] === 'string' && data[referenceField].length === 0) {
+				return false;
+			}
+
+			return true;
+		})
+		.map((referenceField) => {
+			if (referenceField === 'id') {
+				return ctx.result ? ctx.result.id : ctx.params.where.id;
+			}
+
+			return data[referenceField];
+		});
+};
+
+module.exports = {
+	getReferenceFieldValues,
+};

server/services/slug-service/getReferenceFieldValues.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const _ = require('lodash');
+const { toSlug } = require('../../utils/slugification');
+const { getPluginService } = require('../../utils/getPluginService');
+const { shouldUpdateSlug } = require('./shoudUpdateSlug');
+const { getReferenceFieldValues } = require('./getReferenceFieldValues');
+
+module.exports = ({ strapi }) => ({
+	async slugify(ctx) {
+		const { params, model: entityModel } = ctx;
+		const settings = getPluginService('settingsService').get();
+		const { data } = params;
+
+		const model = settings.modelsByUID[entityModel.uid];
+		if (!data) {
+			return;
+		}
+
+		const { field, references } = model;
+
+		// do not add/update slug if it already has a value unless settings specify otherwise
+		if (!settings.shouldUpdateSlug && data[field]) {
+			return;
+		}
+
+		// ensure the reference field has data
+		let referenceFieldValues = getReferenceFieldValues(ctx, data, references);
+
+		// respect skip undefined fields setting
+		const hasUndefinedFields = referenceFieldValues.length < references.length;
+		if ((!settings.skipUndefinedReferences && hasUndefinedFields) || !referenceFieldValues.length) {
+			return;
+		}
+
+		// check if the slug should be updated based on the action type
+		let shouldUpdateSlugByAction = await shouldUpdateSlug(strapi, ctx, references);
+		if (!shouldUpdateSlugByAction) {
+			return;
+		}
+
+		referenceFieldValues = referenceFieldValues.join(' ');
+		const toSlugOptions = settings.slugifyOptions;
+		if (settings.slugifyWithCount) {
+			toSlugOptions.slugifyWithCount = settings.slugifyWithCount;
+		}
+
+		// update slug field based on action type
+		const slug = toSlug(referenceFieldValues, toSlugOptions);
+		if (ctx.action === 'beforeCreate' || ctx.action === 'beforeUpdate') {
+			data[field] = slug;
+		} else if (ctx.action === 'afterCreate') {
+			strapi.entityService.update(model.uid, ctx.result.id, {
+				data: {
+					slug,
+				},
+			});
+		}
+	},
+
+	async findOne(uid, query) {
+		const slugs = await strapi.entityService.findMany(uid, query);
+
+		// single
+		if (slugs && _.isPlainObject(slugs)) {
+			return slugs;
+		}
+
+		// collection
+		if (slugs && _.isArray(slugs) && slugs.length) {
+			return slugs[0];
+		}
+
+		// no result
+		return null;
+	},
+});

server/services/slug-service/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { getReferenceFieldValues } = require('./getReferenceFieldValues');
+
+const shouldUpdateSlugInAfterCreate = (strapi, ctx, references) => {
+	if (!references.includes('id')) {
+		return false;
+	}
+
+	return true;
+};
+
+const shouldUpdateSlugInBeforeCreate = (strapi, ctx, references) => {
+	if (references.includes('id')) {
+		return false;
+	}
+
+	return true;
+};
+
+const shouldUpdateSlugInBeforeUpdate = async (strapi, ctx, references) => {
+	const record = await strapi.entityService.findOne(ctx.model.uid, ctx.params.where.id);
+
+	let currentReferenceFieldValues = getReferenceFieldValues(ctx, record, references);
+	let referenceFieldValues = getReferenceFieldValues(ctx, ctx.params.data, references);
+
+	// only update if reference a reference field has changed
+	if (JSON.stringify(referenceFieldValues) == JSON.stringify(currentReferenceFieldValues)) {
+		return false;
+	}
+
+	return true;
+};
+
+const shouldUpdateSlug = async (strapi, ctx, references) => {
+	let shouldUpdate = false;
+	if (ctx.action === 'beforeCreate') {
+		shouldUpdate = shouldUpdateSlugInBeforeCreate(strapi, ctx, references);
+	} else if (ctx.action === 'afterCreate') {
+		shouldUpdate = shouldUpdateSlugInAfterCreate(strapi, ctx, references);
+	} else if (ctx.action === 'beforeUpdate') {
+		shouldUpdate = shouldUpdateSlugInBeforeUpdate(strapi, ctx, references);
+	}
+
+	return shouldUpdate;
+};
+
+module.exports = {
+	shouldUpdateSlug,
+};