@bprotsyk/aso-core 2.0.33 → 2.0.35

package/lib/utils/server-util.d.ts

@@ -29,7 +29,10 @@ export declare class ServerUtil {
     setupCertbot(): Promise<boolean>;
     setupSSL(email: string, host: string): Promise<void>;
     refresh(): Promise<boolean>;
-    uploadDirectoryToSftp(localDir: string, remoteDir: string, sftpConfig: ISFTP): Promise<void>;
+    uploadDirectoryToSftp(localDir: string, remoteDir: string, sftpConfig: any): Promise<void>;
+    ensureDirectoryExistence(dirPath: string): void;
     generateNginxConfig(domain: string, rootPath: string): Promise<string>;
+    extractUploadedZip(name: string, file: any): Promise<void>;
+    ensureDirectoryExistsViaSSH(sshConfig: ISFTP, remoteDir: string): Promise<void>;
 }
 export {};

package/lib/utils/server-util.js

@@ -4,11 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerUtil = exports.PORT = exports.HOST = exports.PASSWORD = exports.IP = void 0;
+const node_ssh_1 = require("node-ssh");
 const child_process_1 = __importDefault(require("child_process"));
 const ssh2_sftp_client_1 = __importDefault(require("ssh2-sftp-client"));
 const fs_1 = __importDefault(require("fs"));
 const mustache_1 = __importDefault(require("mustache"));
 const path_1 = __importDefault(require("path"));
+const unzipper_1 = __importDefault(require("unzipper"));
 const { promisify } = require("util");
 const execPromise = promisify(child_process_1.default.exec);
 exports.IP = "185.123.53.227";
@@ -169,53 +171,97 @@ class ServerUtil {
         const sftp = new ssh2_sftp_client_1.default();
         try {
             await sftp.connect(sftpConfig);
-            await sftp.stat(remoteDir).catch(async (err) => {
-                if (err.code === 2) {
-                    // Код 2 означає, що директорія не існує
-                    await sftp.mkdir(remoteDir, true);
-                    console.log(`Папка створена: ${remoteDir}`);
-                }
-                else {
-                    console.error(`Помилка під час перевірки або створення папки: ${remoteDir}`, err);
-                    throw err;
-                }
-            });
             const items = fs_1.default.readdirSync(localDir, { withFileTypes: true });
             for (const item of items) {
                 const localPath = path_1.default.join(localDir, item.name);
                 const remotePath = `${remoteDir}/${item.name}`;
                 if (item.isDirectory()) {
-                    await sftp.stat(remotePath).catch(async (err) => {
-                        if (err.code === 2) {
-                            await sftp.mkdir(remotePath, true);
-                            console.log(`Папка створена: ${remotePath}`);
-                        }
-                        else {
-                            console.error(`Помилка під час перевірки або створення папки: ${remotePath}`, err);
+                    // Створення підкаталогу на віддаленому сервері
+                    await sftp.mkdir(remotePath, true).catch(async (err) => {
+                        if (err.code !== 4) { // Ігноруємо помилку "Directory already exists"
+                            console.error(`Помилка під час створення папки: ${remotePath}`, err);
                             throw err;
                         }
                     });
+                    // Рекурсивне копіювання вмісту директорії
                     await this.uploadDirectoryToSftp(localPath, remotePath, sftpConfig);
                 }
                 else {
+                    // Завантаження файлу на віддалений сервер
                     await sftp.put(localPath, remotePath);
                     console.log(`Передано файл: ${localPath} -> ${remotePath}`);
                 }
             }
-            console.log("Усі файли та папки успішно передані.");
+            console.log('Усі файли та папки успішно передані.');
         }
         catch (err) {
-            console.error("Помилка під час передавання файлів через SFTP:", err);
+            console.error('Помилка під час передавання файлів через SFTP:', err);
         }
         finally {
             await sftp.end();
         }
     }
+    ensureDirectoryExistence(dirPath) {
+        if (!fs_1.default.existsSync(dirPath)) {
+            fs_1.default.mkdirSync(dirPath, { recursive: true });
+        }
+    }
     async generateNginxConfig(domain, rootPath) {
         const templatePath = path_1.default.join(__dirname, "..", "templates", "nginx-template.conf");
         const template = fs_1.default.readFileSync(templatePath, "utf8");
         const config = mustache_1.default.render(template, { domain, rootPath });
         return config;
     }
+    async extractUploadedZip(name, file) {
+        const zipFilePath = file.path;
+        const outputDir = path_1.default.join(__dirname, '..', 'uploads', name);
+        console.log('Looking for ZIP file at:', zipFilePath);
+        console.log('Extracting to:', outputDir);
+        this.ensureDirectoryExistence(outputDir);
+        if (!fs_1.default.existsSync(zipFilePath)) {
+            console.error('Error: File not found:', zipFilePath);
+            return;
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                fs_1.default.createReadStream(zipFilePath)
+                    .pipe(unzipper_1.default.Parse())
+                    .on('entry', (entry) => {
+                    // Видаляємо перший сегмент шляху, щоб уникнути кореневої директорії
+                    const entryPath = path_1.default.join(outputDir, ...entry.path.split('/').slice(1));
+                    if (entry.type === 'Directory') {
+                        this.ensureDirectoryExistence(entryPath);
+                    }
+                    else {
+                        this.ensureDirectoryExistence(path_1.default.dirname(entryPath));
+                        entry.pipe(fs_1.default.createWriteStream(entryPath));
+                    }
+                })
+                    .on('close', resolve)
+                    .on('error', reject);
+            });
+            console.log('File successfully extracted.');
+        }
+        catch (err) {
+            console.error('Error extracting file:', err);
+        }
+    }
+    async ensureDirectoryExistsViaSSH(sshConfig, remoteDir) {
+        const ssh = new node_ssh_1.NodeSSH();
+        try {
+            await ssh.connect(sshConfig);
+            // Перевірка, чи існує директорія, і створення її, якщо вона не існує
+            const command = `if [ ! -d "${remoteDir}" ]; then mkdir -p "${remoteDir}"; fi`;
+            await ssh.execCommand(command);
+            console.log(`Перевірено або створено папку: ${remoteDir}`);
+        }
+        catch (err) {
+            console.error('Помилка під час перевірки або створення папки через SSH:', err);
+            throw err;
+        }
+        finally {
+            ssh.dispose();
+        }
+    }
 }
 exports.ServerUtil = ServerUtil;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bprotsyk/aso-core",
-  "version": "2.0.33",
+  "version": "2.0.35",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -37,7 +37,8 @@
     "replace-in-file": "^7.0.1",
     "sleep-promise": "^9.1.0",
     "ssh2-sftp-client": "^11.0.0",
-    "styled-components": "^5.3.9"
+    "styled-components": "^5.3.9",
+    "unzipper": "^0.12.3"
   },
   "devDependencies": {
     "@types/mustache": "^4.2.5",
@@ -45,6 +46,7 @@
     "@types/react": "^18.2.14",
     "@types/react-dom": "^18.3.0",
     "@types/ssh2-sftp-client": "^9.0.4",
+    "@types/unzipper": "^0.10.10",
     "copyfiles": "^2.4.1",
     "typedoc": "^0.23.28",
     "typescript": "^4.9.5"

package/src/utils/server-util.ts

@@ -4,6 +4,8 @@ import Client from "ssh2-sftp-client";
 import fs from "fs";
 import mustache from "mustache";
 import path from "path";
+import unzipper from 'unzipper';
+
 const { promisify } = require("util");
 const execPromise = promisify(ChildProcess.exec);
 
@@ -205,65 +207,53 @@ export class ServerUtil {
     return true;
   }
 
-  async uploadDirectoryToSftp(
+  async  uploadDirectoryToSftp(
     localDir: string,
     remoteDir: string,
-    sftpConfig: ISFTP
+    sftpConfig: any
   ) {
     const sftp = new Client();
-
+  
     try {
       await sftp.connect(sftpConfig);
-
-      await sftp.stat(remoteDir).catch(async (err) => {
-        if (err.code === 2) {
-          // Код 2 означає, що директорія не існує
-          await sftp.mkdir(remoteDir, true);
-          console.log(`Папка створена: ${remoteDir}`);
-        } else {
-          console.error(
-            `Помилка під час перевірки або створення папки: ${remoteDir}`,
-            err
-          );
-          throw err;
-        }
-      });
-
       const items = fs.readdirSync(localDir, { withFileTypes: true });
-
+  
       for (const item of items) {
         const localPath = path.join(localDir, item.name);
         const remotePath = `${remoteDir}/${item.name}`;
-
+  
         if (item.isDirectory()) {
-          await sftp.stat(remotePath).catch(async (err) => {
-            if (err.code === 2) {
-              await sftp.mkdir(remotePath, true);
-              console.log(`Папка створена: ${remotePath}`);
-            } else {
-              console.error(
-                `Помилка під час перевірки або створення папки: ${remotePath}`,
-                err
-              );
+          // Створення підкаталогу на віддаленому сервері
+          await sftp.mkdir(remotePath, true).catch(async (err) => {
+            if (err.code !== 4) { // Ігноруємо помилку "Directory already exists"
+              console.error(`Помилка під час створення папки: ${remotePath}`, err);
               throw err;
             }
           });
-
+  
+          // Рекурсивне копіювання вмісту директорії
           await this.uploadDirectoryToSftp(localPath, remotePath, sftpConfig);
         } else {
+          // Завантаження файлу на віддалений сервер
           await sftp.put(localPath, remotePath);
           console.log(`Передано файл: ${localPath} -> ${remotePath}`);
         }
       }
-
-      console.log("Усі файли та папки успішно передані.");
+  
+      console.log('Усі файли та папки успішно передані.');
     } catch (err) {
-      console.error("Помилка під час передавання файлів через SFTP:", err);
+      console.error('Помилка під час передавання файлів через SFTP:', err);
     } finally {
       await sftp.end();
     }
   }
 
+   ensureDirectoryExistence(dirPath:string) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
   async generateNginxConfig(domain: string, rootPath: string): Promise<string> {
     const templatePath = path.join(
       __dirname,
@@ -275,4 +265,70 @@ export class ServerUtil {
     const config = mustache.render(template, { domain, rootPath });
     return config;
   }
+
+
+  async  extractUploadedZip(name:string, file:any) {
+    const zipFilePath = file.path;
+    const outputDir = path.join(__dirname, '..', 'uploads', name);
+  
+    console.log('Looking for ZIP file at:', zipFilePath);
+    console.log('Extracting to:', outputDir);
+  
+    this.ensureDirectoryExistence(outputDir);
+  
+    if (!fs.existsSync(zipFilePath)) {
+      console.error('Error: File not found:', zipFilePath);
+      return;
+    }
+  
+    try {
+      await new Promise((resolve, reject) => {
+        fs.createReadStream(zipFilePath)
+          .pipe(unzipper.Parse())
+          .on('entry', (entry) => {
+            // Видаляємо перший сегмент шляху, щоб уникнути кореневої директорії
+            const entryPath = path.join(
+              outputDir,
+              ...entry.path.split('/').slice(1)
+            );
+  
+            if (entry.type === 'Directory') {
+              this.ensureDirectoryExistence(entryPath);
+            } else {
+              this.ensureDirectoryExistence(path.dirname(entryPath));
+              entry.pipe(fs.createWriteStream(entryPath));
+            }
+          })
+          .on('close', resolve)
+          .on('error', reject);
+      });
+  
+      console.log('File successfully extracted.');
+    } catch (err) {
+      console.error('Error extracting file:', err);
+    }
+  }
+  
+  async  ensureDirectoryExistsViaSSH(sshConfig:ISFTP, remoteDir:string) {
+    const ssh = new NodeSSH();
+  
+    try {
+      await ssh.connect(sshConfig);
+  
+      // Перевірка, чи існує директорія, і створення її, якщо вона не існує
+      const command = `if [ ! -d "${remoteDir}" ]; then mkdir -p "${remoteDir}"; fi`;
+      await ssh.execCommand(command);
+      console.log(`Перевірено або створено папку: ${remoteDir}`);
+    } catch (err) {
+      console.error(
+        'Помилка під час перевірки або створення папки через SSH:',
+        err
+      );
+      throw err;
+    } finally {
+      ssh.dispose();
+    }
+  }
 }
+
+