@tunghtml/strapi-plugin-export-import-clsx 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tunghtml/strapi-plugin-export-import-clsx",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A powerful Strapi plugin for exporting and importing data with Excel support and advanced filtering",
   "main": "./strapi-server.js",
   "scripts": {
@@ -57,4 +57,4 @@
     "kind": "plugin",
     "category": "data-management"
   }
-}
+}

package/server/controllers/import-controller.js

@@ -12,7 +12,7 @@ module.exports = ({ strapi }) => ({
       
       const importService = strapi.plugin('export-import-clsx').service('import-service');
       
-      const result = await importService.importData(file, targetContentType);
+      const result = await importService.importData(file);
       
       // Create appropriate message based on results
       let message = 'Import completed successfully';

package/server/services/export-service.js

@@ -22,13 +22,13 @@ module.exports = ({ strapi }) => ({
       try {
         // Parse filters from URL format
         const parsedFilters = this.parseFilters(filters);
-        
+
         strapi.log.info(`Exporting ${ct} with raw filters:`, filters);
         strapi.log.info(`Parsed filters:`, parsedFilters);
         strapi.log.info(`Selected IDs:`, selectedIds);
 
         let entries = [];
-        
+
         // If specific IDs are selected, export only those
         if (selectedIds && selectedIds.length > 0) {
           try {
@@ -74,22 +74,18 @@ module.exports = ({ strapi }) => ({
                 populate: '*',
                 // Don't specify status to get all
               });
-              
               // Group by documentId and keep only the best version (published > modified draft > draft)
               const uniqueEntries = new Map();
-              
               for (const entry of allEntries) {
                 const docId = entry.documentId;
                 const isPublished = !!entry.publishedAt;
                 const isModified = entry.updatedAt !== entry.createdAt;
-                
                 if (!uniqueEntries.has(docId)) {
                   uniqueEntries.set(docId, entry);
                 } else {
                   const existing = uniqueEntries.get(docId);
                   const existingIsPublished = !!existing.publishedAt;
                   const existingIsModified = existing.updatedAt !== existing.createdAt;
-                  
                   // Priority: published > modified draft > draft
                   if (isPublished && !existingIsPublished) {
                     uniqueEntries.set(docId, entry);
@@ -98,10 +94,10 @@ module.exports = ({ strapi }) => ({
                   }
                 }
               }
-              
+
               entries = Array.from(uniqueEntries.values());
               strapi.log.info(`Found ${allEntries.length} total entries, ${entries.length} unique entries after deduplication`);
-              
+
               // Apply filters
               if (parsedFilters && Object.keys(parsedFilters).length > 0) {
                 strapi.log.info('Applying filters:', parsedFilters);
@@ -120,9 +116,9 @@ module.exports = ({ strapi }) => ({
             strapi.log.error(`Failed to query entries:`, error);
           }
         }
-        
+
         strapi.log.info(`Final result: ${entries?.length || 0} entries for ${ct} (total found: ${entries?.length || 0})`);
-        
+
         if (entries && entries.length > 0) {
           exportData.data[ct] = entries;
         }
@@ -130,8 +126,9 @@ module.exports = ({ strapi }) => ({
         strapi.log.error(`Failed to export ${ct}:`, error);
       }
     }
-
+    
     if (format === 'excel') {
+      console.log(exportData.data)
       return this.convertToExcel(exportData.data);
     }
 
@@ -140,27 +137,26 @@ module.exports = ({ strapi }) => ({
 
   parseFilters(filters) {
     const parsed = {};
-    
     for (const [key, value] of Object.entries(filters)) {
       // Skip pagination and sorting params
       if (['page', 'pageSize', 'sort', 'locale', 'format', 'contentType', 'selectedIds'].includes(key)) {
         continue;
       }
-      
+
       // Handle URL encoded filter format like filters[$and][0][shortName][$contains]
       if (key.startsWith('filters[')) {
         // Extract the actual filter structure
         const match = key.match(/filters\[([^\]]+)\](?:\[(\d+)\])?\[([^\]]+)\](?:\[([^\]]+)\])?/);
         if (match) {
           const [, operator, index, field, condition] = match;
-          
+
           if (!parsed.filters) parsed.filters = {};
-          
+
           if (operator === '$and') {
             if (!parsed.filters.$and) parsed.filters.$and = [];
             const idx = parseInt(index) || 0;
             if (!parsed.filters.$and[idx]) parsed.filters.$and[idx] = {};
-            
+
             if (condition) {
               if (!parsed.filters.$and[idx][field]) parsed.filters.$and[idx][field] = {};
               parsed.filters.$and[idx][field][condition] = value;
@@ -173,7 +169,7 @@ module.exports = ({ strapi }) => ({
         parsed[key] = value;
       }
     }
-    
+
     return parsed;
   },
 
@@ -192,7 +188,6 @@ module.exports = ({ strapi }) => ({
               if (entry[field]) {
                 const fieldValue = String(entry[field]).toLowerCase();
                 const searchValue = String(criteria.$contains).toLowerCase();
-                
                 if (!fieldValue.includes(searchValue)) {
                   return false;
                 }
@@ -208,30 +203,26 @@ module.exports = ({ strapi }) => ({
           }
         }
       }
-      
       // Handle other filter formats
       for (const [key, value] of Object.entries(filters)) {
         if (key === 'filters') continue; // Already handled above
-        
+
         // Handle simple search (global search)
         if (key === '_q' || key === 'search') {
           // Global search across main fields
           const searchFields = ['shortName', 'name', 'title'];
           const searchValue = String(value).toLowerCase();
-          
           const found = searchFields.some(field => {
             if (entry[field]) {
               return String(entry[field]).toLowerCase().includes(searchValue);
             }
             return false;
           });
-          
           if (!found) {
             return false;
           }
         }
       }
-      
       return true;
     });
 
@@ -245,53 +236,94 @@ module.exports = ({ strapi }) => ({
     for (const [contentType, entries] of Object.entries(data)) {
       // Clean sheet name (Excel has restrictions)
       const sheetName = contentType.replace(/[^\w\s]/gi, '_').substring(0, 31);
-      
       if (entries && entries.length > 0) {
         hasData = true;
-        
+
+        const attr = strapi.contentTypes[contentType].attributes;
+        const customFields = Object.entries(attr)
+          .filter(([key, definition]) => definition.customField)
+          .map(([key, definition]) => key);
+
         // Clean and flatten entries for Excel
         const cleanedEntries = entries.map(entry => {
-          // Keep important system fields for import
-          const { 
-            createdBy, 
-            updatedBy, 
-            localizations,
-            ...entryWithSystemFields 
-          } = entry;
-
-          const flattened = {
-            // Always include these at the beginning for import reference
-            id: entry.id,
-            documentId: entry.documentId,
-            locale: entry.locale || 'en',
-          };
-          
-          const flatten = (obj, prefix = '') => {
-            for (const key in obj) {
-              // Skip already processed system fields and status fields
-              if (['id', 'documentId', 'createdBy', 'updatedBy', 'localizations', 'publishedAt', 'status'].includes(key)) {
-                continue;
-              }
-              
-              if (obj[key] !== null && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
-                // Skip nested objects that are system fields
-                if (key === 'createdBy' || key === 'updatedBy') {
+          const SYSTEM_KEYS = [
+            'documentId', 
+            'locale', 
+            'createdAt', 
+            'updatedAt', 
+            'publishedAt', 
+            'createdBy', 
+            'updatedBy', 
+            'localizations', 
+            'status'
+          ];
+
+          function cleanAndFlatten(obj) {
+            if (Array.isArray(obj)) {
+              return obj.map(cleanAndFlatten);
+            } else if (obj !== null && typeof obj === 'object') {
+              const result = {};
+
+              for (const key in obj) {
+                const value = obj[key];
+
+                // Skip system keys
+                if (SYSTEM_KEYS.includes(key)) continue;
+                if (customFields.includes(key)) continue;
+
+                // Null or primitive
+                if (value === null || typeof value !== 'object') {
+                  result[key] = value;
                   continue;
                 }
-                flatten(obj[key], prefix + key + '_');
-              } else if (Array.isArray(obj[key])) {
-                flattened[prefix + key] = JSON.stringify(obj[key]);
-              } else {
-                flattened[prefix + key] = obj[key];
+
+                // Array handling
+                if (Array.isArray(value)) {
+                  // Array of objects
+                  if (value.length > 0 && typeof value[0] === 'object') {
+                    result[key] = value.map(cleanAndFlatten);
+                  } else {
+                    // Array of primitives
+                    result[key] = value;
+                  }
+                  continue;
+                }
+
+                // Component (no documentId)
+                if (!('documentId' in value)) {
+                  for (const subKey in value) {
+                    if (subKey === 'id') continue; // skip id
+                    result[`${key}_${subKey}`] = value[subKey];
+                  }
+                  continue; // skip keeping the original key
+                }
+                // Relation object (has documentId)
+                result[key] = cleanAndFlatten(value);
               }
+              return result;
+            } else {
+              return obj; // primitive
             }
-          };
-          
-          flatten(entryWithSystemFields);
-          return flattened;
+          }
+          // Example usage
+          const cleaned = cleanAndFlatten(entry);
+          return cleaned;
         });
 
-        const worksheet = XLSX.utils.json_to_sheet(cleanedEntries);
+        function flattenForXLSX(obj) {
+          const result = {};
+          for (const key in obj) {
+            const value = obj[key];
+            if (Array.isArray(value)) {
+              result[key] = JSON.stringify(value);
+            } else {
+              result[key] = value;
+            }
+          }
+          return result;
+        }
+        const cleanedFlat = cleanedEntries.map(entry => flattenForXLSX(entry));
+        const worksheet = XLSX.utils.json_to_sheet(cleanedFlat);
         XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
       } else {
         // Create empty sheet with headers if no data

package/server/services/import-service.js

@@ -1,306 +1,358 @@
-const fs = require('fs');
 const XLSX = require('xlsx');
+const fs = require('fs');
 
-module.exports = ({ strapi }) => ({
-  async importData(file, targetContentType = null) {
-    try {
-      let importData;
-      
-      // Check file extension
-      const fileName = file.name || file.originalFilename || 'unknown.json';
-      const fileExtension = fileName.split('.').pop().toLowerCase();
-      
-      const filePath = file.path || file.filepath;
-      
-      if (!filePath) {
-        throw new Error('File path not found');
-      }
+function toCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+const SYSTEM_KEYS = [
+  'documentId', 
+  'locale', 
+  'createdAt', 
+  'updatedAt', 
+  'publishedAt', 
+  'createdBy', 
+  'updatedBy', 
+  'localizations', 
+  'status'
+];
+
+async function importData(file) {
+  let result;
+  try {
+    let importData;
+    // Check file extension
+    const fileName = file.name || file.originalFilename || 'unknown.json';
+    const fileExtension = fileName.split('.').pop().toLowerCase();
+    const filePath = file.path || file.filepath;
+    if (!filePath) {
+      throw new Error('File path not found');
+    }
+
+    if (fileExtension === 'json') {
+      const fileContent = fs.readFileSync(filePath, 'utf8');
+      importData = JSON.parse(fileContent);
+      strapi.log.info('Parsed JSON data:', Object.keys(importData));
+    } else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
+      importData = transformExcelData(filePath);
+    }
+    result = await bulkInsertData(importData);
+    return result;
+  } catch (error) {
+    // Clean up uploaded file on error
+    const filePath = file && (file.path || file.filepath);
+    if (filePath && fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+    throw error;
+  }
+}
+
+
+function transformExcelData(filePath) {
+    const workbook = XLSX.readFile(filePath);
+    const importData = {};
 
-      if (fileExtension === 'json') {
-        const fileContent = fs.readFileSync(filePath, 'utf8');
-        importData = JSON.parse(fileContent);
-        strapi.log.info('Parsed JSON data:', Object.keys(importData));
-      } else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
-        const workbook = XLSX.readFile(filePath);
-        importData = {};
-        
-        strapi.log.info('Excel sheet names:', workbook.SheetNames);
-        
-        // Convert each sheet to data
-        workbook.SheetNames.forEach(sheetName => {
-          const worksheet = workbook.Sheets[sheetName];
-          const jsonData = XLSX.utils.sheet_to_json(worksheet);
-          strapi.log.info(`Sheet ${sheetName} has ${jsonData.length} rows`);
-          if (jsonData.length > 0) {
-            // Map sheet name back to content type
-            let contentTypeName = sheetName;
-            if (sheetName.startsWith('api__')) {
-              // Convert api__corporate_corporate to api::corporate.corporate
-              contentTypeName = sheetName.replace(/^api__/, 'api::').replace(/_/g, '.');
+    const parseJsonIfNeeded = (value) => {
+        if (typeof value !== 'string') return value;
+        const trimmed = value.trim();
+        if (!trimmed.startsWith('[') && !trimmed.startsWith('{')) return value;
+
+        try {
+        return JSON.parse(trimmed);
+        } catch {
+        return value; // keep as string if invalid JSON
+        }
+    };
+
+    const isComponentField = (key) => {
+        const parts = key.split('_');
+        return parts.length === 2; // exactly one underscore
+    };
+
+    function unflattenRow(rows, targetContentType) {
+      const result = [];
+      for (const row of rows) {
+        const rowData = {};
+
+        for (const [key, value] of Object.entries(row)) {
+            if (value === null || value === undefined || value === '') {
+              rowData[key] = null
             }
-            
-            // Unflatten Excel data back to nested objects
-            const unflattened = jsonData.map((row, index) => {
-              const result = {};
-              
-              // Known component prefixes that should be unflattened
-              const componentPrefixes = ['corporateInfo', 'meetingRequirements', 'internalInfo'];
-              
-              for (const [key, value] of Object.entries(row)) {
-                // Skip completely empty values but keep 0, false, etc.
-                if (value === null || value === undefined || value === '') {
-                  continue;
-                }
-                
-                // Check if this key should be unflattened
-                const shouldUnflatten = key.includes('_') && 
-                  !['createdAt', 'updatedAt', 'publishedAt'].includes(key) &&
-                  componentPrefixes.some(prefix => key.startsWith(prefix + '_'));
-                
-                if (shouldUnflatten) {
-                  // Handle nested objects like corporateInfo_companyName
-                  const parts = key.split('_');
-                  let current = result;
-                  
-                  for (let i = 0; i < parts.length - 1; i++) {
-                    if (!current[parts[i]]) {
-                      current[parts[i]] = {};
-                    }
-                    current = current[parts[i]];
-                  }
-                  
-                  current[parts[parts.length - 1]] = value;
-                } else {
-                  // Handle arrays/JSON strings
-                  if (typeof value === 'string' && (value.startsWith('[') || value.startsWith('{'))) {
-                    try {
-                      result[key] = JSON.parse(value);
-                    } catch (error) {
-                      result[key] = value; // Keep as string if parsing fails
-                    }
-                  } else {
-                    result[key] = value;
-                  }
-                }
-              }
-              
-              // Debug info removed for cleaner logs
-              
-              return result;
-            });
-            
-            importData[contentTypeName] = unflattened;
-            strapi.log.info(`Mapped sheet ${sheetName} to ${contentTypeName}`);
+
+            if (isComponentField(key)) {
+                const [comp, field] = key.split('_');
+
+                if (!rowData[comp]) rowData[comp] = {};
+                rowData[comp][field] = parseJsonIfNeeded(value);
+
+            } else {
+              rowData[key] = parseJsonIfNeeded(value);
+            }
+        }
+
+        existedComponents = getComponentFields(targetContentType);
+        for (const comp of existedComponents) {
+          if (!rowData[comp]) {
+            rowData[comp] = {};
           }
-        });
-        
-        strapi.log.info('Final import data keys:', Object.keys(importData));
-      } else {
-        throw new Error('Unsupported file format. Please use JSON or Excel files.');
+        }
+
+        result.push(rowData);
       }
 
-      const results = {
-        created: 0,
-        updated: 0,
-        errors: [],
-      };
+      return result;
+    };
 
-      // Handle different data structures
-      const dataToProcess = importData.data || importData;
+    const mapSheetNameToContentType = (sheetName) => {
+        if (!sheetName.startsWith('api__')) return sheetName;
+        return sheetName.replace(/^api__/, 'api::').replace(/_/g, '.');
+    };
 
-      for (const [contentType, entries] of Object.entries(dataToProcess)) {
-        try {
-          // If targetContentType is specified, only process that content type
-          if (targetContentType && contentType !== targetContentType) {
-            continue;
-          }
+    workbook.SheetNames.forEach(sheetName => {
+        const worksheet = workbook.Sheets[sheetName];
+        const rows = XLSX.utils.sheet_to_json(worksheet);
 
-          // Skip if not an API content type
-          if (!contentType.startsWith('api::')) {
-            continue;
-          }
+        if (!rows.length) return;
 
-          // Check if content type exists
-          if (!strapi.contentTypes[contentType]) {
-            results.errors.push(`Content type ${contentType} not found`);
-            continue;
-          }
+        const contentTypeName = mapSheetNameToContentType(sheetName);
 
-          if (!Array.isArray(entries)) {
-            results.errors.push(`Invalid data format for ${contentType}`);
-            continue;
-          }
+        strapi.log.info(`Reading sheet "${sheetName}" -> ${rows.length} rows`);
+        strapi.log.info(`Mapped sheet to content-type: ${contentTypeName}`);
+
+        if (contentTypeName.startsWith('api::')) {
+          importData[contentTypeName] = unflattenRow(rows, contentTypeName);
+        } else {
+          strapi.log.error(`Unknown content-type: ${contentTypeName}`);
+          return;
+        }
+    });
+
+    strapi.log.info('Final import data keys:', Object.keys(importData));
+    return importData;
+}
+
+function getRelationFields(contentType) {
+  const schema = strapi.contentTypes[contentType];
+
+  if (!schema) {
+    strapi.log.warn(`Content type ${contentType} not found`);
+    return [];
+  }
+
+  return Object.entries(schema.attributes)
+    .filter(([_, attr]) => attr.type === "relation")
+    .map(([fieldName, attr]) => ({
+      field: toCamel(fieldName),
+      target: attr.target, // e.g. "api::category.category"
+      relation: attr.relation,
+    }));
+}
+
+function getRelationFieldsStrArr(contentType) {
+  const schema = strapi.contentTypes[contentType];
+
+  if (!schema) {
+    strapi.log.warn(`Content type ${contentType} not found`);
+    return [];
+  }
+
+  return Object.entries(schema.attributes)
+    .filter(([_, attr]) => attr.type === "relation")
+    .map(([fieldName, attr]) => toCamel(fieldName));
+}
+
+function getComponentFields(contentType) {
+  const schema = strapi.contentTypes[contentType];
 
-          for (const entry of entries) {
-            try {
-              // Extract system fields for update/create logic
-              const { 
-                id, 
-                documentId, 
-                status,
-                createdAt, 
-                updatedAt, 
-                publishedAt, 
-                createdBy, 
-                updatedBy, 
-                localizations,
-                locale,
-                ...cleanEntry 
-              } = entry;
-
-              // Skip empty entries
-              if (!cleanEntry || Object.keys(cleanEntry).length === 0) {
-                strapi.log.warn('Skipping empty entry');
-                continue;
-              }
-              
-              // Clean up empty string values and convert to null
-              for (const [key, value] of Object.entries(cleanEntry)) {
-                if (value === '' || value === 'null' || value === 'undefined') {
-                  cleanEntry[key] = null;
-                }
-              }
-              
-              let existingEntry = null;
-              let updateMode = false;
-              
-              // Only try to find existing entry if documentId is provided and valid
-              if (documentId && documentId !== '' && documentId !== 'null' && documentId !== 'undefined') {
-                try {
-                  if (strapi.documents) {
-                    existingEntry = await strapi.documents(contentType).findOne({
-                      documentId: documentId,
-                    });
-                    if (existingEntry) {
-                      updateMode = true;
-                      strapi.log.info(`Found existing entry for update: ${documentId}`);
-                    }
-                  }
-                } catch (error) {
-                  // Entry not found, will create new one
-                  strapi.log.info(`DocumentId ${documentId} not found, will create new entry`);
-                }
-              }
-              
-              // If no documentId provided or not found, this will be a new entry
-              if (!existingEntry) {
-                strapi.log.info(`Creating new entry for: ${cleanEntry.shortName || cleanEntry.name || cleanEntry.title || 'Unknown'}`);
-              }
-              
-              // Skip entries without basic required fields
-              if (!cleanEntry.shortName && !cleanEntry.name && !cleanEntry.title) {
-                continue;
-              }
-              
-              // Ensure required components exist for corporate
-              if (contentType === 'api::corporate.corporate') {
-                if (!cleanEntry.corporateInfo) cleanEntry.corporateInfo = {};
-                if (!cleanEntry.meetingRequirements) cleanEntry.meetingRequirements = {};
-                if (!cleanEntry.internalInfo) cleanEntry.internalInfo = {};
-              }
-              
-              if (existingEntry) {
-                // Check if there are actual changes before updating
-                const hasChanges = this.hasDataChanges(existingEntry, cleanEntry);
-                const statusChanged = (status === 'published') !== !!existingEntry.publishedAt;
-                
-                if (hasChanges || statusChanged) {
-                  try {
-                    if (strapi.documents) {
-                      const updateData = {
-                        documentId: existingEntry.documentId,
-                        data: cleanEntry,
-                      };
-                      
-                      // Handle status change
-                      if (statusChanged) {
-                        updateData.status = status === 'published' ? 'published' : 'draft';
-                      }
-                      
-                      await strapi.documents(contentType).update(updateData);
-                      results.updated++;
-                    } else {
-                      await strapi.entityService.update(contentType, existingEntry.id, {
-                        data: cleanEntry,
-                      });
-                      results.updated++;
-                    }
-                  } catch (updateError) {
-                    results.errors.push(`Failed to update entry: ${updateError.message}`);
-                  }
-                } else {
-                  // No changes, skip update
-                  strapi.log.info(`No changes detected for entry: ${cleanEntry.shortName || 'Unknown'}`);
-                }
-              } else {
-                // Create new entry
-                try {
-                  if (strapi.documents) {
-                    await strapi.documents(contentType).create({
-                      data: cleanEntry,
-                      status: status === 'published' ? 'published' : 'draft',
-                    });
-                    results.created++;
-                  } else {
-                    await strapi.entityService.create(contentType, {
-                      data: cleanEntry,
-                    });
-                    results.created++;
-                  }
-                } catch (createError) {
-                  results.errors.push(`Failed to create entry: ${createError.message}`);
-                }
-              }
-            } catch (error) {
-              results.errors.push(`Failed to import entry in ${contentType}: ${error.message}`);
-              strapi.log.error('Import entry error:', error);
+  if (!schema) {
+    strapi.log.warn(`Content type ${contentType} not found`);
+    return [];
+  }
+
+  return Object.entries(schema.attributes)
+    .filter(([_, attr]) => attr.type === "component")
+    .map(([fieldName, attr]) => toCamel(fieldName));
+}
+
+async function handleRelations(entry, contentType) {
+  let relationFields = getRelationFields(contentType);
+  if (relationFields.length === 0) {
+    return entry;
+  }
+
+  let existing = null;
+  const newEntry = { ...entry };
+  let isUpdated = false;
+
+  for (const rel of relationFields) {
+    const { field, target } = rel;
+    const relValue = entry[field];
+    try {
+      if (!relValue) continue;
+
+      if (Array.isArray(relValue)) {
+        const processed = [];
+
+        for (const item of relValue) {
+          if (item.id) {
+            existing = await strapi.documents(target).findFirst({
+              filters: {
+                id: { $eq: item.id }
+              },
+             });
+            if (existing && hasChanges(existing, item, getRelationFieldsStrArr(target))) {
+              await strapi.documents(target).update({ documentId: existing.documentId, data: item });
+              isUpdated = true;
             }
+            processed.push({ id: item.id });
+          } else {
+            const created = await strapi.documents(target).create({ data: item });
+            processed.push({ id: created.id });
           }
-        } catch (error) {
-          results.errors.push(`Failed to process ${contentType}: ${error.message}`);
-          strapi.log.error('Import process error:', error);
         }
+        newEntry[field] = processed;
+        continue;
       }
 
-      // Clean up uploaded file
-      if (filePath && fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
+      if (!relValue.id) {
+        const created = await strapi.documents(target).create({ data: relValue });
+        newEntry[field] = { id: created.id };
+      } else {
+        existing = await strapi.documents(target).findFirst({
+          filters: {
+            id: { $eq: relValue.id }
+          },
+         });
+        if (hasChanges(existing, relValue, getRelationFieldsStrArr(target))) {
+          await strapi.documents(target).update({ documentId: existing.documentId, data: relValue });
+          isUpdated = true;
+        }
+        newEntry[field] = { id: relValue.id };
       }
+    } catch (err) {
+      throw new Error(`Field: ${field}, data: ${JSON.stringify(relValue)}, error: ${err.message}`);
+    }
+  }
 
-      return results;
-    } catch (error) {
-      // Clean up uploaded file on error
-      const filePath = file && (file.path || file.filepath);
-      if (filePath && fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-      }
-      throw error;
+  return [newEntry, isUpdated];
+}
+
+function hasChanges(existing, incoming, relationFieldStrArr = []) {
+  if (!incoming || typeof incoming !== "object") return false;
+
+  for (const key of Object.keys(incoming)) {
+    // Skip system keys
+    if (SYSTEM_KEYS.includes(key)) continue;
+
+    // Skip relation fields entirely
+    if (relationFieldStrArr.includes(key)) continue;
+
+    const newVal = incoming[key];
+    const oldVal = existing[key];
+
+    // If incoming defines a field but existing doesn't → change
+    if (oldVal === undefined || newVal === undefined) {
+      continue;
     }
-  },
-
-  hasDataChanges(existingEntry, newData) {
-    // Compare key fields to detect changes
-    const fieldsToCompare = ['shortName', 'name', 'title'];
-    
-    for (const field of fieldsToCompare) {
-      if (existingEntry[field] !== newData[field]) {
+
+    // Primitive comparison
+    if (newVal === null || typeof newVal !== "object") {
+      if (oldVal !== newVal) {
         return true;
       }
+      continue;
     }
-    
-    // Compare nested objects (components)
-    const componentsToCompare = ['corporateInfo', 'meetingRequirements', 'internalInfo'];
-    
-    for (const component of componentsToCompare) {
-      if (existingEntry[component] && newData[component]) {
-        const existingStr = JSON.stringify(existingEntry[component]);
-        const newStr = JSON.stringify(newData[component]);
-        if (existingStr !== newStr) {
+
+    // ARRAY comparison
+    if (Array.isArray(newVal)) {
+      if (!Array.isArray(oldVal)) return true;
+      if (newVal.length !== oldVal.length) return true;
+      // Compare values shallowly
+      for (let i = 0; i < newVal.length; i++) {
+        if (typeof newVal[i] === "object" && typeof oldVal[i] === "object" && hasChanges(oldVal[i], newVal[i])) {
+          return true;
+        } else if (typeof newVal[i] !== "object" && typeof oldVal[i] !== "object" && newVal[i] !== oldVal[i]) {
           return true;
         }
       }
+      continue;
     }
-    
-    return false;
-  },
-});
+
+    // OBJECT comparison (recursive, but ONLY fields in incoming object)
+    if (typeof newVal === "object" && typeof oldVal === "object") {
+      if (hasChanges(oldVal, newVal)) {
+        return true;
+      }
+      continue;
+    }
+  }
+
+  return false;
+}
+
+
+async function bulkInsertData(importData) {
+  const results = {
+    created: 0,
+    updated: 0,
+    errors: [],
+  };
+
+  for (const [contentType, entries] of Object.entries(importData)) {
+    // Validate entries
+    if (!strapi.contentTypes[contentType]) {
+      results.errors.push(`Content type ${contentType} not found`);
+      continue;
+    }
+    if (!Array.isArray(entries)) {
+      results.errors.push(`Invalid data format for ${contentType}`);
+      continue;
+    }
+
+    for (i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      let existing = null;
+      try {
+        let { id, ...data } = entry; // keep id out, keep everything else
+        let isUpdated = false;
+        let isCreated = false;
+        if (id && id !== 'null' && id !== 'undefined') {
+          existing = await strapi.documents(contentType).findFirst({
+            filters: {
+              id: { $eq: id }
+            },
+            populate: '*'
+          });
+        }
+
+        [data, isUpdated] = await handleRelations(data, contentType);
+
+        if (existing) {
+          if (hasChanges(existing, data)) {
+            await strapi.documents(contentType).update({
+              documentId: existing.documentId,
+              data,
+            });
+            isUpdated = true;
+          }
+        } else {
+          await strapi.documents(contentType).create({ data });
+          isCreated = true;
+        }
+        if (isUpdated) {
+          results.updated++;
+        } else if (isCreated) {
+          results.created++;
+        }
+      } catch (err) {
+        results.errors.push(`Failed ${existing ? 'updating' : 'creating'} on row ${i+2}: ${err.message}`);
+      }
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  importData,
+};