tsoft-cli 1.2.3 → 1.4.0

package/src/commands/StartCommand.js

@@ -0,0 +1,280 @@
+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('../core/Constants');
+const cliProgress = require('cli-progress');
+const { Input } = require('enquirer');
+const { displayAsciiArt, info, unzipFile } = require('../core/Utils');
+
+class StartCommand {
+    static async 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;
+
+        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';
+    }
+
+    static async initializeAndAuthorize(tsoft, themeName) {
+        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('Ortam dosyası başarıyla oluşturuldu.');
+            return true;
+        } else {
+            console.error('Onay kodu gerekli.');
+            return false;
+        }
+    }
+
+    static async handleExistingEnvironment(tsoft, themeName, themeEnvPath) {
+        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...');
+                    return true;
+                } else {
+                    console.warn('Mevcut taşıyıcı jetonu geçersiz. Yeniden yetkilendirmeniz gerekecek.');
+                    fs.unlinkSync(themeEnvPath);
+                }
+            }
+        }
+        return false;
+    }
+
+    static async startWatching(themePath, tsoft, theme) {
+        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}`);
+            await StartCommand.handleFileChange(filePath, tsoft, theme);
+        }).on('unlink', async (filePath) => {
+            console.log(`Dosya silindi ${filePath}`);
+            await StartCommand.handleFileDeletion(filePath, tsoft, theme);
+        }).on('unlinkDir', async (dirPath) => {
+            console.log(`Dizin silindi ${dirPath}`);
+            await StartCommand.handleDirectoryDeletion(dirPath, tsoft, theme);
+        });
+
+        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) => {
+            await StartCommand.handleUserInput(input, tsoft, theme, watcher, rl);
+        });
+    }
+
+    static async handleFileChange(filePath, tsoft, theme) {
+        const env = JSON.parse(fs.readFileSync(path.join(process.cwd(), tsoft.site, theme, `${theme}.env`), 'utf-8'));
+        const fileName = filePath.replace(`${path.join(process.cwd(), tsoft.site, theme)}/`, '');
+        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);
+        }
+    }
+
+    static async handleFileDeletion(filePath, tsoft, theme) {
+        const env = JSON.parse(fs.readFileSync(path.join(process.cwd(), tsoft.site, theme, `${theme}.env`), 'utf-8'));
+        const fileName = filePath.replace(`${path.join(process.cwd(), tsoft.site, theme)}/`, '');
+
+        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);
+        }
+    }
+
+    static async handleDirectoryDeletion(dirPath, tsoft, theme) {
+        const env = JSON.parse(fs.readFileSync(path.join(process.cwd(), tsoft.site, theme, `${theme}.env`), 'utf-8'));
+        const dirName = dirPath.replace(`${path.join(process.cwd(), tsoft.site, theme)}/`, '');
+
+        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);
+        }
+    }
+
+    static async handleUserInput(input, tsoft, theme, watcher, rl) {
+        info();
+        switch (input.trim()) {
+            case 'q':
+                console.log('Dosya izleme işlemi sonlandırılıyor...');
+                watcher.close();
+                rl.close();
+                process.exit(0);
+                break;
+            case 'u':
+                console.log('Tema güncelleniyor...');
+                try {
+                    const result = await StartCommand.updateTheme(tsoft, theme);
+                    console.log(result);
+
+                } catch (error) {
+                    console.error(`Tema güncelleme hatası:`, error);
+                }
+                break;
+            case 's':
+                console.log('Tüm dosyalar ilerleme ile yüklenmeye başlanıyor...');
+                try {
+                    const result = await StartCommand.showProgress(tsoft, theme);
+                    console.log(result);
+
+                } catch (error) {
+                    console.error(`İlerleme gösterim hatası:`, error);
+                }
+                break;
+            case 'e':
+                console.log('.theme dosyası düzenleniyor...');
+                try {
+                    await StartCommand.editThemeFile(tsoft.themeManager, theme);
+                } catch (error) {
+                    console.error(`.theme dosyası düzenleme hatası:`, error);
+                }
+                break;
+            case 'o':
+                console.log('Tema dizini açılıyor...');
+                const openCommand = process.platform === 'win32' ? 'start' :
+                    process.platform === 'darwin' ? 'open' :
+                        'xdg-open';
+                exec(`${openCommand} ${path.join(process.cwd(), tsoft.site, theme)}`, (err) => {
+                    if (err) {
+                        console.error('Tema dizini açılamadı:', err);
+                    } else {
+                        console.log('Tema dizini başarıyla açıldı.');
+                    }
+                });
+                break;
+        }
+    }
+
+    static async start(siteName, themeName, recentlyCreated = false) {
+        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`);
+
+        const existingEnvValid = await StartCommand.handleExistingEnvironment(tsoft, themeName, themeEnvPath);
+        if (existingEnvValid) {
+            await StartCommand.startWatching(path.join(process.cwd(), siteName, themeName), tsoft, themeName);
+            return;
+        }
+
+        const initializedAndAuthorized = await StartCommand.initializeAndAuthorize(tsoft, themeName);
+        if (initializedAndAuthorized) {
+            if(recentlyCreated) {
+                const defaultZipFile = path.join(process.cwd(), siteName, themeName, 'theme.zip');
+                console.log('Default tema dosyaları indirme işlemi başlatılıyor, lütfen bekleyin');
+                const themePath = path.join(process.cwd(), siteName, themeName);
+                await tsoft.fileManager.downloadAndSaveZip(
+                    themePath, defaultZipFile,
+                    tsoft.clientCredentials.bearer,
+                    'default'
+                );
+                console.log('Default tema dosyaları indirildi. Çıkarma işlemi başlatılıyor');
+                await unzipFile(defaultZipFile, themePath);
+                console.log('Çıkarma işlemi tamamlandı.');
+                fs.unlinkSync(defaultZipFile);
+            }
+
+            await StartCommand.startWatching(path.join(process.cwd(), siteName, themeName), tsoft, themeName);
+        }
+    }
+
+    static async updateTheme(tsoft, theme) {
+        const directoryName = path.basename(path.join(process.cwd(), tsoft.site, theme));
+        const response = await tsoft.updateTheme(directoryName);
+        if (response.status === true) {
+            return 'Successfully updated';
+        } else {
+            throw new Error('Update failed');
+        }
+    }
+
+    static async editThemeFile(themeManager, directoryName) {
+        const themePath = path.join(process.cwd(), themeManager.site, directoryName, '.theme');
+        if (!fs.existsSync(themePath)) {
+            console.error('.theme file not found.');
+            return;
+        }
+        console.log(`Opening .theme file: ${themePath}`);
+        const openCommand = process.platform === 'win32' ? 'start' :
+            process.platform === 'darwin' ? 'open' :
+                'xdg-open';
+        exec(`${openCommand} ${themePath}`, (err) => {
+            if (err) {
+                console.error('Failed to open .theme file:', err);
+            } else {
+                console.log('.theme file opened successfully.');
+            }
+        });
+    }
+}
+
+module.exports = StartCommand;

package/src/commands/SyncCommand.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+const { Input } = require('enquirer');
+const { clearScreen } = require('../core/Utils');
+const { selectSite, createThemeDirectory } = require('./CreateCommand');
+const StartCommand = require('./StartCommand');
+const Tsoft = require("../Tsoft");
+const { slugify, unzipFile } = require('../core/Utils');
+
+class SyncCommand {
+    static async syncTheme() {
+        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 selectedSite = await selectSite(sites);
+
+        const tsoft = new Tsoft(selectedSite);
+
+        let recoveryCode;
+        let recoveryData;
+        while (!recoveryData) {
+            const codePrompt = new Input({
+                name: 'code',
+                message: 'Lütfen kurtarma anahtarını girin:'
+            });
+
+            recoveryCode = await codePrompt.run();
+
+            try {
+                recoveryData = await tsoft.startRecovery(recoveryCode);
+            } catch (error) {
+                if (error.message.includes('Çok fazla deneme yapıldı')) {
+                    console.error(`Hata: ${error.message}`);
+                    return;
+                } else {
+                    console.error(`Hata: ${error.message}`);
+                    continue;
+                }
+            }
+
+            if (!recoveryData) {
+                console.error('Kurtarma işlemi başarısız oldu. Lütfen geçerli bir kurtarma anahtarı girin.');
+            }
+        }
+
+        const { secret, public_key } = recoveryData;
+
+        tsoft.clientCredentials.setClientSecret(secret).setClientId(public_key);
+        const authorizeResponse = await tsoft.clientCredentials.authorize(true);
+        const themeInformation = authorizeResponse.data.tokenable;
+
+        const themeName = themeInformation.name;
+        const themeNameSlug = slugify(themeName);
+        const themePath = await createThemeDirectory(selectedSite, themeNameSlug);
+
+        const themeData = {
+            site: selectedSite,
+            name: themeName,
+            author: themeInformation.author,
+            version: themeInformation.version
+        };
+
+        fs.writeFileSync(path.join(themePath, '.theme'), JSON.stringify(themeData, null, 2));
+        tsoft.themeManager.setTheme(themeNameSlug);
+
+        if (!fs.existsSync(themePath)) {
+            fs.mkdirSync(themePath, { recursive: true });
+        }
+
+        clearScreen();
+
+        const zipFilePath = path.join(themePath, 'theme.zip');
+
+        try {
+            console.log('Zip dosyası indiriliyor...');
+            await tsoft.fileManager.downloadAndSaveZip(themePath, zipFilePath, tsoft.clientCredentials.bearer);
+            console.log('İndirme tamamlandı.');
+
+            console.log('Dosyalar çıkarılıyor...');
+            await unzipFile(zipFilePath, themePath);
+            console.log('Çıkarma işlemi tamamlandı.');
+            fs.unlinkSync(zipFilePath);
+        } catch (error) {
+            console.error(`Zip dosyası ile ilgili bir hata oluştu: ${error.message}`);
+            return;
+        }
+
+        tsoft.buildEnvironment();
+
+        // Geliştirme ortamını başlat
+        await StartCommand.start(selectedSite, themeNameSlug);
+    }
+}
+
+module.exports = SyncCommand;

package/src/{client-credentials.js → core/ClientCredentials.js}

@@ -1,27 +1,16 @@
-const {buildPostRequest} = require('./request');
+const {buildPostRequest} = require('./Request');
 
 class ClientCredentials {
-    site;
-    clientId;
-    clientSecret;
-    bearer;
-
     constructor(site) {
         this.site = site;
+        this.clientId = null;
+        this.clientSecret = null;
+        this.bearer = null;
     }
 
-    getEnvironment() {
-        return {
-            site: this.site, clientId: this.clientId, clientSecret: this.clientSecret, bearer: this.bearer
-        }
-    }
-
-    set clientId(clientId) {
+    setClientId(clientId) {
         this.clientId = clientId;
-    }
-
-    get clientId() {
-        return this.clientId;
+        return this;
     }
 
     setClientSecret(clientSecret) {
@@ -29,19 +18,25 @@ class ClientCredentials {
         return this;
     }
 
-    setClientId(clientId) {
-        this.clientId = clientId;
-        return this;
+    getEnvironment() {
+        return {
+            site: this.site,
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            bearer: this.bearer
+        };
     }
 
     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: {
+        const result = await buildPostRequest(this.site, uri, {
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            },
+            body: JSON.stringify({
+                uuid: CLIENT_UUID,
+                configuration: {
                     name: clientConfiguration.name,
                     author: clientConfiguration.author,
                     version: clientConfiguration.version
@@ -51,22 +46,26 @@ class ClientCredentials {
 
         if (result.status === true) {
             this.clientId = result.data.public_key;
+            return true;
         } else {
             return false;
         }
-
-        return true;
     }
 
     async authorize() {
         const uri = "api/v3/admin/auth/auth-application/authorize";
-        return await this.buildPostRequest(uri, {
+        return await buildPostRequest(this.site, uri, {
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            },
             body: JSON.stringify({
-                public_key: this.clientId, secret: this.clientSecret
+                public_key: this.clientId,
+                secret: this.clientSecret
             })
         }).then((result) => {
             if (result.status === true) {
-                this.bearer = result.data.token.plainTextToken
+                this.bearer = result.data.token.plainTextToken;
                 return result;
             }
             return false;
@@ -74,39 +73,35 @@ class ClientCredentials {
             console.error('Hata:', error.message);
             return false;
         });
-
-    }
-
-
-    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, {
+            headers: {
+                Authorization: `Bearer ${token}`
+            },
             body: JSON.stringify({
                 _method: 'GET'
-            }), headers: {
-                Authorization: `Bearer ${token}`
-            }
+            })
         });
         return response.message === 'ok';
     }
 
     async recovery(token) {
-        const uri = 'api/v3/admin/auth/auth-application/recovery/' + token;
-
+        const uri = `api/v3/admin/auth/auth-application/recovery/${token}`;
         const response = await buildPostRequest(this.site, uri);
-
         if (response.status) {
             return {
                 secret: response.data.secret,
                 public_key: response.data.public_key
-            }
+            };
+        } else if (response?.throttle) {
+            const {limit, retryAfter, resetDate} = response.throttle;
+            throw new Error(`Çok fazla deneme yapıldı. Lütfen ${retryAfter} saniye sonra tekrar deneyin. Limit: ${limit}, Reset Zamanı: ${resetDate}`);
         }
-
+        return null;
     }
 }
 
-module.exports = ClientCredentials;
+module.exports = ClientCredentials;

package/src/{constants.js → core/Constants.js}

@@ -1,7 +1,8 @@
 const handleAuthorization = async (credentialHandler) => {
     await credentialHandler.authorize();
 };
-module.exports = Object.freeze({
+
+const Constants = Object.freeze({
     INITIALIZE: {
         type: 'input',
         name: 'site',
@@ -13,4 +14,6 @@ module.exports = Object.freeze({
         message: 'Parolanızı giriniz (Lütfen panelden onaylayınız):',
         handler: handleAuthorization
     }
-});
+});
+
+module.exports = Constants;

package/src/{file-manager.js → core/FileManager.js}

@@ -1,8 +1,7 @@
 const fs = require('fs');
 const path = require('path');
-const utils = require('./utils');
-const { exec } = require('child_process');
-const {buildDownloadZipRequest} = require('./request');
+const Utils = require('./Utils');
+const { buildDownloadZipRequest } = require('./Request');
 
 class FileManager {
     constructor(site) {
@@ -34,12 +33,11 @@ class FileManager {
 
     isAllowedExtension(file) {
         const ext = path.extname(file).substring(1);
-        return utils.allowedExtensions.includes(ext);
+        return Utils.allowedExtensions.includes(ext);
     }
 
-    async downloadAndSaveZip(saveToDir, zipFilePath, bearerToken) {
-        // Fetch the zip file and save it
-        const response = await buildDownloadZipRequest(this.site, `api/v3/admin/online-store-2/theme/download-theme`, {
+    async downloadAndSaveZip(saveToDir, zipFilePath, bearerToken, type = 'none') {
+        const response = await buildDownloadZipRequest(this.site, `api/v3/admin/online-store-2/theme/download-theme?type=${type}`, {
             headers: {
                 'Content-Type': 'application/zip',
                 'Accept': 'application/zip',
@@ -47,23 +45,8 @@ class FileManager {
             }
         });
 
-
         fs.writeFileSync(zipFilePath, Buffer.from(response));
-
         console.log(`Zip dosyası ${zipFilePath} konumuna kaydedildi.`);
-
-        // Open the directory in file explorer
-        const openCommand = process.platform === 'win32' ? 'start' :
-            process.platform === 'darwin' ? 'open' :
-                'xdg-open';
-        exec(`${openCommand} ${saveToDir}`, (err) => {
-            if (err) {
-                console.error('Dizin açılamadı:', err);
-            } else {
-                console.log(`Dizin açıldı: ${saveToDir}`);
-                console.log('Lütfen zip dosyasını bu dizine çıkartın.');
-            }
-        });
     }
 }
 

package/src/core/Request.js

@@ -0,0 +1,41 @@
+class Request {
+    static async buildPostRequest(site, uri, options = {}) {
+        const fetch = (await import('node-fetch')).default;
+        try {
+            const response = await fetch(`https://${site}/${uri}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    ...options.headers
+                },
+                body: options.body
+            });
+            return await response.json();
+        } catch (error) {
+            console.error(error);
+            throw new Error('Request failed');
+        }
+    }
+
+    static async buildDownloadZipRequest(site, uri, options = {}) {
+        const fetch = (await import('node-fetch')).default;
+        try {
+            const response = await fetch(`https://${site}/${uri}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/zip',
+                    'Accept': 'application/zip',
+                    ...options.headers
+                },
+                body: options.body
+            });
+            return await response.arrayBuffer();
+        } catch (error) {
+            console.error(error);
+            throw new Error('Request failed');
+        }
+    }
+}
+
+module.exports = Request;

package/src/{theme-manager.js → core/ThemeManager.js}

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const {slugify} = require('./utils');
+const { slugify } = require('./Utils');
 const http = require('http');
 const https = require('https');
 
@@ -55,8 +55,9 @@ class ThemeManager {
     }
 
     setTheme(theme) {
-        this.theme = slugify(theme)
+        this.theme = slugify(theme);
     }
+
     isRegistered() {
         return this.registered;
     }