@webbycrown/advanced-fields 1.0.0 → 1.0.1

package/admin/src/pages/App.jsx

@@ -0,0 +1,13 @@
+import { Page } from '@strapi/strapi/admin';
+import { Routes, Route } from 'react-router-dom';
+
+const App = () => {
+  return (
+    <Routes>
+      <Route index element={<Page.Error />} />
+      <Route path="*" element={<Page.Error />} />
+    </Routes>
+  );
+};
+
+export { App };

package/admin/src/pluginId.js

@@ -0,0 +1,3 @@
+'use strict';
+
+export const PLUGIN_ID = 'advanced-fields';

package/admin/src/translations/en.json

@@ -0,0 +1,86 @@
+{
+  "advanced-fields.plugin.name": "Advanced Fields",
+  "advanced-fields.input.label": "Advanced Input",
+  "advanced-fields.input.description": "Professional-grade text input with comprehensive validation and advanced configuration options",
+  "advanced-fields.checkbox.label": "Advanced Checkbox",
+  "advanced-fields.checkbox.description": "Unified checkbox field supporting both single and multiple selections with advanced configuration",
+  "advanced-fields.selectinput.label": "Select Input",
+  "advanced-fields.selectinput.description": "Select an option",
+
+  "advanced-fields.input.settings.base.label": "Basic settings",
+  "advanced-fields.input.options.required.label": "Required field",
+  "advanced-fields.input.options.required.description": "You won't be able to create an entry if this field is empty",
+  "advanced-fields.input.options.unique.label": "Unique field",
+  "advanced-fields.input.options.unique.description": "You won't be able to create an entry if there is an existing entry with identical content",
+  "advanced-fields.input.options.maxLength.label": "Maximum length",
+  "advanced-fields.input.options.maxLength.description": "Set the maximum number of characters allowed",
+  "advanced-fields.input.options.minLength.label": "Minimum length",
+  "advanced-fields.input.options.minLength.description": "Set the minimum number of characters allowed",
+  "advanced-fields.input.options.defaultValue.label": "Default value",
+  "advanced-fields.input.options.defaultValue.description": "Set the default value for this field",
+
+  "advanced-fields.input.settings.advanced.label": "Advanced settings",
+  "advanced-fields.input.options.regex.label": "RegExp pattern",
+  "advanced-fields.input.options.regex.description": "The text of the regular expression",
+  "advanced-fields.input.options.placeholder.label": "Placeholder",
+  "advanced-fields.input.options.placeholder.description": "Display text when the field is empty",
+  "advanced-fields.input.options.private.label": "Private field",
+  "advanced-fields.input.options.private.description": "This field will not be included in API responses",
+  "advanced-fields.input.options.customErrorMessage.label": "Custom error message",
+  "advanced-fields.input.options.customErrorMessage.description": "Display a custom error message when validation fails",
+
+  "advanced-fields.checkbox.settings.base.label": "Basic settings",
+  "advanced-fields.checkbox.options.required.label": "Required field",
+  "advanced-fields.checkbox.options.required.description": "You won't be able to create an entry if this field is empty",
+  "advanced-fields.checkbox.options.checkboxType.label": "Checkbox Type",
+  "advanced-fields.checkbox.options.checkboxType.description": "Choose between single checkbox or multiple checkboxes",
+  "advanced-fields.checkbox.options.checkboxType.single": "Single Checkbox",
+  "advanced-fields.checkbox.options.checkboxType.multiple": "Multiple Checkboxes",
+  "advanced-fields.checkbox.options.defaultValue.label": "Default State",
+  "advanced-fields.checkbox.options.defaultValue.description": "Pre-checked state for single checkbox",
+  "advanced-fields.checkbox.options.defaultValue.options.true": "Checked (True)",
+  "advanced-fields.checkbox.options.defaultValue.options.false": "Unchecked (False)",
+
+  "advanced-fields.checkbox.settings.advanced.label": "Advanced settings",
+  "advanced-fields.checkbox.options.customErrorMessage.label": "Custom error message",
+  "advanced-fields.checkbox.options.customErrorMessage.description": "Display a custom error message when validation fails",
+  "advanced-fields.checkbox.options.customErrorMessage.placeholder": "Enter custom error message",
+  "advanced-fields.checkbox.options.private.label": "Private field",
+  "advanced-fields.checkbox.options.private.description": "This field will not be included in API responses",
+  "advanced-fields.checkbox.options.labelOn.label": "Checked Label",
+  "advanced-fields.checkbox.options.labelOn.description": "Custom label displayed when single checkbox is checked",
+  "advanced-fields.checkbox.options.labelOff.label": "Unchecked Label",
+  "advanced-fields.checkbox.options.labelOff.description": "Custom label displayed when single checkbox is unchecked",
+  "advanced-fields.checkbox.options.checkboxOptions.label": "Checkbox Options",
+  "advanced-fields.checkbox.options.checkboxOptions.description": "Define available options for multiple checkboxes (one per line: value|label)",
+  "advanced-fields.checkbox.options.checkboxOptions.placeholder": "option1|Option 1\noption2|Option 2\noption3|Option 3",
+  "advanced-fields.checkbox.options.defaultSelected.label": "Default Selected",
+  "advanced-fields.checkbox.options.defaultSelected.description": "Pre-selected options for multiple checkboxes (one per line)",
+  "advanced-fields.checkbox.options.defaultSelected.placeholder": "option1\noption2",
+  "advanced-fields.checkbox.options.minChoices.label": "Minimum Choices",
+  "advanced-fields.checkbox.options.minChoices.description": "Minimum number of options that must be selected (0 for no minimum)",
+  "advanced-fields.checkbox.options.maxChoices.label": "Maximum Choices",
+  "advanced-fields.checkbox.options.maxChoices.description": "Maximum number of options that can be selected (0 for no maximum)",
+  "advanced-fields.checkbox.options.layout.label": "Layout Style",
+  "advanced-fields.checkbox.options.layout.description": "Visual layout of multiple checkbox options",
+  "advanced-fields.checkbox.options.layout.vertical": "Vertical Stack",
+  "advanced-fields.checkbox.options.layout.horizontal": "Horizontal Row",
+  "advanced-fields.checkbox.options.layout.grid": "Grid Layout",
+
+  "advanced-fields.radio.label": "Multiple Type Choice",
+  "advanced-fields.radio.description": "Select one or more options (radio style)",
+  "advanced-fields.radio.settings.base.label": "Basic settings",
+  "advanced-fields.radio.options.required.label": "Multiple Type Choice",
+  "advanced-fields.radio.options.required.description": "You won't be able to create an entry if this field is empty",
+  "advanced-fields.radio.options.radioOptions.label": "Multiple Type Choice",
+  "advanced-fields.radio.options.radioOptions.description": "Enter one option per line in format: value|label (e.g., \"1|Option 1\")",
+  "advanced-fields.radio.options.radioOptions.placeholder": "1|Option 1\n2|Option 2\n3|Option 3",
+  "advanced-fields.radio.options.selectionType.label": "Selection Type",
+  "advanced-fields.radio.options.selectionType.description": "Allow selecting only one or multiple type choices",
+  "advanced-fields.radio.options.customErrorMessage.label": "Custom error message",
+  "advanced-fields.radio.options.customErrorMessage.description": "Display a custom error message when validation fails",
+  "advanced-fields.radio.options.customErrorMessage.placeholder": "Enter custom error message",
+  "advanced-fields.radio.no-options": "No options defined. Please configure this field in the content type settings.",
+  "advanced-fields.radio.options.type.single": "Single selection",
+  "advanced-fields.radio.options.type.multiple": "Multiple selection"
+}

package/admin/src/utils/getTranslation.js

@@ -0,0 +1,5 @@
+import { PLUGIN_ID } from '../pluginId';
+
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+
+export { getTranslation };

package/index.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const PLUGIN_ID = 'advanced-fields';
+
+const customFields = [
+  {
+    name: 'input',
+    type: 'string',
+    validate: (value, { required, options = {} }) => {
+      // Basic required validation
+      if (required && (!value || value.toString().trim().length === 0)) {
+        return 'This field is required';
+      }
+      
+      // Length validation
+      if (value && options.maxLength && value.length > options.maxLength) {
+        return `Maximum length is ${options.maxLength} characters`;
+      }
+      if (value && options.minLength && value.length < options.minLength) {
+        return `Minimum length is ${options.minLength} characters`;
+      }
+      
+      // Regex validation
+      if (value && options.regex) {
+        try {
+          const regex = new RegExp(options.regex);
+          if (!regex.test(value)) {
+            return options.customErrorMessage || 'Value does not match required format';
+          }
+        } catch (e) {
+          console.warn('Invalid regex pattern:', options.regex);
+        }
+      }
+      
+      // Input type validation
+      if (value && options.inputType) {
+        switch (options.inputType) {
+          case 'email':
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(value)) {
+              return 'Please enter a valid email address';
+            }
+            break;
+          case 'url':
+            try {
+              new URL(value);
+            } catch {
+              return 'Please enter a valid URL';
+            }
+            break;
+          case 'number':
+            if (isNaN(parseFloat(value))) {
+              return 'Please enter a valid number';
+            }
+            break;
+        }
+      }
+      
+      return null;
+    }
+  },
+  {
+    name: 'checkbox',
+    type: 'json',
+    validate: (value, { required, options = {} }) => {
+      console.log('[advanced-fields] Checkbox validation:', {
+        value,
+        required,
+        options,
+        valueType: typeof value,
+        isArray: Array.isArray(value),
+        valueLength: Array.isArray(value) ? value.length : 'N/A',
+        checkboxType: options.checkboxType
+      });
+      
+      // Basic required validation
+      if (required) {
+        if (!value || 
+            (Array.isArray(value) && value.length === 0) ||
+            (typeof value === 'string' && value.trim() === '') ||
+            value === null ||
+            value === undefined) {
+          console.log('[advanced-fields] Checkbox validation failed: required field is empty');
+          return options.customErrorMessage || 'This field is required';
+        }
+      }
+      
+      // If no value and not required, no additional validation needed
+      if (!required && (!value || (Array.isArray(value) && value.length === 0))) {
+        console.log('[advanced-fields] Checkbox validation passed (no value, not required)');
+        return null;
+      }
+      
+      // Choice validation for multiple checkboxes only
+      if (options.checkboxType === 'multiple' && Array.isArray(value)) {
+        if (options.minChoices > 0 && value.length < options.minChoices) {
+          return options.customErrorMessage || `Please select at least ${options.minChoices} option${options.minChoices > 1 ? 's' : ''}`;
+        }
+        if (options.maxChoices > 0 && value.length > options.maxChoices) {
+          return options.customErrorMessage || `Please select at most ${options.maxChoices} option${options.maxChoices > 1 ? 's' : ''}`;
+        }
+      }
+      
+      console.log('[advanced-fields] Checkbox validation passed');
+      return null;
+    }
+  },
+  {
+    name: "radio",
+    type: "json",
+    validate: (value, { required, options = {} }) => {
+      // Basic required validation
+      if (required) {
+        if (!value || 
+            (Array.isArray(value) && value.length === 0) ||
+            (typeof value === 'string' && value.trim() === '') ||
+            value === null ||
+            value === undefined) {
+          return 'This field is required';
+        }
+      }
+      
+      // Choice validation
+      if (Array.isArray(value)) {
+        if (options.minChoices > 0 && value.length < options.minChoices) {
+          return `Please select at least ${options.minChoices} option${options.minChoices > 1 ? 's' : ''}`;
+        }
+        if (options.maxChoices > 0 && value.length > options.maxChoices) {
+          return `Please select at most ${options.maxChoices} option${options.maxChoices > 1 ? 's' : ''}`;
+        }
+      }
+      
+      return null;
+    }
+  }
+];
+
+module.exports = {
+  register({ strapi }) {
+    console.log(`[${PLUGIN_ID}] Registering custom fields...`);
+    
+    // Ensure custom fields registry is available
+    if (!strapi.customFields) {
+      console.error(`[${PLUGIN_ID}] Custom fields registry not available`);
+      return;
+    }
+    
+    // Register custom fields with proper error handling
+    customFields.forEach((field) => {
+      try {
+        console.log(`[${PLUGIN_ID}] Registering field: ${field.name} (type: ${field.type})`);
+        
+        const fieldConfig = {
+          name: field.name,
+          pluginId: PLUGIN_ID,
+          type: field.type,
+        };
+        
+        // Add validation function if it exists
+        if (field.validate) {
+          fieldConfig.validate = field.validate;
+          console.log(`[${PLUGIN_ID}] Added validation function for field: ${field.name}`);
+        }
+        
+        strapi.customFields.register(fieldConfig);
+        console.log(`[${PLUGIN_ID}] Successfully registered field: ${field.name}`);
+      } catch (error) {
+        console.error(`[${PLUGIN_ID}] Failed to register field ${field.name}:`, error.message);
+        console.error(`[${PLUGIN_ID}] Error details:`, error);
+      }
+    });
+    
+    console.log(`[${PLUGIN_ID}] All custom fields registration completed`);
+  },
+
+  bootstrap({ strapi }) {
+    console.log(`[${PLUGIN_ID}] Bootstrap starting...`);
+    
+    // Wait a bit for registration to complete
+    setTimeout(() => {
+      // Verify all fields are registered only if customFields.get is available
+      if (strapi.customFields && typeof strapi.customFields.get === 'function') {
+        customFields.forEach((field) => {
+          try {
+            const registeredField = strapi.customFields.get(`${PLUGIN_ID}.${field.name}`);
+            if (registeredField) {
+              console.log(`[${PLUGIN_ID}] ✅ Field verified: ${field.name}`);
+            } else {
+              console.error(`[${PLUGIN_ID}] ❌ Field not found in registry: ${field.name}`);
+            }
+          } catch (error) {
+            console.error(`[${PLUGIN_ID}] Error verifying field ${field.name}:`, error.message);
+          }
+        });
+      } else {
+        console.log(`[${PLUGIN_ID}] Skipping field verification (customFields.get not available)`);
+      }
+    }, 100);
+    
+    console.log(`[${PLUGIN_ID}] Bootstrap completed`);
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webbycrown/advanced-fields",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "keywords": [
     "strapi",
     "plugin",
@@ -26,6 +26,10 @@
   },
   "files": [
     "dist",
+    "admin",
+    "strapi-server.js",
+    "strapi-server.mjs",
+    "index.js",
     "README.md",
     "LICENSE"
   ],

package/strapi-server.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const PLUGIN_ID = 'advanced-fields';
+
+const customFields = [
+  {
+    name: 'input',
+    type: 'string',
+    validate: (value, { required, options = {} }) => {
+      // Parse field options
+      const {
+        minLength = 0,
+        maxLength = 0,
+        regex = '',
+        customErrorMessage = ''
+      } = options;
+      
+      // Check required validation
+      if (required && (!value || value.trim().length === 0)) {
+        return customErrorMessage || 'This field is required';
+      }
+      
+      // If no value, no additional validation needed
+      if (!value || value.trim().length === 0) {
+        return null;
+      }
+      
+      const stringValue = value.toString().trim();
+      
+      // Check min/max length validation
+      if (minLength > 0 && stringValue.length < minLength) {
+        return customErrorMessage || `Minimum length is ${minLength} characters`;
+      }
+      if (maxLength > 0 && stringValue.length > maxLength) {
+        return customErrorMessage || `Maximum length is ${maxLength} characters`;
+      }
+      
+      // Check regex validation
+      if (regex && regex.trim()) {
+        try {
+          const regexPattern = new RegExp(regex);
+          if (!regexPattern.test(stringValue)) {
+            return customErrorMessage || 'Value does not match the required pattern';
+          }
+        } catch (e) {
+          // Invalid regex pattern, skip validation
+        }
+      }
+      
+      return null;
+    }
+  },
+  {
+    name: 'checkbox',
+    type: 'json',
+    validate: (value, { required, options = {} }) => {
+      // Parse field options
+      const {
+        checkboxType = 'single',
+        minChoices = 0,
+        maxChoices = 0,
+        customErrorMessage = ''
+      } = options;
+      
+      // Check required validation
+      if (required) {
+        if (!value || 
+            (Array.isArray(value) && value.length === 0) ||
+            (typeof value === 'string' && value.trim() === '') ||
+            value === null ||
+            value === undefined) {
+          return customErrorMessage || 'This field is required';
+        }
+      }
+      
+      // If no value, no additional validation needed
+      if (!value || (Array.isArray(value) && value.length === 0)) {
+        return null;
+      }
+      
+      const values = Array.isArray(value) ? value : [];
+      
+      // Check min/max choices validation (only for multiple mode)
+      if (checkboxType === 'multiple') {
+        if (minChoices > 0 && values.length < minChoices) {
+          return customErrorMessage || `Please select at least ${minChoices} option${minChoices > 1 ? 's' : ''}`;
+        }
+        if (maxChoices > 0 && values.length > maxChoices) {
+          return customErrorMessage || `Please select at most ${maxChoices} option${maxChoices > 1 ? 's' : ''}`;
+        }
+      }
+      
+      return null;
+    }
+  },
+  {
+    name: "radio",
+    type: "json",
+    validate: (value, { required, options = {} }) => {
+      // Parse field options
+      const {
+        selectionType = 'single',
+        minChoices = 0,
+        maxChoices = 0,
+        customErrorMessage = ''
+      } = options;
+      
+      // Check required validation
+      if (required) {
+        if (!value || 
+            (Array.isArray(value) && value.length === 0) ||
+            (typeof value === 'string' && value.trim() === '') ||
+            value === null ||
+            value === undefined) {
+          return customErrorMessage || 'This field is required';
+        }
+      }
+      
+      // If no value, no additional validation needed
+      if (!value || (Array.isArray(value) && value.length === 0)) {
+        return null;
+      }
+      
+      const values = Array.isArray(value) ? value : [];
+      
+      // Check min/max choices validation (only for multiple mode)
+      if (selectionType === 'multiple') {
+        if (minChoices > 0 && values.length < minChoices) {
+          return customErrorMessage || `Please select at least ${minChoices} option${minChoices > 1 ? 's' : ''}`;
+        }
+        if (maxChoices > 0 && values.length > maxChoices) {
+          return customErrorMessage || `Please select at most ${maxChoices} option${maxChoices > 1 ? 's' : ''}`;
+        }
+      }
+      
+      return null;
+    }
+  }
+];
+
+module.exports = {
+  register({ strapi }) {
+    // Ensure custom fields registry is available
+    if (!strapi.customFields) {
+      return;
+    }
+    
+    // Register custom fields with proper error handling
+    customFields.forEach((field) => {
+      try {
+        const fieldConfig = {
+          name: field.name,
+          plugin: PLUGIN_ID,
+          type: field.type,
+        };
+        
+        // Add validation function if it exists
+        if (field.validate) {
+          fieldConfig.validate = field.validate;
+        }
+        
+        strapi.customFields.register(fieldConfig);
+      } catch (error) {
+        // Silent error handling
+      }
+    });
+  },
+
+  bootstrap({ strapi }) {
+    // Wait longer for registration to complete
+    setTimeout(() => {
+      // Verify all fields are registered only if customFields.get is available
+      if (strapi.customFields && typeof strapi.customFields.get === 'function') {
+        customFields.forEach((field) => {
+          try {
+            const registeredField = strapi.customFields.get(`${PLUGIN_ID}.${field.name}`);
+            // Field verification completed silently
+          } catch (error) {
+            // Silent error handling
+          }
+        });
+      }
+    }, 1000);
+  },
+};
+

package/strapi-server.mjs

@@ -0,0 +1,74 @@
+'use strict';
+
+const PLUGIN_ID = 'advanced-fields';
+
+const customFields = [
+  {
+    name: 'input',
+    type: 'string',
+  },
+  {
+    name: 'checkbox',
+    type: 'json',
+  },
+  {
+    name: "radio",
+    type: "json"
+  }
+];
+
+module.exports = {
+  register({ strapi }) {
+    console.log(`[${PLUGIN_ID}] Registering custom fields...`);
+    
+    // Ensure custom fields registry is available
+    if (!strapi.customFields) {
+      console.error(`[${PLUGIN_ID}] Custom fields registry not available`);
+      return;
+    }
+    
+    // Register custom fields with proper error handling
+    customFields.forEach((field) => {
+      try {
+        console.log(`[${PLUGIN_ID}] Registering field: ${field.name} (type: ${field.type})`);
+        strapi.customFields.register({
+          name: field.name,
+          plugin: PLUGIN_ID,
+          type: field.type,
+        });
+        console.log(`[${PLUGIN_ID}] Successfully registered field: ${field.name}`);
+      } catch (error) {
+        console.error(`[${PLUGIN_ID}] Failed to register field ${field.name}:`, error.message);
+      }
+    });
+    
+    console.log(`[${PLUGIN_ID}] All custom fields registration completed`);
+  },
+
+  bootstrap({ strapi }) {
+    console.log(`[${PLUGIN_ID}] Bootstrap starting...`);
+    
+    // Wait longer for registration to complete
+    setTimeout(() => {
+      // Verify all fields are registered only if customFields.get is available
+      if (strapi.customFields && typeof strapi.customFields.get === 'function') {
+        customFields.forEach((field) => {
+          try {
+            const registeredField = strapi.customFields.get(`${PLUGIN_ID}.${field.name}`);
+            if (registeredField) {
+              console.log(`[${PLUGIN_ID}] ✅ Field verified: ${field.name}`);
+            } else {
+              console.error(`[${PLUGIN_ID}] ❌ Field not found in registry: ${field.name}`);
+            }
+          } catch (error) {
+            console.error(`[${PLUGIN_ID}] Error verifying field ${field.name}:`, error.message);
+          }
+        });
+      } else {
+        console.log(`[${PLUGIN_ID}] Skipping field verification (customFields.get not available)`);
+      }
+    }, 1000);
+    
+    console.log(`[${PLUGIN_ID}] Bootstrap completed`);
+  },
+};