@fecommunity/reactpress 2.0.0-beta-4-beta.1 → 2.0.0-beta.0

package/scripts/{reactpress-publish.js → publish-packages.js}

@@ -10,9 +10,9 @@ const crypto = require('crypto');
 // Package build order (dependencies first)
 const packages = [
   {
-    name: '@fecommunity/reactpress',
-    path: '.',
-    description: 'Main ReactPress package'
+    name: '@fecommunity/reactpress-config',
+    path: 'config',
+    description: 'Configuration management package'
   },
   {
     name: '@fecommunity/reactpress-server', 
@@ -66,31 +66,8 @@ function getPackageHash(packagePath) {
   return generateHash(fullPath);
 }
 
-// Check if package has meaningful changes (for build)
-function hasMeaningfulChangesForBuild(packagePath, packageName) {
-  try {
-    // Create a hash file path to store previous hash in node_modules
-    const hashFilePath = path.join(process.cwd(), 'node_modules', '.build-cache', `${packageName.replace('/', '_')}.hash`);
-    
-    // Generate current hash
-    const currentHash = getPackageHash(packagePath);
-    
-    // Check if we have a previous hash
-    if (fs.existsSync(hashFilePath)) {
-      const previousHash = fs.readFileSync(hashFilePath, 'utf8').trim();
-      return currentHash !== previousHash;
-    }
-    
-    // If no previous hash, consider it as having changes
-    return true;
-  } catch (error) {
-    console.log(chalk.yellow(`⚠️  Could not check changes for ${packageName}, assuming changes exist`));
-    return true;
-  }
-}
-
-// Check if package has meaningful changes (for publish)
-function hasMeaningfulChangesForPublish(packagePath, packageName) {
+// Check if package has meaningful changes
+function hasMeaningfulChanges(packagePath, packageName) {
   try {
     // Create a hash file path to store previous hash in node_modules
     const hashFilePath = path.join(process.cwd(), 'node_modules', '.publish-cache', `${packageName.replace('/', '_')}.hash`);
@@ -112,27 +89,8 @@ function hasMeaningfulChangesForPublish(packagePath, packageName) {
   }
 }
 
-// Save package hash (for build)
-function savePackageHashForBuild(packagePath, packageName) {
-  try {
-    const hashFilePath = path.join(process.cwd(), 'node_modules', '.build-cache', `${packageName.replace('/', '_')}.hash`);
-    
-    // Ensure cache directory exists
-    const cacheDir = path.dirname(hashFilePath);
-    if (!fs.existsSync(cacheDir)) {
-      fs.mkdirSync(cacheDir, { recursive: true });
-    }
-    
-    // Generate and save current hash
-    const currentHash = getPackageHash(packagePath);
-    fs.writeFileSync(hashFilePath, currentHash);
-  } catch (error) {
-    console.log(chalk.yellow(`⚠️  Could not save hash for ${packageName}`));
-  }
-}
-
-// Save package hash (for publish)
-function savePackageHashForPublish(packagePath, packageName) {
+// Save package hash
+function savePackageHash(packagePath, packageName) {
   try {
     const hashFilePath = path.join(process.cwd(), 'node_modules', '.publish-cache', `${packageName.replace('/', '_')}.hash`);
     
@@ -251,67 +209,8 @@ function updateVersion(packagePath, newVersion) {
   console.log(chalk.green(`✅ Version updated from ${oldVersion} to ${newVersion}`));
 }
 
-// Fix workspace dependencies for build
-function fixWorkspaceDependenciesForBuild(packagePath) {
-  console.log(chalk.blue(`🔧 Fixing workspace dependencies for build: ${packagePath}...`));
-  
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-  
-  // Fix dependencies
-  const depTypes = ['dependencies', 'devDependencies', 'peerDependencies'];
-  
-  depTypes.forEach(depType => {
-    if (pkg[depType]) {
-      Object.keys(pkg[depType]).forEach(depName => {
-        // Check if it's a workspace dependency
-        if (pkg[depType][depName] === 'workspace:*' || pkg[depType][depName].startsWith('workspace:')) {
-          // For build purposes, we'll use the file: protocol to reference local packages
-          const depPackage = packages.find(p => p.name === depName);
-          if (depPackage) {
-            console.log(chalk.gray(`  Replacing ${depName} workspace dependency with file reference`));
-            pkg[depType][depName] = `file:../${depPackage.path}`;
-          }
-        }
-      });
-    }
-  });
-  
-  // Write the updated package.json
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-  console.log(chalk.green(`✅ Workspace dependencies fixed for build: ${packagePath}`));
-}
-
-// Restore workspace dependencies after build
-function restoreWorkspaceDependenciesAfterBuild(packagePath) {
-  console.log(chalk.blue(`🔄 Restoring workspace dependencies after build: ${packagePath}...`));
-  
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-  
-  // Restore dependencies
-  const depTypes = ['dependencies', 'devDependencies', 'peerDependencies'];
-  
-  depTypes.forEach(depType => {
-    if (pkg[depType]) {
-      Object.keys(pkg[depType]).forEach(depName => {
-        // Check if this is one of our internal packages referenced with file:
-        const depPackage = packages.find(p => p.name === depName);
-        if (depPackage && pkg[depType][depName].startsWith('file:')) {
-          console.log(chalk.gray(`  Restoring ${depName} to workspace dependency`));
-          pkg[depType][depName] = 'workspace:*';
-        }
-      });
-    }
-  });
-  
-  // Write the updated package.json
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-  console.log(chalk.green(`✅ Workspace dependencies restored after build: ${packagePath}`));
-}
-
 // Fix workspace dependencies for publish
-function fixWorkspaceDependenciesForPublish(packagePath, packageVersions) {
+function fixWorkspaceDependencies(packagePath, packageVersions) {
   console.log(chalk.blue(`🔧 Fixing workspace dependencies for publish: ${packagePath}...`));
   
   const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
@@ -342,7 +241,7 @@ function fixWorkspaceDependenciesForPublish(packagePath, packageVersions) {
 }
 
 // Restore workspace dependencies after publish
-function restoreWorkspaceDependenciesAfterPublish(packagePath) {
+function restoreWorkspaceDependencies(packagePath) {
   console.log(chalk.blue(`🔄 Restoring workspace dependencies for ${packagePath}...`));
   
   const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
@@ -370,33 +269,25 @@ function restoreWorkspaceDependenciesAfterPublish(packagePath) {
 }
 
 // Build package
-function buildPackage(pkg) {
-  console.log(chalk.blue(`\n🔨 Building ${pkg.name} (${pkg.description})...`));
+function buildPackage(packagePath, packageName) {
+  console.log(chalk.blue(`\n🔨 Building ${packageName}...`));
   
   try {
-    // Fix workspace dependencies for build
-    fixWorkspaceDependenciesForBuild(pkg.path);
-    
-    try {
-      if (pkg.path === 'config') {
-        execSync('pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
-      } else if (pkg.path === 'server') {
-        execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
-      } else if (pkg.path === 'client') {
-        execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
-      } else if (pkg.path === 'toolkit') {
-        execSync('pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
-      } else if (pkg.path === 'templates/hello-world' || pkg.path === 'templates/twentytwentyfive') {
-        // Templates don't need to be built, just validate package.json
-        console.log(chalk.gray('  Templates do not require building, skipping...'));
-      }
-      console.log(chalk.green(`✅ ${pkg.name} built successfully`));
-    } finally {
-      // Always restore workspace dependencies
-      restoreWorkspaceDependenciesAfterBuild(pkg.path);
-    }
+    if (packagePath === 'config') {
+      execSync('pnpm run build', { cwd: path.join(process.cwd(), packagePath), stdio: 'inherit' });
+    } else if (packagePath === 'server') {
+      execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), packagePath), stdio: 'inherit' });
+    } else if (packagePath === 'client') {
+      execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), packagePath), stdio: 'inherit' });
+    } else if (packagePath === 'toolkit') {
+      execSync('pnpm run build', { cwd: path.join(process.cwd(), packagePath), stdio: 'inherit' });
+    } else if (packagePath === 'templates/hello-world' || packagePath === 'templates/twentytwentyfive') {
+      // Templates don't need to be built, just validate package.json
+      console.log(chalk.gray('  Templates do not require building, skipping...'));
+    }
+    console.log(chalk.green(`✅ ${packageName} built successfully`));
   } catch (error) {
-    console.log(chalk.red(`❌ Failed to build ${pkg.name}`));
+    console.log(chalk.red(`❌ Failed to build ${packageName}`));
     throw error;
   }
 }
@@ -451,57 +342,8 @@ function checkEnvironment() {
   return true;
 }
 
-// Build packages function
-async function buildPackages() {
-  console.log(chalk.blue('🏗️  ReactPress Package Builder\n'));
-  
-  // Show current versions
-  console.log(chalk.cyan('📋 Current package versions:'));
-  packages.forEach(pkg => {
-    const version = getCurrentVersion(pkg.path);
-    console.log(chalk.gray(`  ${pkg.name}: ${version}`));
-  });
-  console.log();
-  
-  try {
-    // Track which packages actually need to be built
-    const packagesToBuild = [];
-    
-    // Check for meaningful changes in each package
-    for (const pkg of packages) {
-      if (fs.existsSync(path.join(process.cwd(), pkg.path))) {
-        if (hasMeaningfulChangesForBuild(pkg.path, pkg.name)) {
-          packagesToBuild.push(pkg);
-          console.log(chalk.blue(`\n📦 ${pkg.name} has changes, will be built`));
-        } else {
-          console.log(chalk.gray(`\n⏭️  ${pkg.name} has no meaningful changes, skipping...`));
-        }
-      } else {
-        console.log(chalk.yellow(`⚠️  Package ${pkg.name} directory not found, skipping...`));
-      }
-    }
-    
-    if (packagesToBuild.length === 0) {
-      console.log(chalk.green('\n✅ No packages have meaningful changes. Nothing to build!'));
-      return;
-    }
-    
-    // Build packages that have changes
-    for (const pkg of packagesToBuild) {
-      await buildPackage(pkg);
-      // Save the hash after successful build
-      savePackageHashForBuild(pkg.path, pkg.name);
-    }
-    
-    console.log(chalk.green(`\n🎉 ${packagesToBuild.length} package(s) built successfully!`));
-  } catch (error) {
-    console.error(chalk.red('❌ Build failed:'), error);
-    process.exit(1);
-  }
-}
-
-// Publish packages function
-async function publishPackages() {
+// Main function
+async function main() {
   // Check if called with --no-build flag
   const noBuild = process.argv.includes('--no-build');
   
@@ -550,7 +392,7 @@ async function publishPackages() {
     // Check for meaningful changes in each package
     for (const pkg of packages) {
       if (fs.existsSync(path.join(process.cwd(), pkg.path))) {
-        if (hasMeaningfulChangesForPublish(pkg.path, pkg.name)) {
+        if (hasMeaningfulChanges(pkg.path, pkg.name)) {
           packagesToBuild.push(pkg);
           console.log(chalk.blue(`\n📦 ${pkg.name} has changes, will be built`));
         } else {
@@ -568,9 +410,9 @@ async function publishPackages() {
     
     // Build packages that have changes
     for (const pkg of packagesToBuild) {
-      buildPackage(pkg);
+      buildPackage(pkg.path, pkg.name);
       // Save the hash after successful build
-      savePackageHashForPublish(pkg.path, pkg.name);
+      savePackageHash(pkg.path, pkg.name);
     }
     
     console.log(chalk.green(`\n🎉 ${packagesToBuild.length} package(s) built successfully!`));
@@ -591,7 +433,7 @@ async function publishPackages() {
     ]);
     
     // Check if the selected package has meaningful changes
-    if (!hasMeaningfulChangesForPublish(selectedPackage.path, selectedPackage.name)) {
+    if (!hasMeaningfulChanges(selectedPackage.path, selectedPackage.name)) {
       console.log(chalk.gray(`\n⏭️  ${selectedPackage.name} has no meaningful changes, skipping...`));
       console.log(chalk.green('✅ Nothing to publish!'));
       return;
@@ -641,13 +483,13 @@ async function publishPackages() {
     packageVersions[selectedPackage.name] = newVersion;
     
     // Fix workspace dependencies before publishing
-    fixWorkspaceDependenciesForPublish(selectedPackage.path, packageVersions);
+    fixWorkspaceDependencies(selectedPackage.path, packageVersions);
     
     try {
       updateVersion(selectedPackage.path, newVersion);
       // Only build if not disabled
       if (!noBuild) {
-        buildPackage(selectedPackage);
+        buildPackage(selectedPackage.path, selectedPackage.name);
       }
       
       // Determine tag based on version type
@@ -655,12 +497,12 @@ async function publishPackages() {
       publishPackage(selectedPackage.path, selectedPackage.name, tag);
       
       // Save the hash after successful publish
-      savePackageHashForPublish(selectedPackage.path, selectedPackage.name);
+      savePackageHash(selectedPackage.path, selectedPackage.name);
       
       console.log(chalk.green(`\n🎉 ${selectedPackage.name} v${newVersion} published successfully!`));
     } finally {
       // Always restore workspace dependencies
-      restoreWorkspaceDependenciesAfterPublish(selectedPackage.path);
+      restoreWorkspaceDependencies(selectedPackage.path);
     }
     
     return;
@@ -708,7 +550,7 @@ async function publishPackages() {
         continue;
       }
       
-      if (hasMeaningfulChangesForPublish(pkg.path, pkg.name)) {
+      if (hasMeaningfulChanges(pkg.path, pkg.name)) {
         packagesToPublish.push(pkg);
         console.log(chalk.blue(`\n📦 ${pkg.name} has changes, will be published`));
       } else {
@@ -744,21 +586,21 @@ async function publishPackages() {
       packageVersions[pkg.name] = newVersion;
       
       // Fix workspace dependencies before publishing
-      fixWorkspaceDependenciesForPublish(pkg.path, packageVersions);
+      fixWorkspaceDependencies(pkg.path, packageVersions);
       
       try {
         updateVersion(pkg.path, newVersion);
         // Only build if not disabled
         if (!noBuild) {
-          buildPackage(pkg);
+          buildPackage(pkg.path, pkg.name);
         }
         publishPackage(pkg.path, pkg.name, tag);
         
         // Save the hash after successful publish
-        savePackageHashForPublish(pkg.path, pkg.name);
+        savePackageHash(pkg.path, pkg.name);
       } finally {
         // Always restore workspace dependencies
-        restoreWorkspaceDependenciesAfterPublish(pkg.path);
+        restoreWorkspaceDependencies(pkg.path);
       }
     }
     
@@ -847,7 +689,7 @@ async function publishPackages() {
         continue;
       }
       
-      if (hasMeaningfulChangesForPublish(pkg.path, pkg.name)) {
+      if (hasMeaningfulChanges(pkg.path, pkg.name)) {
         packagesToPublish.push(pkg);
         console.log(chalk.blue(`\n📦 ${pkg.name} has changes, will be published`));
       } else {
@@ -869,13 +711,13 @@ async function publishPackages() {
       packageVersions[pkg.name] = pkgVersion;
       
       // Fix workspace dependencies before publishing
-      fixWorkspaceDependenciesForPublish(pkg.path, packageVersions);
+      fixWorkspaceDependencies(pkg.path, packageVersions);
       
       try {
         updateVersion(pkg.path, pkgVersion);
         // Only build if not disabled
         if (!noBuild) {
-          buildPackage(pkg);
+          buildPackage(pkg.path, pkg.name);
         }
         
         // Determine tag based on version type and branch
@@ -883,10 +725,10 @@ async function publishPackages() {
         publishPackage(pkg.path, pkg.name, tag);
         
         // Save the hash after successful publish
-        savePackageHashForPublish(pkg.path, pkg.name);
+        savePackageHash(pkg.path, pkg.name);
       } finally {
         // Always restore workspace dependencies
-        restoreWorkspaceDependenciesAfterPublish(pkg.path);
+        restoreWorkspaceDependencies(pkg.path);
       }
     }
     
@@ -907,39 +749,7 @@ ${Object.entries(packageVersions).map(([name, version]) => `- ${name}@${version}
   }
 }
 
-// Main function
-async function main() {
-  // Check command line arguments
-  const args = process.argv.slice(2);
-  
-  if (args.includes('--publish')) {
-    // When called with --publish, start the publish process
-    console.log(chalk.blue('🏗️  ReactPress Package Builder\n'));
-    
-    // Show current versions
-    console.log(chalk.cyan('📋 Current package versions:'));
-    packages.forEach(pkg => {
-      const version = getCurrentVersion(pkg.path);
-      console.log(chalk.gray(`  ${pkg.name}: ${version}`));
-    });
-    console.log();
-    
-    // Start the publish process
-    await publishPackages();
-  } else if (args.includes('--build')) {
-    // When called with --build, just build packages
-    await buildPackages();
-  } else {
-    // Default behavior - show help
-    console.log(chalk.blue('🏗️  ReactPress CLI\n'));
-    console.log('Usage:');
-    console.log('  node scripts/reactpress-cli.js --build    Build all packages');
-    console.log('  node scripts/reactpress-cli.js --publish  Publish packages (interactive)');
-    console.log('');
-  }
-}
-
 main().catch(error => {
-  console.error(chalk.red('❌ Operation failed:'), error);
+  console.error(chalk.red('❌ Publishing failed:'), error);
   process.exit(1);
-});
+});

package/scripts/reactpress-server-old.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+const express = require('express');
+const mysql = require('mysql2/promise');
+const chalk = require('chalk');
+const open = require('open');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const PORT = 3003;
+const envPath = path.join(process.cwd(), '.env');
+
+// WordPress-style 5-minute installation
+async function install() {
+  console.log(chalk.blue('🚀 ReactPress 5-Minute Installation'));
+  console.log(chalk.cyan('🌍 Starting installation wizard...'));
+  
+  const app = express();
+  app.use(express.json());
+  app.get('/', (req, res) => res.send(getHTML()));
+  
+  app.post('/test-db', async (req, res) => {
+    const { host, port, user, password, database } = req.body;
+    try {
+      const conn = await mysql.createConnection({ host, port: parseInt(port), user, password });
+      await conn.execute(`CREATE DATABASE IF NOT EXISTS \`${database}\` CHARACTER SET utf8mb4`);
+      await conn.end();
+      res.json({ success: true, message: 'Database connection successful!' });
+    } catch (error) {
+      res.json({ success: false, message: error.message });
+    }
+  });
+  
+  app.post('/install', async (req, res) => {
+    const { db, site } = req.body;
+    const env = `DB_HOST=${db.host}\nDB_PORT=${db.port}\nDB_USER=${db.user}\nDB_PASSWD=${db.password}\nDB_DATABASE=${db.database}\nCLIENT_SITE_URL=${site.clientUrl}\nSERVER_SITE_URL=${site.serverUrl}\nJWT_SECRET=${crypto.randomBytes(32).toString('hex')}\n`;
+    fs.writeFileSync(envPath, env);
+    res.json({ success: true, message: 'ReactPress installed successfully!' });
+    setTimeout(() => {
+      console.log(chalk.green('\n🎉 Installation completed!'));
+      console.log(chalk.cyan('Run: npx reactpress-server start'));
+      process.exit(0);
+    }, 2000);
+  });
+  
+  const server = app.listen(PORT, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(chalk.green(`✅ Installation wizard: ${url}`));
+    open(url);
+    console.log(chalk.gray('Press Ctrl+C to cancel\n'));
+  });
+  
+  process.on('SIGINT', () => {
+    console.log(chalk.yellow('\n⚠️ Installation cancelled'));
+    server.close();
+    process.exit(0);
+  });
+}
+
+function start() {
+  if (!fs.existsSync(envPath)) {
+    console.log(chalk.red('❌ No configuration found!'));
+    console.log(chalk.yellow('Run: npx reactpress-server install'));
+    return;
+  }
+  console.log(chalk.blue('🚀 Starting ReactPress Server...'));
+  const { spawn } = require('child_process');
+  spawn('npm', ['run', 'start:dev'], { cwd: path.resolve(__dirname, '../server'), stdio: 'inherit' });
+}
+
+            if (!clientUrl || !serverUrl) {
+                showNotice('Please fill in all site URLs.', 'error', 'installResult');
+                return;
+            }
+            
+            const installBtn = document.getElementById('installBtn');
+            const originalText = installBtn.innerHTML;
+            
+            installBtn.disabled = true;
+            installBtn.innerHTML = '<span class="wp-loader"></span>Installing ReactPress...';
+            
+            try {
+                const response = await fetch('/install', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        db: dbData,
+                        site: { clientUrl, serverUrl }
+                    })
+                });
+                
+                const result = await response.json();
+                
+                if (result.success) {
+                    showStep(3);
+                } else {
+                    showNotice(result.message, 'error', 'installResult');
+                }
+            } catch (error) {
+                showNotice('Installation failed. Please try again.', 'error', 'installResult');
+            } finally {
+                installBtn.disabled = false;
+                installBtn.innerHTML = originalText;
+            }
+        }
+        
+        // Initialize progress bar
+        updateProgress();
+        
+        // Auto-focus first input
+        document.getElementById('dbHost').focus();
+    </script>
+</body>
+</html>`;
+}
+
+// Main entry point
+const args = process.argv.slice(2);
+if (args.length === 0 || args[0] === 'install') {
+  install();
+} else if (args[0] === 'start') {
+  start();
+} else {
+  console.log(chalk.blue('ReactPress Server CLI'));
+  console.log(chalk.gray('npx reactpress-server         # Install'));
+  console.log(chalk.gray('npx reactpress-server start   # Start server'));
+}