strapi-to-lokalise-plugin/admin/src/utils/compatibility.js

Preview and sync Lokalise translations from Strapi admin

export const getStrapiVersion = (strapi) => {
  const version =
    strapi?.config?.info?.strapi?.version ||
    strapi?.config?.info?.version ||
    process.env.STRAPI_VERSION ||
    null;

  if (!version) {
    if (strapi?.server?.httpServer) return { version: '5.x', major: 5, isV5: true, isV4: false };
    if (strapi?.server?.koa) return { version: '4.x', major: 4, isV5: false, isV4: true };
    return { version: null, major: null, isV5: false, isV4: false };
  }

  const [major, minor] = version.split('.').map((n) => parseInt(n, 10));

  return {
    version,
    major,
    minor,
    isV5: major >= 5,
    isV4: major === 4,
  };
};

export const isFeatureAvailable = (strapi, feature) => {
  const version = getStrapiVersion(strapi);
  const matrix = {
    'vite-admin': version.isV5,
    'webpack-admin': version.isV4,
    'i18n-plugin': true,
  };
  return matrix[feature] ?? true;
};

export const getApiEndpoint = (path) => {
  if (path.startsWith('/')) return `/api/lokalise-sync${path}`;
  return `/api/lokalise-sync/${path}`;
};

export const safePluginCall = (strapi, method, ...args) => {
  try {
    const plugin = strapi?.plugin('lokalise-sync');
    if (!plugin) return null;
    if (typeof plugin[method] === 'function') {
      return plugin[method](...args);
    }
  } catch (error) {
    console.error(`[lokalise-sync] Error calling ${method}:`, error);
  }
  return null;
};

export default {
  getStrapiVersion,
  isFeatureAvailable,
  getApiEndpoint,
  safePluginCall,
};
/**
 * Compatibility utilities for Strapi v4.x and v5.x
 * 
 * This module provides utilities to detect Strapi version and
 * adjust plugin behavior if needed.
 */

/**
 * Detect the Strapi version from the strapi instance
 * @param {Object} strapi - Strapi instance
 * @returns {Object} Version information
 */
export const getStrapiVersion = (strapi) => {
  if (!strapi) {
    return { major: null, minor: null, version: null };
  }

  // Try to get version from strapi.config
  let version = strapi.config?.info?.strapi?.version || 
                strapi.config?.info?.version ||
                process.env.STRAPI_VERSION ||
                null;

  if (!version) {
    // Try to detect from package structure
    // Strapi v5 uses different internal structure
    if (strapi.server?.koa) {
      // Likely v4 (uses Koa directly)
      return { major: 4, minor: null, version: '4.x', isV5: false };
    } else if (strapi.server?.httpServer) {
      // Likely v5 (uses httpServer)
      return { major: 5, minor: null, version: '5.x', isV5: true };
    }
    
    return { major: null, minor: null, version: null };
  }

  // Parse version string (e.g., "4.15.0" or "5.0.0")
  const parts = version.split('.');
  const major = parseInt(parts[0], 10) || null;
  const minor = parseInt(parts[1], 10) || null;

  return {
    major,
    minor,
    version,
    isV5: major >= 5,
    isV4: major === 4,
  };
};

/**
 * Check if a feature is available in the current Strapi version
 * @param {Object} strapi - Strapi instance
 * @param {string} feature - Feature name to check
 * @returns {boolean}
 */
export const isFeatureAvailable = (strapi, feature) => {
  const version = getStrapiVersion(strapi);
  
  if (!version.major) {
    // If we can't detect version, assume it's available (fail open)
    return true;
  }

  // Feature compatibility matrix
  const features = {
    'vite-admin': version.isV5,
    'webpack-admin': version.isV4,
    'i18n-plugin': true, // Available in both
  };

  return features[feature] ?? true;
};

/**
 * Get the appropriate API endpoint format for the current Strapi version
 * @param {Object} strapi - Strapi instance
 * @param {string} path - API path
 * @returns {string} Full API endpoint
 */
export const getApiEndpoint = (strapi, path) => {
  const version = getStrapiVersion(strapi);
  
  // Both v4 and v5 use the same plugin API structure
  // But we can adjust if needed
  if (path.startsWith('/')) {
    return `/api/lokalise-sync${path}`;
  }
  
  return `/api/lokalise-sync/${path}`;
};

/**
 * Safe plugin API access with version compatibility
 * @param {Object} strapi - Strapi instance
 * @param {string} method - Method name
 * @param {...any} args - Arguments
 * @returns {any}
 */
export const safePluginCall = (strapi, method, ...args) => {
  try {
    const plugin = strapi.plugin('lokalise-sync');
    if (!plugin) {
      console.warn('[lokalise-sync] Plugin not found');
      return null;
    }

    if (typeof plugin[method] === 'function') {
      return plugin[method](...args);
    }

    console.warn(`[lokalise-sync] Method ${method} not found on plugin`);
    return null;
  } catch (error) {
    console.error(`[lokalise-sync] Error calling ${method}:`, error);
    return null;
  }
};

export default {
  getStrapiVersion,
  isFeatureAvailable,
  getApiEndpoint,
  safePluginCall,
};