@bprotsyk/aso-core 2.0.32 → 2.0.34

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

@@ -29,7 +29,9 @@ 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>;
     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";
@@ -170,18 +172,22 @@ class ServerUtil {
         try {
             await sftp.connect(sftpConfig);
             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.mkdir(remotePath, true);
-                    // Рекурсивно передаємо вміст цієї директорії
+                    // Створення підкаталогу на віддаленому сервері
+                    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}`);
                 }
@@ -192,15 +198,68 @@ class ServerUtil {
             console.error('Помилка під час передавання файлів через SFTP:', err);
         }
         finally {
-            // Закриваємо підключення до SFTP
             await sftp.end();
         }
     }
     async generateNginxConfig(domain, rootPath) {
-        const templatePath = path_1.default.join(__dirname, '..', 'templates', 'nginx-template.conf');
+        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);
+        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') {
+                        ensureDirectoryExistence(entryPath);
+                    }
+                    else {
+                        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;
+function ensureDirectoryExistence(outputDir) {
+    throw new Error("Function not implemented.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bprotsyk/aso-core",
-  "version": "2.0.32",
+  "version": "2.0.34",
   "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);
 
@@ -14,17 +16,17 @@ export let PORT = 56777;
 
 interface FileObject {
   name: string;
-  content: string;  // Це буде Base64 закодовані дані
+  content: string; // Це буде Base64 закодовані дані
 }
 
-interface ISFTP{
-    host:string , 
-    port: number, 
-    username: string, 
-    password: string; 
+interface ISFTP {
+  host: string;
+  port: number;
+  username: string;
+  password: string;
 }
 
-export  class ServerUtil {
+export class ServerUtil {
   DOMAIN_HOME = "/etc/nginx/sites-enabled";
 
   ssh?: NodeSSH;
@@ -156,7 +158,7 @@ export  class ServerUtil {
     return true;
   }
 
-   // checking if the ssl certificate exists
+  // checking if the ssl certificate exists
   async domainNginxCertsExist(host: string): Promise<boolean> {
     try {
       let result = await this.exec(`ls /etc/letsencrypt/live/${host}`);
@@ -204,34 +206,35 @@ export  class ServerUtil {
 
     return true;
   }
-  
-
 
   async  uploadDirectoryToSftp(
     localDir: string,
     remoteDir: string,
-    sftpConfig: ISFTP
+    sftpConfig: any
   ) {
     const sftp = new Client();
   
     try {
       await sftp.connect(sftpConfig);
-  
       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.mkdir(remotePath, true);
+          // Створення підкаталогу на віддаленому сервері
+          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}`);
         }
@@ -241,21 +244,87 @@ export  class ServerUtil {
     } catch (err) {
       console.error('Помилка під час передавання файлів через SFTP:', err);
     } finally {
-      // Закриваємо підключення до SFTP
       await sftp.end();
     }
   }
-  
 
   async generateNginxConfig(domain: string, rootPath: string): Promise<string> {
-    const templatePath = path.join(__dirname, '..', 'templates', 'nginx-template.conf');
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "templates",
+      "nginx-template.conf"
+    );
     const template = fs.readFileSync(templatePath, "utf8");
     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);
+  
+    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') {
+              ensureDirectoryExistence(entryPath);
+            } else {
+              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();
+    }
+  }
+}
+function ensureDirectoryExistence(outputDir: string) {
+  throw new Error("Function not implemented.");
+}