@gruodis/slug-for-strapi 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gruodis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# Slug For Strapi
+
+## 🚀 Installation
+
+```bash
+npm install @gruodis/slug-for-strapi
+# or
+yarn add @gruodis/slug-for-strapi
+```
+
+## Config
+
+`config/plugins.ts`:
+
+```javascript
+module.exports = {
+  'slug-for-strapi': {
+    enabled: true,
+    resolve: './node_modules/@gruodis/slug-for-strapi', // Path to the plugin
+    config: {
+      enabled: true,                    // Enable/disable plugin globally
+      sourceField: 'title',             // Primary field to generate slug from
+      fallbackField: 'name',            // Fallback field if primary is empty
+      addSuffixForUnique: true,         // Add suffixes for uniqueness
+      updateExistingSlugs: true,        // Update existing slugs when title changes
+      slugifyOptions: {
+        lower: true,
+        strict: true,
+        locale: 'lt'
+      }
+    }
+  }
+};
+```
+
+## 📖 Usage
+
+1. **Add a `slug` field** to any content type in your Strapi schema
+2. **Create or edit entries** - slugs will be automatically generated from `title` or `name` fields
+3. **String support** - Works with regular string fields
+
+### Example Content Type Schema
+
+```json
+{
+  "kind": "collectionType",
+  "collectionName": "articles",
+  "info": {
+    "singularName": "article",
+    "pluralName": "articles",
+    "displayName": "Articles"
+  },
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "slug": {
+      "type": "uid",
+      "targetField": "title"
+    }
+  }
+}
+```
+
+## 🔧 API Endpoints
+
+### 🔍 Find By Slug
+
+For every content type with a generated slug, the plugin automatically creates a GET endpoint:
+
+- `GET /api/:pluralApiId/slug/:slug`
+
+Example:
+- `GET /api/articles/slug/my-awesome-article`
+
+Response:
+```json
+{
+  "data": {
+    "id": 1,
+    "documentId": "...",
+    "title": "My Awesome Article",
+    "slug": "my-awesome-article",
+    ...
+  }
+}
+```
+
+> **Note:** These endpoints are read-only and public by default.
+
+## 📝 Field Types Supported
+
+### Regular String
+```json
+{
+  "title": "My Article Title"
+}
+```
+
+Will generate: `my-article-title`
+
+## Multi-locale Support
+
+The plugin supports different locales for transliteration. You can change the locale in your `config/plugins.ts`.
+
+## 🔧 Development
+
+```bash
+
+
+# Install dependencies
+npm install
+
+# Build the plugin
+npm run build
+```
+
+## 📄 License
+
+MIT License.

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@gruodis/slug-for-strapi",
+  "version": "1.0.0",
+  "description": "Does what it says. Slug for Strapi.",
+  "main": "strapi-server.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "develop": "tsc -w",
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 0"
+  },
+  "keywords": [
+    "strapi",
+    "plugin",
+    "slug",
+    "auto-generation",
+    "universal"
+  ],
+  "author": "Gruodis",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gruodis/slug-for-strapi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Gruodis/slug-for-strapi/issues"
+  },
+  "homepage": "https://github.com/Gruodis/slug-for-strapi#readme",
+  "strapi": {
+    "name": "slug-for-strapi",
+    "displayName": "Slug For Strapi",
+    "description": "Does what it says. Slug for Strapi.",
+    "kind": "plugin"
+  },
+  "dependencies": {
+    "slugify": "^1.6.6"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=6.0.0"
+  },
+  "files": [
+    "dist",
+    "server",
+    "admin",
+    "strapi-admin.js",
+    "strapi-server.js",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ]
+} 

package/server/bootstrap.js

@@ -0,0 +1,103 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // Register universal lifecycle hooks at Strapi startup
+  const registerSlugLifecycles = () => {
+    console.log('🚀 [Slug For Strapi] Initializing plugin...');
+    
+    // Get plugin configuration from Strapi
+    const pluginConfig = strapi.config.get('plugin.slug-for-strapi') || {};
+    console.log('⚙️ [Slug For Strapi] Plugin configuration:', pluginConfig);
+    
+    const slugService = strapi.plugin('slug-for-strapi').service('slug-generator');
+    
+    // Get all content-types with slug field
+    const contentTypesWithSlug = slugService.getContentTypesWithSlug();
+    
+    if (contentTypesWithSlug.length === 0) {
+      console.log('⚠️ [Slug For Strapi] No content-types found with slug field');
+      return;
+    }
+
+    // Register lifecycle hooks for each content-type
+    contentTypesWithSlug.forEach(({ uid, displayName }) => {
+      console.log(`📝 [Slug For Strapi] Registering lifecycle for ${displayName} (${uid})`);
+      
+      // In Strapi v5 use direct registration via strapi.db.lifecycles
+      strapi.db.lifecycles.subscribe({
+        models: [uid],
+        
+        // beforeCreate hook
+        async beforeCreate(event) {
+          const { data } = event.params;
+          console.log(`🆕 [Slug For Strapi] beforeCreate for ${uid}:`, data.title || data.name);
+          
+          if (!data.slug) {
+            const slug = await slugService.generateSlugForEntry(data, uid);
+            if (slug) {
+              data.slug = slug;
+              console.log(`✅ [Slug For Strapi] Slug created: "${slug}"`);
+            }
+          }
+        },
+
+        // beforeUpdate hook
+        async beforeUpdate(event) {
+          const { data, where } = event.params;
+          console.log(`🔄 [Slug For Strapi] beforeUpdate for ${uid}:`, data.title || data.name);
+          
+          // Generate slug only if it's missing or needs update
+          if (data.title || data.name) {
+            // Get current entity
+            const currentEntity = await strapi.db.query(uid).findOne({ where });
+            
+            // Try to generate slug (service decides whether to update or not)
+            const slug = await slugService.generateSlugForEntry(data, uid, currentEntity?.documentId);
+            if (slug) {
+              data.slug = slug;
+              console.log(`✅ [Slug For Strapi] Slug updated: "${slug}"`);
+            } else if (currentEntity?.slug) {
+              console.log(`⚠️ [Slug For Strapi] Slug already exists, skipping: "${currentEntity.slug}"`);
+            }
+          }
+        }
+      });
+    });
+    
+    console.log(`✅ [Slug For Strapi] Plugin initialized for ${contentTypesWithSlug.length} content-types`);
+
+    // Register findBySlug routes for each content-type
+    contentTypesWithSlug.forEach(({ uid, displayName }) => {
+      const contentType = strapi.contentTypes[uid];
+      const pluralName = contentType.info.pluralName;
+      
+      if (!pluralName) {
+        console.warn(`⚠️ [Slug For Strapi] Could not determine pluralName for ${uid}`);
+        return;
+      }
+
+      // Check if route already exists (plugin might re-initialize)
+      const routePath = `/api/${pluralName}/slug/:slug`;
+      const routes = strapi.server.router.stack.filter(layer => layer.path === routePath);
+      
+      if (routes.length > 0) {
+        console.log(`ℹ️ [Slug For Strapi] Route already exists, skipping: GET ${routePath}`);
+        return;
+      }
+
+      console.log(`🛣️ [Slug For Strapi] Registering route: GET ${routePath}`);
+
+      // Add route to Strapi Koa router
+      strapi.server.router.get(routePath, async (ctx, next) => {
+        // Add UID to params for controller
+        ctx.params.uid = uid;
+        
+        // Call controller
+        await strapi.plugin('slug-for-strapi').controller('general').findBySlug(ctx, next);
+      });
+    });
+  };
+
+  // Run registration after full Strapi initialization
+  registerSlugLifecycles();
+}; 

package/server/config/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+module.exports = {
+  default: {
+    // Global settings
+    enabled: true,
+    sourceField: 'title', // Primary field to generate slug from
+    fallbackField: 'name', // Fallback field if primary is empty
+    addSuffixForUnique: true, // Add suffixes for uniqueness (-1, -2, -3)
+    slugifyOptions: {
+      lower: true,
+      strict: true,
+      locale: 'lt'
+    },
+    
+    // Content-types settings (filled automatically)
+    contentTypes: {
+      // 'api::article.article': { enabled: true },
+      // 'api::page.page': { enabled: true },
+    }
+  },
+  validator: (config) => {
+    // Configuration validation
+    if (typeof config.enabled !== 'boolean') {
+      throw new Error('enabled must be a boolean');
+    }
+    if (typeof config.sourceField !== 'string') {
+      throw new Error('sourceField must be a string');
+    }
+  },
+}; 

package/server/controllers/general.js

@@ -0,0 +1,29 @@
+'use strict';
+
+module.exports = ({ strapi }) => ({
+  async findBySlug(ctx) {
+    const { uid, slug } = ctx.params;
+
+    if (!uid || !slug) {
+      return ctx.badRequest('Missing uid or slug');
+    }
+
+    try {
+      const entity = await strapi.db.query(uid).findOne({
+        where: { slug },
+        populate: true,
+      });
+
+      if (!entity) {
+        return ctx.notFound();
+      }
+
+      const sanitizedEntity = await strapi.contentAPI.sanitize.output(entity, strapi.getModel(uid));
+
+      ctx.body = { data: sanitizedEntity };
+    } catch (error) {
+      strapi.log.error(error);
+      ctx.internalServerError('An error occurred while fetching the entity by slug');
+    }
+  },
+});

package/server/controllers/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const general = require('./general');
+
+module.exports = {
+  general,
+}; 

package/server/index.js

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

package/server/routes/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = [
+  // Settings routes removed as configuration is done via config/plugins.ts
+]; 

package/server/services/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const slugGenerator = require('./slug-generator');
+
+module.exports = {
+  'slug-generator': slugGenerator,
+}; 

package/server/services/slug-generator.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const slugify = require('slugify');
+
+module.exports = ({ strapi }) => ({
+  /**
+   * Extracts text from field (string)
+   * @param {any} fieldValue - field value
+   * @returns {string} - text for slug generation
+   */
+  extractTextFromField(fieldValue) {
+    if (!fieldValue) return '';
+
+    // If it's a regular string
+    if (typeof fieldValue === 'string') {
+      console.log('🔍 [Slug For Strapi] Regular string detected');
+      return fieldValue;
+    }
+
+    console.log('⚠️ [Slug For Strapi] Unsupported field type (not a string):', typeof fieldValue, fieldValue);
+    return '';
+  },
+
+  /**
+   * Generates unique slug
+   * @param {string} text - source text
+   * @param {string} contentType - content type
+   * @param {string} documentId - document ID (to exclude from check)
+   * @param {object} options - slugify options
+   * @returns {Promise<string>} - unique slug
+   */
+  async generateUniqueSlug(text, contentType, documentId = null, options = {}) {
+    if (!text) {
+      console.log('⚠️ [Slug For Strapi] Empty text for slug generation');
+      return '';
+    }
+
+    // Get settings from Strapi config
+    const config = strapi.config.get('plugin.slug-for-strapi');
+    
+    // Generate base slug with settings from configuration
+    const baseSlug = slugify(text, {
+      ...config.slugifyOptions,
+      ...options
+    });
+
+    console.log('🔄 [Slug For Strapi] Base slug:', baseSlug);
+
+    // Check uniqueness
+    let slug = baseSlug;
+    let counter = 1;
+
+    while (true) {
+      // Find existing entries with this slug
+      const existing = await strapi.db.query(contentType).findOne({
+        where: { 
+          slug: slug,
+          ...(documentId && { documentId: { $ne: documentId } })
+        }
+      });
+
+      if (!existing) {
+        console.log('✅ [Slug For Strapi] Unique slug found:', slug);
+        break;
+      }
+
+      slug = `${baseSlug}-${counter}`;
+      counter++;
+      console.log('🔄 [Slug For Strapi] Trying slug:', slug);
+    }
+
+    return slug;
+  },
+
+  /**
+   * Generates slug for entry
+   * @param {object} data - entry data
+   * @param {string} contentType - content type
+   * @param {string} documentId - document ID
+   * @returns {Promise<string|null>} - generated slug or null
+   */
+  async generateSlugForEntry(data, contentType, documentId = null) {
+    console.log(`🔍 [Slug For Strapi] generateSlugForEntry called for ${contentType}`);
+    console.log(`📋 [Slug For Strapi] Data:`, JSON.stringify(data, null, 2));
+    
+    // Get current settings from Strapi config
+    const config = strapi.config.get('plugin.slug-for-strapi');
+    console.log(`⚙️ [Slug For Strapi] Configuration:`, config);
+    
+    // Check if plugin is enabled globally
+    if (!config.enabled) {
+      console.log(`❌ [Slug For Strapi] Plugin disabled globally`);
+      return null;
+    }
+
+    // Check if enabled for this content-type
+    const contentTypeConfig = config.contentTypes[contentType];
+    if (contentTypeConfig && contentTypeConfig.enabled === false) {
+      console.log(`⚠️ [Slug For Strapi] Generation disabled for ${contentType}`);
+      return null;
+    }
+
+    // If slug already exists, check update settings
+    if (data.slug && !config.updateExistingSlugs) {
+      console.log(`⚠️ [Slug For Strapi] Slug already exists, skipping: "${data.slug}"`);
+      return null;
+    }
+    
+    if (data.slug && config.updateExistingSlugs) {
+      console.log(`🔄 [Slug For Strapi] Slug exists, but updating according to settings: "${data.slug}"`);
+    }
+
+    console.log(`🔍 [Slug For Strapi] Looking for text in field "${config.sourceField}":`, data[config.sourceField]);
+
+    // Get text from primary field
+    let sourceText = this.extractTextFromField(
+      data[config.sourceField]
+    );
+
+    console.log(`📝 [Slug For Strapi] Extracted text from primary field:`, sourceText);
+
+    // If primary field is empty, try fallback
+    if (!sourceText && config.fallbackField) {
+      console.log(`🔍 [Slug For Strapi] Trying fallback field "${config.fallbackField}":`, data[config.fallbackField]);
+      sourceText = this.extractTextFromField(
+        data[config.fallbackField]
+      );
+      console.log(`📝 [Slug For Strapi] Extracted text from fallback field:`, sourceText);
+    }
+
+    if (!sourceText) {
+      console.log(`⚠️ [Slug For Strapi] No text found for slug generation in ${contentType}`);
+      console.log(`🔍 [Slug For Strapi] Checked fields: ${config.sourceField}, ${config.fallbackField}`);
+      return null;
+    }
+
+    console.log(`🚀 [Slug For Strapi] Generating slug for ${contentType} from text:`, sourceText);
+
+    // Generate unique slug
+    const slug = await this.generateUniqueSlug(
+      sourceText,
+      contentType,
+      documentId,
+      config.slugifyOptions
+    );
+
+    console.log(`✅ [Slug For Strapi] Final slug:`, slug);
+    return slug;
+  },
+
+  /**
+   * Processes all content-types and finds those with slug field
+   * @returns {Array} - list of content-types with slug field
+   */
+  getContentTypesWithSlug() {
+    const contentTypes = strapi.contentTypes;
+    const typesWithSlug = [];
+
+    for (const [uid, contentType] of Object.entries(contentTypes)) {
+      // Skip system types
+      if (!uid.startsWith('api::')) continue;
+
+      // Check if slug field exists
+      if (contentType.attributes && contentType.attributes.slug) {
+        typesWithSlug.push({
+          uid,
+          displayName: contentType.info?.displayName || uid,
+          hasSlugField: true,
+          hasTitleField: !!contentType.attributes.title,
+          hasNameField: !!contentType.attributes.name,
+        });
+      }
+    }
+
+    console.log('📋 [Slug For Strapi] Found content-types with slug field:', typesWithSlug);
+    return typesWithSlug;
+  }
+}); 

package/strapi-admin.js

@@ -0,0 +1,12 @@
+'use strict';
+
+export default {
+  register(app) {
+    // Registration of link in main menu removed, as settings are done via config file
+    // app.addMenuLink({...});
+  },
+  
+  bootstrap(app) {
+    console.log('🚀 [Slug For Strapi] Admin panel bootstrap');
+  },
+}; 

package/strapi-server.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./server');