wp-blank-scripts 4.0.0-alpha.2 → 4.0.0-alpha.4

package/lib/deployProject.js

@@ -1,13 +1,14 @@
 const fs = require('fs');
 const path = require('path');
-const mysql = require('mysql');
+const ora = require('ora');
 const Rsync = require('rsync');
 const { rimraf } = require('rimraf');
 
 const exportSql = require('./exportSQL');
 const cleanShellPath = require('../utils/cleanShellPath');
-const tunnel = require('../utils/tunnelSsh');
 const git = require('../utils/git');
+const _ssh2 = require('ssh2');
+const SSH2Client = _ssh2.Client || _ssh2;
 const runProjectBuildTask = require('../utils/runProjectBuildTask');
 const bumpVersion = require('../utils/bumpVersion');
 const execAsync = require('../utils/execAsync');
@@ -15,7 +16,6 @@ const { DEPLOY_MODES } = require('../constants');
 const getProjectPath = require('../utils/getProjectPath');
 const getSettings = require('../utils/projectSettings');
 const logger = require('../logger');
-const replaceSQL = require('../utils/replaceSQL');
 
 // Default options
 const defaultOptions = {
@@ -24,9 +24,6 @@ const defaultOptions = {
   mySQLPort: 3306,
 };
 
-let m;
-let t;
-
 let options;
 let settings;
 let deployModeOptions;
@@ -61,44 +58,86 @@ function setDeployModeOptions(deployBuildDir) {
   };
 }
 
-async function createTunnel() {
-  // Get server access info
+async function deployMySQLviaSSH(file) {
   const server = settings.server[options.environment];
   const serverPassword = options.serverPassword;
-
-  const { tunnelHost, tunnelPort, mySQLPort } = options;
+  const { user: dbUser, password: dbPassword, database } = settings.mysql[options.environment];
 
   let serverPrivateKey;
   if (options.serverPrivateKey) {
     serverPrivateKey = fs.readFileSync(cleanShellPath(options.serverPrivateKey));
   }
 
-  // Setup SSL Tunnel for remote MySQL access
-  const tunnelConfig = {
-    username: server.user,
-    host: server.host,
-    password: serverPassword,
-    dstHost: server.host,
-    dstPort: mySQLPort,
-    localHost: tunnelHost,
-    localPort: tunnelPort,
-    privateKey: serverPrivateKey,
-  };
+  const spinner = ora(`Connecting to ${server.host} for MySQL import...`).start();
 
   return new Promise((resolve, reject) => {
-    t = tunnel(tunnelConfig, (error) => {
-      if (error) {
-        reject(new Error(`Error connecting: ${error}`));
-        return;
-      }
+    const conn = new SSH2Client();
+
+    conn.on('ready', () => {
+      spinner.text = `Importing SQL into ${database}...`;
+
+      // Wrap password in single quotes, escaping any single quotes within it
+      const escapedPassword = dbPassword.replace(/'/g, "'\\''");
+      const cmd = `mysql -u ${dbUser} -p'${escapedPassword}' ${database}`;
 
-      logger.log(`Created tunnel to ${tunnelConfig.host}`);
-      resolve();
+      conn.exec(cmd, (err, stream) => {
+        if (err) {
+          conn.end();
+          spinner.fail('MySQL import failed');
+          reject(new Error(`SSH exec error: ${err.message}`));
+          return;
+        }
+
+        let stderr = '';
+        stream.resume(); // drain stdout so the stream can close
+        stream.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        stream.on('close', (code) => {
+          conn.end();
+          // Filter the harmless password-on-cli warning from stderr
+          const errorOutput = stderr
+            .replace(/.*Using a password on the command line.*\n?/g, '')
+            .trim();
+          if (code !== 0) {
+            spinner.fail('MySQL import failed');
+            reject(new Error(`MySQL import failed (exit ${code}): ${errorOutput}`));
+          } else {
+            spinner.succeed('SQL deployment was successful');
+            resolve();
+          }
+        });
+
+        // Pipe SQL file and explicitly end stdin when done
+        const sqlStream = fs.createReadStream(file);
+        sqlStream.on('end', () => stream.stdin.end());
+        sqlStream.on('error', (err) => {
+          spinner.fail('Failed to read SQL file');
+          reject(new Error(`SQL file read error: ${err.message}`));
+        });
+        sqlStream.pipe(stream.stdin, { end: false });
+      });
     });
 
-    t.on('error', (error) => {
-      reject(new Error(`${error}`));
+    conn.on('error', (err) => {
+      spinner.fail('SSH connection error');
+      reject(new Error(`SSH connection error: ${err.message}`));
     });
+
+    const connectConfig = {
+      host: server.host,
+      port: server.sshPort || 22,
+      username: server.user,
+    };
+
+    if (serverPrivateKey) {
+      connectConfig.privateKey = serverPrivateKey;
+    } else if (serverPassword) {
+      connectConfig.password = serverPassword;
+    }
+
+    conn.connect(connectConfig);
   });
 }
 
@@ -175,72 +214,6 @@ async function deployToServer() {
   });
 }
 
-async function connectMySQL() {
-  // Environment info
-  const { host } = settings.server[options.environment];
-  const { user, password, database } = settings.mysql[options.environment];
-
-  // Tunnel info
-  const { tunnelHost, tunnelPort } = options;
-
-  return new Promise((resolve, reject) => {
-    m = mysql.createConnection({
-      host: tunnelHost,
-      port: tunnelPort,
-      user,
-      password,
-      database,
-      multipleStatements: true,
-    });
-
-    m.connect((err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-
-      logger.log(`Connected to ${host} as id ${m.threadId}`);
-      resolve();
-    });
-  });
-}
-
-async function deployMySQL(file) {
-  return new Promise((resolve, reject) => {
-    if (!file || !fs.existsSync(file)) {
-      reject(new Error('SQL file missing'));
-      return;
-    }
-
-    logger.log('Starting SQL deployment');
-
-    const sql = fs.readFileSync(file).toString();
-    m.query(sql, (error) => {
-      if (error) {
-        reject(new Error(`failed: ${error}`));
-        return;
-      }
-
-      logger.log('SQL deployment was successful');
-      resolve();
-    });
-  });
-}
-
-async function disconnectMySQL() {
-  return new Promise((resolve, reject) => {
-    m.end((err) => {
-      if (err) {
-        reject(new Error(`Error disconnecting: ${err.stack}`));
-        return;
-      }
-
-      logger.log('Disconnected from MySQL server');
-      resolve();
-    });
-  });
-}
-
 module.exports = async (selectOptions, callbacks) => {
   options = {
     ...defaultOptions,
@@ -274,20 +247,10 @@ module.exports = async (selectOptions, callbacks) => {
 
   if (options.sql) {
     const file = await exportSql({ environment: options.environment });
-    await createTunnel();
-    await connectMySQL();
 
     if (file) {
-      await replaceSQL({
-        environmentIn: 'local',
-        environmentOut: options.environment,
-        file,
-      });
-
-      await deployMySQL(file);
+      await deployMySQLviaSSH(file);
     }
-
-    await disconnectMySQL();
   }
 
   await bumpVersion(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wp-blank-scripts",
-  "version": "4.0.0-alpha.2",
+  "version": "4.0.0-alpha.4",
   "description": "Personal Wordpress Scripts",
   "main": "index.js",
   "bin": {
@@ -55,7 +55,6 @@
     "inquirer": "3.0.4",
     "lint-staged": "^13.3.0",
     "mini-css-extract-plugin": "^2.10.1",
-    "mysql": "^2.18.1",
     "node-fetch": "^2.7.0",
     "ora": "^5.4.1",
     "postcss": "^8.5.8",

package/webpack.base.config.js

@@ -303,7 +303,8 @@ function makeBaseConfig(options) {
                 sourceMap: !isProd,
                 additionalData: (content, loaderContext) =>
                   loaderContext.resourcePath.endsWith('.css') ? content : sassVariables + content,
-                sassOptions: {
+                sassOptions: (loaderContext) => ({
+                  syntax: loaderContext.resourcePath.endsWith('.css') ? 'scss' : undefined,
                   loadPaths: [process.cwd()],
                   // Handle @import 'node_modules/foo/bar' resolving to a .css file.
                   // Dart Sass won't find .css files when the extension is omitted, so
@@ -331,7 +332,7 @@ function makeBaseConfig(options) {
                   // project-by-project via: wp-scripts migrate-sass
                   // New projects using @use/@forward won't trigger these.
                   silenceDeprecations: ['import', 'color-functions', 'slash-div', 'global-builtin'],
-                },
+                }),
               },
             },
           ],

package/utils/tunnelSsh.js

@@ -1,134 +0,0 @@
-const net = require('net');
-const { Client: Connection } = require('ssh2');
-const events = require('events');
-
-const noop = () => {};
-
-function createConfig(config) {
-  const env = process.env;
-
-  config = {
-    username: env.TUNNELSSH_USER || env.USER || env.USERNAME || 'root',
-    port: 22,
-    host: null,
-    srcPort: 0,
-    srcHost: '127.0.0.1',
-    dstPort: null,
-    dstHost: '127.0.0.1',
-    localHost: '127.0.0.1',
-    localPort: config.dstPort,
-    agent: process.env.SSH_AUTH_SOCK,
-    ...config,
-  };
-
-  if (!config.host) {
-    throw new Error('host not set');
-  }
-
-  if (!config.dstPort) {
-    throw new Error('dstPort not set');
-  }
-
-  return config;
-}
-
-function bindSSHConnection(config, netConnection) {
-  const sshConnection = new Connection();
-  netConnection.on('close', sshConnection.end.bind(sshConnection));
-
-  sshConnection.on('ready', function () {
-    netConnection.emit('sshConnection', sshConnection, netConnection);
-    sshConnection.forwardOut(
-      config.srcHost,
-      config.srcPort,
-      config.dstHost,
-      config.dstPort,
-      function (err, sshStream) {
-        if (err) {
-          // Bubble up the error => netConnection => server
-          netConnection.emit('error', err);
-          return;
-        }
-
-        netConnection.emit('sshStream', sshStream);
-        netConnection.pipe(sshStream).pipe(netConnection);
-      }
-    );
-  });
-  return sshConnection;
-}
-
-function createServer(config) {
-  let server;
-  const connections = [];
-  let connectionCount = 0;
-
-  server = net.createServer(function (netConnection) {
-    let sshConnection;
-    connectionCount++;
-    netConnection.on('error', server.emit.bind(server, 'error'));
-    netConnection.on('close', function () {
-      connectionCount--;
-      if (connectionCount === 0) {
-        if (!config.keepAlive) {
-          setTimeout(function () {
-            if (connectionCount === 0) {
-              server.close();
-            }
-          }, 2);
-        }
-      }
-    });
-
-    server.emit('netConnection', netConnection, server);
-    sshConnection = bindSSHConnection(config, netConnection);
-    sshConnection.on('error', server.emit.bind(server, 'error'));
-
-    netConnection.on('sshStream', function (sshStream) {
-      sshStream.on('error', function () {
-        server.close();
-      });
-    });
-
-    connections.push(sshConnection, netConnection);
-    try {
-      sshConnection.connect(config);
-    } catch (error) {
-      server.emit('error', error);
-    }
-  });
-
-  server.on('close', function () {
-    connections.forEach(function (connection) {
-      connection.end();
-    });
-  });
-
-  return server;
-}
-
-function tunnel(configArgs, callback) {
-  let server;
-  let config;
-
-  if (!callback) {
-    callback = noop;
-  }
-  try {
-    config = createConfig(configArgs);
-    server = createServer(config);
-
-    server.listen(config.localPort, config.localHost, function (error) {
-      callback(error, server);
-    });
-  } catch (e) {
-    server = new events.EventEmitter();
-    setImmediate(function () {
-      callback(e);
-      server.emit('error', e);
-    });
-  }
-  return server;
-}
-
-module.exports = tunnel;