[_]: fix/circular-dependency

src/commands/add-cert.ts

@@ -1,9 +1,9 @@
 import { Command } from '@oclif/core';
 import { exec } from 'child_process';
-import { ConfigService } from '../services/config.service';
 import os from 'node:os';
 import path from 'node:path';
 import { CLIUtils } from '../utils/cli.utils';
+import { WEBDAV_SSL_CERTS_DIR } from '../constants/configs';
 
 export default class AddCert extends Command {
   static readonly args = {};
@@ -14,7 +14,7 @@ export default class AddCert extends Command {
   static readonly enableJsonFlag = true;
 
   public run = async () => {
-    const certPath = path.join(ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt');
+    const certPath = path.join(WEBDAV_SSL_CERTS_DIR, 'cert.crt');
     const platform = os.platform();
 
     const scriptBasePath = path.join(__dirname, '../../scripts');

src/commands/logs.ts

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
-import { ConfigService } from '../services/config.service';
 import { CLIUtils } from '../utils/cli.utils';
+import { INTERNXT_CLI_LOGS_DIR } from '../constants/configs';
 
 export default class Logs extends Command {
   static readonly args = {};
@@ -11,9 +11,9 @@ export default class Logs extends Command {
   static readonly enableJsonFlag = true;
 
   public run = async () => {
-    const message = `Internxt CLI logs are located at ${ConfigService.INTERNXT_CLI_LOGS_DIR}`;
+    const message = `Internxt CLI logs are located at ${INTERNXT_CLI_LOGS_DIR}`;
     CLIUtils.log(this.log.bind(this), message);
-    return { success: true, message, path: ConfigService.INTERNXT_CLI_LOGS_DIR };
+    return { success: true, message, path: INTERNXT_CLI_LOGS_DIR };
   };
 
   public catch = async (error: Error) => {

src/constants/configs.ts

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import os from 'node:os';
+
+export const INTERNXT_CLI_DATA_DIR = path.join(os.homedir(), '.internxt-cli');
+export const INTERNXT_CLI_LOGS_DIR = path.join(INTERNXT_CLI_DATA_DIR, 'logs');
+export const INTERNXT_TMP_DIR = os.tmpdir();
+export const CREDENTIALS_FILE = path.join(INTERNXT_CLI_DATA_DIR, '.inxtcli');
+export const DRIVE_SQLITE_FILE = path.join(INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
+export const WEBDAV_SSL_CERTS_DIR = path.join(INTERNXT_CLI_DATA_DIR, 'certs');
+export const WEBDAV_CONFIGS_FILE = path.join(INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
+export const WEBDAV_DEFAULT_HOST = '127.0.0.1';
+export const WEBDAV_DEFAULT_PORT = '3005';
+export const WEBDAV_DEFAULT_PROTOCOL = 'https';
+export const WEBDAV_DEFAULT_TIMEOUT = 0;
+export const WEBDAV_DEFAULT_CREATE_FULL_PATH = true;

src/services/config.service.ts

@@ -1,24 +1,22 @@
-import path from 'node:path';
-import os from 'node:os';
 import fs from 'node:fs/promises';
 import { ConfigKeys } from '../types/config.types';
 import { LoginCredentials, WebdavConfig } from '../types/command.types';
 import { CryptoService } from './crypto.service';
 import { isFileNotFoundError } from '../utils/errors.utils';
+import {
+  CREDENTIALS_FILE,
+  INTERNXT_CLI_DATA_DIR,
+  INTERNXT_CLI_LOGS_DIR,
+  WEBDAV_CONFIGS_FILE,
+  WEBDAV_DEFAULT_CREATE_FULL_PATH,
+  WEBDAV_DEFAULT_HOST,
+  WEBDAV_DEFAULT_PORT,
+  WEBDAV_DEFAULT_PROTOCOL,
+  WEBDAV_DEFAULT_TIMEOUT,
+  WEBDAV_SSL_CERTS_DIR,
+} from '../constants/configs';
 
 export class ConfigService {
-  static readonly INTERNXT_CLI_DATA_DIR = path.join(os.homedir(), '.internxt-cli');
-  static readonly INTERNXT_CLI_LOGS_DIR = path.join(this.INTERNXT_CLI_DATA_DIR, 'logs');
-  static readonly INTERNXT_TMP_DIR = os.tmpdir();
-  static readonly CREDENTIALS_FILE = path.join(this.INTERNXT_CLI_DATA_DIR, '.inxtcli');
-  static readonly DRIVE_SQLITE_FILE = path.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
-  static readonly WEBDAV_SSL_CERTS_DIR = path.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
-  static readonly WEBDAV_CONFIGS_FILE = path.join(this.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
-  static readonly WEBDAV_DEFAULT_HOST = '127.0.0.1';
-  static readonly WEBDAV_DEFAULT_PORT = '3005';
-  static readonly WEBDAV_DEFAULT_PROTOCOL = 'https';
-  static readonly WEBDAV_DEFAULT_TIMEOUT = 0;
-  static readonly WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
   public static readonly instance: ConfigService = new ConfigService();
 
   /**
@@ -42,7 +40,7 @@ export class ConfigService {
     await this.ensureInternxtCliDataDirExists();
     const credentialsString = JSON.stringify(loginCredentials);
     const encryptedCredentials = CryptoService.instance.encryptText(credentialsString);
-    await fs.writeFile(ConfigService.CREDENTIALS_FILE, encryptedCredentials, 'utf8');
+    await fs.writeFile(CREDENTIALS_FILE, encryptedCredentials, 'utf8');
   };
 
   /**
@@ -51,9 +49,9 @@ export class ConfigService {
    **/
   public clearUser = async (): Promise<void> => {
     try {
-      const stat = await fs.stat(ConfigService.CREDENTIALS_FILE);
+      const stat = await fs.stat(CREDENTIALS_FILE);
       if (stat.size === 0) return;
-      await fs.writeFile(ConfigService.CREDENTIALS_FILE, '', 'utf8');
+      await fs.writeFile(CREDENTIALS_FILE, '', 'utf8');
     } catch (error) {
       if (!isFileNotFoundError(error)) {
         throw error;
@@ -67,7 +65,7 @@ export class ConfigService {
    **/
   public readUser = async (): Promise<LoginCredentials | undefined> => {
     try {
-      const encryptedCredentials = await fs.readFile(ConfigService.CREDENTIALS_FILE, 'utf8');
+      const encryptedCredentials = await fs.readFile(CREDENTIALS_FILE, 'utf8');
       const credentialsString = CryptoService.instance.decryptText(encryptedCredentials);
       const loginCredentials = JSON.parse(credentialsString) as LoginCredentials;
       return loginCredentials;
@@ -79,52 +77,52 @@ export class ConfigService {
   public saveWebdavConfig = async (webdavConfig: WebdavConfig): Promise<void> => {
     await this.ensureInternxtCliDataDirExists();
     const configs = JSON.stringify(webdavConfig);
-    await fs.writeFile(ConfigService.WEBDAV_CONFIGS_FILE, configs, 'utf8');
+    await fs.writeFile(WEBDAV_CONFIGS_FILE, configs, 'utf8');
   };
 
   public readWebdavConfig = async (): Promise<WebdavConfig> => {
     try {
-      const configsData = await fs.readFile(ConfigService.WEBDAV_CONFIGS_FILE, 'utf8');
+      const configsData = await fs.readFile(WEBDAV_CONFIGS_FILE, 'utf8');
       const configs = JSON.parse(configsData);
       return {
-        host: configs?.host ?? ConfigService.WEBDAV_DEFAULT_HOST,
-        port: configs?.port ?? ConfigService.WEBDAV_DEFAULT_PORT,
-        protocol: configs?.protocol ?? ConfigService.WEBDAV_DEFAULT_PROTOCOL,
-        timeoutMinutes: configs?.timeoutMinutes ?? ConfigService.WEBDAV_DEFAULT_TIMEOUT,
-        createFullPath: configs?.createFullPath ?? ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
+        host: configs?.host ?? WEBDAV_DEFAULT_HOST,
+        port: configs?.port ?? WEBDAV_DEFAULT_PORT,
+        protocol: configs?.protocol ?? WEBDAV_DEFAULT_PROTOCOL,
+        timeoutMinutes: configs?.timeoutMinutes ?? WEBDAV_DEFAULT_TIMEOUT,
+        createFullPath: configs?.createFullPath ?? WEBDAV_DEFAULT_CREATE_FULL_PATH,
       };
     } catch {
       return {
-        host: ConfigService.WEBDAV_DEFAULT_HOST,
-        port: ConfigService.WEBDAV_DEFAULT_PORT,
-        protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
-        timeoutMinutes: ConfigService.WEBDAV_DEFAULT_TIMEOUT,
-        createFullPath: ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
+        host: WEBDAV_DEFAULT_HOST,
+        port: WEBDAV_DEFAULT_PORT,
+        protocol: WEBDAV_DEFAULT_PROTOCOL,
+        timeoutMinutes: WEBDAV_DEFAULT_TIMEOUT,
+        createFullPath: WEBDAV_DEFAULT_CREATE_FULL_PATH,
       };
     }
   };
 
   ensureInternxtCliDataDirExists = async () => {
     try {
-      await fs.access(ConfigService.INTERNXT_CLI_DATA_DIR);
+      await fs.access(INTERNXT_CLI_DATA_DIR);
     } catch {
-      await fs.mkdir(ConfigService.INTERNXT_CLI_DATA_DIR);
+      await fs.mkdir(INTERNXT_CLI_DATA_DIR);
     }
   };
 
   ensureWebdavCertsDirExists = async () => {
     try {
-      await fs.access(ConfigService.WEBDAV_SSL_CERTS_DIR);
+      await fs.access(WEBDAV_SSL_CERTS_DIR);
     } catch {
-      await fs.mkdir(ConfigService.WEBDAV_SSL_CERTS_DIR);
+      await fs.mkdir(WEBDAV_SSL_CERTS_DIR);
     }
   };
 
   ensureInternxtLogsDirExists = async () => {
     try {
-      await fs.access(ConfigService.INTERNXT_CLI_LOGS_DIR);
+      await fs.access(INTERNXT_CLI_LOGS_DIR);
     } catch {
-      await fs.mkdir(ConfigService.INTERNXT_CLI_LOGS_DIR);
+      await fs.mkdir(INTERNXT_CLI_LOGS_DIR);
     }
   };
 }

src/utils/logger.utils.ts

@@ -1,5 +1,5 @@
 import winston from 'winston';
-import { ConfigService } from '../services/config.service';
+import { INTERNXT_CLI_LOGS_DIR } from '../constants/configs';
 
 const maxLogSize = 40 * 1024 * 1024;
 const maxLogsFiles = 5;
@@ -12,14 +12,14 @@ export const logger = winston.createLogger({
     new winston.transports.File({
       filename: 'internxt-cli-error.log',
       level: 'error',
-      dirname: ConfigService.INTERNXT_CLI_LOGS_DIR,
+      dirname: INTERNXT_CLI_LOGS_DIR,
       maxsize: maxLogSize,
       maxFiles: maxLogsFiles,
       tailable: true,
     }),
     new winston.transports.File({
       filename: 'internxt-cli-combined.log',
-      dirname: ConfigService.INTERNXT_CLI_LOGS_DIR,
+      dirname: INTERNXT_CLI_LOGS_DIR,
       maxsize: maxLogSize,
       maxFiles: maxLogsFiles,
       tailable: true,
@@ -35,14 +35,14 @@ export const webdavLogger = winston.createLogger({
     new winston.transports.File({
       filename: 'internxt-webdav-error.log',
       level: 'error',
-      dirname: ConfigService.INTERNXT_CLI_LOGS_DIR,
+      dirname: INTERNXT_CLI_LOGS_DIR,
       maxsize: maxLogSize,
       maxFiles: maxLogsFiles,
       tailable: true,
     }),
     new winston.transports.File({
       filename: 'internxt-webdav-combined.log',
-      dirname: ConfigService.INTERNXT_CLI_LOGS_DIR,
+      dirname: INTERNXT_CLI_LOGS_DIR,
       maxsize: maxLogSize,
       maxFiles: maxLogsFiles,
       tailable: true,

src/utils/network.utils.ts

@@ -4,8 +4,8 @@ import { readFile, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import selfsigned from 'selfsigned';
 import parseRange from 'range-parser';
-import { ConfigService } from '../services/config.service';
 import { WebdavConfig } from '../types/command.types';
+import { WEBDAV_SSL_CERTS_DIR } from '../constants/configs';
 
 export class NetworkUtils {
   static getAuthFromCredentials(creds: NetworkCredentials): { username: string; password: string } {
@@ -16,8 +16,8 @@ export class NetworkUtils {
   }
 
   static readonly WEBDAV_SSL_CERTS_PATH = {
-    cert: path.join(ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
-    privateKey: path.join(ConfigService.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
+    cert: path.join(WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
+    privateKey: path.join(WEBDAV_SSL_CERTS_DIR, 'priv.key'),
   };
 
   static async generateNewSelfsignedCerts(configs: WebdavConfig): Promise<SelfsignedCert> {