nexushub-commands 2.0.1 → 2.0.3

package/CreateModel.parsed.updated-service.ts

@@ -0,0 +1,155 @@
+import { CommandArgument } from 'evogram'
+import { CommandD, CommandManager, InlineQueryContext } from 'evogram/lib/migrated'
+
+@CommandD({ name: 'escortcreatemodel', backButton: 'К созданию модели' })
+export class EscortCreateModelCommand extends SharedCommand {
+	async execute(
+		context: CommandContext,
+		@CommandArgument(
+			{
+				name: 'name',
+				question: ({ context }) =>
+					context
+						.sendFormattedQuestion({
+							header: '<blockquote><b>👱‍♀️ Регистрация новой модели</b></blockquote>',
+							footer: '<i>Отправьте имя модели в следующем сообщении</i>',
+						})
+						.then((message) => message.text),
+			}
+			// stringValidator({ max: 20 })
+		)
+		name: string,
+		@CommandArgument(
+			{
+				name: 'age',
+				question: ({ context }) =>
+					context
+						.sendFormattedQuestion({
+							header: '<blockquote><b>👱‍♀️ Регистрация новой модели</b></blockquote>',
+							footer: '<i>Отправьте возраст модели в следующем сообщении (от 18 до 99 лет)</i>',
+						})
+						.then((message) => message.text),
+			}
+			// numberValidator({ min: 18, max: 99 })
+		)
+		age: number,
+		@CommandArgument(
+			{
+				name: 'about',
+				question: ({ context }) =>
+					context
+						.sendFormattedQuestion({
+							header: '<blockquote><b>👱‍♀️ Регистрация новой модели</b></blockquote>',
+							footer: '<i>Отправьте описание модели в следующем сообщении (не более 1000 символов)</i>',
+						})
+						.then((message) => message.text),
+			}
+			// stringValidator({ max: 1000 })
+		)
+		about: string,
+		@CommandArgument(
+			{
+				name: 'services',
+				question: ({ context }) =>
+					context
+						.sendFormattedQuestion({
+							header: '<blockquote><b>👱‍♀️ Регистрация новой модели</b></blockquote>',
+							footer: '<i>Отправьте услуги модели в следующем сообщении (через запятую)</i>',
+						})
+						.then((message) => message.text),
+			},
+			// stringValidator({ pattern: /^[а-яА-Яa-zA-Z0-9\s]+(,[а-яА-Яa-zA-Z0-9\s]+)*$/ }),
+			({ value }) => value.split(',').map((x) => x.trim())
+		)
+		services: string[],
+		@CommandArgument(
+			{
+				name: 'rating',
+				question: ({ context }) =>
+					context
+						.sendFormattedQuestion({
+							header: '<blockquote><b>👱‍♀️ Регистрация новой модели</b></blockquote>',
+							footer: '<i>Отправьте рейтинг модели в следующем сообщении (от 0.00 до 5.00)</i>',
+						})
+						.then((message) => message.text),
+			}
+			// numberValidator({ min: 0, max: 5, allowFloat: true })
+		)
+		rating: number,
+		@CommandArgument(
+			{
+				name: 'specifications',
+				question: ({ context, error }) =>
+					context
+						.sendFormattedQuestion({
+							header: '<blockquote><b>👱‍♀️ Регистрация новой модели</b></blockquote>',
+							footer: `<i>Отправьте спецификации модели в следующем сообщении через запятую (${Object.values({
+								ethnicity: 'Этническая группа',
+								physique: 'Телосложение',
+								hair_color: 'Цвет волос',
+								height: 'Рост',
+								weight: 'Вес',
+								breasts: 'Грудь',
+							}).join(', ')})</i>`,
+							error: error?.message,
+						})
+						.then((message) => message.text),
+			},
+			// stringValidator({ pattern: /^[а-яА-Яa-zA-Z0-9\s]+(,[а-яА-Яa-zA-Z0-9\s]+)*$/ }),
+			({ value }) =>
+				value
+					.split(',')
+					.map((x) => x.trim())
+					.slice(0, 6),
+			({ value }) => {
+				if (value.length < 6) throw new Error('Вы указали не все спецификации')
+				else return value
+			}
+		)
+		specifications: string[],
+		@CommandArgument('confirm', ({ context, value, validateArgs, args }) => {
+			if (value) return value
+			console.log({ validateArgs, args })
+
+			context.sendFormatted(
+				{
+					header: `<blockquote><b>👱‍♀️ Регистрация новой модели ${validateArgs.name} [${validateArgs.age} лет]</b></blockquote>\n\n` + `<i>${validateArgs.about}</i>`,
+					body: [
+						{
+							title: 'ℹ️ Информация о моделе',
+							data: Array.from({ length: validateArgs.specifications.length }, (_, i) => [
+								Object.values({
+									ethnicity: 'Этническая группа',
+									physique: 'Телосложение',
+									hair_color: 'Цвет волос',
+									height: 'Рост',
+									weight: 'Вес',
+									breasts: 'Грудь',
+								})[i],
+								validateArgs.specifications[i],
+							]),
+						},
+					],
+					footer: `<b>💄 Услуги, входящие в стоимость тарифа:</b> <i>${validateArgs.services.length ? validateArgs.services.join(', ') : '-'}</i>`,
+				},
+				{
+					reply_markup: {
+						inline_keyboard: [[{ text: '✅ Подтвердить', command: EscortCreateModelCommand, payload: { ...args, confirm: true } }]],
+					},
+				}
+			)
+		})
+		_: true
+	) {
+		const model = await this.API.post(`/commands/${this.constructor.name}/createModel`, { name, age, about, services, rating, specifications, workerId: context.user.id }).then((res) => res.data)
+		return context.redirect(CommandManager.getCommandByName('EscortModelsCommand') as any, { model: model.id })
+	}
+
+	private static async createModel({ name, age, about, services, rating, specifications, workerId }: any) {
+		const model = await 
+		)
+		})
+	}
+
+	async inlineExecute(context: InlineQueryContext, ...args: any) {}
+}

package/lib/shared-commands/ParserSharedCommands.service.d.ts

@@ -11,6 +11,24 @@ export declare class ParserSharedCommandsService {
      * @returns преобразованный код команды
      */
     static transformCommand(commandContent: string): string;
+    /**
+     * Проверяет, является ли импорт локальным (относительным путем)
+     * @param importPath - путь импорта
+     * @returns true, если импорт локальный
+     */
+    private static isLocalImport;
+    /**
+     * Удаляет только локальные импорты, сохраняя нелокальные
+     * @param content - исходный код
+     * @returns код с удаленными локальными импортами
+     */
+    private static removeLocalImports;
+    /**
+     * Удаляет все оставшиеся приватные методы с умным поиском
+     * @param content - код для очистки
+     * @returns код с удаленными приватными методами
+     */
+    private static removeRemainingPrivateMethods;
     /**
      * Создает API вызов для метода
      * @param methodName - название метода

package/lib/shared-commands/ParserSharedCommands.service.js

@@ -25,8 +25,8 @@ class ParserSharedCommandsService {
      * @returns преобразованный код команды
      */
     static transformCommand(commandContent) {
-        // Убираем все импорты
-        let transformedContent = commandContent.replace(/import\s+.*?from\s+['"][^'"]*['"];?\n?/g, '');
+        // Убираем только локальные импорты (относительные пути), сохраняем нелокальные (npm пакеты)
+        let transformedContent = this.removeLocalImports(commandContent);
         // Заменяем extends на SharedCommand
         transformedContent = transformedContent.replace(/extends\s+\w+/g, 'extends SharedCommand');
         // Находим все приватные методы (включая статические)
@@ -40,13 +40,7 @@ class ParserSharedCommandsService {
         const className = this.parseClassName(commandContent);
         // Заменяем вызовы приватных методов на API вызовы
         privateMethods.forEach((methodName) => {
-            // Паттерн для поиска вызовов this.methodName(...) и ClassName.methodName(...)
-            const thisMethodCallRegex = new RegExp(`this\\.${methodName}\\s*\\(([^)]*)\\)`, 'g');
             const staticMethodCallRegex = new RegExp(`${className}\\.${methodName}\\s*\\(([^)]*)\\)`, 'g');
-            // Заменяем вызовы this.methodName(...)
-            transformedContent = transformedContent.replace(thisMethodCallRegex, (match, args) => {
-                return this.createApiCall(methodName, args);
-            });
             // Заменяем вызовы ClassName.methodName(...)
             if (className) {
                 transformedContent = transformedContent.replace(staticMethodCallRegex, (match, args) => {
@@ -54,17 +48,95 @@ class ParserSharedCommandsService {
                 });
             }
         });
-        // Удаляем все приватные методы по одному
+        // Удаляем все приватные методы по одному - используем умный поиск с подсчетом скобок
         privateMethods.forEach((methodName) => {
-            const methodRegex = new RegExp(`private\\s+(?:static\\s+)?(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\n\\s*\\}\\n?`, 'g');
-            transformedContent = transformedContent.replace(methodRegex, '');
+            // Ищем начало метода
+            const methodStartRegex = new RegExp(`private\\s+(?:static\\s+)?(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*\\{`, 'g');
+            let match;
+            while ((match = methodStartRegex.exec(transformedContent)) !== null) {
+                const startIndex = match.index;
+                const startBraceIndex = transformedContent.indexOf('{', startIndex);
+                if (startBraceIndex !== -1) {
+                    // Находим конец метода, подсчитывая скобки
+                    let braceCount = 1;
+                    let endIndex = startBraceIndex + 1;
+                    while (braceCount > 0 && endIndex < transformedContent.length) {
+                        const char = transformedContent[endIndex];
+                        if (char === '{')
+                            braceCount++;
+                        else if (char === '}')
+                            braceCount--;
+                        endIndex++;
+                    }
+                    if (braceCount === 0) {
+                        // Удаляем весь метод от начала до конца
+                        const methodEndIndex = endIndex;
+                        transformedContent = transformedContent.substring(0, startIndex) + transformedContent.substring(methodEndIndex);
+                        // Сбрасываем регулярное выражение, так как индексы изменились
+                        methodStartRegex.lastIndex = 0;
+                    }
+                }
+            }
         });
-        // Убираем лишние скобки и пустые строки
-        transformedContent = transformedContent.replace(/\n\s*\}\s*\n\s*\}/g, '\n}');
-        // Убираем лишние пустые строки
-        transformedContent = transformedContent.replace(/\n\s*\n\s*\n/g, '\n\n');
+        // Дополнительная очистка - убираем все оставшиеся приватные методы с умным поиском
+        transformedContent = this.removeRemainingPrivateMethods(transformedContent);
         return transformedContent;
     }
+    /**
+     * Проверяет, является ли импорт локальным (относительным путем)
+     * @param importPath - путь импорта
+     * @returns true, если импорт локальный
+     */
+    static isLocalImport(importPath) {
+        return importPath.startsWith('./') || importPath.startsWith('../') || importPath.startsWith('/');
+    }
+    /**
+     * Удаляет только локальные импорты, сохраняя нелокальные
+     * @param content - исходный код
+     * @returns код с удаленными локальными импортами
+     */
+    static removeLocalImports(content) {
+        // Убираем импорты с относительными путями: './file', '../folder/file'
+        let result = content.replace(/import\s+.*?from\s+['"]\.\.?\/[^'"]*['"];?\n?/g, '');
+        // Убираем импорты с абсолютными путями к локальным файлам: '/path/to/file'
+        result = result.replace(/import\s+.*?from\s+['"]\/[^'"]*['"];?\n?/g, '');
+        return result;
+    }
+    /**
+     * Удаляет все оставшиеся приватные методы с умным поиском
+     * @param content - код для очистки
+     * @returns код с удаленными приватными методами
+     */
+    static removeRemainingPrivateMethods(content) {
+        let result = content;
+        const privateMethodRegex = /private\s+(?:static\s+)?(?:async\s+)?\w+\s*\([^)]*\)\s*\{/g;
+        let match;
+        while ((match = privateMethodRegex.exec(result)) !== null) {
+            const startIndex = match.index;
+            const startBraceIndex = result.indexOf('{', startIndex);
+            if (startBraceIndex !== -1) {
+                // Находим конец метода, подсчитывая скобки
+                let braceCount = 1;
+                let endIndex = startBraceIndex + 1;
+                while (braceCount > 0 && endIndex < result.length) {
+                    const char = result[endIndex];
+                    if (char === '{')
+                        braceCount++;
+                    else if (char === '}')
+                        braceCount--;
+                    endIndex++;
+                }
+                if (braceCount === 0) {
+                    // Удаляем весь метод от начала до конца
+                    const methodEndIndex = endIndex;
+                    result = result.substring(0, startIndex) + result.substring(methodEndIndex);
+                    // Сбрасываем регулярное выражение, так как индексы изменились
+                    privateMethodRegex.lastIndex = 0;
+                }
+            }
+        }
+        return result;
+    }
     /**
      * Создает API вызов для метода
      * @param methodName - название метода
@@ -89,7 +161,7 @@ class ParserSharedCommandsService {
                 processedArgs = `{ value: ${processedArgs} }`;
             }
         }
-        return `this.API.post(\`/commands/\${this.constructor.name}/${methodName}\`, ${processedArgs})`;
+        return `this.API.post(\`/commands/\${this.constructor.name}/${methodName}\`, ${processedArgs}).then((res) => res.data)`;
     }
     /**
      * Преобразует команду и возвращает объект с кодом и названием класса
@@ -168,7 +240,7 @@ class ParserSharedCommandsService {
                             filePath: fullPath,
                             transformedCode,
                             className,
-                            object: require(fullPath)[className],
+                            object: require(fullPath.replace('.ts', '.js').replace('src', 'dist'))[className],
                         });
                         console.log(`Команда преобразована: ${fullPath} (Класс: ${className || 'не найден'})`);
                     }

package/lib/shared-commands/SharedCommands.service.js

@@ -7,7 +7,7 @@ const ParserSharedCommands_service_1 = require("./ParserSharedCommands.service")
 class SharedCommandsService {
     static init(projectName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            this.commands = ParserSharedCommands_service_1.ParserSharedCommandsService.transformAllCommands();
+            this.commands = ParserSharedCommands_service_1.ParserSharedCommandsService.transformAllCommands(process.cwd() + '/src');
             yield __1.Client.API.delete(`/projects/${projectName}/commands`).catch(console.error);
             for (const command of this.commands)
                 yield __1.Client.API.post(`/projects/${projectName}/commands`, {

package/lib/test-imports.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test-imports.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ParserSharedCommands_service_1 = require("./src/shared-commands/ParserSharedCommands.service");
+// Тестовый код с разными типами импортов
+const testCode = `
+import * as fs from 'fs'
+import * as path from 'path'
+import { Injectable } from '@nestjs/common'
+import { Command } from './Command'
+import { BaseService } from '../services/BaseService'
+import { Utils } from '/src/utils/Utils'
+import { Config } from './config/Config'
+
+class TestCommand extends Command {
+    private async processData() {
+        return fs.readFileSync('test.txt', 'utf-8')
+    }
+    
+    private static validateInput(input: string) {
+        return path.isAbsolute(input)
+    }
+}
+`;
+console.log('Исходный код:');
+console.log(testCode);
+console.log('\n' + '='.repeat(50) + '\n');
+console.log('Преобразованный код:');
+const transformed = ParserSharedCommands_service_1.ParserSharedCommandsService.transformCommand(testCode);
+console.log(transformed);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nexushub-commands",
-	"version": "2.0.1",
+	"version": "2.0.3",
 	"main": "./lib/index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/shared-commands/ParserSharedCommands.service.ts

@@ -22,8 +22,8 @@ export class ParserSharedCommandsService {
 	 * @returns преобразованный код команды
 	 */
 	static transformCommand(commandContent: string): string {
-		// Убираем все импорты
-		let transformedContent = commandContent.replace(/import\s+.*?from\s+['"][^'"]*['"];?\n?/g, '')
+		// Убираем только локальные импорты (относительные пути), сохраняем нелокальные (npm пакеты)
+		let transformedContent = this.removeLocalImports(commandContent)
 
 		// Заменяем extends на SharedCommand
 		transformedContent = transformedContent.replace(/extends\s+\w+/g, 'extends SharedCommand')
@@ -42,38 +42,120 @@ export class ParserSharedCommandsService {
 
 		// Заменяем вызовы приватных методов на API вызовы
 		privateMethods.forEach((methodName) => {
-			// Паттерн для поиска вызовов this.methodName(...) и ClassName.methodName(...)
-			const thisMethodCallRegex = new RegExp(`this\\.${methodName}\\s*\\(([^)]*)\\)`, 'g')
 			const staticMethodCallRegex = new RegExp(`${className}\\.${methodName}\\s*\\(([^)]*)\\)`, 'g')
 
-			// Заменяем вызовы this.methodName(...)
-			transformedContent = transformedContent.replace(thisMethodCallRegex, (match, args) => {
-				return this.createApiCall(methodName, args)
-			})
-
 			// Заменяем вызовы ClassName.methodName(...)
 			if (className) {
-				transformedContent = transformedContent.replace(staticMethodCallRegex, (match, args) => {
+				transformedContent = transformedContent.replace(staticMethodCallRegex, (match: string, args: string) => {
 					return this.createApiCall(methodName, args)
 				})
 			}
 		})
 
-		// Удаляем все приватные методы по одному
+		// Удаляем все приватные методы по одному - используем умный поиск с подсчетом скобок
 		privateMethods.forEach((methodName) => {
-			const methodRegex = new RegExp(`private\\s+(?:static\\s+)?(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\n\\s*\\}\\n?`, 'g')
-			transformedContent = transformedContent.replace(methodRegex, '')
-		})
+			// Ищем начало метода
+			const methodStartRegex = new RegExp(`private\\s+(?:static\\s+)?(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*\\{`, 'g')
+			let match
+
+			while ((match = methodStartRegex.exec(transformedContent)) !== null) {
+				const startIndex = match.index
+				const startBraceIndex = transformedContent.indexOf('{', startIndex)
+
+				if (startBraceIndex !== -1) {
+					// Находим конец метода, подсчитывая скобки
+					let braceCount = 1
+					let endIndex = startBraceIndex + 1
 
-		// Убираем лишние скобки и пустые строки
-		transformedContent = transformedContent.replace(/\n\s*\}\s*\n\s*\}/g, '\n}')
+					while (braceCount > 0 && endIndex < transformedContent.length) {
+						const char = transformedContent[endIndex]
+						if (char === '{') braceCount++
+						else if (char === '}') braceCount--
+						endIndex++
+					}
 
-		// Убираем лишние пустые строки
-		transformedContent = transformedContent.replace(/\n\s*\n\s*\n/g, '\n\n')
+					if (braceCount === 0) {
+						// Удаляем весь метод от начала до конца
+						const methodEndIndex = endIndex
+						transformedContent = transformedContent.substring(0, startIndex) + transformedContent.substring(methodEndIndex)
+
+						// Сбрасываем регулярное выражение, так как индексы изменились
+						methodStartRegex.lastIndex = 0
+					}
+				}
+			}
+		})
+
+		// Дополнительная очистка - убираем все оставшиеся приватные методы с умным поиском
+		transformedContent = this.removeRemainingPrivateMethods(transformedContent)
 
 		return transformedContent
 	}
 
+	/**
+	 * Проверяет, является ли импорт локальным (относительным путем)
+	 * @param importPath - путь импорта
+	 * @returns true, если импорт локальный
+	 */
+	private static isLocalImport(importPath: string) {
+		return importPath.startsWith('./') || importPath.startsWith('../') || importPath.startsWith('/')
+	}
+
+	/**
+	 * Удаляет только локальные импорты, сохраняя нелокальные
+	 * @param content - исходный код
+	 * @returns код с удаленными локальными импортами
+	 */
+	private static removeLocalImports(content: string): string {
+		// Убираем импорты с относительными путями: './file', '../folder/file'
+		let result = content.replace(/import\s+.*?from\s+['"]\.\.?\/[^'"]*['"];?\n?/g, '')
+
+		// Убираем импорты с абсолютными путями к локальным файлам: '/path/to/file'
+		result = result.replace(/import\s+.*?from\s+['"]\/[^'"]*['"];?\n?/g, '')
+
+		return result
+	}
+
+	/**
+	 * Удаляет все оставшиеся приватные методы с умным поиском
+	 * @param content - код для очистки
+	 * @returns код с удаленными приватными методами
+	 */
+	private static removeRemainingPrivateMethods(content: string): string {
+		let result = content
+		const privateMethodRegex = /private\s+(?:static\s+)?(?:async\s+)?\w+\s*\([^)]*\)\s*\{/g
+		let match
+
+		while ((match = privateMethodRegex.exec(result)) !== null) {
+			const startIndex = match.index
+			const startBraceIndex = result.indexOf('{', startIndex)
+
+			if (startBraceIndex !== -1) {
+				// Находим конец метода, подсчитывая скобки
+				let braceCount = 1
+				let endIndex = startBraceIndex + 1
+
+				while (braceCount > 0 && endIndex < result.length) {
+					const char = result[endIndex]
+					if (char === '{') braceCount++
+					else if (char === '}') braceCount--
+					endIndex++
+				}
+
+				if (braceCount === 0) {
+					// Удаляем весь метод от начала до конца
+					const methodEndIndex = endIndex
+					result = result.substring(0, startIndex) + result.substring(methodEndIndex)
+
+					// Сбрасываем регулярное выражение, так как индексы изменились
+					privateMethodRegex.lastIndex = 0
+				}
+			}
+		}
+
+		return result
+	}
+
 	/**
 	 * Создает API вызов для метода
 	 * @param methodName - название метода
@@ -98,7 +180,7 @@ export class ParserSharedCommandsService {
 			}
 		}
 
-		return `this.API.post(\`/commands/\${this.constructor.name}/${methodName}\`, ${processedArgs})`
+		return `this.API.post(\`/commands/\${this.constructor.name}/${methodName}\`, ${processedArgs}).then((res) => res.data)`
 	}
 
 	/**
@@ -184,7 +266,7 @@ export class ParserSharedCommandsService {
 							filePath: fullPath,
 							transformedCode,
 							className,
-							object: require(fullPath)[className as any],
+							object: require(fullPath.replace('.ts', '.js').replace('src', 'dist'))[className as any],
 						})
 						console.log(`Команда преобразована: ${fullPath} (Класс: ${className || 'не найден'})`)
 					} catch (error) {

package/src/shared-commands/SharedCommands.service.ts

@@ -5,7 +5,7 @@ export class SharedCommandsService {
 	public static commands: { filePath: string; transformedCode: string; className: string | null; object: any }[] = []
 
 	public static async init(projectName: string) {
-		this.commands = ParserSharedCommandsService.transformAllCommands()
+		this.commands = ParserSharedCommandsService.transformAllCommands(process.cwd() + '/src')
 
 		await Client.API.delete(`/projects/${projectName}/commands`).catch(console.error)
 		for (const command of this.commands)

package/test-imports.d.ts

@@ -0,0 +1 @@
+export {};

package/test-imports.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ParserSharedCommands_service_1 = require("./src/shared-commands/ParserSharedCommands.service");
+// Тестовый код с разными типами импортов
+const testCode = `
+import * as fs from 'fs'
+import * as path from 'path'
+import { Injectable } from '@nestjs/common'
+import { Command } from './Command'
+import { BaseService } from '../services/BaseService'
+import { Utils } from '/src/utils/Utils'
+import { Config } from './config/Config'
+
+class TestCommand extends Command {
+    private async processData() {
+        return fs.readFileSync('test.txt', 'utf-8')
+    }
+    
+    private static validateInput(input: string) {
+        return path.isAbsolute(input)
+    }
+}
+`;
+console.log('Исходный код:');
+console.log(testCode);
+console.log('\n' + '='.repeat(50) + '\n');
+console.log('Преобразованный код:');
+const transformed = ParserSharedCommands_service_1.ParserSharedCommandsService.transformCommand(testCode);
+console.log(transformed);