@qelos/plugins-cli 0.0.11 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qelos/plugins-cli",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "CLI to manage QELOS plugins",
   "main": "cli.mjs",
   "bin": {

package/services/configurations.mjs

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { join } from 'node:path';
 import { logger } from './logger.mjs';
+import { appUrl } from './sdk.mjs';
 
 /**
  * Push configurations from local directory to remote
@@ -38,6 +39,25 @@ export async function pushConfigurations(sdk, path) {
       
       logger.step(`Pushing configuration: ${key}`);
       
+      // Special handling for app-configuration: ensure QELOS_URL hostname is in websiteUrls
+      if (key === 'app-configuration') {
+        try {
+          const qelosUrl = new URL(appUrl);
+          const hostname = qelosUrl.hostname;
+          
+          if (!configData.metadata.websiteUrls) {
+            configData.metadata.websiteUrls = [];
+          }
+          
+          if (!configData.metadata.websiteUrls.includes(hostname)) {
+            configData.metadata.websiteUrls.push(hostname);
+            logger.info(`Added ${hostname} to websiteUrls`);
+          }
+        } catch (error) {
+          logger.warning(`Failed to parse QELOS_URL: ${error.message}`);
+        }
+      }
+      
       const existingConfig = existingConfigurations.find(
         config => config.key === key
       );

package/services/micro-frontends.mjs

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.mjs';
+
+/**
+ * Convert a string to kebab-case
+ * @param {string} str - String to convert
+ * @returns {string} Kebab-cased string
+ */
+function toKebabCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+/**
+ * Extract micro-frontend structures to separate HTML files
+ * @param {Array} microFrontends - Array of micro-frontend objects
+ * @param {string} pluginPath - Base path for the plugin directory
+ * @returns {Array} Updated micro-frontends with $ref instead of structure
+ */
+export function extractMicroFrontendStructures(microFrontends, pluginPath) {
+  if (!microFrontends || microFrontends.length === 0) {
+    return microFrontends;
+  }
+
+  const microFrontendsDir = path.join(pluginPath, 'micro-frontends');
+  
+  // Create micro-frontends directory if it doesn't exist
+  if (!fs.existsSync(microFrontendsDir)) {
+    fs.mkdirSync(microFrontendsDir, { recursive: true });
+  }
+
+  return microFrontends.map((mf) => {
+    // Skip if no structure or structure is already a reference
+    if (!mf.structure || typeof mf.structure === 'object') {
+      return mf;
+    }
+
+    // Generate filename from route name or micro-frontend name
+    const fileName = mf.route?.name 
+      ? toKebabCase(mf.route.name) 
+      : toKebabCase(mf.name);
+    
+    const htmlFileName = `${fileName}.html`;
+    const htmlFilePath = path.join(microFrontendsDir, htmlFileName);
+    const relativeRef = `./micro-frontends/${htmlFileName}`;
+
+    // Write structure to HTML file
+    fs.writeFileSync(htmlFilePath, mf.structure, 'utf-8');
+    logger.debug(`Extracted structure to: ${relativeRef}`);
+
+    // Return micro-frontend with $ref instead of structure
+    return {
+      ...mf,
+      structure: { $ref: relativeRef }
+    };
+  });
+}
+
+/**
+ * Load content from a $ref reference
+ * @param {string} ref - Reference path (relative, absolute, or URL)
+ * @param {string} basePath - Base path for resolving relative references
+ * @returns {Promise<string>} Loaded content
+ */
+async function loadReference(ref, basePath) {
+  // Handle HTTP/HTTPS URLs
+  if (ref.startsWith('http://') || ref.startsWith('https://')) {
+    logger.debug(`Loading structure from URL: ${ref}`);
+    try {
+      const response = await fetch(ref);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.text();
+    } catch (error) {
+      throw new Error(`Failed to load from URL ${ref}: ${error.message}`);
+    }
+  }
+
+  // Handle absolute and relative paths
+  const filePath = path.isAbsolute(ref) 
+    ? ref 
+    : path.resolve(basePath, ref);
+
+  logger.debug(`Loading structure from file: ${filePath}`);
+  
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Referenced file does not exist: ${filePath}`);
+  }
+
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+/**
+ * Resolve micro-frontend structures from $ref references
+ * @param {Array} microFrontends - Array of micro-frontend objects
+ * @param {string} pluginPath - Base path for resolving relative references
+ * @returns {Promise<Array>} Updated micro-frontends with resolved structures
+ */
+export async function resolveMicroFrontendStructures(microFrontends, pluginPath) {
+  if (!microFrontends || microFrontends.length === 0) {
+    return microFrontends;
+  }
+
+  return await Promise.all(microFrontends.map(async (mf) => {
+    // Skip if no structure or structure is not a reference object
+    if (!mf.structure || typeof mf.structure !== 'object' || !mf.structure.$ref) {
+      return mf;
+    }
+
+    const ref = mf.structure.$ref;
+    
+    try {
+      const content = await loadReference(ref, pluginPath);
+      
+      // Return micro-frontend with resolved structure
+      return {
+        ...mf,
+        structure: content
+      };
+    } catch (error) {
+      logger.error(`Failed to resolve $ref for ${mf.name}: ${error.message}`);
+      throw error;
+    }
+  }));
+}

package/services/plugins.mjs

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { join } from 'node:path';
 import { logger } from './logger.mjs';
+import { extractMicroFrontendStructures, resolveMicroFrontendStructures } from './micro-frontends.mjs';
 
 /**
  * Push plugins from local directory to remote
@@ -38,6 +40,19 @@ export async function pushPlugins(sdk, path) {
       
       logger.step(`Pushing plugin: ${apiPath}`);
       
+      // Resolve micro-frontend structures from $ref references
+      if (pluginData.microFrontends && pluginData.microFrontends.length > 0) {
+        try {
+          pluginData.microFrontends = await resolveMicroFrontendStructures(
+            pluginData.microFrontends,
+            path
+          );
+        } catch (error) {
+          logger.error(`Failed to resolve micro-frontend structures for ${apiPath}`, error);
+          throw new Error(`Failed to resolve structures for ${apiPath}: ${error.message}`);
+        }
+      }
+      
       const existingPlugin = existingPlugins.find(
         plugin => plugin.apiPath === apiPath
       );
@@ -126,6 +141,7 @@ export async function pullPlugins(sdk, targetPath) {
   await Promise.all(plugins.map(async (plugin) => {
     const fileName = `${plugin.apiPath}.plugin.json`;
     const filePath = join(targetPath, fileName);
+    const pluginDir = join(targetPath, plugin.apiPath);
 
     // Fetch full plugin details
     const fullPlugin = await sdk.managePlugins.getById(plugin._id);
@@ -135,6 +151,12 @@ export async function pullPlugins(sdk, targetPath) {
       return rest;
     }
 
+    // Extract micro-frontend structures to separate files
+    const processedMicroFrontends = extractMicroFrontendStructures(
+      (fullPlugin.microFrontends || []).map(removeIdFromObject),
+      targetPath
+    );
+
     const relevantFields = {
       name: fullPlugin.name,
       description: fullPlugin.description,
@@ -145,7 +167,7 @@ export async function pullPlugins(sdk, targetPath) {
       authAcquire: fullPlugin.authAcquire,
       proxyUrl: fullPlugin.proxyUrl,
       subscribedEvents: (fullPlugin.subscribedEvents || []).map(removeIdFromObject),
-      microFrontends: (fullPlugin.microFrontends || []).map(removeIdFromObject),
+      microFrontends: processedMicroFrontends,
       injectables: (fullPlugin.injectables || []).map(removeIdFromObject),
       navBarGroups: (fullPlugin.navBarGroups || []).map(removeIdFromObject),
       cruds: (fullPlugin.cruds || []).map(removeIdFromObject),

package/services/sdk.mjs

@@ -1,25 +1,27 @@
-import { createJiti } from 'jiti';
-import { logger } from './logger.mjs';
+import { createJiti } from "jiti";
+import { logger } from "./logger.mjs";
 
 const jiti = createJiti(import.meta.url);
 
-export async function initializeSdk() {
-  const appUrl = process.env.QELOS_URL || "http://localhost:3000";
-  const username = process.env.QELOS_USERNAME || 'test@test.com';
-  const password = process.env.QELOS_PASSWORD || 'admin';
+export const appUrl = process.env.QELOS_URL || "http://localhost:3000";
 
+export async function initializeSdk() {
+  const username = process.env.QELOS_USERNAME || "test@test.com";
+  const password = process.env.QELOS_PASSWORD || "admin";
   try {
-    logger.debug('Initializing Qelos SDK...');
-    
+    logger.debug("Initializing Qelos SDK...");
+
     if (process.env.VERBOSE) {
       logger.showConfig({
-        'QELOS_URL': appUrl,
-        'QELOS_USERNAME': username,
-        'QELOS_PASSWORD': password
+        QELOS_URL: appUrl,
+        QELOS_USERNAME: username,
+        QELOS_PASSWORD: password,
       });
     }
 
-    const QelosAdministratorSDK = await jiti('@qelos/sdk/src/administrator/index.ts');
+    const QelosAdministratorSDK = await jiti(
+      "@qelos/sdk/src/administrator/index.ts"
+    );
 
     const sdk = new QelosAdministratorSDK.default({
       appUrl,
@@ -32,24 +34,28 @@ export async function initializeSdk() {
       password,
     });
 
-    logger.debug('Authentication successful');
+    logger.debug("Authentication successful");
     return sdk;
-
   } catch (error) {
     // Handle connection errors
-    if (error.cause?.code === 'UND_ERR_CONNECT_TIMEOUT' || 
-        error.cause?.code === 'ENOTFOUND' || 
-        error.cause?.code === 'ECONNREFUSED' ||
-        error.message?.includes('fetch failed')) {
+    if (
+      error.cause?.code === "UND_ERR_CONNECT_TIMEOUT" ||
+      error.cause?.code === "ENOTFOUND" ||
+      error.cause?.code === "ECONNREFUSED" ||
+      error.message?.includes("fetch failed")
+    ) {
       logger.connectionError(appUrl, error.cause || error);
-    } 
+    }
     // Handle authentication errors
-    else if (error.response?.status === 401 || error.message?.includes('authentication')) {
+    else if (
+      error.response?.status === 401 ||
+      error.message?.includes("authentication")
+    ) {
       logger.authError(username, appUrl);
     }
     // Handle other errors
     else {
-      logger.error('Failed to initialize SDK', error);
+      logger.error("Failed to initialize SDK", error);
     }
 
     process.exit(1);