@profitlich/template-toolkit 2.4.3 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@profitlich/template-toolkit",
-    "version": "2.4.3",
+    "version": "2.5.0",
     "description": "Shared SCSS layout system, JS utilities, components and build scripts for profitlich template repos",
     "type": "module",
     "exports": {

package/scripts/deploy.js

@@ -2,27 +2,50 @@ import ftp from 'basic-ftp';
 import dotenv from 'dotenv';
 import { glob } from 'glob';
 import path from 'path';
+import fs from 'fs/promises';
 import readline from 'readline';
 import cliProgress from 'cli-progress';
 
 // Helper for making sure the upload progress bars go to 100%
 const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
 
-export async function runDeploy(mode, uploadTasks) {
+async function isNewer(client, localFile, remotePath) {
+    const localStat = await fs.stat(localFile);
+    try {
+        const remoteDate = await client.lastMod(remotePath);
+        return localStat.mtimeMs > remoteDate.getTime();
+    } catch {
+        // File doesn't exist remotely (550) or server doesn't support MDTM — upload it
+        return true;
+    }
+}
+
+async function createClient(accessOptions) {
     const client = new ftp.Client();
     client.ftp.verbose = false;
+    await client.access(accessOptions);
+    return client;
+}
+
+export async function runDeploy(mode, uploadTasks, options = {}) {
+    const parallel = options.parallel ?? 3;
+    const modeUpper = mode.toUpperCase();
+
+    const accessOptions = {
+        host: process.env[`FTP_HOST_${modeUpper}`],
+        user: process.env[`FTP_USER_${modeUpper}`],
+        password: process.env[`FTP_PASSWORD_${modeUpper}`],
+        secure: true
+    };
+
+    const mainClient = new ftp.Client();
+    mainClient.ftp.verbose = false;
     let activeProgressBar = null;
 
     try {
-        const modeUpper = mode.toUpperCase();
         console.log(`🚀 Starting deployment for: ${modeUpper}`);
 
-        await client.access({
-            host: process.env[`FTP_HOST_${modeUpper}`],
-            user: process.env[`FTP_USER_${modeUpper}`],
-            password: process.env[`FTP_PASSWORD_${modeUpper}`],
-            secure: true
-        });
+        await mainClient.access(accessOptions);
 
         for (const task of uploadTasks) {
             console.log(`\nProcessing Task: ${task.name}`);
@@ -38,24 +61,65 @@ export async function runDeploy(mode, uploadTasks) {
                 continue;
             }
 
-            const newBar = new cliProgress.SingleBar({
+            // Determine which files are newer than their remote counterparts
+            process.stdout.write(`  Checking ${files.length} files...`);
+            const filesToUpload = [];
+            for (const file of files) {
+                const relativeFile = path.relative(task.localBase, file);
+                const remotePath = path.join(task.remoteDir, relativeFile).replace(/\\/g, '/');
+                if (await isNewer(mainClient, file, remotePath)) {
+                    filesToUpload.push({ file, remotePath });
+                }
+            }
+            process.stdout.write(` ${filesToUpload.length} changed.\n`);
+
+            if (filesToUpload.length === 0) {
+                console.log('  All files are up to date, skipping.');
+                continue;
+            }
+
+            const progressBar = new cliProgress.SingleBar({
                 format: '  Upload |{bar}| {percentage}%   {value}/{total} files   {duration_formatted}',
                 barCompleteChar: '█',
                 barIncompleteChar: '░',
                 hideCursor: true
             });
 
-            activeProgressBar = newBar;
-            activeProgressBar.start(files.length, 0);
+            activeProgressBar = progressBar;
+            progressBar.start(filesToUpload.length, 0);
 
-            for (const file of files) {
-                const relativeFile = path.relative(task.localBase, file);
-                const remotePath = path.join(task.remoteDir, relativeFile).replace(/\\/g, '/');
-
-                await client.ensureDir(path.dirname(remotePath));
-                await client.uploadFrom(file, remotePath);
-
-                activeProgressBar.increment();
+            if (parallel <= 1) {
+                for (const { file, remotePath } of filesToUpload) {
+                    await mainClient.ensureDir(path.dirname(remotePath));
+                    await mainClient.uploadFrom(file, remotePath);
+                    progressBar.increment();
+                }
+            } else {
+                // Pre-create all required remote directories with the main client
+                const uniqueDirs = [...new Set(filesToUpload.map(({ remotePath }) => path.dirname(remotePath)))];
+                for (const dir of uniqueDirs) {
+                    await mainClient.ensureDir(dir);
+                }
+
+                // Spawn parallel worker connections
+                const workerCount = Math.min(parallel, filesToUpload.length);
+                const workers = await Promise.all(
+                    Array.from({ length: workerCount }, () => createClient(accessOptions))
+                );
+
+                const queue = [...filesToUpload];
+                await Promise.all(workers.map(async (workerClient) => {
+                    try {
+                        while (true) {
+                            const item = queue.shift();
+                            if (!item) break;
+                            await workerClient.uploadFrom(item.file, item.remotePath);
+                            progressBar.increment();
+                        }
+                    } finally {
+                        workerClient.close();
+                    }
+                }));
             }
 
             activeProgressBar.stop();
@@ -71,15 +135,16 @@ export async function runDeploy(mode, uploadTasks) {
         }
         console.error('Deployment failed:', err);
     } finally {
-        client.close();
+        mainClient.close();
     }
 }
 
 /**
  * Run the deploy script.
  * @param {Array} uploadTasks - array of { name, localPattern, localBase, remoteDir, ignore? }
+ * @param {Object} options - { parallel: number } (default: { parallel: 3 })
  */
-export function run(uploadTasks) {
+export function run(uploadTasks, options = {}) {
     const mode = process.argv[2];
     if (!mode || (mode !== 'staging' && mode !== 'production')) {
         console.error('Error: a mode needs to be given, either "staging" or "production"');
@@ -99,7 +164,7 @@ export function run(uploadTasks) {
             rl.close();
             if (answer.toLowerCase() === 'yes') {
                 console.log('Confirmed. Starting upload...');
-                runDeploy(mode, uploadTasks);
+                runDeploy(mode, uploadTasks, options);
             } else {
                 console.log('❌ Deployment aborted.');
                 process.exit(0);
@@ -107,6 +172,6 @@ export function run(uploadTasks) {
         });
     // In all other modes run deploy without prompt
     } else {
-        runDeploy(mode, uploadTasks);
+        runDeploy(mode, uploadTasks, options);
     }
 }