plugin-data-source-mssql 2.0.10 → 2.0.12

package/dist/server/data-source/MssqlIntrospector.js

@@ -30,6 +30,9 @@ __export(MssqlIntrospector_exports, {
 });
 module.exports = __toCommonJS(MssqlIntrospector_exports);
 var import_data_source_manager = require("@nocobase/data-source-manager");
+var import_sequelize = require("sequelize");
+var import_sql_quote = require("../security/sql-quote");
+var import_mssql_bulk_introspection = require("./mssql-bulk-introspection");
 const mssqlFieldTypeMap = {
   // String types
   varchar: ["string", "uuid", "nanoid"],
@@ -70,6 +73,14 @@ const mssqlFieldTypeMap = {
 class MssqlIntrospector extends import_data_source_manager.DatabaseIntrospector {
   /** Cache of { tableName → pk column names[] } loaded by preloadAllPrimaryKeys() */
   primaryKeyCache = null;
+  /**
+   * Cache of { tableName → describeTable-compatible column map } loaded in ONE
+   * schema-wide query by preloadAllColumns(). When present, getTableColumnsInfo()
+   * serves column metadata from memory instead of a per-table describeTable() call,
+   * eliminating the N+1 introspection round trips. null = not preloaded (fall back
+   * to per-table describeTable).
+   */
+  columnsCache = null;
   /**
    * Cache of { tableName → Set<columnName> } for columns with Full-Text Search indexes.
    * null = not yet loaded; empty Map = loaded but no FTS columns found (or FTS not installed).
@@ -110,11 +121,35 @@ class MssqlIntrospector extends import_data_source_manager.DatabaseIntrospector
       this.primaryKeyCache = null;
     }
   }
+  /**
+   * Load column metadata for ALL tables in the schema in ONE bulk query and cache it.
+   * This is the anti-N+1 path: instead of Sequelize's describeTable() issuing a
+   * per-table `sp_columns`-style round trip, the whole catalog is fetched once and
+   * grouped in memory. Call before the parallel introspection loop; getTableColumnsInfo()
+   * then serves from `columnsCache` and falls back to describeTable() only if the
+   * preload failed.
+   */
+  async preloadAllColumns(schemaName = "dbo") {
+    try {
+      const rows = await this.db.sequelize.query((0, import_mssql_bulk_introspection.buildBulkColumnsSql)(schemaName), {
+        type: "SELECT"
+      });
+      this.columnsCache = (0, import_mssql_bulk_introspection.groupColumnsByTable)(rows);
+      this.db.logger.debug(`[MSSQL] Preloaded column metadata for ${this.columnsCache.size} tables`);
+    } catch (err) {
+      this.db.logger.warn("[MSSQL] Failed to bulk-preload columns, will fall back to per-table describeTable:", err);
+      this.columnsCache = null;
+    }
+  }
   /**
    * Load Full-Text Search index info for ALL columns in one query and cache the result.
    * Call this once before queries run so that text operators can route to CONTAINS() vs LIKE.
    */
-  async preloadFTSIndexedColumns(schemaName = "dbo") {
+  async preloadFTSIndexedColumns(schemaName = "dbo", tableNames) {
+    if (tableNames && !tableNames.length) {
+      this.ftsColumnCache = /* @__PURE__ */ new Map();
+      return;
+    }
     try {
       const sql = `
         SELECT t.name AS table_name, c.name AS column_name
@@ -123,6 +158,7 @@ class MssqlIntrospector extends import_data_source_manager.DatabaseIntrospector
         INNER JOIN sys.tables t ON fic.object_id = t.object_id
         INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
         WHERE s.name = ${this.db.sequelize.escape(schemaName)}
+        ${tableNames ? `AND t.name IN (${tableNames.map((name) => this.db.sequelize.escape(name)).join(", ")})` : ""}
       `;
       const rows = await this.db.sequelize.query(sql, { type: "SELECT" });
       const cache = /* @__PURE__ */ new Map();
@@ -147,31 +183,25 @@ class MssqlIntrospector extends import_data_source_manager.DatabaseIntrospector
     if (!this.ftsColumnCache) return false;
     return ((_a = this.ftsColumnCache.get(tableName)) == null ? void 0 : _a.has(columnName)) ?? false;
   }
-  /**
-   * Override getTableList to handle MSSQL's object-format table names.
-   * MSSQL's showAllTables() may return {tableName: 'Name', schema: 'dbo'} objects.
-   */
+  /** List only tables in the configured schema; names are relative to that schema. */
   async getTableList() {
-    const tables = await this.db.sequelize.getQueryInterface().showAllTables();
-    return tables.map((table) => {
-      if (typeof table === "string") {
-        return table;
-      }
-      if (table && typeof table === "object") {
-        return table.tableName || table.name || String(Object.values(table).find((v) => typeof v === "string"));
-      }
-      return String(table);
-    });
+    const rows = await this.db.sequelize.query(
+      "SELECT t.name AS name FROM sys.tables t INNER JOIN sys.schemas s ON s.schema_id = t.schema_id WHERE s.name = :schema",
+      { replacements: { schema: this.db.options.schema || "dbo" }, type: import_sequelize.QueryTypes.SELECT }
+    );
+    return rows.map((row) => row.name);
   }
   /**
    * Override getTableColumnsInfo to handle MSSQL-specific column metadata.
    * Adds PK detection fallback via sys.indexes query.
    */
   async getTableColumnsInfo(tableInfo2) {
-    const columns = await this.db.sequelize.getQueryInterface().describeTable(tableInfo2);
+    var _a;
+    const tableName = typeof tableInfo2 === "string" ? tableInfo2 : tableInfo2.tableName;
+    const cached = (_a = this.columnsCache) == null ? void 0 : _a.get(tableName);
+    const columns = cached ? Object.fromEntries(Object.entries(cached).map(([k, v]) => [k, { ...v }])) : await this.db.sequelize.getQueryInterface().describeTable(tableInfo2);
     let hasPrimaryKey = Object.values(columns).some((col) => col.primaryKey);
     if (!hasPrimaryKey) {
-      const tableName = typeof tableInfo2 === "string" ? tableInfo2 : tableInfo2.tableName;
       const schemaName = typeof tableInfo2 === "string" ? "dbo" : tableInfo2.schema || "dbo";
       let pkColumns;
       if (this.primaryKeyCache !== null) {
@@ -220,8 +250,12 @@ class MssqlIntrospector extends import_data_source_manager.DatabaseIntrospector
    */
   async getTableConstraints(tableInfo2) {
     try {
-      const tableName = typeof tableInfo2 === "string" ? tableInfo2 : tableInfo2.tableName;
-      return await this.db.sequelize.getQueryInterface().showIndex(tableName);
+      const name = typeof tableInfo2 === "string" ? tableInfo2 : tableInfo2.tableName;
+      const schema = typeof tableInfo2 === "string" ? this.db.options.schema || "dbo" : tableInfo2.schema || "dbo";
+      return await this.db.sequelize.query("EXEC sys.sp_helpindex @objname = :name", {
+        replacements: { name: `${(0, import_sql_quote.quoteIdentifier)(schema)}.${(0, import_sql_quote.quoteIdentifier)(name)}` },
+        type: import_sequelize.QueryTypes.SHOWINDEXES
+      });
     } catch (err) {
       this.db.logger.warn(
         `[MSSQL] Failed to get indexes for ${typeof tableInfo2 === "string" ? tableInfo2 : tableInfo2.tableName}:`,
@@ -230,24 +264,13 @@ class MssqlIntrospector extends import_data_source_manager.DatabaseIntrospector
       return [];
     }
   }
-  /**
-   * Override to handle MSSQL auto-increment detection.
-   * MSSQL uses IDENTITY columns, not serial/nextval sequences.
-   */
-  columnAttribute(columnsInfo, columnName, indexes) {
-    const attr = super.columnAttribute(columnsInfo, columnName, indexes);
-    return attr;
-  }
-  /**
-   * Override getViewList — MSSQL view listing support
-   */
+  /** List only views in the configured schema; the generic MSSQL query interface has no listViews. */
   async getViewList() {
-    try {
-      const views = await this.db.queryInterface.listViews();
-      return views.map((view) => typeof view === "string" ? view : view.name || String(view));
-    } catch {
-      return [];
-    }
+    const rows = await this.db.sequelize.query(
+      "SELECT v.name AS name FROM sys.views v INNER JOIN sys.schemas s ON s.schema_id = v.schema_id WHERE s.name = :schema",
+      { replacements: { schema: this.db.options.schema || "dbo" }, type: import_sequelize.QueryTypes.SELECT }
+    );
+    return rows.map((row) => row.name);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/data-source/MssqlRepository.js

@@ -35,10 +35,12 @@ class MssqlRepository extends import_database.Repository {
   mssqlCursorBuilder;
   constructor(collection) {
     super(collection);
+    const modelOptions = this.model.options;
     this.mssqlCursorBuilder = new import_MssqlSmartCursorBuilder.MssqlSmartCursorBuilder(
       this.database.sequelize,
       this.model.tableName,
-      collection
+      collection,
+      modelOptions == null ? void 0 : modelOptions.schema
     );
   }
   /**

package/dist/server/data-source/MssqlSmartCursorBuilder.js

@@ -41,6 +41,7 @@ __export(MssqlSmartCursorBuilder_exports, {
 module.exports = __toCommonJS(MssqlSmartCursorBuilder_exports);
 var import_sequelize = require("sequelize");
 var import_lodash = __toESM(require("lodash"));
+var import_sql_quote = require("../security/sql-quote");
 class SingleColumnCursorStrategy {
   columnName;
   constructor(columnName) {
@@ -106,10 +107,21 @@ class MssqlSmartCursorBuilder {
   sequelize;
   tableName;
   collection;
-  constructor(sequelize, tableName, collection) {
+  schema;
+  constructor(sequelize, tableName, collection, schema) {
     this.sequelize = sequelize;
     this.tableName = tableName;
     this.collection = collection;
+    this.schema = schema;
+  }
+  /**
+   * Fully schema-qualified, bracket-quoted object name for OBJECT_ID(). NocoBase stores the schema
+   * separately from tableName, so passing a bare tableName makes OBJECT_ID() resolve only the
+   * connection's default schema and silently miss every table living in any other schema.
+   */
+  getQualifiedTableName() {
+    const quotedTable = (0, import_sql_quote.quoteIdentifier)(this.tableName);
+    return this.schema ? `${(0, import_sql_quote.quoteIdentifier)(this.schema)}.${quotedTable}` : quotedTable;
   }
   /**
    * Auto-detect the best cursor strategy based on table structure
@@ -142,7 +154,7 @@ class MssqlSmartCursorBuilder {
     try {
       const indexRows = await this.sequelize.query(indexInfoSql, {
         type: import_sequelize.QueryTypes.SELECT,
-        replacements: [this.tableName],
+        replacements: [this.getQualifiedTableName()],
         raw: true
       });
       const indexes = /* @__PURE__ */ new Map();
@@ -223,7 +235,9 @@ class MssqlSmartCursorBuilder {
       }
       return this.getFallbackStrategy();
     } catch (error) {
-      console.error("[MssqlSmartCursorBuilder] Error getting index info:", error);
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[MssqlSmartCursorBuilder] Error getting index info: ${message}
+`);
       return this.getFallbackStrategy();
     }
   }
@@ -254,9 +268,10 @@ class MssqlSmartCursorBuilder {
     let isFirst = true;
     options.order = cursorStrategy.buildSort();
     options["parseSort"] = false;
+    const baseWhere = options.where;
     while (hasMoreData) {
       if (!isFirst) {
-        options.where = cursorStrategy.buildWhere(options.where, cursorRecord);
+        options.where = cursorStrategy.buildWhere(baseWhere, cursorRecord);
       }
       if (isFirst) {
         isFirst = false;

package/dist/server/data-source/mssql-bulk-introspection.js

@@ -0,0 +1,100 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 mssql_bulk_introspection_exports = {};
+__export(mssql_bulk_introspection_exports, {
+  buildBulkColumnsSql: () => buildBulkColumnsSql,
+  formatColumnType: () => formatColumnType,
+  groupColumnsByTable: () => groupColumnsByTable
+});
+module.exports = __toCommonJS(mssql_bulk_introspection_exports);
+var import_sql_quote = require("../security/sql-quote");
+function buildBulkColumnsSql(schemaName) {
+  const schema = (0, import_sql_quote.quoteUnicodeStringLiteral)(schemaName);
+  return `
+SELECT
+  o.name AS table_name,
+  c.name AS column_name,
+  t.name AS data_type,
+  c.max_length AS max_length,
+  c.is_nullable AS is_nullable,
+  c.is_identity AS is_identity,
+  d.definition AS default_value,
+  CAST(ep.value AS NVARCHAR(MAX)) AS column_comment
+FROM sys.columns c
+INNER JOIN sys.types t
+  ON c.system_type_id = t.system_type_id AND c.user_type_id = t.user_type_id
+INNER JOIN sys.tables o
+  ON c.object_id = o.object_id
+INNER JOIN sys.schemas u
+  ON u.schema_id = o.schema_id
+LEFT JOIN sys.default_constraints d
+  ON c.default_object_id = d.object_id
+LEFT JOIN sys.extended_properties ep
+  ON ep.major_id = c.object_id AND ep.minor_id = c.column_id AND ep.class = 1 AND ep.name = 'MS_Description'
+WHERE u.name = ${schema}
+  AND o.is_ms_shipped = 0
+ORDER BY o.name, c.column_id
+`;
+}
+function formatColumnType(dataType, maxLength) {
+  const type = dataType.toUpperCase();
+  const isCharOrBinary = /CHAR|BINARY/.test(type);
+  if (!isCharOrBinary) {
+    return type;
+  }
+  if (maxLength === -1) {
+    return `${type}(MAX)`;
+  }
+  const charLength = type.startsWith("N") && !type.includes("BINARY") ? maxLength / 2 : maxLength;
+  return `${type}(${charLength})`;
+}
+function groupColumnsByTable(rows) {
+  const byTable = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let table = byTable.get(row.table_name);
+    if (!table) {
+      table = {};
+      byTable.set(row.table_name, table);
+    }
+    table[row.column_name] = {
+      type: formatColumnType(row.data_type, row.max_length),
+      allowNull: !!row.is_nullable,
+      defaultValue: row.default_value ?? void 0,
+      primaryKey: false,
+      // resolved separately via the PK cache
+      autoIncrement: !!row.is_identity,
+      comment: row.column_comment ?? null
+    };
+  }
+  return byTable;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildBulkColumnsSql,
+  formatColumnType,
+  groupColumnsByTable
+});

package/dist/server/plugin.js

@@ -34,17 +34,279 @@ var import_server = require("@nocobase/server");
 var import_MssqlExternalDataSource = require("./data-source/MssqlExternalDataSource");
 var import_database = require("@nocobase/database");
 var import_mssql_dialect = require("./dialects/mssql-dialect");
+var import_utils = require("@nocobase/utils");
+var import_lodash = require("lodash");
+var import_selection = require("./selection");
 class PluginDataSourceMssqlServer extends import_server.Plugin {
+  selectionSyncs = /* @__PURE__ */ new Map();
   async beforeLoad() {
     import_database.Database.registerDialect(import_mssql_dialect.MssqlDialect);
     this.app.dataSourceManager.factory.register("mssql", import_MssqlExternalDataSource.MssqlExternalDataSource);
   }
-  // No custom load() needed:
-  // - Test connection: core `dataSources:testConnection` dispatches to
-  //   MssqlExternalDataSource.testConnection() via the factory automatically.
-  // - Collection destroy: core `dataSourcesCollections.afterDestroy` hook
-  //   handles in-memory cleanup + cluster sync for all external data sources.
-  // - CRUD: core `plugin-data-source-manager` provides full lifecycle management.
+  async load() {
+    this.app.dataSourceManager.afterAddDataSource((dataSource) => {
+      if (dataSource instanceof import_MssqlExternalDataSource.MssqlExternalDataSource) {
+        this.reconcileSelection(dataSource.name).catch(() => {
+          this.app.log.warn("[MSSQL] Failed to reconcile selected collections after datasource reload");
+        });
+      }
+    });
+    this.app.resourceManager.registerPreActionHandler("dataSources:readTables", async (ctx, next) => {
+      const { dataSourceKey, dbOptions } = ctx.action.params.values || {};
+      if ((dbOptions == null ? void 0 : dbOptions.type) !== "mssql") {
+        await next();
+        return;
+      }
+      const manager = this.app.dataSourceManager;
+      const probe = manager.factory.create("mssql", { name: dataSourceKey, ...dbOptions });
+      const owned = ![...manager.dataSources.values()].includes(probe);
+      let requestFailed = false;
+      let requestError;
+      try {
+        ctx.body = await probe.readTables();
+      } catch (error) {
+        requestFailed = true;
+        requestError = error;
+      } finally {
+        if (owned) {
+          try {
+            await probe.close();
+          } catch (error) {
+            if (requestFailed) {
+              this.app.log.warn("[MSSQL] Failed to close temporary table-list connection");
+            } else {
+              requestFailed = true;
+              requestError = error;
+            }
+          }
+        }
+      }
+      if (requestFailed) throw requestError;
+    });
+    this.app.resourceManager.registerPreActionHandler("dataSources:loadTables", async (ctx, next) => {
+      const { dataSourceKey, tables } = ctx.action.params.values || {};
+      const dataSource = this.app.dataSourceManager.get(dataSourceKey);
+      if (!(dataSource instanceof import_MssqlExternalDataSource.MssqlExternalDataSource)) {
+        await next();
+        return;
+      }
+      if (!Array.isArray(tables) || tables.some((name) => typeof name !== "string" || !name)) {
+        ctx.throw(400, "Invalid table list");
+      }
+      const tableNames = [...new Set(tables)];
+      const row = await this.app.db.getRepository("dataSources").findOne({
+        filterByTk: dataSourceKey
+      });
+      if (!row) ctx.throw(404, "Data source not found");
+      const configuration = (0, import_lodash.cloneDeep)((0, import_lodash.omit)(row.get("options") || {}, "selectedCollections"));
+      const resolvedConfiguration = this.app.environment.renderJsonTemplate(configuration);
+      const activeConfiguration = (0, import_lodash.pick)(dataSource.options, Object.keys(resolvedConfiguration));
+      if (!(0, import_lodash.isEqual)(activeConfiguration, resolvedConfiguration))
+        ctx.throw(409, "Data source changed; retry loading tables");
+      const prepared = await dataSource.prepareTables(tableNames);
+      const selectedMode = await (0, import_selection.withLockedDataSource)(this.app.db, dataSourceKey, async (locked, transaction) => {
+        const options = locked.get("options");
+        if (!(0, import_lodash.isEqual)((0, import_lodash.omit)(options || {}, "selectedCollections"), configuration)) {
+          ctx.throw(409, "Data source changed; retry loading tables");
+        }
+        if ((options == null ? void 0 : options.addAllCollections) !== false || !Array.isArray(options.selectedCollections)) return false;
+        const selectedCollections = [.../* @__PURE__ */ new Set([...options.selectedCollections, ...tableNames])];
+        if (!(0, import_lodash.isEqual)(selectedCollections, options.selectedCollections)) {
+          locked.set("options", { ...options, selectedCollections });
+          await locked.save({ transaction, hooks: false });
+        }
+        return true;
+      });
+      if (selectedMode) {
+        const ready = new Map(tableNames.map((name, index) => [name, prepared[index]]));
+        try {
+          await this.reconcileSelection(dataSourceKey, ready, dataSource, configuration, tableNames);
+        } finally {
+          await this.sendSyncMessage({ type: "selectionChanged", dataSourceKey, refreshTables: tableNames });
+        }
+      } else if (this.app.dataSourceManager.get(dataSourceKey) === dataSource) {
+        const latest = await this.app.db.getRepository("dataSources").findOne({
+          filterByTk: dataSourceKey
+        });
+        const localData = await (latest == null ? void 0 : latest.loadLocalData()) || {};
+        if (this.app.dataSourceManager.get(dataSourceKey) !== dataSource || !(0, import_lodash.isEqual)((0, import_lodash.omit)((latest == null ? void 0 : latest.get("options")) || {}, "selectedCollections"), configuration)) {
+          ctx.throw(409, "Data source changed; retry loading tables");
+        }
+        for (const collection of prepared) {
+          const [merged] = dataSource.mergeWithLoadedCollections([collection], localData);
+          dataSource.collectionManager.defineCollection(merged);
+        }
+      }
+    });
+    this.app.resourceManager.registerPreActionHandler("dataSources.collections:destroy", async (ctx, next) => {
+      const { associatedIndex, filterByTk, filter } = ctx.action.params;
+      const dataSourceKey = ctx.action.sourceId || associatedIndex;
+      const dataSource = this.app.dataSourceManager.get(dataSourceKey);
+      if (!(dataSource instanceof import_MssqlExternalDataSource.MssqlExternalDataSource)) {
+        await next();
+        return;
+      }
+      const current = await this.app.db.getRepository("dataSources").findOne({ filterByTk: dataSourceKey });
+      const currentOptions = current == null ? void 0 : current.get("options");
+      if ((currentOptions == null ? void 0 : currentOptions.addAllCollections) !== false || !Array.isArray(currentOptions.selectedCollections)) {
+        await next();
+        return;
+      }
+      const requested = (Array.isArray(filterByTk) ? filterByTk : [filterByTk]).filter(
+        (name) => typeof name === "string" && name.length > 0
+      );
+      if (filterByTk !== void 0 && filterByTk !== null && requested.length === 0) {
+        ctx.body = true;
+        return;
+      }
+      if (Array.isArray(filterByTk) && requested.length !== filterByTk.length) {
+        ctx.throw(400, "Invalid collection names");
+      }
+      if (!requested.length && !(0, import_utils.isValidFilter)(filter)) {
+        ctx.body = true;
+        return;
+      }
+      const result = await (0, import_selection.withLockedDataSource)(this.app.db, dataSourceKey, async (model, transaction) => {
+        const collections = this.app.db.getRepository("dataSourcesCollections");
+        const hasFilter = (0, import_utils.isValidFilter)(filter);
+        const options = model.get("options");
+        const resolvedConfiguration = this.app.environment.renderJsonTemplate(
+          (0, import_lodash.omit)(options || {}, "selectedCollections")
+        );
+        if (!(0, import_lodash.isEqual)((0, import_lodash.pick)(dataSource.options, Object.keys(resolvedConfiguration)), resolvedConfiguration)) {
+          ctx.throw(409, "Data source changed; retry deleting collections");
+        }
+        let names = requested;
+        if (hasFilter || !requested.length) {
+          const records = await collections.find({
+            filter: { $and: [{ dataSourceKey }, ...hasFilter ? [filter] : []] },
+            transaction,
+            context: ctx
+          });
+          const matching = records.map((record) => String(record.get("name")));
+          names = requested.length ? requested.filter((name) => matching.includes(name)) : matching;
+        }
+        const tableNames = names.flatMap((name) => {
+          var _a;
+          const physical = (_a = dataSource.collectionManager.getCollection(name)) == null ? void 0 : _a.options.tableName;
+          if (typeof physical === "string") return [physical];
+          const schema = dataSource.collectionManager.db.options.schema || "dbo";
+          const matching = (options.selectedCollections || []).filter(
+            (tableName) => dataSource.introspector.tableInfoToCollectionOptions({ tableName, schema }).name === name
+          );
+          return matching.length ? matching : [name];
+        });
+        if (names.length) {
+          await this.app.db.getRepository("dataSourcesFields").destroy({
+            filter: { dataSourceKey, collectionName: { $in: names } },
+            transaction,
+            individualHooks: false,
+            hooks: false,
+            context: ctx
+          });
+          await collections.destroy({
+            filter: { dataSourceKey, name: { $in: names } },
+            transaction,
+            individualHooks: false,
+            hooks: false,
+            context: ctx
+          });
+        }
+        const selectedMode = (options == null ? void 0 : options.addAllCollections) === false && Array.isArray(options.selectedCollections);
+        if (selectedMode) {
+          const selectedCollections = options.selectedCollections.filter((name) => !tableNames.includes(name));
+          if (selectedCollections.length !== options.selectedCollections.length) {
+            model.set("options", { ...options, selectedCollections });
+            await model.save({ transaction, hooks: false });
+          }
+        }
+        return { names, selectedMode };
+      });
+      if (result.selectedMode) {
+        try {
+          await this.reconcileSelection(dataSourceKey);
+        } finally {
+          await this.sendSyncMessage({ type: "selectionChanged", dataSourceKey });
+        }
+      } else {
+        const manager = this.app.pm.get("data-source-manager");
+        for (const name of result.names) {
+          dataSource.collectionManager.removeCollection(name);
+          await (manager == null ? void 0 : manager.sendSyncMessage({ type: "removeDataSourceCollection", dataSourceKey, collectionName: name }));
+        }
+      }
+      ctx.body = true;
+    });
+  }
+  async handleSyncMessage(message) {
+    if ((message == null ? void 0 : message.type) === "selectionChanged") {
+      const refreshTables = Array.isArray(message.refreshTables) ? message.refreshTables.filter((name) => typeof name === "string") : [];
+      await this.reconcileSelection(message.dataSourceKey, /* @__PURE__ */ new Map(), void 0, void 0, refreshTables);
+    }
+  }
+  async reconcileSelection(dataSourceKey, prepared = /* @__PURE__ */ new Map(), preparedSource, preparedConfiguration, refreshTables = []) {
+    const previous = this.selectionSyncs.get(dataSourceKey) || Promise.resolve();
+    const pending = previous.catch(() => void 0).then(async () => {
+      const dataSource = this.app.dataSourceManager.get(dataSourceKey);
+      if (!(dataSource instanceof import_MssqlExternalDataSource.MssqlExternalDataSource)) return;
+      const model = await this.app.db.getRepository("dataSources").findOne({
+        filterByTk: dataSourceKey
+      });
+      const options = model == null ? void 0 : model.get("options");
+      if ((options == null ? void 0 : options.addAllCollections) !== false || !Array.isArray(options.selectedCollections)) return;
+      const configuration = (0, import_lodash.omit)(options, "selectedCollections");
+      const resolvedConfiguration = this.app.environment.renderJsonTemplate(configuration);
+      if (!(0, import_lodash.isEqual)((0, import_lodash.pick)(dataSource.options, Object.keys(resolvedConfiguration)), resolvedConfiguration)) return;
+      if (preparedSource !== dataSource || !(0, import_lodash.isEqual)(preparedConfiguration, configuration)) prepared.clear();
+      const selected = new Set(options.selectedCollections);
+      const existing = dataSource.collectionManager.getCollections();
+      const physicalName = (collection) => typeof collection.options.tableName === "string" ? collection.options.tableName : collection.name;
+      const loaded = new Set(existing.map(physicalName));
+      const missing = [...selected].filter((name) => !loaded.has(name));
+      const targets = [.../* @__PURE__ */ new Set([...missing, ...refreshTables.filter((name) => selected.has(name))])];
+      if (this.app.dataSourceManager.get(dataSourceKey) !== dataSource) return;
+      for (const collection of existing) {
+        if (!selected.has(physicalName(collection))) dataSource.collectionManager.removeCollection(collection.name);
+      }
+      dataSource.options.addAllCollections = false;
+      dataSource.options.selectedCollections = [...selected];
+      if (!targets.length) return;
+      const localData = await model.loadLocalData();
+      await dataSource.introspector.preloadFTSIndexedColumns(
+        dataSource.collectionManager.db.options.schema || "dbo",
+        [...selected]
+      );
+      for (const name of targets) {
+        const wasPrepared = prepared.has(name);
+        try {
+          const collection = prepared.get(name) || (await dataSource.prepareTables([name], localData))[0];
+          const [merged] = dataSource.mergeWithLoadedCollections([collection], localData);
+          if (this.app.dataSourceManager.get(dataSourceKey) !== dataSource) return;
+          const previous2 = existing.find((item) => physicalName(item) === name);
+          const previousOptions = previous2 && {
+            ...previous2.options,
+            fields: previous2.getFields().map((field) => field.options)
+          };
+          if (previous2) dataSource.collectionManager.removeCollection(previous2.name);
+          try {
+            dataSource.collectionManager.defineCollection(merged);
+          } catch (error) {
+            if (previousOptions) dataSource.collectionManager.defineCollection(previousOptions);
+            throw error;
+          }
+        } catch (error) {
+          this.app.log.warn(`[MSSQL] Failed to restore selected collection ${name}`);
+          if (wasPrepared) throw error;
+        }
+      }
+    });
+    this.selectionSyncs.set(dataSourceKey, pending);
+    try {
+      await pending;
+    } finally {
+      if (this.selectionSyncs.get(dataSourceKey) === pending) this.selectionSyncs.delete(dataSourceKey);
+    }
+  }
 }
 var plugin_default = PluginDataSourceMssqlServer;
 // Annotate the CommonJS export names for ESM import in node: