@nkhang1902/strapi-plugin-export-import-clsx 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkhang1902/strapi-plugin-export-import-clsx",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A powerful Strapi plugin for exporting and importing data with Excel support and advanced filtering",
   "main": "./strapi-server.js",
   "scripts": {

package/server/services/import-service.js

@@ -5,18 +5,6 @@ function toCamel(str) {
   return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
 
-const SYSTEM_KEYS = [
-  'documentId',
-  'locale',
-  'createdAt',
-  'updatedAt',
-  'publishedAt',
-  'createdBy',
-  'updatedBy',
-  'localizations',
-  'status'
-];
-
 const SHORTCUT_FIELDS = [
   'email','businessEmail','name','title','tickerCode',
 ]
@@ -56,18 +44,6 @@ function transformExcelData(filePath) {
     const workbook = XLSX.readFile(filePath);
     const importData = {};
 
-    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
@@ -83,13 +59,13 @@ function transformExcelData(filePath) {
             if (value === null || value === undefined || value === '') {
               rowData[key] = null
             } else if (attr[key] && attr[key].customField && attr[key].type === 'json' && attr[key].default === '[]') {
-              rowData[key] = parseJsonIfNeeded(value).split('|');
+              rowData[key] = value.split('|');
             } else if (isComponentField(key)) {
               const [comp, field] = key.split('_');
               if (!rowData[comp]) rowData[comp] = {};
-              rowData[comp][field] = parseJsonIfNeeded(value);
+              rowData[comp][field] = value;
             } else {
-              rowData[key] = parseJsonIfNeeded(value);
+              rowData[key] = value;
             }
         }
         result.push(rowData);
@@ -258,55 +234,101 @@ function handleComponents(data, existing, contentType) {
   return data;
 }
 
-function hasChanges(existing, incoming) {
-  if (!incoming || typeof incoming !== "object") return false;
-  if (!existing || typeof existing !== "object") return true;
-  for (const key of Object.keys(incoming)) {
-    // Skip system keys
-    if (SYSTEM_KEYS.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;
-    }
+function sanitizeEntryBeforeWrite(data, uid, path = '', errors = []) {
+  const schema = strapi.contentTypes[uid];
+  const cleaned = {};
+
+  for (const [key, attr] of Object.entries(schema.attributes)) {
+    const value = data[key];
+    const fieldPath = path ? `${path}.${key}` : key;
 
-    // Primitive comparison
-    if (newVal === null || typeof newVal !== "object") {
-      if (oldVal !== newVal) {
-        return true;
+    if (value === undefined) continue;
+
+    if (attr.type === 'component') {
+      if (!value) {
+        cleaned[key] = attr.repeatable ? [] : null;
+        continue;
       }
+
+      cleaned[key] = attr.repeatable
+        ? value.map((v, i) =>
+            sanitizeComponent(v, attr.component, `${fieldPath}[${i}]`, errors)
+          )
+        : sanitizeComponent(value, attr.component, fieldPath, errors);
       continue;
     }
 
-    // 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;
+    if (attr.type === 'relation') {
+      cleaned[key] = value;
+    } else {
+      cleaned[key] = sanitizePrimitive(value, attr, fieldPath, errors);
     }
+  }
 
-    // OBJECT comparison (recursive, but ONLY fields in incoming object)
-    if (typeof newVal === "object" && typeof oldVal === "object") {
-      if (hasChanges(oldVal, newVal)) {
-        return true;
-      }
-      continue;
+  return cleaned;
+}
+
+function sanitizeComponent(data, uid, path, errors) {
+  const schema = strapi.components[uid];
+  if (!schema) return data;
+
+  const cleaned = {};
+
+  for (const [key, attr] of Object.entries(schema.attributes)) {
+    const value = data?.[key];
+    const fieldPath = `${path}.${key}`;
+
+    if (attr.type === 'component') {
+      cleaned[key] = attr.repeatable
+        ? (value || []).map((v, i) =>
+            sanitizeComponent(v, attr.component, `${fieldPath}[${i}]`, errors)
+          )
+        : sanitizeComponent(value, attr.component, fieldPath, errors);
+    } else {
+      cleaned[key] = sanitizePrimitive(value, attr, fieldPath, errors);
     }
   }
 
-  return false;
+  return cleaned;
 }
 
+function sanitizePrimitive(value, attr, path, errors) {
+  if (value === null || value === undefined || value === '') return null;
+
+  switch (attr.type) {
+    case 'string':
+    case 'text':
+    case 'richtext':
+    case 'email':
+      return String(value).trim();
+
+    case 'boolean':
+      if ([true, 'true', 1, '1', 'yes', 'y'].includes(value)) return true;
+      if ([false, 'false', 0, '0', 'no', 'n'].includes(value)) return false;
+      return false;
+
+    case 'integer':
+    case 'biginteger': {
+      const i = parseInt(value, 10);
+      return Number.isNaN(i) ? 0 : i;
+    }
+
+    case 'float':
+    case 'decimal': {
+      const f = parseFloat(value);
+      return Number.isNaN(f) ? 0 : f;
+    }
+
+    case 'date':
+    case 'datetime': {
+      const d = new Date(value);
+      return isNaN(d.getTime()) ? null : d.toISOString();
+    }
+
+    default:
+      return value;
+  }
+}
 
 async function bulkInsertData(importData) {
   const results = {
@@ -367,21 +389,26 @@ async function importEntries(entries, contentType) {
         }
 
         // Handle relations & components
-        data = await handleRelations(data, contentType, trx);
+        data = await handleRelations(data, contentType);
         data = await handleComponents(data, existing, contentType);
 
+        const sanitizeErrors = [];
+        data = sanitizeEntryBeforeWrite(data, contentType, '', sanitizeErrors);
+
+        if (sanitizeErrors.length) {
+          throw new Error(`Data validation failed:\n${sanitizeErrors.join('\n')}`);
+        }
+
         // Update
         if (existing) {
-          if (hasChanges(existing, data)) {
-            await strapi.documents(contentType).update(
-              {
-                documentId: existing.documentId,
-                data,
-              },
-              { transaction: trx }
-            );
-            results.updated++;
-          }
+          await strapi.documents(contentType).update(
+            {
+              documentId: existing.documentId,
+              data,
+            },
+            { transaction: trx }
+          );
+          results.updated++;
         }
 
         // Create