@boristype/bt-cli 0.1.0-alpha.0

package/build/wshcm/uploader.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WshcmUploader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+/**
+ * Описание файла для загрузки
+ */
+class FileDescription {
+    /** Абсолютный путь к файлу */
+    path;
+    /** Относительный путь от базовой директории */
+    relative;
+    /** MD5 хеш относительного пути (в верхнем регистре) */
+    hash;
+    /** Размер файла в байтах */
+    size;
+    constructor(filePath, basePath) {
+        this.path = filePath;
+        this.relative = path.relative(basePath, filePath).replace(/\\/g, '/');
+        this.hash = crypto.createHash('md5').update(this.relative).digest('hex').toUpperCase();
+        this.size = fs.statSync(filePath).size;
+    }
+}
+/**
+ * Информация о чанке файла
+ */
+class ChunkInfo {
+    /** Путь к файлу */
+    path;
+    /** Начало чанка в файле (байты) */
+    chunkStart;
+    /** Конец чанка в файле (байты) */
+    chunkEnd;
+    /** Хеш файла */
+    hash;
+    /** Индекс чанка */
+    index;
+    constructor(filePath, chunkStart, chunkEnd, hash, index) {
+        this.path = filePath;
+        this.chunkStart = chunkStart;
+        this.chunkEnd = chunkEnd;
+        this.hash = hash;
+        this.index = index;
+    }
+    toString() {
+        return `[ ${this.hash} : '${this.path}' : (${this.index}) ${this.chunkStart}-${this.chunkEnd} ]`;
+    }
+}
+/**
+ * Загрузчик файлов для WSHCM
+ *
+ * Позволяет загружать файлы и директории на сервер WebSoft HCM
+ * с разбиением на чанки и последующей сборкой на сервере.
+ *
+ * @example
+ * ```typescript
+ * const evaluator = client.createEvaluator();
+ * await evaluator.initialize();
+ *
+ * const uploader = new WshcmUploader({
+ *   evaluator,
+ *   path: './myfile.txt',
+ *   destination: 'x-local://wt/uploaded/',
+ *   chunkSize: 4 * 1024 * 1024 // 4MB
+ * });
+ *
+ * await uploader.prepare();
+ * await uploader.upload((uploaded, total) => {
+ *   console.log(`Progress: ${(uploaded / total * 100).toFixed(2)}%`);
+ * });
+ * const urls = await uploader.finish();
+ *
+ * await evaluator.close();
+ * ```
+ */
+class WshcmUploader {
+    evaluator;
+    chunkSize;
+    uploadPath;
+    destination;
+    isDir = false;
+    isFile = false;
+    isGlob = false;
+    totalSize = 0;
+    /** Базовый путь для вычисления relative paths */
+    basePath = '';
+    /** Имя для finish скрипта (пустое для glob режима) */
+    uploadName = '';
+    files = [];
+    // Пути на сервере
+    destPath = '';
+    tempPath = '';
+    chunkPath1 = '';
+    chunkPath2 = '';
+    /**
+     * Создает новый загрузчик файлов
+     *
+     * Lifecycle evaluator-а управляется вызывающим кодом —
+     * uploader не вызывает evaluator.close().
+     */
+    constructor(options) {
+        this.evaluator = options.evaluator;
+        this.uploadPath = options.path;
+        this.destination = options.destination;
+        this.chunkSize = options.chunkSize || 4 * 1024 * 1024; // 4MB по умолчанию
+    }
+    /**
+     * Подготавливает загрузку: сканирует файлы, создает структуру на сервере
+     *
+     * Поддерживаемые форматы path:
+     * - `file.txt` — загрузка одного файла
+     * - `dir/` — загрузка директории (как вложенная папка)
+     * - `dir/*` — загрузка содержимого директории (без вложенной папки)
+     */
+    async prepare() {
+        // Проверяем glob-паттерн (dir/* или dir\*)
+        if (this.uploadPath.endsWith('/*') || this.uploadPath.endsWith('\\*')) {
+            this.isGlob = true;
+            const dirPath = this.uploadPath.slice(0, -2);
+            if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+                throw new Error(`Glob pattern requires existing directory: ${dirPath}`);
+            }
+            this.basePath = dirPath;
+            this.uploadName = ''; // пустое имя сигнализирует glob-режим на сервере
+            this.scanDirectory(dirPath, dirPath);
+        }
+        else {
+            // Обычный режим: файл или директория
+            const stats = fs.statSync(this.uploadPath);
+            if (stats.isDirectory()) {
+                this.isDir = true;
+                this.basePath = path.dirname(this.uploadPath);
+                this.uploadName = path.basename(this.uploadPath);
+                this.scanDirectory(this.uploadPath, this.basePath);
+            }
+            else if (stats.isFile()) {
+                this.isFile = true;
+                this.basePath = path.dirname(this.uploadPath);
+                this.uploadName = path.basename(this.uploadPath);
+                const fileDesc = new FileDescription(this.uploadPath, this.basePath);
+                this.files.push(fileDesc);
+            }
+            else {
+                throw new Error('Path is not a file or directory');
+            }
+        }
+        // Сортируем файлы по размеру (от меньших к большим) для эффективного батчинга
+        this.files.sort((a, b) => a.size - b.size);
+        // Вычисляем общий размер
+        this.totalSize = this.files.reduce((sum, file) => sum + file.size, 0);
+        // Читаем скрипт подготовки
+        const prepareScript = fs.readFileSync(path.join(__dirname, '..', '..', 'resources', 'upload_prepare.bs'), 'utf-8');
+        // Заменяем переменную
+        const script = prepareScript.replace('{{destination}}', this.destination);
+        // Выполняем на сервере
+        const response = await this.evaluator.eval(script);
+        // Сохраняем пути
+        this.destPath = response.dest_path.replace(/\\/g, '\\\\');
+        this.tempPath = response.temp_path.replace(/\\/g, '\\\\');
+        const [part1, part2] = response.chunk_path.split('RELATIVE_PATH_HASH');
+        this.chunkPath1 = part1.replace(/\\/g, '\\\\');
+        this.chunkPath2 = part2.replace(/\\/g, '\\\\');
+        // Создаем директории для чанков на сервере
+        const obtainDirCode = this.files
+            .map(file => `ObtainDirectory('${this.chunkPath1}${file.hash}', true);`)
+            .join('\n');
+        await this.evaluator.eval(obtainDirCode);
+    }
+    /**
+     * Загружает файлы на сервер по частям (чанкам)
+     * Мелкие чанки группируются в батчи для оптимизации
+     * @param callback - функция для отслеживания прогресса
+     */
+    async upload(callback) {
+        const chunks = [];
+        // Создаем список всех чанков (файлы уже отсортированы по размеру)
+        for (const file of this.files) {
+            this.chunksFromFile(file, chunks);
+        }
+        // Группируем чанки в батчи
+        const batches = this.batchChunks(chunks);
+        let uploadedBytes = 0;
+        // Загружаем батчи
+        for (const batch of batches) {
+            uploadedBytes += await this.uploadBatch(batch);
+            if (callback) {
+                callback(uploadedBytes, this.totalSize);
+            }
+        }
+    }
+    /**
+     * Финализирует загрузку: собирает чанки и перемещает файлы в целевую директорию
+     * @returns массив URL загруженных файлов
+     */
+    async finish() {
+        // Читаем скрипт финализации
+        const finishScript = fs.readFileSync(path.join(__dirname, '..', '..', 'resources', 'upload_finish.bs'), 'utf-8');
+        // Заменяем переменные
+        const filePaths = JSON.stringify(this.files.map(f => f.relative));
+        let script = finishScript;
+        script = script.replace('{{file_name}}', this.uploadName);
+        script = script.replace('{{dest_path}}', this.destPath);
+        script = script.replace('{{temp_path}}', this.tempPath);
+        script = script.replace('{{file_paths}}', filePaths);
+        // Выполняем на сервере
+        const response = await this.evaluator.eval(script);
+        if (response.error) {
+            throw new Error(response.message || 'Upload finish failed');
+        }
+        return response.value || [];
+    }
+    /**
+     * Сканирует директорию рекурсивно и добавляет файлы в список
+     */
+    scanDirectory(dirPath, basePath) {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                this.scanDirectory(fullPath, basePath);
+            }
+            else if (entry.isFile()) {
+                const fileDesc = new FileDescription(fullPath, basePath);
+                this.files.push(fileDesc);
+            }
+        }
+    }
+    /**
+     * Разбивает файл на чанки
+     */
+    chunksFromFile(file, chunks) {
+        let index = 0;
+        for (let start = 0; start < file.size; start += this.chunkSize) {
+            const end = Math.min(start + this.chunkSize, file.size);
+            chunks.push(new ChunkInfo(file.path, start, end, file.hash, index));
+            index++;
+        }
+    }
+    /**
+     * Группирует чанки в батчи для оптимизации загрузки
+     * Суммарный размер данных в батче не превышает chunkSize
+     */
+    batchChunks(chunks) {
+        const batches = [];
+        let currentBatch = [];
+        let currentSize = 0;
+        for (const chunk of chunks) {
+            const chunkSize = chunk.chunkEnd - chunk.chunkStart;
+            // Если батч переполнится — закрываем его
+            if (currentSize + chunkSize > this.chunkSize && currentBatch.length > 0) {
+                batches.push(currentBatch);
+                currentBatch = [];
+                currentSize = 0;
+            }
+            currentBatch.push(chunk);
+            currentSize += chunkSize;
+        }
+        if (currentBatch.length > 0) {
+            batches.push(currentBatch);
+        }
+        return batches;
+    }
+    /**
+     * Загружает батч чанков одним запросом
+     * @returns размер загруженных данных в байтах
+     */
+    async uploadBatch(batch) {
+        const statements = [];
+        let totalSize = 0;
+        for (const chunk of batch) {
+            const size = chunk.chunkEnd - chunk.chunkStart;
+            const buffer = Buffer.alloc(size);
+            const fd = await fs.promises.open(chunk.path, 'r');
+            await fd.read(buffer, 0, size, chunk.chunkStart);
+            await fd.close();
+            const encoded = buffer.toString('base64');
+            const serverPath = `${this.chunkPath1}${chunk.hash}${this.chunkPath2}_${chunk.index}`;
+            statements.push(`PutFileData('${serverPath}', Base64Decode('${encoded}'))`);
+            totalSize += size;
+        }
+        await this.evaluator.eval(statements.join('\n'));
+        return totalSize;
+    }
+}
+exports.WshcmUploader = WshcmUploader;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@boristype/bt-cli",
+  "version": "0.1.0-alpha.0",
+  "description": "This tool compiles TypeScript into valid SP-XML JavaScript (also known as BorisScript), ensuring full compliance with the specific constraints and APIs of the WebSoft HCM platform.",
+  "main": "./build/index.js",
+  "bin": {
+    "btc": "./build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md"
+  ],
+  "author": "punkhomov",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BorisType/BorisType.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BorisType/BorisType/issues"
+  },
+  "homepage": "https://github.com/BorisType/BorisType#readme",
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/archiver": "^7.0.0",
+    "archiver": "^7.0.1",
+    "chalk": "^5.6.0",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.1",
+    "fast-xml-parser": "^5.3.3",
+    "typescript": "^5.9.2",
+    "@boristype/ws-client": "^0.1.0-alpha.0",
+    "@boristype/bt-ir": "^0.1.0-alpha.0",
+    "@boristype/ws-version": "^0.1.0-alpha.0"
+  },
+  "peerDependencies": {
+    "@boristype/runtime": "^0.1.0-alpha.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}