@nkhang1902/strapi-plugin-export-import-clsx 1.0.3

package/server/services/import-service.js

@@ -0,0 +1,416 @@
+const XLSX = require('xlsx');
+const fs = require('fs');
+
+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',
+]
+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 = {};
+
+    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 = [];
+      const attr = strapi.contentTypes[targetContentType].attributes;
+      for (const row of rows) {
+        const rowData = {};
+
+        for (const [key, value] of Object.entries(row)) {
+            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('|');
+            } else if (isComponentField(key)) {
+              const [comp, field] = key.split('_');
+              if (!rowData[comp]) rowData[comp] = {};
+              rowData[comp][field] = parseJsonIfNeeded(value);
+            } else {
+              rowData[key] = parseJsonIfNeeded(value);
+            }
+        }
+        result.push(rowData);
+      }
+
+      return result;
+    };
+
+    const mapSheetNameToContentType = (sheetName) => {
+        return "api::" + sheetName + "." + sheetName;
+    };
+
+    workbook.SheetNames.forEach(sheetName => {
+        const worksheet = workbook.Sheets[sheetName];
+        const rows = XLSX.utils.sheet_to_json(worksheet);
+
+        if (!rows.length) return;
+
+        const contentTypeName = mapSheetNameToContentType(sheetName);
+
+        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 getComponentFields(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 === "component")
+    .map(([fieldName, attr]) => toCamel(fieldName));
+}
+
+async function handleRelations(entry, contentType) {
+  async function resolveRelationValue(field, value, target) {
+    const targetAttr = strapi.contentTypes[target].attributes;
+    for (const field of SHORTCUT_FIELDS) {
+      if (!targetAttr[field]) continue;
+      const existing = await strapi.documents(target).findFirst({
+        filters: { [field]: { $eq: value } },
+      });
+      if (existing) return {id: existing.id};
+      throw new Error(`Data with ${field} ${value} not found`);
+    }
+    return null;
+  }
+
+  const relationFields = getRelationFields(contentType);
+  if (relationFields.length === 0) return entry;
+
+  const updatedEntry = { ...entry };
+
+  for (const rel of relationFields) {
+    const { field, target, relation } = rel;
+
+    let value = entry[field];
+    if (!value || value === "") {
+      if (relation === "manyToMany" || relation === "oneToMany") {
+        updatedEntry[field] = [];
+      } else {
+        updatedEntry[field] = null;
+      }
+      continue;
+    };
+
+    // Convert CSV to array
+    if (typeof value === "string" && (relation === "manyToMany" || relation === "oneToMany")) {
+      value = value.split("|");
+    } else if (typeof value === "string" && value.includes("|")) {
+      throw new Error(`Invalid value for field ${field}: ${value}, ${field} is not an array`);
+    }
+
+    const values = Array.isArray(value) ? value : [value];
+    try {
+      const processed = [];
+
+      for (const v of values) {
+        if (!v || v === "") continue;
+        const resolved = await resolveRelationValue(field, v, target);
+        if (resolved) processed.push(resolved);
+      }
+
+      updatedEntry[field] = Array.isArray(value) ? processed : processed[0];
+    } catch (err) {
+      throw new Error(
+        `Failed processing field ${field} with value ${JSON.stringify(value)}: ${err.message}`
+      );
+    }
+  }
+
+  return updatedEntry;
+}
+
+function handleComponents(data, existing, contentType) {
+  // Get the component fields for this content type
+  const compFields = getComponentFields(contentType);
+
+  for (const field of compFields) {
+    const newValue = data[field];
+    const oldValue = existing?.[field];
+
+    if (!newValue || !oldValue) continue;
+
+    //single component
+    if (!Array.isArray(newValue)) {
+      if (oldValue?.id) {
+        data[field].id = oldValue.id;
+      }
+      for (const key of Object.keys(data[field])) {
+        if (Array.isArray(oldValue[key])) {
+          data[field][key] = data[field][key].split("|");
+        }
+      }
+      continue;
+    }
+
+    //multiple components
+    if (Array.isArray(newValue) && Array.isArray(oldValue)) {
+      data[field] = newValue.map((block, i) => {
+        const oldBlock = oldValue[i];
+        if (oldBlock?.id) {
+          return { id: oldBlock.id, ...block };
+        }
+        for (const key of Object.keys(block)) {
+          if (Array.isArray(oldBlock[key])) {
+            block[key] = block[key].split("|");
+          }
+        }
+        return block;
+      });
+    }
+  }
+
+  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;
+    }
+
+    // Primitive comparison
+    if (newVal === null || typeof newVal !== "object") {
+      if (oldVal !== newVal) {
+        return true;
+      }
+      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;
+    }
+
+    // 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;
+    }
+
+    try {
+      const { created, updated, errors } = await importEntries(entries, contentType);
+      results.created += created;
+      results.updated += updated;
+      results.errors = results.errors.concat(errors);
+    } catch (err) {
+      results.errors.push(err.message);
+    }
+  }
+
+  return results;
+}
+
+async function importEntries(entries, contentType) {
+  const results = { created: 0, updated: 0, errors: [] };
+
+  await strapi.db.transaction(async ({ trx, rollback, onRollback }) => {
+    onRollback(() => {
+      strapi.log.error("Transaction rolled back due to an error!");
+      strapi.log.error(results.errors);
+    });
+
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      let existing = null;
+
+      try {
+        let { id, ...data } = entry;
+
+        // Check if document exists
+        if (id && id !== "null" && id !== "undefined") {
+          existing = await strapi.documents(contentType).findFirst(
+            {
+              filters: { id },
+              populate: "*",
+            },
+            { transaction: trx }
+          );
+        }
+
+        // Handle relations & components
+        data = await handleRelations(data, contentType, trx);
+        data = await handleComponents(data, existing, contentType);
+
+        // Update
+        if (existing) {
+          if (hasChanges(existing, data)) {
+            await strapi.documents(contentType).update(
+              {
+                documentId: existing.documentId,
+                data,
+              },
+              { transaction: trx }
+            );
+            results.updated++;
+          }
+        }
+
+        // Create
+        else {
+          await strapi.documents(contentType).create(
+            { data },
+            { transaction: trx }
+          );
+          results.created++;
+        }
+      } catch (err) {
+        results.errors.push(
+          `Failed ${existing ? "updating" : "creating"} on row ${
+            i + 2
+          }: ${err.message}`
+        );
+        results.created = 0;
+        results.updated = 0;
+
+        // IMPORTANT: force rollback
+        throw err;
+      }
+    }
+  });
+
+  return results;
+}
+
+
+module.exports = {
+  importData,
+};

package/server/services/index.js

@@ -0,0 +1,7 @@
+const exportService = require('./export-service');
+const importService = require('./import-service');
+
+module.exports = {
+  'export-service': exportService,
+  'import-service': importService,
+};

package/strapi-admin.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import pluginPkg from './package.json';
+import pluginId from './admin/src/pluginId';
+import Initializer from './admin/src/components/Initializer';
+import ExportImportButtons from './admin/src/components/ExportImportButtons';
+
+const name = pluginPkg.strapi.name;
+
+export default {
+  register(app) {
+    const plugin = {
+      id: pluginId,
+      initializer: Initializer,
+      isReady: false,
+      name,
+    };
+
+    app.registerPlugin(plugin);
+  },
+
+  bootstrap(app) {
+    // Try different injection methods for Strapi v5
+    try {
+      // Method 1: Direct injection
+      if (app.injectContentManagerComponent) {
+        app.injectContentManagerComponent('listView', 'actions', {
+          name: 'export-import-buttons',
+          Component: ExportImportButtons,
+        });
+      }
+      // Method 2: Plugin-based injection
+      else if (app.getPlugin) {
+        const contentManager = app.getPlugin('content-manager');
+        if (contentManager && contentManager.injectComponent) {
+          contentManager.injectComponent('listView', 'actions', {
+            name: 'export-import-buttons',
+            Component: ExportImportButtons,
+          });
+        }
+      }
+      // Method 3: Global injection
+      else if (app.addComponent) {
+        app.addComponent('content-manager.listView.actions', ExportImportButtons);
+      }
+    } catch (error) {
+      console.warn('Failed to inject export-import buttons:', error);
+      
+      // Fallback: Add as menu item if injection fails
+      app.addMenuLink({
+        to: `/plugins/${pluginId}`,
+        icon: () => React.createElement('span', null, '📊'),
+        intlLabel: {
+          id: `${pluginId}.plugin.name`,
+          defaultMessage: 'Export Import',
+        },
+        Component: async () => {
+          const component = await import('./admin/src/pages/App');
+          return component;
+        },
+        permissions: [],
+      });
+    }
+  },
+
+  async registerTrads(app) {
+    const { locales } = app;
+
+    const importedTrads = await Promise.all(
+      locales.map((locale) => {
+        return import(`./admin/src/translations/${locale}.json`)
+          .then(({ default: data }) => {
+            return {
+              data: data,
+              locale,
+            };
+          })
+          .catch(() => {
+            return {
+              data: {},
+              locale,
+            };
+          });
+      })
+    );
+
+    return Promise.resolve(importedTrads);
+  },
+};

package/strapi-server.js

@@ -0,0 +1,34 @@
+module.exports = {
+  register({ strapi }) {
+    // Register phase
+  },
+
+  bootstrap({ strapi }) {
+    // Bootstrap phase
+  },
+
+  destroy({ strapi }) {
+    // Destroy phase
+  },
+
+  config: {
+    default: {},
+    validator() {},
+  },
+
+  controllers: {
+    'export-controller': require('./server/controllers/export-controller'),
+    'import-controller': require('./server/controllers/import-controller'),
+  },
+
+  routes: require('./server/routes'),
+
+  services: {
+    'export-service': require('./server/services/export-service'),
+    'import-service': require('./server/services/import-service'),
+  },
+
+  contentTypes: {},
+  policies: {},
+  middlewares: {},
+};