@tachybase/plugin-database-clean 1.6.2

package/dist/server/resourcers/database-clean.js

@@ -0,0 +1,303 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var database_clean_exports = {};
+__export(database_clean_exports, {
+  default: () => database_clean_default
+});
+module.exports = __toCommonJS(database_clean_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+var import_server = require("@tego/server");
+var import_constants = require("../constants");
+var import_database_service = require("../services/database-service");
+var import_filtered_backup_service = require("../services/filtered-backup-service");
+var import_lock = require("../utils/lock");
+var database_clean_default = {
+  name: "databaseClean",
+  actions: {
+    /**
+     * 获取表列表
+     */
+    async list(ctx, next) {
+      const { page = import_server.DEFAULT_PAGE, pageSize = import_server.DEFAULT_PER_PAGE, sort } = ctx.action.params;
+      const service = new import_database_service.DatabaseService(ctx.tego);
+      const tables = await service.getWhitelistTables();
+      tables.sort((a, b) => {
+        const aTime = a.updatedAt || a.createdAt;
+        const bTime = b.updatedAt || b.createdAt;
+        if (!aTime && !bTime) return 0;
+        if (!aTime) return 1;
+        if (!bTime) return -1;
+        return bTime.getTime() - aTime.getTime();
+      });
+      const count = tables.length;
+      const start = (Number(page) - 1) * Number(pageSize);
+      const end = start + Number(pageSize);
+      const rows = tables.slice(start, end);
+      ctx.body = {
+        count,
+        rows,
+        page: Number(page),
+        pageSize: Number(pageSize),
+        totalPage: Math.ceil(count / Number(pageSize))
+      };
+      await next();
+    },
+    /**
+     * 获取表信息
+     */
+    async get(ctx, next) {
+      const { filterByTk } = ctx.action.params;
+      if (!filterByTk) {
+        ctx.throw(400, "Table name is required");
+        return;
+      }
+      const collection = ctx.tego.db.getCollection(filterByTk);
+      if (!collection) {
+        ctx.throw(404, `Collection ${filterByTk} not found`);
+        return;
+      }
+      if (!import_constants.WHITELIST_TABLES.includes(filterByTk)) {
+        ctx.throw(403, `Collection ${filterByTk} is not in whitelist`);
+        return;
+      }
+      const service = new import_database_service.DatabaseService(ctx.tego);
+      const tableInfo = await service.getTableInfo(filterByTk);
+      const rawAttributes = collection.model.rawAttributes || {};
+      const hasCreatedAt = collection.hasField("createdAt") || "createdAt" in rawAttributes;
+      const hasUpdatedAt = collection.hasField("updatedAt") || "updatedAt" in rawAttributes;
+      let minId = null;
+      let maxId = null;
+      if (tableInfo.rowCount > 0) {
+        const idRange = await service.getIdRange(filterByTk);
+        minId = idRange.minId;
+        maxId = idRange.maxId;
+      }
+      ctx.body = {
+        ...tableInfo,
+        hasCreatedAt,
+        hasUpdatedAt,
+        minId,
+        maxId
+      };
+      await next();
+    },
+    /**
+     * 获取表数据
+     */
+    async data(ctx, next) {
+      const { filterByTk, page = import_server.DEFAULT_PAGE, pageSize = import_server.DEFAULT_PER_PAGE, filter, sort } = ctx.action.params;
+      if (!filterByTk) {
+        ctx.throw(400, "Table name is required");
+        return;
+      }
+      const collection = ctx.tego.db.getCollection(filterByTk);
+      if (!collection) {
+        ctx.throw(404, `Collection ${filterByTk} not found`);
+        return;
+      }
+      if (!import_constants.WHITELIST_TABLES.includes(filterByTk)) {
+        ctx.throw(403, `Collection ${filterByTk} is not in whitelist`);
+        return;
+      }
+      const repository = ctx.tego.db.getRepository(filterByTk);
+      const limit = Number(pageSize);
+      const offset = (Number(page) - 1) * limit;
+      let sortFields = [];
+      if (sort) {
+        sortFields = Array.isArray(sort) ? sort : [sort];
+      } else {
+        if (collection.hasField("updatedAt")) {
+          sortFields.push("-updatedAt");
+        }
+        if (collection.hasField("createdAt")) {
+          sortFields.push("-createdAt");
+        }
+        if (sortFields.length === 0) {
+          const primaryKey = collection.model.primaryKeyAttribute || "id";
+          sortFields.push(`-${primaryKey}`);
+        }
+      }
+      const [rows, count] = await repository.findAndCount({
+        filter: filter || {},
+        limit,
+        offset,
+        sort: sortFields
+      });
+      let filteredMinId = null;
+      let filteredMaxId = null;
+      if (count > 0) {
+        const primaryKey = collection.model.primaryKeyAttribute || "id";
+        const minResult = await repository.findOne({
+          filter: filter || {},
+          sort: [primaryKey],
+          fields: [primaryKey]
+        });
+        const maxResult = await repository.findOne({
+          filter: filter || {},
+          sort: [`-${primaryKey}`],
+          fields: [primaryKey]
+        });
+        if (minResult && maxResult) {
+          filteredMinId = minResult[primaryKey];
+          filteredMaxId = maxResult[primaryKey];
+        }
+      }
+      ctx.body = {
+        count,
+        rows,
+        page: Number(page),
+        pageSize: Number(pageSize),
+        totalPage: Math.ceil(count / limit),
+        filteredMinId,
+        filteredMaxId
+      };
+      await next();
+    },
+    /**
+     * 备份数据
+     */
+    async backup(ctx, next) {
+      const { collectionName, filter } = ctx.action.params.values;
+      if (!collectionName) {
+        ctx.throw(400, "Collection name is required");
+        return;
+      }
+      const collection = ctx.tego.db.getCollection(collectionName);
+      if (!collection) {
+        ctx.throw(404, `Collection ${collectionName} not found`);
+        return;
+      }
+      if (!import_constants.WHITELIST_TABLES.includes(collectionName)) {
+        ctx.throw(403, `Collection ${collectionName} is not in whitelist`);
+        return;
+      }
+      const lock = new import_lock.DatabaseCleanLock(ctx.tego);
+      const locked = await lock.acquire(collectionName);
+      if (!locked) {
+        ctx.throw(409, `Collection ${collectionName} is being processed`);
+        return;
+      }
+      try {
+        const backupService = new import_filtered_backup_service.FilteredBackupService(ctx.tego);
+        const result = await backupService.backupCollection({
+          collectionName,
+          filter,
+          appName: ctx.tego.name
+        });
+        ctx.body = {
+          fileName: result.fileName,
+          filePath: result.filePath,
+          status: "success"
+        };
+      } catch (error) {
+        ctx.throw(500, `Backup failed: ${error.message}`);
+      } finally {
+        await lock.release(collectionName);
+      }
+      await next();
+    },
+    /**
+     * 清理数据
+     */
+    async clean(ctx, next) {
+      const { collectionName, filter, vacuumFull } = ctx.action.params.values;
+      if (!collectionName) {
+        ctx.throw(400, "Collection name is required");
+        return;
+      }
+      const collection = ctx.tego.db.getCollection(collectionName);
+      if (!collection) {
+        ctx.throw(404, `Collection ${collectionName} not found`);
+        return;
+      }
+      if (!import_constants.WHITELIST_TABLES.includes(collectionName)) {
+        ctx.throw(403, `Collection ${collectionName} is not in whitelist`);
+        return;
+      }
+      const lock = new import_lock.DatabaseCleanLock(ctx.tego);
+      const locked = await lock.acquire(collectionName);
+      if (!locked) {
+        ctx.throw(409, `Collection ${collectionName} is being processed`);
+        return;
+      }
+      try {
+        const cleanService = new import_database_service.DatabaseService(ctx.tego);
+        const result = await cleanService.cleanData({
+          collectionName,
+          filter
+        });
+        await cleanService.vacuum(collectionName, vacuumFull);
+        ctx.body = {
+          deletedCount: result.deletedCount,
+          vacuumFull: !!vacuumFull,
+          status: "success"
+        };
+      } catch (error) {
+        ctx.throw(500, `Clean failed: ${error.message}`);
+      } finally {
+        await lock.release(collectionName);
+      }
+      await next();
+    },
+    /**
+     * 下载备份文件
+     */
+    async download(ctx, next) {
+      const { filterByTk } = ctx.action.params;
+      if (!filterByTk) {
+        ctx.throw(400, "File name is required");
+        return;
+      }
+      const storageDir = import_node_path.default.resolve(
+        process.env.TEGO_RUNTIME_HOME || process.cwd(),
+        "storage",
+        "backups",
+        ctx.tego.name !== "main" ? ctx.tego.name : ""
+      );
+      const filePath = import_node_path.default.resolve(storageDir, filterByTk);
+      try {
+        await import_promises.default.access(filePath);
+      } catch {
+        ctx.throw(404, `Backup file ${filterByTk} not found`);
+        return;
+      }
+      if (!filterByTk.startsWith("db-clean_")) {
+        ctx.throw(403, "Invalid backup file");
+        return;
+      }
+      const stats = import_node_fs.default.statSync(filePath);
+      ctx.set("Content-Length", stats.size.toString());
+      ctx.set("Content-Type", "application/zip");
+      ctx.attachment(filterByTk);
+      ctx.body = import_node_fs.default.createReadStream(filePath);
+      await next();
+    }
+  }
+};

package/dist/server/services/database-service.d.ts

@@ -0,0 +1,46 @@
+import { Application } from '@tego/server';
+export interface TableInfo {
+    name: string;
+    origin: string;
+    size: number;
+    rowCount: number;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+}
+export interface CleanOptions {
+    collectionName: string;
+    filter?: any;
+}
+export declare class DatabaseService {
+    private app;
+    private adapter;
+    constructor(app: Application);
+    /**
+     * 获取白名单中的表列表
+     */
+    getWhitelistTables(): Promise<TableInfo[]>;
+    /**
+     * 获取单个表的信息
+     */
+    getTableInfo(collectionName: string): Promise<TableInfo>;
+    /**
+     * 获取表的 ID 范围
+     */
+    getIdRange(collectionName: string): Promise<{
+        minId: number | null;
+        maxId: number | null;
+    }>;
+    /**
+     * 清理符合筛选条件的数据
+     * 注意：清理操作使用通用的 repository.destroy，不依赖特定数据库
+     */
+    cleanData(options: CleanOptions): Promise<{
+        deletedCount: number;
+    }>;
+    /**
+     * 执行 VACUUM 操作以释放磁盘空间
+     * @param collectionName 集合名称
+     * @param full 是否使用 VACUUM FULL（会锁表但真正释放空间）
+     */
+    vacuum(collectionName: string, full?: boolean): Promise<void>;
+}

package/dist/server/services/database-service.js

@@ -0,0 +1,138 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var database_service_exports = {};
+__export(database_service_exports, {
+  DatabaseService: () => DatabaseService
+});
+module.exports = __toCommonJS(database_service_exports);
+var import_adapters = require("../adapters");
+var import_constants = require("../constants");
+class DatabaseService {
+  constructor(app) {
+    this.app = app;
+    this.adapter = import_adapters.DatabaseAdapterFactory.getAdapter(app);
+  }
+  /**
+   * 获取白名单中的表列表
+   */
+  async getWhitelistTables() {
+    const tables = [];
+    const existingCollections = /* @__PURE__ */ new Set();
+    for (const collection of this.app.db.collections.values()) {
+      if (import_constants.WHITELIST_TABLES.includes(collection.name)) {
+        existingCollections.add(collection.name);
+      }
+    }
+    for (const tableName of import_constants.WHITELIST_TABLES) {
+      if (!existingCollections.has(tableName)) {
+        continue;
+      }
+      const collection = this.app.db.getCollection(tableName);
+      if (!collection) {
+        continue;
+      }
+      try {
+        const tableInfo = await this.getTableInfo(collection.name);
+        tables.push(tableInfo);
+      } catch (error) {
+        this.app.logger.warn(`Failed to get info for table ${tableName}:`, error);
+      }
+    }
+    return tables;
+  }
+  /**
+   * 获取单个表的信息
+   */
+  async getTableInfo(collectionName) {
+    const collection = this.app.db.getCollection(collectionName);
+    if (!collection) {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+    if (!import_constants.WHITELIST_TABLES.includes(collectionName)) {
+      throw new Error(`Collection ${collectionName} is not in whitelist`);
+    }
+    const sizeInfo = await this.adapter.getTableSize(collection);
+    const size = sizeInfo.totalSize;
+    const rowCount = await this.adapter.getRowCount(collection);
+    let createdAt = null;
+    let updatedAt = null;
+    if (rowCount > 0) {
+      const rawAttributes = collection.model.rawAttributes || {};
+      const hasCreatedAt = collection.hasField("createdAt") || "createdAt" in rawAttributes;
+      const hasUpdatedAt = collection.hasField("updatedAt") || "updatedAt" in rawAttributes;
+      const timeRange = await this.adapter.getTimeRange(collection, hasCreatedAt, hasUpdatedAt);
+      createdAt = timeRange.minCreatedAt;
+      updatedAt = timeRange.maxUpdatedAt || timeRange.maxCreatedAt;
+    }
+    return {
+      name: collectionName,
+      origin: collection.origin || "unknown",
+      size,
+      rowCount,
+      createdAt,
+      updatedAt
+    };
+  }
+  /**
+   * 获取表的 ID 范围
+   */
+  async getIdRange(collectionName) {
+    const collection = this.app.db.getCollection(collectionName);
+    if (!collection) {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+    return await this.adapter.getIdRange(collection);
+  }
+  /**
+   * 清理符合筛选条件的数据
+   * 注意：清理操作使用通用的 repository.destroy，不依赖特定数据库
+   */
+  async cleanData(options) {
+    const { collectionName, filter } = options;
+    const collection = this.app.db.getCollection(collectionName);
+    if (!collection) {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+    if (!import_constants.WHITELIST_TABLES.includes(collectionName)) {
+      throw new Error(`Collection ${collectionName} is not in whitelist`);
+    }
+    const repository = this.app.db.getRepository(collectionName);
+    const result = await repository.destroy({
+      filter: filter || {}
+    });
+    return {
+      deletedCount: result
+    };
+  }
+  /**
+   * 执行 VACUUM 操作以释放磁盘空间
+   * @param collectionName 集合名称
+   * @param full 是否使用 VACUUM FULL（会锁表但真正释放空间）
+   */
+  async vacuum(collectionName, full = false) {
+    const collection = this.app.db.getCollection(collectionName);
+    if (!collection) {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+    await this.adapter.vacuum(collection, full);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseService
+});

package/dist/server/services/filtered-backup-service.d.ts

@@ -0,0 +1,40 @@
+import { Application } from '@tego/server';
+export interface BackupFilter {
+    createdAt?: {
+        $gte?: string;
+        $lte?: string;
+    };
+    updatedAt?: {
+        $gte?: string;
+        $lte?: string;
+    };
+    id?: {
+        $gte?: number;
+        $lte?: number;
+    };
+}
+export interface BackupOptions {
+    collectionName: string;
+    filter?: BackupFilter;
+    fileName?: string;
+    appName?: string;
+}
+export declare class FilteredBackupService {
+    private app;
+    private workDir;
+    constructor(app: Application);
+    /**
+     * 生成备份文件名
+     */
+    static generateFileName(collectionName: string, filter?: BackupFilter): string;
+    /**
+     * 备份单个集合的筛选数据
+     */
+    backupCollection(options: BackupOptions): Promise<{
+        fileName: string;
+        filePath: string;
+    }>;
+    private packDumpedDir;
+    private getStorageDir;
+    private clearWorkDir;
+}