@dnax/core 0.46.3 → 0.47.0

package/lib/media/SyncAdapter.ts

@@ -1,5 +1,6 @@
 import { Cfg } from "../../config";
-import { FilesystemSftpAdapter } from "../media/sftp";
+import { FilesystemSftpAdapter } from "./sftp";
+//
 async function syncAdapterFileSystem() {
   const mediaCollections = Cfg.collections?.filter(
     (col) => col.type == "media" && col?.media?.enabled
@@ -8,12 +9,14 @@ async function syncAdapterFileSystem() {
   mediaCollections?.map((col) => {
     if (col?.media?.filesystemAdapter) {
       let currentAdapter = col?.media?.filesystemAdapter;
+
       // for sftp
       if (currentAdapter?.type == "sftp") {
         let setAdapter = col?.media?.filesystemAdapter as InstanceType<
           typeof FilesystemSftpAdapter
         >;
-        setAdapter.init(col);
+        //console.log("setAdapter", setAdapter);
+        setAdapter.syncCollectionMedia(col);
       }
     }
   });

package/lib/media/sftp.ts

@@ -1,130 +1,113 @@
-type args = "--delete";
-type config = {
+import { Client } from "ssh2";
+import type { SFTPWrapper } from "ssh2";
+import { consola } from "consola";
+import path from "path";
+import chokidar from "chokidar";
+import fs from "fs-extra";
+import type { Collection } from "../../types";
+const BASE_DIR = "/uploads/";
+type ConfigType = {
   host: string;
   port?: number;
   username: string;
   password: string;
   remoteDir: string;
+  path?: string;
   ignorePatterns?: string[];
-  args?: args[];
+  //privateKeyPath?: string;
 };
-import Client from "ssh2-sftp-client";
-import chokidar from "chokidar";
-import fs from "fs-extra";
-import path from "path";
-import { cleanDoubleSlashes } from "ufo";
-import type { Collection } from "../../types";
-
 class FilesystemSftpAdapter {
-  #sftp;
-  type: "sftp" = "sftp";
-  #connected: Boolean = false;
-  config;
-  constructor(config: config) {
+  conn: Client;
+  type: "sftp";
+  config: ConfigType;
+  constructor(
+    config = {
+      port: 22,
+    } as ConfigType
+  ) {
     this.config = config;
-    this.config.port = config?.port || 22;
-    this.#sftp = new Client();
     this.type = "sftp";
+    this.conn = new Client({
+      //captureRejections: true,
+    });
     return this;
   }
 
-  async connect() {
-    await this.#sftp
-      .connect({
-        ...this.config,
-      })
+  async syncCollectionMedia(col: Collection) {
+    if (!this.config?.remoteDir) this.config.remoteDir = "/home/" + col?.slug;
+    await this.connect()
       .then((e) => {
-        this.#connected = true;
+        let visibility = col?.media?.visibility || "public";
+
+        let dirToWatch = path.join(
+          process.cwd(),
+          BASE_DIR,
+          col?.slug,
+          visibility
+        );
+        dirToWatch = path.resolve(dirToWatch);
+        const watcher = chokidar.watch(dirToWatch, {
+          persistent: true,
+          ignoreInitial: true,
+          ignored: this.config.ignorePatterns || [],
+        });
+
+        watcher.on("all", (event, filePath) => {
+          if (event == "change" || event == "add") {
+            //consola.info(`SFTP: ${event} ${filePath}`);
+            let remotePath = path.join(
+              this.config.remoteDir,
+              path.basename(filePath)
+            );
+            this.put(filePath, remotePath);
+          }
+        });
       })
       .catch((err) => {
-        console.error(err?.message);
+        consola.error(`SFTP: Failed to connect ${this.config.host}`.red);
       });
-    //.finally(() => {});
   }
 
-  async sync(
-    p: string,
-    type: "add" | "change" | "unlink" | "addDir" | "unlinkDir"
-  ) {
-    try {
-      if (!this.#connected) return;
-      let remotePathDest =
-        this.config.remoteDir + p?.replace(process.cwd(), "");
-      let remoteDir = path.dirname(remotePathDest);
-
-      //let remoteFile = remotePathDest.replace(/\\/g, "/");
-
-      if (fs.existsSync(p)) {
-        let stats = fs.statSync(p);
-        if (stats.isFile()) {
-          await this.#sftp.mkdir(remoteDir, true).catch();
-          // Téléverser le fichier
-          let alreadyExists = await this.#sftp.exists(remotePathDest);
-          if (!alreadyExists) {
-            await this.#sftp.put(p, remotePathDest, {}).catch((err) => {
-              console.error("Fichier televerser", err?.message);
+  connect(): Promise<{ sftp: SFTPWrapper; conn: Client }> {
+    return new Promise((resolve, reject) => {
+      this.conn
+        .on("ready", () => {
+          this.conn.sftp((err, sftp) => {
+            if (err) {
+              this.conn.end();
+              return reject(err?.message);
+            }
+            resolve({
+              sftp: sftp,
+              conn: this.conn,
             });
-          }
-        }
-      } else {
-        // Supprimer le fichier
-        this.#sftp.delete(remotePathDest);
-      }
-    } catch (err: any) {
-      console.error(err?.message);
-    }
+          });
+        })
+        .on("error", (err) => reject(err?.message))
+        .connect(this.config);
+    });
   }
-
-  watchDir(dir: string) {
-    try {
-      let local_dir = cleanDoubleSlashes(dir);
-      const watcher = chokidar.watch(path.resolve(local_dir), {
-        persistent: true,
-        ignoreInitial: false,
-        ignored: this?.config?.ignorePatterns || [],
-      });
-
-      watcher
-        .on("add", (path) => this.sync(path, "add"))
-        .on("change", (path) => this.sync(path, "change"))
-        .on("unlink", (path) => this.sync(path, "unlink"))
-        .on("addDir", (path) => this.sync(path, "addDir"))
-        .on("unlinkDir", (path) => this.sync(path, "unlinkDir"));
-    } catch (err: any) {
-      console.error(err?.message);
-    }
-  }
-
-  async init(col: Collection) {
-    let buildPath = "/uploads/";
-    if (!col?.media?.visibility && col?.media?.enabled) {
-      col.media.visibility = "public";
-    }
-    buildPath += col?.slug + "/" + col?.media?.visibility;
-    let watchLocalDir = path.resolve(process.cwd() + "/" + buildPath);
-
-    await this.connect()
-      .then(async (ops) => {
-        let remoteDir = this.config.remoteDir + buildPath;
-
-        let remoteDirExisis = await this.#sftp.exists(remoteDir);
-
-        //console.log("remoteDirExisis", remoteDir, remoteDirExisis);
-
-        if (!remoteDirExisis) {
-          await this.#sftp.mkdir(remoteDir, true).catch((err) => {});
-          // console.log("Watch", watchLocalDir);
-
-          setTimeout(() => {
-            this.watchDir(watchLocalDir);
-          }, 1000);
-        } else {
-          this.watchDir(watchLocalDir);
+  async put(localPath: string, remotePath: string) {
+    let { sftp, conn } = await this.connect();
+    return new Promise(async (resolve, reject) => {
+      sftp.fastPut(
+        localPath,
+        remotePath,
+        {
+          mode: 0o777,
+        },
+        (err) => {
+          conn.end();
+          if (err) {
+            console.log("Error exist");
+          }
+          if (err) {
+            reject(err?.message);
+          }
+          resolve(true);
         }
-      })
-      .catch((err) => {
-        console.error(err?.message);
-      });
+      );
+    });
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.46.3",
+  "version": "0.47.0",
   "module": "index.ts",
   "type": "module",
   "bin": {
@@ -54,7 +54,7 @@
     "rfc6902": "^5.1.2",
     "sharp": "^0.33.5",
     "signaldb": "^0.24.5",
-    "ssh2-sftp-client": "12.0.0",
+    "ssh2": "^1.16.0",
     "ufo": "^1.5.4",
     "urlencode": "^2.0.0",
     "uuid": "^11.1.0"