wok-server 0.7.2 → 0.8.0

package/README.md

@@ -15,15 +15,6 @@
 - **数据库** — MySQL、MongoDB
 - **其他** — 周期任务
 
-## 为什么选择 Wok Server
-
-- 函数式为主，少量面向对象，学习成本低
-- 保持克制，不引入代理、装饰器等增强技术
-- 轻量封装，兼容第三方 HTTP 生态
-- 完整的类型定义，配合 IDE 智能补全，开发效率高
-- 注释即文档，方法及参数均有详细说明
-- 内置国际化支持，可扩展多语言
-
 ## 快速开始
 
 ```bash
@@ -61,12 +52,108 @@ npx skills add peaktai/wok-server --all
 npx skills add https://gitee.com/tai/wok-server.git --all
 ```
 
-## FAQ
+## 为什么选择 Wok Server
+
+核心原则只有一个：**实用主义**。每一个设计决策，都是在"简单透明"和"功能强大"之间选择了前者——不是因为做不到，而是因为**选择不做**。
+
+### 纯对象配置，没有魔法
+
+实体和数据库的映射就是一个普通对象，不需要学习装饰器、反射或任何框架特有的语法：
+
+```ts
+export interface User {
+  id: string
+  name: string
+}
+
+export const tableUser: Table<User> = {
+  tableName: 'user',
+  id: 'id',
+  columns: ['name']
+}
+```
+
+所有信息一目了然，出问题直接看这一个文件。不需要理解隐式的元数据系统，AI 和人类都容易理解。
+
+### 显式优于隐式
+
+读写分离、数据源选择都由代码显式决定，不会出现"写后读到旧数据"的意外：
+
+```ts
+const masterMgr = getMysqlManager('master')
+const slaveMgr = getMysqlManager('slave')
+
+// 写操作显式走主库
+await masterMgr.insert(tableUser, { id: '001', nickname: 'jack' })
+
+// 读操作显式走从库
+const user = await slaveMgr.findById(tableUser, '001')
+```
+
+代码多一点，但完全可控。调试时清晰知道 SQL 发到了哪里。
+
+### 纯 SQL 迁移，零学习成本
+
+迁移就是按顺序执行的 SQL 文件，框架只负责"按顺序执行 + 版本记录"：
+
+```sql
+-- 001_init.sql
+CREATE TABLE `user` (
+  `id` varchar(32) NOT NULL PRIMARY KEY,
+  `nickname` varchar(100) DEFAULT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 002_add_age.sql
+ALTER TABLE `user` ADD COLUMN `age` int DEFAULT NULL AFTER `nickname`;
+```
+
+会 SQL 就会写迁移，完全透明，DBA 可直接审查，任何数据库特性都能用。
+
+### 统一且直觉的 API
+
+查询 API 遵循统一模式，学会一个，其他都是同一模式：
+
+| 操作 | 单条 | 列表 | 分页 | 部分字段 |
+|------|------|------|------|---------|
+| 查询 | `findFirst` | `find` | `paginate` | `findSelect` / `paginateSelect` |
+
+条件查询用链式方法，不需要记忆操作符类名：
+
+```ts
+await mgr.findFirst(tableUser, c =>
+  c.like('name', 'Bob%').gt('age', 18).between('score', 60, 100)
+)
+```
+
+方法名就是自然语言，不需要 import 任何东西。
+
+### 简单直接的类型系统
+
+类型是约束工具，不是智力游戏：
+
+```ts
+// findById 返回 User | undefined
+const user = await mgr.findById(tableUser, '001')
+
+// insert 参数自动处理可选字段和元组表达式
+await mgr.insert(tableUser, { id: '001', name: 'Bob' })
+
+// findSelect 返回 Pick<User, K>
+const list = await mgr.findSelect(tableUser, ['id', 'name'])
+```
+
+没有复杂的条件类型、映射类型体操或 `DeepPartial` 等抽象概念。用简单的泛型参数实现类型安全，配合 IDE 智能补全，开发效率高。
+
+### 函数式为主，学习成本低
 
-### 为什么内置 MySQL 和 MongoDB 驱动？
+以函数式风格为主，少量面向对象，保持克制，不引入代理、装饰器等增强技术。轻量封装，兼容第三方 HTTP 生态。注释即文档，方法及参数均有详细说明。内置国际化支持，可扩展多语言。
 
-mysql2 和 mongodb 驱动已直接集成，安装一个包即可使用，避免多个包的版本冲突和维护成本。对于后端应用，包体积的增加影响有限。
+### 对 AI 编程友好
 
-### 为什么 WebSocket、文件上传等功能需要自行引入？
+wok-server 的简单透明设计，在 AI 辅助编程时代有天然优势：
 
-这些功能基于 Node.js 原生 `http` 模块，天然兼容框架，无需专门适配。由用户按需引入第三方库，可以充分利用社区生态，同时减少框架的维护负担。
+- 纯对象配置 = AI 容易理解上下文，不需要理解框架特有的元数据系统
+- 显式调用 = AI 从代码本身就能理解意图，不需要追踪隐式的配置
+- 纯 SQL 迁移 = AI 直接生成可执行代码，没有生成步骤、没有交互、没有黑盒转换
+- 无关联 ORM 自动加载 = AI 写 join 时必须显式写 SQL，性能问题更容易从 SQL 本身识别
+- 统一的元组表达式 = AI 学习一次模式，到处复用，不容易混淆

package/dist/http-client/index.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getJson = exports.postJson = exports.doRequest = void 0;
 const http_1 = require("http");
 const https_1 = require("https");
-const url_1 = require("url");
 /**
  * 发送 http 请求.
  * @param opts
@@ -11,7 +10,7 @@ const url_1 = require("url");
  */
 function doRequest(opts) {
     return new Promise((resolve, reject) => {
-        const url = new url_1.URL(opts.url);
+        const url = new URL(opts.url);
         // query
         if (opts.query) {
             Object.entries(opts.query).forEach(entry => {

package/dist/lock/index.js

@@ -5,6 +5,9 @@ const crypto_1 = require("crypto");
 /**
  * 锁管理器，主要用于将不确定的顺序且有冲突的异步操作顺序执行，
  * 防止异步流程庞大穿插执行造成的数据混乱和错误，常见于请求的处理。
+ *
+ * ⚠️ 注意：这是一个本地内存锁，仅在当前进程内生效，不支持分布式场景。
+ * 如果需要在多进程、多服务器环境下使用，请使用 Redis 等分布式锁方案。
  */
 class ServerLockManager {
     /**
@@ -13,7 +16,7 @@ class ServerLockManager {
     lockMap = new Map();
     constructor() {
         // 定期清理，将过期的信息移除，防止内存泄漏
-        setTimeout(() => {
+        setInterval(() => {
             const keysToBeDeleted = [];
             const now = Date.now();
             for (const entry of this.lockMap.entries()) {
@@ -95,7 +98,7 @@ class ServerLockManager {
      */
     sleep() {
         return new Promise((resolve, reject) => {
-            setTimeout(resolve, 0);
+            setTimeout(resolve, 50);
         });
     }
 }

package/dist/mvc/config.js

@@ -13,7 +13,8 @@ function getConfig() {
         corsAllowOrigin: '*',
         tlsEnable: false,
         tlsKey: '',
-        tlsCert: ''
+        tlsCert: '',
+        maxBodySize: 10 * 1024 * 1024
     }, 'SERVER', {
         port: [(0, validation_1.notNull)(), (0, validation_1.min)(80), (0, validation_1.max)(65535)],
         timeout: [(0, validation_1.notNull)(), (0, validation_1.min)(1000), (0, validation_1.max)(600000)],
@@ -21,7 +22,8 @@ function getConfig() {
         corsAllowOrigin: [(0, validation_1.notBlank)()],
         corsAllowHeaders: [(0, validation_1.notBlank)()],
         corsAllowMethods: [(0, validation_1.notBlank)()],
-        tlsEnable: [(0, validation_1.notNull)()]
+        tlsEnable: [(0, validation_1.notNull)()],
+        maxBodySize: [(0, validation_1.notNull)(), (0, validation_1.min)(0)]
     });
 }
 exports.getConfig = getConfig;

package/dist/mvc/exchange.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerExchange = void 0;
+exports.ServerExchange = exports.PayloadTooLargeError = void 0;
+const config_1 = require("./config");
 const query_1 = require("./query");
 const render_1 = require("./render");
 const text_1 = require("./render/text");
+/**
+ * 请求体超出大小限制时抛出的错误
+ */
+class PayloadTooLargeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PayloadTooLargeError';
+    }
+}
+exports.PayloadTooLargeError = PayloadTooLargeError;
 /**
  * 服务的数据交换对象.
  */
@@ -15,7 +26,11 @@ class ServerExchange {
         this.request = request;
         this.response = response;
     }
-    bodyBuffer() {
+    /**
+     * 读取请求体为 Buffer
+     * @param maxSize 最大字节数，不传则使用全局配置 SERVER_MAX_BODY_SIZE，设为 0 不限制
+     */
+    bodyBuffer(maxSize) {
         if (this.#bufferPromise) {
             return this.#bufferPromise;
         }
@@ -23,21 +38,31 @@ class ServerExchange {
             if (this.request.readableEnded) {
                 throw new Error('Request has ended!');
             }
+            const limit = maxSize ?? (0, config_1.getConfig)().maxBodySize;
             let body = [];
+            let received = 0;
             this.request
                 .resume()
                 .on('error', reject)
-                .on('data', chunk => body.push(chunk))
+                .on('data', (chunk) => {
+                received += chunk.length;
+                if (limit > 0 && received > limit) {
+                    this.request.pause();
+                    reject(new PayloadTooLargeError(`Request body exceeds ${limit} bytes`));
+                    return;
+                }
+                body.push(chunk);
+            })
                 .on('end', () => resolve(Buffer.concat(body)));
         });
         return this.#bufferPromise;
     }
-    async bodyText() {
-        const buffer = await this.bodyBuffer();
+    async bodyText(maxSize) {
+        const buffer = await this.bodyBuffer(maxSize);
         return buffer.toString('utf-8');
     }
-    async bodyJson() {
-        const buffer = await this.bodyBuffer();
+    async bodyJson(maxSize) {
+        const buffer = await this.bodyBuffer(maxSize);
         const bodyText = buffer.toString('utf-8');
         if (!bodyText || !bodyText.trim()) {
             return {};

package/dist/mvc/index.js

@@ -37,7 +37,7 @@ async function stopWebServer() {
     if (!SERVER) {
         return;
     }
-    SERVER.stop();
+    await SERVER.stop();
     SERVER = undefined;
 }
 exports.stopWebServer = stopWebServer;

package/dist/mvc/server.js

@@ -71,8 +71,12 @@ class WokServer {
                 this.handleRequest(req, res).catch(error => {
                     (0, log_1.getLogger)().error(`Handle request failed：${req.url}`, error);
                     if (!res.writableEnded) {
-                        // 响应 500
-                        (0, render_1.renderError)(res, error.message ? error.message : 'Internal Server Error', 500);
+                        if (error instanceof exchange_1.PayloadTooLargeError) {
+                            (0, render_1.renderError)(res, error.message, 413);
+                        }
+                        else {
+                            (0, render_1.renderError)(res, error.message ? error.message : 'Internal Server Error', 500);
+                        }
                     }
                 });
             });
@@ -90,8 +94,12 @@ class WokServer {
                 this.handleRequest(req, res).catch(error => {
                     (0, log_1.getLogger)().error(`Handle request failed：${req.url}`, error);
                     if (!res.writableEnded) {
-                        // 响应 500
-                        (0, render_1.renderError)(res, error.message ? error.message : 'Internal Server Error', 500);
+                        if (error instanceof exchange_1.PayloadTooLargeError) {
+                            (0, render_1.renderError)(res, error.message, 413);
+                        }
+                        else {
+                            (0, render_1.renderError)(res, error.message ? error.message : 'Internal Server Error', 500);
+                        }
                     }
                 });
             });

package/dist/mysql/manager/base.js

@@ -102,9 +102,6 @@ class BaseMysqlManager {
      * @returns
      */
     async deleteOne(table, criteria) {
-        if (!Object.keys(criteria).length) {
-            throw new exception_1.MysqlException('criteria cannot be empty !');
-        }
         const res = await this.queryWithConnection(conn => (0, ops_1.deleteMany)(this.opts.config, conn, {
             table,
             criteria,
@@ -133,7 +130,7 @@ class BaseMysqlManager {
     /**
      * 插入数据. 不支持自增加长id,id必须提前生成，请使用 uuid.
      * @param table 表信息
-     * @param data 数据，数据必须是 T 的实例, T 必须是已配置的实体类类型，否则无法完成操作
+     * @param data 完整实体数据，必填字段必须存在
      * @returns 插入后的数据
      */
     insert(table, data) {
@@ -142,7 +139,7 @@ class BaseMysqlManager {
     /**
      * 批量插入
      * @param table 表
-     * @param list 要插入的数据列表
+     * @param list 要插入的完整实体数据列表
      */
     insertMany(table, list) {
         return this.queryWithConnection(conn => (0, ops_1.insertMany)(this.opts.config, conn, table, list));
@@ -151,7 +148,7 @@ class BaseMysqlManager {
      * Upsert 单条数据
      * 如果主键冲突则更新，否则插入
      * @param table 表信息
-     * @param data 数据
+     * @param data 完整实体数据
      * @returns
      */
     upsert(table, data) {
@@ -161,7 +158,7 @@ class BaseMysqlManager {
      * Upsert 多条数据
      * 如果主键冲突则更新，否则插入
      * @param table 表
-     * @param list 要插入的数据列表
+     * @param list 要插入的完整实体数据列表
      * @returns 影响的行数
      */
     upsertMany(table, list) {
@@ -171,7 +168,7 @@ class BaseMysqlManager {
      * Upsert 单条数据（支持自定义更新器）
      * 如果主键冲突则按自定义逻辑更新，否则插入
      * @param table 表信息
-     * @param data 插入的数据
+     * @param data 完整实体数据
      * @param updater 冲突时的更新器
      * @returns
      */

package/dist/mysql/manager/ops/delete.js

@@ -51,7 +51,8 @@ async function deleteMany(config, connection, opts) {
     }
     // 数量限制
     if (opts.limit) {
-        sql += ` limit ${opts.limit} `;
+        sql += ` limit ? `;
+        values.push(opts.limit);
     }
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     return res.affectedRows;

package/dist/mysql/manager/ops/find.js

@@ -58,9 +58,11 @@ async function find(config, conn, opts) {
     }
     // 数量限制
     if (opts.limit) {
-        sql += ` limit ${opts.limit} `;
+        sql += ` limit ? `;
+        values.push(opts.limit);
         if (opts.offset) {
-            sql += ` offset ${opts.offset}`;
+            sql += ` offset ?`;
+            values.push(opts.offset);
         }
     }
     const res = await (0, utils_1.promiseQuery)(config, conn, sql, values);
@@ -90,9 +92,11 @@ async function findSelect(config, conn, opts) {
     }
     // 数量限制
     if (opts.limit) {
-        sql += ` limit ${opts.limit} `;
+        sql += ` limit ? `;
+        values.push(opts.limit);
         if (opts.offset) {
-            sql += ` offset ${opts.offset}`;
+            sql += ` offset ?`;
+            values.push(opts.offset);
         }
     }
     const res = await (0, utils_1.promiseQuery)(config, conn, sql, values);

package/dist/mysql/manager/ops/insert.js

@@ -1,28 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insertMany = exports.insert = exports.processInsertValue = void 0;
+exports.insertMany = exports.insert = void 0;
 const exception_1 = require("../../exception");
 const utils_1 = require("../utils");
 const utils_2 = require("./utils");
-/**
- * 处理 insert value，支持表达式
- * @returns { frag: SQL 片段, values: 参数值数组 }
- */
-function processInsertValue(value) {
-    if (Array.isArray(value)) {
-        if (value[0] === 'now') {
-            return { frag: 'NOW()', values: [] };
-        }
-        if (value[0] === 'set') {
-            return { frag: '?', values: [(0, utils_2.processColumnValue)(value[1])] };
-        }
-        if (value[0] === 'expr') {
-            return { frag: value[1], values: value[2] || [] };
-        }
-    }
-    return { frag: '?', values: [(0, utils_2.processColumnValue)(value)] };
-}
-exports.processInsertValue = processInsertValue;
 /**
  * 为表插入数据
  * @param connection
@@ -49,23 +30,22 @@ async function insert(config, connection, table, data) {
         columnsSet.add(table.updatedDate.column);
     }
     const columns = Array.from(columnsSet);
-    // 构建 sql，逐列处理以支持表达式
-    const fragList = [];
-    const insertValues = [];
-    for (const col of columns) {
-        const { frag, values: vs } = processInsertValue(data[col]);
-        fragList.push(frag);
-        insertValues.push(...vs);
-    }
-    const sql = `insert into ??(${columns.map(() => '??').join(',')}) values(${fragList.join(',')})`;
-    const values = [table.tableName, ...columns, ...insertValues];
+    // 构建 sql
+    const sql = `insert into ??(${columns.map(() => '??').join(',')}) values(${columns.map(() => '?').join(',')})`;
+    const values = [
+        table.tableName,
+        ...columns,
+        ...columns.map(col => (0, utils_2.processColumnValue)(data[col]))
+    ];
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const packet = res;
     if (packet.affectedRows !== 1) {
         throw new exception_1.MysqlException(`Insert failed，table：${table.tableName}，primary key: ${data[table.id]}`);
     }
     // 自动生成的id处理
-    if (packet.insertId && (data[table.id] === undefined || data[table.id] === null)) {
+    if (packet.insertId &&
+        (data[table.id] === undefined || data[table.id] === null)) {
+        ;
         data[table.id] = packet.insertId;
     }
     return data;
@@ -106,21 +86,16 @@ async function insertMany(config, connection, table, list) {
         if (idx > 0) {
             sql += ',';
         }
-        const fragList = [];
-        const rowValues = [];
         if (table.createdDate) {
+            ;
             data[table.createdDate.column] = createdData;
         }
         if (table.updatedDate) {
+            ;
             data[table.updatedDate.column] = updatedDate;
         }
-        for (const col of columns) {
-            const { frag, values: vs } = processInsertValue(data[col]);
-            fragList.push(frag);
-            rowValues.push(...vs);
-        }
-        sql += `(${fragList.join(',')})`;
-        values.push(...rowValues);
+        sql += `(${columns.map(() => '?').join(',')})`;
+        values.push(...columns.map(col => (0, utils_2.processColumnValue)(data[col])));
     });
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const rsh = res;

package/dist/mysql/manager/ops/update.js

@@ -213,7 +213,8 @@ async function updateMany(config, connection, opts) {
     }
     // 数量限制
     if (opts.limit) {
-        sql += ` limit ${opts.limit} `;
+        sql += ` limit ? `;
+        values.push(opts.limit);
     }
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const packet = res;

package/dist/mysql/manager/ops/upsert.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upsertWithUpdater = exports.upsertMany = exports.upsert = void 0;
 const utils_1 = require("../utils");
-const insert_1 = require("./insert");
+const utils_2 = require("./utils");
 const update_1 = require("./update");
 /**
  * Upsert 单条数据
@@ -33,26 +33,19 @@ async function upsert(config, connection, table, data) {
     }
     const columns = Array.from(columnsSet);
     // 构建 insert values
-    const fragList = [];
-    const insertValues = [];
-    for (const col of columns) {
-        const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
-        fragList.push(frag);
-        insertValues.push(...vs);
-    }
-    const insertSql = `insert into ??(${columns.map(() => '??').join(',')}) values(${fragList.join(',')})`;
+    const insertSql = `insert into ??(${columns.map(() => '??').join(',')}) values(${columns.map(() => '?').join(',')})`;
+    const insertValues = [table.tableName, ...columns, ...columns.map(col => (0, utils_2.processColumnValue)(data[col]))];
     // 构建 on duplicate key update（排除 id）
     const updateColumns = columns.filter(col => col !== table.id);
     const updateFragments = [];
     const updateValues = [];
     for (const col of updateColumns) {
-        const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
-        updateFragments.push(`?? = ${frag}`);
-        updateValues.push(col, ...vs);
+        updateFragments.push(`?? = ?`);
+        updateValues.push(col, (0, utils_2.processColumnValue)(data[col]));
     }
     const updateSql = ` on duplicate key update ${updateFragments.join(',')}`;
     const sql = insertSql + updateSql;
-    const values = [table.tableName, ...columns, ...insertValues, ...updateValues];
+    const values = [...insertValues, ...updateValues];
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const packet = res;
     if (packet.insertId && (data[table.id] === undefined || data[table.id] === null)) {
@@ -98,21 +91,14 @@ async function upsertMany(config, connection, table, list) {
         if (idx > 0) {
             sql += ',';
         }
-        const fragList = [];
-        const rowValues = [];
         if (table.createdDate) {
             data[table.createdDate.column] = createdData;
         }
         if (table.updatedDate) {
             data[table.updatedDate.column] = updatedDate;
         }
-        for (const col of columns) {
-            const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
-            fragList.push(frag);
-            rowValues.push(...vs);
-        }
-        sql += `(${fragList.join(',')})`;
-        values.push(...rowValues);
+        sql += `(${columns.map(() => '?').join(',')})`;
+        values.push(...columns.map(col => (0, utils_2.processColumnValue)(data[col])));
     });
     const updateColumns = columns.filter(col => col !== table.id);
     sql += ` on duplicate key update ${updateColumns.map(() => '?? = values(??)').join(',')}`;
@@ -156,18 +142,12 @@ async function upsertWithUpdater(config, connection, table, data, updater) {
     }
     const columns = Array.from(columnsSet);
     // 构建 insert values
-    const fragList = [];
-    const insertValues = [];
-    for (const col of columns) {
-        const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
-        fragList.push(frag);
-        insertValues.push(...vs);
-    }
-    const insertSql = `insert into ??(${columns.map(() => '??').join(',')}) values(${fragList.join(',')})`;
+    const insertSql = `insert into ??(${columns.map(() => '??').join(',')}) values(${columns.map(() => '?').join(',')})`;
+    const insertValues = [table.tableName, ...columns, ...columns.map(col => (0, utils_2.processColumnValue)(data[col]))];
     const convertRes = (0, update_1.updatorToSql)(table, updater);
     const updateSql = ` on duplicate key update ${convertRes.sql}`;
     const sql = insertSql + updateSql;
-    const values = [table.tableName, ...columns, ...insertValues, ...convertRes.values];
+    const values = [...insertValues, ...convertRes.values];
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const packet = res;
     if (packet.insertId && (data[table.id] === undefined || data[table.id] === null)) {

package/dist/mysql/migration.js

@@ -30,14 +30,21 @@ async function migrate(config, conn) {
         if (!file.endsWith('.sql')) {
             throw new Error(`版本文件名没有以 .sql 为后缀：${file}`);
         }
-        const version = parseInt(file.substring(0, file.length - 4));
-        if (isNaN(version)) {
-            throw new Error(`Version file is not named with a number：${file}`);
+        const match = file.match(/^(\d+)/);
+        if (!match) {
+            throw new Error(`Version file name must start with a number：${file}`);
         }
+        const version = parseInt(match[1]);
         versions.push({ version, filePath });
     }
     // 排序，判定顺序
     versions.sort((o1, o2) => o1.version - o2.version);
+    // 去重校验
+    for (let i = 1; i < versions.length; i++) {
+        if (versions[i].version === versions[i - 1].version) {
+            throw new Error(`Duplicate version number ${versions[i].version} in files: ${versions[i - 1].filePath} and ${versions[i].filePath}`);
+        }
+    }
     for (let i = 0; i < versions.length; i++) {
         const version = versions[i];
         if (version.version !== i + 1) {