@cloudbase/manager-node 4.11.0-alpha.2 → 4.11.0-alpha.4

package/lib/mysql/types/backup.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/mysql/types/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/mysql/types/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);
+__exportStar(require("./account"), exports);
+__exportStar(require("./backup"), exports);

package/lib/storage/index.js

@@ -617,21 +617,17 @@ class StorageService {
             Error
         };
     }
-    /**
-     * 获取文件存储权限
-     * READONLY：所有用户可读，仅创建者和管理员可写
-     * PRIVATE：仅创建者及管理员可读写
-     * ADMINWRITE：所有用户可读，仅管理员可写
-     * ADMINONLY：仅管理员可读写
-     * CUSTOM：自定义安全规则
-     * @returns {Promise<{ acl: AclType, rule?: IStorageAclRule }>}
-     */
-    async getStorageAcl() {
+    async getStorageAcl(options) {
         const { bucket, env } = this.getStorageConfig();
         const res = await this.tcbService.request('DescribeStorageSafeRule', {
             EnvId: env,
             Bucket: bucket
         });
+        // 默认行为：返回简单的 AclType（向后兼容）
+        if (!(options === null || options === void 0 ? void 0 : options.withRule)) {
+            return res.AclTag;
+        }
+        // 带规则模式：返回对象
         const result = { acl: res.AclTag };
         if (res.AclTag === 'CUSTOM' && res.Rule) {
             try {
@@ -730,6 +726,56 @@ class StorageService {
         }
         return fileList;
     }
+    /**
+     * 列出指定目录下的文件和子目录（不递归，只列当前层）
+     * 使用 COS Delimiter 参数实现
+     * @param {string} dirPath 目录路径，空字符串表示根目录
+     * @returns {Promise<{ files: IListFileInfo[], directories: string[] }>}
+     */
+    async listCurrentDirectory(dirPath = '') {
+        const { bucket, region } = this.getStorageConfig();
+        const cos = this.getCos();
+        const getBucket = util_1.default.promisify(cos.getBucket).bind(cos);
+        // 确保目录路径以 / 结尾（除了根目录）
+        let prefix = dirPath;
+        if (prefix && !prefix.endsWith('/')) {
+            prefix = prefix + '/';
+        }
+        const files = [];
+        const directories = [];
+        let marker = '';
+        let isTruncated = true;
+        while (isTruncated) {
+            const res = await getBucket({
+                Bucket: bucket,
+                Region: region,
+                Prefix: prefix,
+                Delimiter: '/', // 关键：使用分隔符，不递归子目录
+                MaxKeys: 1000,
+                Marker: marker
+            });
+            // 文件列表（不包含子目录）
+            if (res.Contents) {
+                // 过滤掉目录本身（Key === prefix 的情况）
+                const fileItems = res.Contents.filter((item) => item.Key !== prefix);
+                files.push(...fileItems);
+            }
+            // 子目录列表（CommonPrefixes）
+            if (res.CommonPrefixes) {
+                const dirs = res.CommonPrefixes.map((item) => item.Prefix);
+                directories.push(...dirs);
+            }
+            isTruncated = res.IsTruncated === 'true' || res.IsTruncated === true;
+            if (isTruncated) {
+                // 防止无限循环：如果 IsTruncated 为 true 但 NextMarker 为空，则跳出循环
+                if (!res.NextMarker) {
+                    break;
+                }
+                marker = res.NextMarker;
+            }
+        }
+        return { files, directories };
+    }
     /**
      * 遍历本地文件夹
      * 忽略不包含 dir 路径，即如果 ignore 匹配 dir，dir 也不会被忽略
@@ -862,6 +908,356 @@ class StorageService {
         });
         return res;
     }
+    // ===== 复制/移动/搜索方法 =====
+    /**
+     * 复制单个文件
+     * @param options.sourcePath 源文件路径（云端路径，如 images/a.jpg）
+     * @param options.destPath 目标文件路径（云端路径，如 backup/a.jpg）
+     * @param options.force 是否强制覆盖
+     * @param options.skipExisting 是否跳过已存在的文件
+     * @returns 复制结果
+     */
+    async copyFile(options) {
+        const { sourcePath, destPath, force = false, skipExisting = false } = options;
+        const { bucket, region } = this.getStorageConfig();
+        // 1. 检查源文件是否存在
+        let sourceFileInfo;
+        try {
+            sourceFileInfo = await this.getFileInfo(sourcePath);
+        }
+        catch (e) {
+            if (e.statusCode === 404 || e.code === 'NoSuchKey') {
+                throw new error_1.CloudBaseError(`源文件不存在: ${sourcePath}`, {
+                    code: 'SOURCE_NOT_FOUND'
+                });
+            }
+            throw e;
+        }
+        // 2. 检查目标文件是否存在
+        let destExists = false;
+        let destFileInfo = null;
+        try {
+            destFileInfo = await this.getFileInfo(destPath);
+            destExists = true;
+        }
+        catch (e) {
+            if (e.statusCode !== 404 && e.code !== 'NoSuchKey') {
+                throw e;
+            }
+        }
+        if (destExists) {
+            if (skipExisting) {
+                return {
+                    success: true,
+                    sourcePath,
+                    destPath,
+                    status: 'skipped',
+                    // COS SDK 返回的 Size 单位已经是 bytes
+                    size: (destFileInfo === null || destFileInfo === void 0 ? void 0 : destFileInfo.Size) ? parseInt(destFileInfo.Size, 10) : undefined
+                };
+            }
+            if (!force) {
+                throw new error_1.CloudBaseError(`目标文件已存在: ${destPath}`, {
+                    code: 'DEST_EXISTS'
+                });
+            }
+        }
+        // 3. 执行复制（使用 COS SDK putObjectCopy）
+        const cos = this.getCos();
+        const putObjectCopy = util_1.default.promisify(cos.putObjectCopy).bind(cos);
+        // CopySource 格式: {bucket}.cos.{region}.myqcloud.com/{key}
+        // 注意: key 需要 URL 编码
+        // cspell:ignore myqcloud
+        const copySource = `${bucket}.cos.${region}.myqcloud.com/${encodeURIComponent(sourcePath)}`;
+        const res = await putObjectCopy({
+            Bucket: bucket,
+            Region: region,
+            Key: destPath,
+            CopySource: copySource
+        });
+        if (res.statusCode !== 200) {
+            throw new error_1.CloudBaseError(`复制文件失败：${JSON.stringify(res)}`);
+        }
+        // 4. 返回复制结果
+        return {
+            success: true,
+            sourcePath,
+            destPath,
+            status: 'copied',
+            // COS SDK 返回的 Size 单位已经是 bytes
+            size: (sourceFileInfo === null || sourceFileInfo === void 0 ? void 0 : sourceFileInfo.Size) ? parseInt(sourceFileInfo.Size, 10) : undefined
+        };
+    }
+    /**
+     * 复制目录
+     * 遍历源目录下的所有文件，并行复制到目标目录
+     * @param options.sourcePath 源目录路径
+     * @param options.destPath 目标目录路径
+     * @param options.include 包含模式（glob 格式）
+     * @param options.exclude 排除模式（glob 格式）
+     * @param options.force 是否强制覆盖
+     * @param options.skipExisting 是否跳过已存在的文件
+     * @param options.parallel 并发数，默认 20
+     * @param options.onProgress 进度回调
+     * @returns 复制结果数组
+     */
+    async copyDirectory(options) {
+        const { sourcePath, destPath, include, exclude, force = false, skipExisting = false, parallel = 20, onProgress } = options;
+        // 1. 列出源目录所有文件
+        const sourceKey = this.getCloudKey(sourcePath);
+        const files = await this.walkCloudDir(sourceKey);
+        if (!files || !files.length) {
+            // 进一步检查目录是否存在（通过 listCurrentDirectory）
+            // 如果目录存在但为空，listCurrentDirectory 会返回空的 files 和 directories
+            // 如果目录不存在，COS 仍然返回成功但结果为空
+            // 这里通过检查源路径的父目录来判断
+            const parentPath = sourcePath.includes('/')
+                ? sourcePath.substring(0, sourcePath.lastIndexOf('/'))
+                : '';
+            const { directories } = await this.listCurrentDirectory(parentPath);
+            const dirExists = directories.some(d => {
+                const normalizedDir = d.endsWith('/') ? d.slice(0, -1) : d;
+                return normalizedDir === sourceKey.slice(0, -1) || normalizedDir === sourcePath;
+            });
+            if (dirExists) {
+                throw new error_1.CloudBaseError(`源目录为空: ${sourcePath}`, {
+                    code: 'SOURCE_EMPTY'
+                });
+            }
+            else {
+                throw new error_1.CloudBaseError(`源目录不存在: ${sourcePath}`, {
+                    code: 'SOURCE_NOT_FOUND'
+                });
+            }
+        }
+        // 2. 过滤文件（使用 micromatch）
+        let filteredFiles = files.filter(f => !f.Key.endsWith('/')); // 排除目录
+        if (include) {
+            const patterns = Array.isArray(include) ? include : [include];
+            filteredFiles = filteredFiles.filter(f => {
+                const relativePath = f.Key.replace(sourceKey, '');
+                return micromatch_1.default.isMatch(relativePath, patterns);
+            });
+        }
+        if (exclude) {
+            const patterns = Array.isArray(exclude) ? exclude : [exclude];
+            filteredFiles = filteredFiles.filter(f => {
+                const relativePath = f.Key.replace(sourceKey, '');
+                return !micromatch_1.default.isMatch(relativePath, patterns);
+            });
+        }
+        if (!filteredFiles.length) {
+            return [];
+        }
+        // 3. 构建复制任务
+        let copiedCount = 0;
+        let skippedCount = 0;
+        const destKey = destPath.endsWith('/') ? destPath : destPath + '/';
+        const tasks = filteredFiles.map(file => async () => {
+            const relativePath = file.Key.replace(sourceKey, '');
+            const targetPath = destKey + relativePath;
+            try {
+                const result = await this.copyFile({
+                    sourcePath: file.Key,
+                    destPath: targetPath,
+                    force,
+                    skipExisting
+                });
+                if (result.status === 'copied')
+                    copiedCount++;
+                if (result.status === 'skipped')
+                    skippedCount++;
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    copied: copiedCount,
+                    skipped: skippedCount,
+                    total: filteredFiles.length,
+                    currentFile: file.Key
+                });
+                return result;
+            }
+            catch (e) {
+                return {
+                    success: false,
+                    sourcePath: file.Key,
+                    destPath: targetPath,
+                    status: 'failed',
+                    error: e.message
+                };
+            }
+        });
+        // 4. 使用 AsyncTaskParallelController 并发执行
+        const controller = new parallel_1.AsyncTaskParallelController(parallel, 50);
+        controller.loadTasks(tasks);
+        return controller.run();
+    }
+    /**
+     * 移动文件（复制后删除源文件）
+     * 注意：移动操作是「复制 + 删除」的两步操作，如果删除失败，文件会同时存在于源和目标位置
+     * @param options 与 copyFile 相同的选项
+     * @returns 移动结果，如果删除源文件失败会在 error 字段说明
+     */
+    async moveFile(options) {
+        const result = await this.copyFile(options);
+        if (result.status === 'copied') {
+            // 复制成功后使用 COS SDK 直接删除源文件
+            const { bucket, region } = this.getStorageConfig();
+            const cos = this.getCos();
+            const deleteObject = util_1.default.promisify(cos.deleteObject).bind(cos);
+            // 注意：文件路径不需要用 getCloudKey()，getCloudKey() 会在末尾加 /，用于目录
+            const sourceKey = options.sourcePath;
+            try {
+                await deleteObject({
+                    Bucket: bucket,
+                    Region: region,
+                    Key: sourceKey
+                });
+            }
+            catch (e) {
+                // 删除失败时，文件已复制成功，返回结果但附带错误信息
+                return Object.assign(Object.assign({}, result), { error: `文件已复制但删除源文件失败: ${e.message}` });
+            }
+        }
+        return result;
+    }
+    /**
+     * 移动目录（复制后删除源目录）
+     * 注意：移动操作是「复制 + 删除」的两步操作，如果部分删除失败，文件会同时存在于源和目标位置
+     * @param options 与 copyDirectory 相同的选项
+     * @returns 移动结果数组，删除失败的文件会在对应结果的 error 字段说明
+     */
+    async moveDirectory(options) {
+        const results = await this.copyDirectory(options);
+        // 只删除复制成功的文件
+        const copiedFiles = results
+            .filter(r => r.status === 'copied')
+            .map(r => r.sourcePath);
+        if (copiedFiles.length > 0) {
+            // 使用 COS SDK deleteMultipleObject 批量删除源文件
+            const { bucket, region } = this.getStorageConfig();
+            const cos = this.getCos();
+            const deleteMultipleObject = util_1.default.promisify(cos.deleteMultipleObject).bind(cos);
+            // COS deleteMultipleObject 单次最多删除 1000 个对象，这里按 500 分片
+            const files = [...copiedFiles];
+            const total = Math.ceil(files.length / 500);
+            const sliceGroup = [];
+            for (let i = 0; i < total; i++) {
+                sliceGroup.push(files.splice(0, 500));
+            }
+            // 收集删除失败的文件
+            const deleteFailedFiles = new Map();
+            const tasks = sliceGroup.map(async (group) => {
+                try {
+                    const res = await deleteMultipleObject({
+                        Bucket: bucket,
+                        Region: region,
+                        Objects: group.map(file => ({ Key: file }))
+                    });
+                    // 检查部分删除失败的情况
+                    if (res.Error && res.Error.length > 0) {
+                        for (const err of res.Error) {
+                            deleteFailedFiles.set(err.Key, err.Message || 'Unknown error');
+                        }
+                    }
+                }
+                catch (e) {
+                    // 整批删除失败，记录所有文件
+                    for (const file of group) {
+                        deleteFailedFiles.set(file, e.message);
+                    }
+                }
+            });
+            await Promise.all(tasks);
+            // 将删除失败信息附加到对应的结果中
+            if (deleteFailedFiles.size > 0) {
+                for (const result of results) {
+                    if (result.status === 'copied' && deleteFailedFiles.has(result.sourcePath)) {
+                        result.error = `文件已复制但删除源文件失败: ${deleteFailedFiles.get(result.sourcePath)}`;
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * 搜索文件和目录（只搜索当前目录，不递归）
+     * @param options.pattern 搜索模式（支持 glob 或正则表达式）
+     * @param options.path 搜索目录路径（不指定则搜索根目录）
+     * @param options.isRegex 是否为正则表达式模式
+     * @param options.fileType 文件类型过滤
+     * @param options.limit 限制返回数量，默认 100
+     * @param options.includeDetails 是否包含详细信息（大小、修改时间）
+     * @returns 搜索结果数组（包含文件和目录）
+     */
+    async searchFiles(options) {
+        const { pattern, path: searchPath = '', isRegex = false, fileType, limit = 100, includeDetails = true } = options;
+        // 构建匹配器
+        let matcher;
+        if (isRegex) {
+            // 正则表达式模式
+            // 安全检查：限制正则表达式长度和复杂度，防止 ReDoS 攻击
+            const MAX_REGEX_LENGTH = 200;
+            if (pattern.length > MAX_REGEX_LENGTH) {
+                throw new error_1.CloudBaseError(`正则表达式过长，最大允许 ${MAX_REGEX_LENGTH} 字符`, {
+                    code: 'PATTERN_TOO_LONG'
+                });
+            }
+            // 检测潜在的危险模式（嵌套量词）
+            const dangerousPatterns = /(\+|\*|\{[0-9,]+\})\s*(\+|\*|\?|\{[0-9,]+\})/;
+            if (dangerousPatterns.test(pattern)) {
+                throw new error_1.CloudBaseError('正则表达式包含潜在的危险模式（嵌套量词），可能导致性能问题', {
+                    code: 'PATTERN_DANGEROUS'
+                });
+            }
+            try {
+                const regex = new RegExp(pattern);
+                matcher = (name) => regex.test(name);
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError(`正则表达式语法错误: ${e.message}`, {
+                    code: 'PATTERN_SYNTAX_ERROR'
+                });
+            }
+        }
+        else {
+            // Glob 模式 - 使用 micromatch
+            matcher = (name) => micromatch_1.default.isMatch(name, pattern);
+        }
+        const results = [];
+        // 只列出当前目录（使用 Delimiter，不递归）
+        const { files, directories } = await this.listCurrentDirectory(searchPath);
+        // 处理目录
+        for (const dir of directories) {
+            // 获取目录名（去掉末尾的 / 和前缀）
+            const dirPath = dir.endsWith('/') ? dir.slice(0, -1) : dir;
+            const dirName = dirPath.split('/').pop() || dirPath;
+            if (matcher(dirName)) {
+                results.push({
+                    key: dir,
+                    type: 'directory'
+                });
+            }
+        }
+        // 处理文件
+        let matchedFiles = files.filter(f => {
+            const basename = f.Key.split('/').pop() || f.Key;
+            return matcher(basename);
+        });
+        // 文件类型过滤
+        if (fileType) {
+            const ext = fileType.startsWith('.') ? fileType : `.${fileType}`;
+            matchedFiles = matchedFiles.filter(f => f.Key.toLowerCase().endsWith(ext.toLowerCase()));
+        }
+        for (const f of matchedFiles) {
+            results.push({
+                key: f.Key,
+                type: 'file',
+                size: includeDetails ? parseInt(f.Size, 10) : undefined,
+                lastModified: includeDetails ? new Date(f.LastModified).toISOString() : undefined
+            });
+        }
+        // 限制总数量
+        return results.slice(0, limit);
+    }
     /**
      * 获取 COS 配置
      */
@@ -1074,9 +1470,27 @@ __decorate([
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "walkCloudDirCustom", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "listCurrentDirectory", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "putBucketWebsite", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "getBucket", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "copyFile", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "copyDirectory", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "moveFile", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "moveDirectory", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "searchFiles", null);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "4.11.0-alpha.2",
+    "version": "4.11.0-alpha.4",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/types/database/index.d.ts

@@ -15,6 +15,38 @@ interface IMgoQueryInfo {
     MgoLimit?: number;
     MgoOffset?: number;
 }
+/** 待执行命令参数 */
+interface IMgoCommandParam {
+    /** 表名 */
+    TableName: string;
+    /** 操作类型：UPDATE / QUERY / INSERT / DELETE / COMMAND */
+    CommandType: string;
+    /** 待执行命令（JSON 字符串） */
+    Command: string;
+}
+/** MongoDB 连接器配置 */
+interface IMongoConnector {
+    /** 连接器实例 ID */
+    InstanceId?: string;
+    /** MongoDB 数据库名 */
+    DatabaseName?: string;
+}
+/** RunCommands 请求参数 */
+interface IRunCommandsOptions {
+    /** 待执行命令列表 */
+    MgoCommands: IMgoCommandParam[];
+    /** 实例 ID，如 tnt-xxxx。不传则自动使用当前环境的数据库实例 ID */
+    Tag?: string;
+    /** 环境 ID。不传则自动使用当前环境 ID */
+    EnvId?: string;
+    /** Mongo 连接器实例信息 */
+    MongoConnector?: IMongoConnector;
+}
+/** RunCommands 返回结果 */
+interface IRunCommandsResult extends IResponseInfo {
+    /** 返回结果，每个元素是一个 JSON 字符串 */
+    Data: string[];
+}
 interface ICollectionInfo extends IResponseInfo {
     Collections: Array<TableInfo>;
     Pager: Pager;
@@ -38,6 +70,52 @@ interface IDatabaseMigrateQueryInfo extends IResponseInfo {
 interface IDatabaseImportAndExportInfo extends IResponseInfo {
     JobId: number;
 }
+/** 回档表格名称映射信息 */
+interface IModifyTableNamesInfo {
+    /** 原表名 */
+    OldTableName: string;
+    /** 新表名 */
+    NewTableName: string;
+}
+/** 回档任务信息 */
+interface IRestoreTask {
+    /** 恢复任务ID */
+    TaskId?: string;
+    /** 任务状态 */
+    Status?: string;
+    /** 任务创建时间 */
+    Time?: string;
+    /** 环境ID */
+    EnvId?: string;
+    /** 恢复类型 */
+    Type?: string;
+}
+/** 任意时间回档范围 */
+interface IRestoreTableTimeRange {
+    [key: string]: any;
+}
+/** 获取可回档表格返回结果 */
+interface IDescribeRestoreTablesResult extends IResponseInfo {
+    /** 可回档表格列表 */
+    Tables: string[];
+}
+/** 获取回档任务返回结果 */
+interface IDescribeRestoreTaskResult extends IResponseInfo {
+    /** 回档任务列表 */
+    Tasks: IRestoreTask[];
+}
+/** 获取可回档时间返回结果 */
+interface IDescribeRestoreTimeResult extends IResponseInfo {
+    /** 可回档时间列表 */
+    RestoreTimes: string[];
+    /** 任意时间回档列表 */
+    RestoreTimeRanges: IRestoreTableTimeRange[];
+}
+/** 实例表格回档返回结果 */
+interface IRestoreTCBTablesResult extends IResponseInfo {
+    /** 流程ID */
+    FlowId: number;
+}
 export declare class DatabaseService {
     static tcbServiceVersion: IServiceVersion;
     static flexdbServiceVersion: IServiceVersion;
@@ -62,5 +140,39 @@ export declare class DatabaseService {
     migrateStatus(jobId: number): Promise<IDatabaseMigrateQueryInfo>;
     import(collectionName: string, file: any, options: any): Promise<IDatabaseImportAndExportInfo>;
     export(collectionName: string, file: any, options: any): Promise<IDatabaseImportAndExportInfo>;
+    /**
+     * 获取可回档表格
+     * @param time 回档时间，格式 YYYY-MM-DD HH:MM:SS
+     * @param filters 过滤器（可选）
+     * @param instanceId 实例ID（可选，不传则自动使用当前环境的数据库实例 ID）
+     * @returns 可回档表格列表
+     */
+    describeRestoreTables(time: string, filters?: string[], instanceId?: string): Promise<IDescribeRestoreTablesResult>;
+    /**
+     * 获取回档任务
+     * @param instanceId 实例ID（可选，不传则自动使用当前环境的数据库实例 ID）
+     * @returns 回档任务列表
+     */
+    describeRestoreTask(instanceId?: string): Promise<IDescribeRestoreTaskResult>;
+    /**
+     * 获取可回档时间
+     * @param instanceId 实例ID（可选，不传则自动使用当前环境的数据库实例 ID）
+     * @returns 可回档时间列表及任意时间回档列表
+     */
+    describeRestoreTime(instanceId?: string): Promise<IDescribeRestoreTimeResult>;
+    /**
+     * 实例表格回档
+     * @param time 回档时间，格式 YYYY-MM-DD HH:MM:SS
+     * @param modifyTableNamesInfo 回档表格信息（原表名 → 新表名映射）
+     * @param instanceId 实例ID（可选，不传则自动使用当前环境的数据库实例 ID）
+     * @returns 流程ID
+     */
+    restoreTables(time: string, modifyTableNamesInfo: IModifyTableNamesInfo[], instanceId?: string): Promise<IRestoreTCBTablesResult>;
+    /**
+     * 执行文档型数据库命令
+     * @param options 命令参数（命令列表、可选的 Tag/EnvId/MongoConnector）
+     * @returns 执行结果，Data 为 JSON 字符串数组
+     */
+    runCommands(options: IRunCommandsOptions): Promise<IRunCommandsResult>;
 }
 export {};

package/types/environment.d.ts

@@ -11,6 +11,7 @@ import { ThirdService } from './third';
 import { AccessService } from './access';
 import { UserService } from './user';
 import { CloudBaseRunService } from './cloudBaseRun';
+import { MysqlService } from './mysql';
 import { EnvInfo } from './interfaces';
 export declare class Environment {
     inited: boolean;
@@ -29,6 +30,7 @@ export declare class Environment {
     private accessService;
     private userService;
     private cloudBaseRunService;
+    private mysqlService;
     constructor(context: CloudBaseContext, envId: string);
     lazyInit(): Promise<any>;
     getEnvId(): string;
@@ -44,6 +46,7 @@ export declare class Environment {
     getAccessService(): AccessService;
     getUserService(): UserService;
     getCloudBaseRunService(): CloudBaseRunService;
+    getMysqlService(): MysqlService;
     getCommonService(serviceType: string, serviceVersion: any): CommonService;
     getServicesEnvInfo(): Promise<any>;
     getAuthConfig(): {

package/types/index.d.ts

@@ -12,6 +12,7 @@ import { ThirdService } from './third';
 import { AccessService } from './access';
 import { UserService } from './user';
 import { CloudBaseRunService } from './cloudBaseRun';
+import { MysqlService } from './mysql';
 import { DocsService } from './docs';
 interface CloudBaseConfig {
     secretId?: string;
@@ -49,6 +50,7 @@ declare class CloudBase {
     get database(): DatabaseService;
     get hosting(): HostingService;
     get access(): AccessService;
+    get mysql(): MysqlService;
     get cloudApp(): CloudBaseRunService;
     commonService(service?: string, version?: string): CommonService;
     get env(): EnvService;