tsoft-cli 1.0.2 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [1.2.0] - 2024-06-12
+### Added
+- Yeni site ismi girildiğinde geçerli olup olmadığını kontrol eden özellik eklendi.
+- Kullanıcı komut satırı etkileşimleri için `enquirer` kütüphanesi kullanımı güncellendi.
+- Dosya izleme ve tema güncelleme özellikleri geliştirildi.
+
+### Changed
+- `ThemeManager` sınıfı geliştirildi ve yeni yöntemler eklendi.
+- `start.js` dosyasında önemli iyileştirmeler yapıldı.
+- `create.js` dosyasında kullanıcı girişleri doğrulandı ve daha kullanıcı dostu hale getirildi.
+
+### Fixed
+- Birkaç hata düzeltildi ve genel kod kalitesi iyileştirildi.

package/README.md

@@ -0,0 +1,10 @@
+# T-Soft CLI
+
+## Özet
+T-Soft CLI, T-Soft tarafından geliştirilen bir komut satırı aracıdır. Bu araç ile T-Soft ön yüz geliştirme süreçlerinde kullanılan bazı işlemler otomatize edilmiştir. Bu sayede geliştirme süreçleri hızlandırılmış ve daha verimli hale getirilmiştir.
+
+## Kurulum
+```bash
+npm install -g tsoft-cli
+```
+

package/bin/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+const { Select, Input } = require('enquirer');
+const { start } = require('../src/commands/start');
+const { createTheme } = require('../src/commands/create');
+const { clearScreen, displayAsciiArt } = require('../src/utils');
+const fs = require('fs');
+const path = require('path');
+
+async function selectSiteAndTheme() {
+    const cwd = process.cwd();
+    const sites = fs.readdirSync(cwd).filter(file => {
+        return file.charAt(0) !== '.' && !['node_modules', 'build', 'dist'].includes(file);
+    }).filter(file => fs.statSync(path.join(cwd, file)).isDirectory());
+
+    if (sites.length === 0) {
+        console.error('Mevcut dizinde site bulunamadı.');
+        return null;
+    }
+
+    const sitePrompt = new Select({
+        name: 'site',
+        message: 'Bir site seçin:',
+        choices: sites
+    });
+
+    const selectedSite = await sitePrompt.run();
+
+    const themes = fs.readdirSync(path.join(cwd, selectedSite)).filter(file => {
+        return fs.statSync(path.join(cwd, selectedSite, file)).isDirectory();
+    });
+
+    if (themes.length === 0) {
+        console.error('Seçilen site dizininde tema bulunamadı.');
+        return null;
+    }
+
+    const themePrompt = new Select({
+        name: 'theme',
+        message: 'Bir tema seçin:',
+        choices: themes
+    });
+
+    const selectedTheme = await themePrompt.run();
+
+    return { siteName: selectedSite, themeName: selectedTheme };
+}
+
+async function showMainMenu() {
+    clearScreen();
+
+    await displayAsciiArt();
+
+    const prompt = new Select({
+        name: 'command',
+        message: 'Bir komut seçin',
+        choices: ['Yeni bir tema oluştur', 'Geliştirme ortamını başlat', 'Çıkış']
+    });
+
+    const answer = await prompt.run();
+
+    if (answer === 'Yeni bir tema oluştur') {
+        await createTheme();
+    } else if (answer === 'Geliştirme ortamını başlat') {
+        const selection = await selectSiteAndTheme();
+        if (selection) {
+            await start(selection.siteName, selection.themeName);
+        }
+    } else {
+        console.log('Programdan çıkılıyor. Hoşça kalın!');
+        process.exit(0);
+    }
+}
+
+showMainMenu();

package/jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    testEnvironment: 'node',
+};

package/package.json

@@ -1,24 +1,28 @@
 {
   "name": "tsoft-cli",
-  "version": "1.0.2",
-  "description": "",
+  "version": "1.2.0",
+  "description": "A theme development cli for developers who want to create themes for T-Soft.",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "bin": {
-    "tsoft-cli": "./bin/tsoft-cli.js"
+    "tsoft-cli": "./bin/index.js"
   },
   "dependencies": {
-    "axios": "^1.7.2",
     "chokidar": "^3.6.0",
+    "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
-    "fs": "^0.0.1-security",
-    "inquirer": "^9.2.23",
-    "lodash": "^4.17.21"
+    "enquirer": "^2.4.1",
+    "figlet": "^1.7.0",
+    "fs": "^0.0.1-security"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "mock-fs": "^5.2.0"
+  }
 }

package/src/client-credentials.js

@@ -0,0 +1,88 @@
+const buildPostRequest = require('./request');
+
+class ClientCredentials {
+    site;
+    clientId;
+    clientSecret;
+    bearer;
+
+    constructor(site) {
+        this.site = site;
+    }
+
+    getEnvironment() {
+        return {
+            site: this.site, clientId: this.clientId, clientSecret: this.clientSecret, bearer: this.bearer
+        }
+    }
+
+    set clientId(clientId) {
+        this.clientId = clientId;
+    }
+
+    get clientId() {
+        return this.clientId;
+    }
+
+    setClientSecret(clientSecret) {
+        this.clientSecret = clientSecret;
+        return this;
+    }
+
+    async register(CLIENT_UUID, clientConfiguration = {}) {
+
+        const uri = "api/v3/admin/auth/auth-application";
+        const result = await this.buildPostRequest(uri, {
+            header: {
+                'Content-Type': 'application/json', 'Accept': 'application/json',
+            }, body: JSON.stringify({
+                uuid: CLIENT_UUID, configuration: {
+                    theme: clientConfiguration.theme,
+                    author: clientConfiguration.author,
+                    version: clientConfiguration.version
+                }
+            })
+        });
+
+        if (result.status === true) {
+            this.clientId = result.data.public_key;
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+
+    async authorize() {
+        const uri = "api/v3/admin/auth/auth-application/authorize";
+        await this.buildPostRequest(uri, {
+            body: JSON.stringify({
+                public_key: this.clientId, secret: this.clientSecret
+            })
+        }).then((result) => {
+            if (result.status === true) {
+                this.bearer = result.data.token.plainTextToken
+            }
+        });
+
+    }
+
+
+    async buildPostRequest(uri, options = {}) {
+        return buildPostRequest(this.site, uri, options);
+    }
+
+    async validateToken(token) {
+        const uri = 'api/v3/admin/auth/me';
+        const response = await buildPostRequest(this.site, uri, {
+            body: JSON.stringify({
+                _method: 'GET'
+            }), headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        return response.message === 'ok';
+    }
+}
+
+module.exports = ClientCredentials;

package/src/commands/create.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+const { Select, Input } = require('enquirer');
+const {slugify} = require('../utils');
+const { start } = require('./start');
+const ThemeManager = require('../theme-manager');
+
+async function createTheme() {
+    const cwd = process.cwd();
+    const sites = fs.readdirSync(cwd).filter(file => {
+        return file.charAt(0) !== '.' && !['node_modules', 'build', 'dist'].includes(file);
+    }).filter(file => fs.statSync(path.join(cwd, file)).isDirectory());
+
+    const siteChoices = [...sites, 'Yeni bir site oluştur'];
+
+    const sitePrompt = new Select({
+        name: 'site',
+        message: 'Çalışmak istediğiniz sitenin adı:',
+        choices: siteChoices
+    });
+
+    const selectedSite = await sitePrompt.run();
+
+    let siteName;
+    if (selectedSite === 'Yeni bir site oluştur') {
+        const newSitePrompt = new Input({
+            name: 'newSite',
+            message: 'Yeni site adı:'
+        });
+        siteName = await newSitePrompt.run();
+
+        const themeManager = new ThemeManager(siteName);
+        try {
+            const isValid = await themeManager.checkSiteValidity(siteName);
+            if (!isValid) {
+                console.error('Geçersiz site adı. Lütfen geçerli bir site adı girin.');
+                return;
+            }
+        } catch (error) {
+            console.error('Site doğrulaması sırasında hata oluştu:', error.message);
+            return;
+        }
+
+    } else {
+        siteName = selectedSite;
+    }
+
+    const themeNamePrompt = new Input({
+        name: 'themeName',
+        message: 'Tema adı:'
+    });
+
+    const authorPrompt = new Input({
+        name: 'author',
+        message: 'Author (isteğe bağlı):'
+    });
+
+    const versionPrompt = new Input({
+        name: 'version',
+        message: 'Version (isteğe bağlı, varsayılan 1.0.0):',
+        initial: '1.0.0'
+    });
+
+    const themeName = await themeNamePrompt.run();
+    const author = await authorPrompt.run();
+    const version = await versionPrompt.run();
+
+    const themeNameSlug = slugify(themeName);
+
+    const themePath = path.join(cwd, siteName, themeNameSlug);
+
+    if (!fs.existsSync(themePath)) {
+        fs.mkdirSync(themePath, { recursive: true });
+    }
+
+    const themeData = {
+        site: siteName,
+        theme: themeName,
+        author: author,
+        version: version
+    };
+
+    fs.writeFileSync(path.join(themePath, '.theme'), JSON.stringify(themeData, null, 2));
+
+    console.log(`Tema "${themeName}" başarıyla oluşturuldu.`);
+
+    // Doğrudan start fonksiyonuna geçiş yap
+    await start(siteName, themeNameSlug);
+}
+
+module.exports = {
+    createTheme
+};

package/src/commands/start.js

@@ -0,0 +1,211 @@
+const fs = require('fs');
+const path = require('path');
+const chokidar = require('chokidar');
+const readline = require('readline');
+const { exec } = require('child_process');
+const Tsoft = require('../tsoft');
+const constants = require('../constants');
+const cliProgress = require('cli-progress');
+const { Input } = require('enquirer');
+const { displayAsciiArt, clearScreen, info, slugify } = require('../utils');
+
+async function showProgress(tsoft, theme) {
+    const themePath = path.join(process.cwd(), tsoft.site, theme);
+    const fileList = tsoft.fileManager.listFilesRecursive(themePath).filter(file => !file.includes('.env'));
+    const totalFiles = fileList.length;
+
+    // Yeni bir ilerleme çubuğu oluşturun ve shades_classic temasını kullanın
+    const progressBar = new cliProgress.SingleBar({
+        format: 'İlerleme |{bar}| {percentage}% || {value}/{total} Dosya Yüklendi',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        clearOnComplete: true
+    });
+    progressBar.start(totalFiles, 0);
+
+    for (let i = 0; i < totalFiles; i++) {
+        const file = fileList[i];
+        const fileName = tsoft.fileManager.getRelativePath(theme, file);
+        const content = tsoft.fileManager.readFile(file);
+        const env = tsoft.themeManager.getEnvironment(theme);
+
+        try {
+            await tsoft.saveFile(theme, fileName, content, env.bearer);
+        } catch (error) {
+            console.error(`Dosya yükleme hatası ${fileName}:`, error);
+        }
+        progressBar.update(i + 1);
+    }
+
+    progressBar.stop();
+
+    return 'Tüm dosyalar ilerleme ile başarıyla yüklendi';
+}
+
+async function start(siteName, themeName) {
+    await displayAsciiArt();
+    console.log('Geliştirme ortamı aşağıdaki ayrıntılarla başlatılıyor:');
+    console.log(`Site Adı: ${siteName}`);
+    console.log(`Tema Adı: ${themeName}`);
+
+    const tsoft = new Tsoft(siteName);
+    const themeEnvPath = path.join(process.cwd(), siteName, themeName, `${themeName}.env`);
+
+    // .env dosyasının var olup olmadığını ve geçerli bir JSON içerip içermediğini kontrol edin
+    let envData = {};
+    if (fs.existsSync(themeEnvPath)) {
+        try {
+            envData = JSON.parse(fs.readFileSync(themeEnvPath, 'utf-8'));
+        } catch (error) {
+            console.warn(`${themeEnvPath} dosyasında geçersiz JSON formatı. Bu dosya silinecek ve yeniden yetkilendirmeniz gerekecek.`);
+            fs.unlinkSync(themeEnvPath);
+            console.info('Geçersiz ortam dosyası silindi. Başlatma işlemine devam ediliyor...');
+        }
+
+        if (envData.bearer) {
+            const bearerTokenValid = await tsoft.isTokenValid(themeName);
+
+            if (bearerTokenValid) {
+                console.info('Geçerli bir taşıyıcı jetonuna sahip mevcut ortam dosyası bulundu. Mevcut yapılandırma ile devam ediliyor...');
+                // Dosya değişikliklerini izlemeye başlayın
+                await startWatching(siteName, themeName, tsoft);
+                return;
+            } else {
+                console.warn('Mevcut taşıyıcı jetonu geçersiz. Yeniden yetkilendirmeniz gerekecek.');
+                fs.unlinkSync(themeEnvPath);
+            }
+        }
+    }
+
+    await tsoft.initialize(themeName);
+
+    const approvalPrompt = new Input({
+        name: 'approval',
+        message: 'Lütfen onay kodunu sağlayın:'
+    });
+
+    const approval = await approvalPrompt.run();
+
+    if (approval) {
+        await constants.APPROVAL.handler(tsoft.clientCredentials.setClientSecret(approval));
+        tsoft.buildEnvironment();
+        console.info('Hazırsınız');
+        // Dosya değişikliklerini izlemeye başlayın
+        await startWatching(siteName, themeName, tsoft);
+    } else {
+        console.error('Onay kodu gerekli.');
+    }
+}
+
+async function startWatching(site, theme, tsoft) {
+    const themePath = path.join(process.cwd(), site, theme);
+    const envPath = path.join(themePath, `${theme}.env`);
+
+    if (!fs.existsSync(envPath)) {
+        console.error('Ortam dosyası bulunamadı. Lütfen temayı önce başlatın.');
+        return;
+    }
+
+    const watcher = chokidar.watch(themePath, {
+        ignored: /(^|[\/\\])(\.theme|(.*?)\.env)$/, // .theme ve .env dosyaları yoksayılır
+        persistent: true
+    });
+
+    watcher.on('change', async (filePath) => {
+        console.log(`Dosya değiştirildi ${filePath}`);
+
+        const env = JSON.parse(fs.readFileSync(envPath, 'utf-8'));
+        const fileName = filePath.replace(`${themePath}/`, '');
+        const content = fs.readFileSync(filePath).toString();
+
+        try {
+            await tsoft.saveFile(theme, fileName, content, env.bearer);
+            console.log(`Dosya başarıyla yüklendi ${fileName}`);
+        } catch (error) {
+            console.error(`Dosya yükleme hatası ${fileName}:`, error);
+        }
+    }).on('unlink', async (filePath) => {
+        console.log(`Dosya silindi ${filePath}`);
+
+        const env = JSON.parse(fs.readFileSync(envPath, 'utf-8'));
+        const fileName = filePath.replace(`${themePath}/`, '');
+
+        try {
+            await tsoft.deleteFile(theme, fileName, env.bearer);
+            console.log(`Dosya başarıyla silindi ${fileName}`);
+        } catch (error) {
+            console.error(`Dosya silme hatası ${fileName}:`, error);
+        }
+    }).on('unlinkDir', async (dirPath) => {
+        console.log(`Dizin silindi ${dirPath}`);
+
+        const env = JSON.parse(fs.readFileSync(envPath, 'utf-8'));
+        const dirName = dirPath.replace(`${themePath}/`, '');
+
+        try {
+            await tsoft.deleteDirectory(theme, dirName, env.bearer);
+            console.log(`Dizin başarıyla silindi ${dirName}`);
+        } catch (error) {
+            console.error(`Dizin silme hatası ${dirName}:`, error);
+        }
+    });
+
+    console.log(`${themePath} dizinindeki dosya değişiklikleri izleniyor`);
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    info();
+
+    rl.on('line', async (input) => {
+        if (input.trim() === 'q') {
+            console.log('Dosya izleme işlemi sonlandırılıyor...');
+            watcher.close();
+            rl.close();
+            process.exit(0);
+        } else if (input.trim() === 'u') {
+            console.log('Tema güncelleniyor...');
+            try {
+                const result = await updateTheme(tsoft, theme);
+                console.log(result);
+                info();
+            } catch (error) {
+                console.error(`Tema güncelleme hatası:`, error);
+            }
+        } else if (input.trim() === 's') {
+            clearScreen();
+            console.log('Tüm dosyalar ilerleme ile yüklenmeye başlanıyor...');
+            try {
+                const result = await showProgress(tsoft, theme);
+                console.log(result);
+                info();
+            } catch (error) {
+                console.error(`İlerleme gösterim hatası:`, error);
+            }
+        } else if (input.trim() === 'e') {
+            console.log('.theme dosyası düzenleniyor...');
+            try {
+                await editThemeFile(tsoft.themeManager, theme);
+            } catch (error) {
+                console.error(`.theme dosyası düzenleme hatası:`, error);
+            }
+        } else if (input.trim() === 'o') {
+            console.log('Tema dizini açılıyor...');
+            const openCommand = process.platform === 'win32' ? 'start' :
+                process.platform === 'darwin' ? 'open' :
+                    'xdg-open';
+            exec(`${openCommand} ${themePath}`, (err) => {
+                if (err) {
+                    console.error('Tema dizini açılamadı:', err);
+                } else {
+                    console.log('Tema dizini başarıyla açıldı.');
+                }
+            });
+        }
+    });
+}
+
+module.exports = { start };

package/src/constants.js

@@ -0,0 +1,16 @@
+const handleAuthorization = async (credentialHandler) => {
+    await credentialHandler.authorize();
+};
+module.exports = Object.freeze({
+    INITIALIZE: {
+        type: 'input',
+        name: 'site',
+        message: 'Lütfen site adresini giriniz (örnek: https://tsoft.com.tr):'
+    },
+    APPROVAL: {
+        type: 'input',
+        name: 'approval',
+        message: 'Parolanızı giriniz (Lütfen panelden onaylayınız):',
+        handler: handleAuthorization
+    }
+});

package/src/file-manager.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const path = require('path');
+const utils = require('./utils');
+
+class FileManager {
+    constructor(site) {
+        this.site = site;
+        this.cwd = process.cwd();
+    }
+
+    listFilesRecursive(directory, fileList = []) {
+        const files = fs.readdirSync(directory);
+        files.forEach(file => {
+            const fullPath = path.join(directory, file);
+            if (fs.statSync(fullPath).isDirectory()) {
+                this.listFilesRecursive(fullPath, fileList);
+            } else {
+                this.isAllowedExtension(fullPath) && fileList.push(fullPath);
+            }
+        });
+        return fileList;
+    }
+
+    getRelativePath(theme, file) {
+        const themePath = path.join(this.cwd, this.site, theme);
+        return file.replace(`${themePath}/`, '');
+    }
+
+    readFile(file) {
+        return fs.readFileSync(file).toString();
+    }
+
+    isAllowedExtension(file) {
+        const ext = path.extname(file).substring(1);
+        return utils.allowedExtensions.includes(ext);
+    }
+}
+
+module.exports = FileManager;

package/src/request.js

@@ -0,0 +1,16 @@
+module.exports = (site, uri, options = {}) => {
+    return fetch("https://" + site + '/' + uri, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...options.headers ?? {}
+        },
+        body: options.body
+    })
+        .then((response) => response.json())
+        .then((result) => {
+            return result
+        })
+        .catch((error) => console.error(error));
+}

package/src/theme-manager.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const {slugify} = require('./utils');
+const http = require('http');
+const https = require('https');
+
+class ThemeManager {
+    constructor(site) {
+        this.site = site;
+        this.cwd = process.cwd();
+        this.theme = null;
+        this.registered = false;
+    }
+
+    async initializeTheme(theme, reInit = false) {
+        this.theme = theme;
+        const themePath = path.join(this.cwd, this.site, theme);
+        const themeEnvPath = path.join(themePath, `${theme}.env`);
+
+        if (reInit) {
+            // await fs.rm(themePath, {recursive: true, force: true}, (err, file) => {});
+        }
+
+        if (!fs.existsSync(path.join(this.cwd, this.site))) {
+            fs.mkdirSync(path.join(this.cwd, this.site));
+        }
+        if (!fs.existsSync(themePath)) {
+            fs.mkdirSync(themePath);
+        }
+        if (reInit || !fs.existsSync(themeEnvPath)) {
+            fs.writeFileSync(themeEnvPath, '');
+            this.registered = false;
+        } else {
+            const data = fs.readFileSync(themeEnvPath);
+            try {
+                const environment = JSON.parse(data.toString());
+                this.registered = Boolean(environment.bearer);
+            } catch (e) {
+                this.registered = false;
+            }
+        }
+
+        try {
+            const isValid = await this.checkSiteValidity();
+            if (!isValid) {
+                console.error('Geçersiz site: Siteye ulaşılamıyor.');
+                return false;
+            }
+        } catch (error) {
+            console.error('Geçersiz site: Siteye ulaşılamıyor.', error.message);
+            return false;
+        }
+
+        return true;
+    }
+
+    isRegistered() {
+        return this.registered;
+    }
+
+    buildEnvironment(environment) {
+        const envPath = path.join(this.cwd, this.site, this.theme, `${this.theme}.env`);
+        fs.writeFileSync(envPath, JSON.stringify(environment));
+    }
+
+    getEnvironment(theme) {
+        const themeEnvPath = path.join(this.cwd, this.site, slugify(theme), `${slugify(theme)}.env`);
+        return JSON.parse(fs.readFileSync(themeEnvPath));
+    }
+
+    getThemeInfo(directoryName) {
+        const themePath = path.join(process.cwd(), this.site, slugify(directoryName), '.theme');
+        if (fs.existsSync(themePath)) {
+            const themeInfo = fs.readFileSync(themePath, 'utf-8');
+            try {
+                return JSON.parse(themeInfo);
+            } catch (error) {
+                console.error('.theme dosyasını ayrıştırma hatası:', error);
+                return null;
+            }
+        } else {
+            console.error('.theme dosyası bulunamadı:', themePath);
+            return null;
+        }
+    }
+
+    checkSiteValidity() {
+        return new Promise((resolve, reject) => {
+            const url = new URL(`https://${this.site}/Y/R`);
+            const request = url.protocol === 'https:' ? https : http;
+
+            const req = request.get(url, (res) => {
+                if (res.statusCode === 200) {
+                    resolve(true);
+                } else {
+                    resolve(false);
+                }
+            });
+
+            req.on('error', (err) => {
+                reject(err);
+            });
+
+            req.end();
+        });
+    }
+}
+
+module.exports = ThemeManager;

package/src/tsoft.js

@@ -0,0 +1,138 @@
+const ClientCredentials = require('./client-credentials');
+const constants = require('./constants');
+const FileManager = require('./file-manager');
+const ThemeManager = require('./theme-manager');
+const path = require("path");
+const buildPostRequest = require('./request');
+
+class Tsoft {
+    static TSOFT_CLI_UUID = '7583a318-8542-4ec8-980c-48ea67031be3';
+    static ONLINESTORE_SAVE_URI = 'api/v3/admin/online-store-2/theme/file-manager?q=save';
+    static ONLINESTORE_DELETE_URI = 'api/v3/admin/online-store-2/theme/file-manager?q=delete';
+    static UPDATE_THEME_URI = 'api/v3/admin/online-store-2/theme/update-theme';
+
+
+    constructor(site) {
+        this.site = site;
+        this.themeManager = new ThemeManager(site);
+        this.fileManager = new FileManager(site);
+        this.clientCredentials = new ClientCredentials(site);
+    }
+
+    async initialize(theme, reInit = false) {
+        await this.themeManager.initializeTheme(theme, reInit);
+        if (!this.themeManager.isRegistered()) {
+            return await this.register(Tsoft.TSOFT_CLI_UUID, this.themeManager.getThemeInfo(theme));
+        } else {
+            console.warn('You are already registered');
+        }
+    }
+
+    buildEnvironment() {
+        this.themeManager.buildEnvironment(this.clientCredentials.getEnvironment());
+    }
+
+    async authorize() {
+        await this.clientCredentials.authorize();
+    }
+
+    async register(CLIENT_UUID, clientConfiguration = {}) {
+        const response = await this.clientCredentials.register(CLIENT_UUID, clientConfiguration);
+        return response === true ? constants.APPROVAL : null;
+    }
+
+    async saveOnlineStore(theme) {
+        const fileList = this.fileManager.listFilesRecursive(
+            path.join(process.cwd(), this.site, theme)
+        );
+        await Promise.all(fileList.filter(file => !file.includes('.env')).map(async file => {
+            const fileName = this.fileManager.getRelativePath(theme, file);
+            const content = this.fileManager.readFile(file);
+            const env = this.themeManager.getEnvironment(theme);
+            const result = await buildPostRequest(this.site, Tsoft.ONLINESTORE_SAVE_URI, {
+                headers: {
+                    Authorization: `Bearer ${env.bearer}`
+                },
+                body: JSON.stringify({
+                    theme: theme,
+                    path: fileName,
+                    content: content
+                })
+            });
+        }));
+    }
+
+    async saveFile(theme, fileName, content, bearerToken) {
+        return await buildPostRequest(this.site, Tsoft.ONLINESTORE_SAVE_URI, {
+            headers: {
+                Authorization: `Bearer ${bearerToken}`,
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                theme: theme,
+                path: fileName,
+                content: content
+            })
+        });
+    }
+
+    async deleteFile(theme, fileName, bearerToken) {
+
+        return await buildPostRequest(this.site, Tsoft.ONLINESTORE_DELETE_URI, {
+            headers: {
+                Authorization: `Bearer ${bearerToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                theme: theme,
+                items: [
+                    {type: 'file', path: fileName}
+                ]
+            })
+        });
+
+    }
+
+    async deleteDirectory(theme, folderName, bearerToken) {
+        return await buildPostRequest(this.site, Tsoft.ONLINESTORE_DELETE_URI, {
+            headers: {
+                Authorization: `Bearer ${bearerToken}`,
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                theme: theme,
+                items: [
+                    {type: 'dir', path: folderName}
+                ]
+            })
+        });
+    }
+
+
+    async isTokenValid(theme) {
+        const env = this.themeManager.getEnvironment(theme);
+        return await this.clientCredentials.validateToken(env.bearer);
+    }
+
+    async updateTheme(directoryName) {
+        const env = this.themeManager.getEnvironment(directoryName);
+        const themeInfo = this.themeManager.getThemeInfo(directoryName); // .theme bilgisi alınıyor
+
+        return await buildPostRequest(this.site, Tsoft.UPDATE_THEME_URI, {
+            headers: {
+                Authorization: `Bearer ${env.bearer}`,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                theme: directoryName,
+                themeInfo: themeInfo
+            })
+        });
+    }
+
+}
+
+module.exports = Tsoft;

package/src/utils.js

@@ -0,0 +1,45 @@
+const figlet = require("figlet");
+module.exports = {
+    slugify: function (text) {
+        return text.toString().toLowerCase()
+            .replace(/\s+/g, '-')
+            .replace(/[^\w\-]+/g, '')
+            .replace(/\-\-+/g, '-')
+            .replace(/^-+/, '')
+            .replace(/-+$/, '');
+    },
+    allowedExtensions: ['theme', 'twig', 'css', 'js', 'md', 'json', 'svg', 'jpeg', 'jpg', 'png', 'gif', 'webp'],
+    clearScreen: function () {
+        process.stdout.write('\x1B[2J\x1B[0f');
+    },
+    displayAsciiArt: async function () {
+        return new Promise((resolve, reject) => {
+            figlet('T-SOFT CLI', {
+                font: 'Standard',
+            }, (err, data) => {
+                if (err) {
+                    console.log('Something went wrong...');
+                    console.dir(err);
+                    reject(err);
+                    return;
+                }
+                console.log(data);
+                resolve();
+            });
+        });
+    },
+    info: function () {
+        console.log('\n' +
+            '********************************************************\n' +
+            '*                                                      *\n' +
+            '*  Dosya izlemeyi sonlandırmak için "q" tuşuna basın,  *\n' +
+            '*  Temayı güncellemek için "u" tuşuna basın,           *\n' +
+            '*  Temayı kaydetmek için "s" tuşuna basın,             *\n' +
+            '*  .theme dosyasını düzenlemek için "e" tuşuna basın,  *\n' +
+            '*  Tema dizinini açmak için "o" tuşuna basın.          *\n' +
+            '*                                                      *\n' +
+            '********************************************************\n'
+        );
+    }
+
+}

package/tests/FileManager.test.js

@@ -0,0 +1,90 @@
+const path = require('path');
+const mockFs = require('mock-fs');
+const FileManager = require('../src/file-manager');
+
+describe('FileManager', () => {
+    const site = 'testSite';
+    const fileManager = new FileManager(site);
+
+    beforeEach(() => {
+        mockFs({
+            '/testDir': {
+                'file1.js': 'console.log("file1");',
+                'file2.css': 'body { margin: 0; }',
+                'subdir': {
+                    'file3.jpg': '',
+                    'file4.png': ''
+                }
+            },
+            [`${process.cwd()}/${site}`]: {
+                'myTheme': {
+                    'file.js': 'console.log("test");'
+                }
+            }
+        });
+    });
+
+    afterEach(() => {
+        mockFs.restore();
+    });
+
+    describe('listFilesRecursive', () => {
+        it('should list all files recursively', () => {
+            // Act
+            const result = fileManager.listFilesRecursive('/testDir');
+
+            // Assert
+            expect(result).toEqual([
+                '/testDir/file1.js',
+                '/testDir/file2.css',
+                '/testDir/subdir/file3.jpg',
+                '/testDir/subdir/file4.png'
+            ]);
+        });
+    });
+
+    describe('getRelativePath', () => {
+        it('should get the relative path of a file', () => {
+            // Arrange
+            const theme = 'myTheme';
+            const file = path.join(process.cwd(), site, theme, 'file.js');
+            const expectedRelativePath = 'file.js';
+
+            // Act
+            const result = fileManager.getRelativePath(theme, file);
+
+            // Assert
+            expect(result).toBe(expectedRelativePath);
+        });
+    });
+
+    describe('readFile', () => {
+        it('should read the contents of a file', () => {
+            // Arrange
+            const file = '/testDir/file1.js';
+            const fileContents = 'console.log("file1");';
+
+            // Act
+            const result = fileManager.readFile(file);
+
+            // Assert
+            expect(result).toBe(fileContents);
+        });
+    });
+
+    describe('isAllowedExtension', () => {
+        it('should return true for allowed extensions', () => {
+            // Arrange
+            const allowedFile = 'file.js';
+            const notAllowedFile = 'file.exe';
+
+            // Act
+            const isAllowedFileResult = fileManager.isAllowedExtension(allowedFile);
+            const isNotAllowedFileResult = fileManager.isAllowedExtension(notAllowedFile);
+
+            // Assert
+            expect(isAllowedFileResult).toBe(true);
+            expect(isNotAllowedFileResult).toBe(false);
+        });
+    });
+});

package/bin/tsoft-cli.js

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-const Common = require('../src/common');
-const { program } = require('commander');
-const axios = require('axios');
-const chokidar = require('chokidar');
-const path = require('path');
-const fs = require('fs');
-const _ = require('lodash');
-
-program
-    .command('init')
-    .description('Initialize the CLI')
-    .action(() => {
-        init();
-    });
-
-program.parse(process.argv);
-
-function init() {
-     (async () => {
-        const {default: inquirer} = await import('inquirer');
-
-        const tsoft = new Common();
-
-        if (Common.skip !== true) {
-            await tsoft.handleStep1(
-                (await inquirer.prompt(
-                    [
-                        {
-                            type: 'input',
-                            name: 'step1',
-                            message: 'Site Adresi https://(tsoft.com.tr):'
-                        },
-                    ]
-                ))
-            )
-
-            await tsoft.handleStep2(
-                (await inquirer.prompt(
-                    [
-                        {
-                            type: 'input',
-                            name: 'step2',
-                            message: 'Parola (Panelden Onaylayın):'
-                        },
-                    ]
-                ))
-            )
-
-            await tsoft.handleStep3(
-                (await inquirer.prompt(
-                    [
-                        {
-                            type: 'input',
-                            name: 'step3',
-                            message: 'Tema Adı:'
-                        },
-                    ]
-                ))
-            )
-        } else {
-
-            const debouncedSendFileChange = _.debounce(async (data) => {
-                try {
-                    const response = await axios.post('https://'+this.site+'/api', { data });
-                    console.log('API response:', response.data);
-                } catch (error) {
-                    console.error('Error sending API request:', error);
-                }
-            }, 1000);
-
-            const watchDirectory = path.join(__dirname, 'themes'); // İzlemek istediğiniz dizinin yolunu belirtin
-            const watcher = chokidar.watch(watchDirectory, {
-                persistent: true,
-                ignored: /(^|[\/\\])\../,
-                ignoreInitial: true,
-                followSymlinks: true,
-                depth: 99,
-                awaitWriteFinish: {
-                    stabilityThreshold: 2000,
-                    pollInterval: 100
-                }
-            });
-
-            watcher.on('all', (event, filePath) => {
-                if (event === 'change' || event === 'add' || event === 'unlink') {
-                    console.log(`File ${filePath} has been ${event}`);
-
-                    // Dosya değişikliğinde dosya içeriğini oku ve debounce edilmiş API'ye gönder
-                    fs.readFile(filePath, 'utf8', (err, data) => {
-                        if (err) {
-                            console.error('Error reading file:', err);
-                            return;
-                        }
-
-                        debouncedSendFileChange(data);
-                    });
-                }
-            });
-
-        }
-
-    })();
-}
-
-
-

package/src/common.js

@@ -1,117 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-
-class Common {
-    static CLIENT_UUID = "7583a318-8542-4ec8-980c-48ea67031be3";
-
-
-    site = null;
-    public_key = null;
-    secret = null;
-
-    theme = null;
-
-    bearer = null;
-
-    static skip = false;
-
-    constructor() {
-        try {
-            const environment = JSON.parse(fs.readFileSync(path.join(__dirname, '.environment'), 'utf8'))
-
-            this.site = environment.site;
-            this.public_key = environment.public_key;
-            this.secret = environment.secret;
-            this.theme = environment.theme;
-            this.bearer = environment.bearer;
-
-            Common.skip = true;
-        } catch (error) {
-
-        }
-    }
-
-    handleEnv(envObject) {
-        const filePath = path.join(__dirname, '.environment');
-
-        fs.writeFile(filePath, envObject, (err) => {
-            if (err) {
-                console.error('Error writing file:', err);
-            } else {
-                console.log('File written successfully');
-            }
-        });
-    }
-
-    async handleStep1(message) {
-        this.site = message.step1;
-        await this.authorizationRequest();
-    }
-
-    async handleStep2(message) {
-        this.secret = message.step2;
-        await this.login();
-    }
-
-    async handleStep3(message) {
-        this.theme = message.step3;
-
-        this.handleEnv(JSON.stringify({
-            site: this.site,
-            public_key: this.public_key,
-            secret: this.secret,
-            theme: this.theme,
-            bearer: this.bearer
-        }));
-    }
-
-
-    async authorizationRequest() {
-        const myHeaders = new Headers();
-        myHeaders.append("Content-Type", "application/json");
-        myHeaders.append("Accept", "application/json");
-
-        const raw = JSON.stringify({
-            "uuid": Common.CLIENT_UUID,
-        });
-
-        const requestOptions = {
-            method: "POST",
-            headers: myHeaders,
-            body: raw,
-            redirect: "follow"
-        };
-
-        fetch("https://" + this.site + "/api/v3/admin/auth/auth-application", requestOptions)
-            .then((response) => response.json())
-            .then((result) => {
-                this.public_key = result.public_key
-            })
-            .catch((error) => console.error(error));
-    }
-
-    async login() {
-        const myHeaders = new Headers();
-        const formdata = new FormData();
-        formdata.append("public_key", this.public_key);
-        formdata.append("secret", this.secret);
-
-        const requestOptions = {
-            method: "POST",
-            headers: myHeaders,
-            body: formdata,
-            redirect: "follow"
-        };
-
-        fetch("https://" + this.site + "/api/v3/admin/auth/auth-application/authorize", requestOptions)
-            .then((response) => response.json())
-            .then((result) => {
-                this.bearer = result?.token?.plainTextToken;
-            })
-            .catch((error) => console.error(error));
-    }
-
-
-}
-
-module.exports = Common;