plugin-data-source-mssql 2.0.10 → 2.0.12

package/src/server/plugin.ts

@@ -8,23 +8,318 @@
  */
 
 import { Plugin } from '@nocobase/server';
-import { MssqlExternalDataSource } from './data-source/MssqlExternalDataSource';
+import { MssqlExternalDataSource, type MssqlDataSourceOptions } from './data-source/MssqlExternalDataSource';
 import { Database } from '@nocobase/database';
 import { MssqlDialect } from './dialects/mssql-dialect';
+import { isValidFilter } from '@nocobase/utils';
+import { cloneDeep, isEqual, omit, pick } from 'lodash';
+import type { CollectionOptions, LoadedCollections } from '@nocobase/data-source-manager';
+import type { Model } from '@nocobase/database';
+import { withLockedDataSource } from './selection';
+
+type DataSourceRecord = Model & { loadLocalData(): Promise<LoadedCollections> };
+type SelectionSyncMessage = { type: 'selectionChanged'; dataSourceKey: string; refreshTables?: string[] };
 
 export class PluginDataSourceMssqlServer extends Plugin {
+  private selectionSyncs = new Map<string, Promise<void>>();
+
   async beforeLoad() {
     Database.registerDialect(MssqlDialect);
-    (this as any).app.dataSourceManager.factory.register('mssql', MssqlExternalDataSource);
+    this.app.dataSourceManager.factory.register('mssql', 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 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?.type !== 'mssql') {
+        await next();
+        return;
+      }
+
+      const manager = this.app.dataSourceManager;
+      const probe = manager.factory.create('mssql', { name: dataSourceKey, ...dbOptions }) as MssqlExternalDataSource;
+      const owned = ![...manager.dataSources.values()].includes(probe);
+      let requestFailed = false;
+      let requestError: unknown;
+      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 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)] as string[];
+      const row = (await this.app.db.getRepository('dataSources').findOne({
+        filterByTk: dataSourceKey,
+      })) as DataSourceRecord | null;
+      if (!row) ctx.throw(404, 'Data source not found');
+      const configuration = cloneDeep(omit(row.get('options') || {}, 'selectedCollections'));
+      const resolvedConfiguration = this.app.environment.renderJsonTemplate(configuration);
+      const activeConfiguration = pick(dataSource.options, Object.keys(resolvedConfiguration));
+      if (!isEqual(activeConfiguration, resolvedConfiguration))
+        ctx.throw(409, 'Data source changed; retry loading tables');
+      // Validate the entire batch before changing either the runtime or the stored selection.
+      // Do not embed a pre-transaction metadata snapshot: a concurrent delete may remove it.
+      const prepared = await dataSource.prepareTables(tableNames);
+      const selectedMode = await withLockedDataSource(this.app.db, dataSourceKey, async (locked, transaction) => {
+        const options = locked.get('options') as MssqlDataSourceOptions;
+        if (!isEqual(omit(options || {}, 'selectedCollections'), configuration)) {
+          ctx.throw(409, 'Data source changed; retry loading tables');
+        }
+        if (options?.addAllCollections !== false || !Array.isArray(options.selectedCollections)) return false;
+        const selectedCollections = [...new Set([...options.selectedCollections, ...tableNames])];
+        if (!isEqual(selectedCollections, options.selectedCollections)) {
+          locked.set('options', { ...options, selectedCollections });
+          // Core's options hooks reconnect and reload before commit; sync explicitly after commit instead.
+          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,
+        })) as DataSourceRecord | null;
+        const localData = (await latest?.loadLocalData()) || {};
+        if (
+          this.app.dataSourceManager.get(dataSourceKey) !== dataSource ||
+          !isEqual(omit(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 MssqlExternalDataSource)) {
+        await next();
+        return;
+      }
+      const current = await this.app.db.getRepository('dataSources').findOne({ filterByTk: dataSourceKey });
+      const currentOptions = current?.get('options') as MssqlDataSourceOptions | undefined;
+      if (currentOptions?.addAllCollections !== false || !Array.isArray(currentOptions.selectedCollections)) {
+        await next();
+        return;
+      }
+      const requested = (Array.isArray(filterByTk) ? filterByTk : [filterByTk]).filter(
+        (name): name is string => typeof name === 'string' && name.length > 0,
+      );
+      if (filterByTk !== undefined && 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 && !isValidFilter(filter)) {
+        ctx.body = true;
+        return;
+      }
+      const result = await withLockedDataSource(this.app.db, dataSourceKey, async (model, transaction) => {
+        const collections = this.app.db.getRepository('dataSourcesCollections');
+        const hasFilter = isValidFilter(filter);
+        const options = model.get('options') as MssqlDataSourceOptions;
+        const resolvedConfiguration = this.app.environment.renderJsonTemplate(
+          omit(options || {}, 'selectedCollections'),
+        );
+        if (!isEqual(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) => {
+          const physical = dataSource.collectionManager.getCollection(name)?.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) {
+          // The core row hooks mutate the live collection manager before commit. Suppress them
+          // here and perform equivalent runtime removal and peer sync only after commit.
+          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?.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?.sendSyncMessage({ type: 'removeDataSourceCollection', dataSourceKey, collectionName: name });
+        }
+      }
+      ctx.body = true;
+    });
+  }
+
+  async handleSyncMessage(message: SelectionSyncMessage) {
+    if (message?.type === 'selectionChanged') {
+      const refreshTables = Array.isArray(message.refreshTables)
+        ? message.refreshTables.filter((name) => typeof name === 'string')
+        : [];
+      await this.reconcileSelection(message.dataSourceKey, new Map(), undefined, undefined, refreshTables);
+    }
+  }
+
+  private async reconcileSelection(
+    dataSourceKey: string,
+    prepared = new Map<string, CollectionOptions>(),
+    preparedSource?: MssqlExternalDataSource,
+    preparedConfiguration?: Record<string, unknown>,
+    refreshTables: string[] = [],
+  ) {
+    const previous = this.selectionSyncs.get(dataSourceKey) || Promise.resolve();
+    const pending = previous
+      .catch(() => undefined)
+      .then(async () => {
+        const dataSource = this.app.dataSourceManager.get(dataSourceKey);
+        if (!(dataSource instanceof MssqlExternalDataSource)) return;
+        const model = (await this.app.db.getRepository('dataSources').findOne({
+          filterByTk: dataSourceKey,
+        })) as DataSourceRecord | null;
+        const options = model?.get('options') as MssqlDataSourceOptions | undefined;
+        if (options?.addAllCollections !== false || !Array.isArray(options.selectedCollections)) return;
+        const configuration = omit(options, 'selectedCollections');
+        const resolvedConfiguration = this.app.environment.renderJsonTemplate(configuration);
+        if (!isEqual(pick(dataSource.options, Object.keys(resolvedConfiguration)), resolvedConfiguration)) return;
+        if (preparedSource !== dataSource || !isEqual(preparedConfiguration, configuration)) prepared.clear();
+
+        const selected = new Set(options.selectedCollections);
+        const existing = dataSource.collectionManager.getCollections();
+        const physicalName = (collection: (typeof existing)[number]) =>
+          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 = [...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 as MssqlDataSourceOptions).addAllCollections = false;
+        (dataSource.options as MssqlDataSourceOptions).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 previous = existing.find((item) => physicalName(item) === name);
+            const previousOptions = previous && {
+              ...previous.options,
+              fields: previous.getFields().map((field) => field.options),
+            };
+            if (previous) dataSource.collectionManager.removeCollection(previous.name);
+            try {
+              dataSource.collectionManager.defineCollection(merged);
+            } catch (error) {
+              if (previousOptions) dataSource.collectionManager.defineCollection(previousOptions);
+              throw error;
+            }
+          } catch (error) {
+            // A stale selected table must not prevent removing a different table or syncing its selection.
+            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);
+    }
+  }
 }
 
 export default PluginDataSourceMssqlServer;
-

package/src/server/security/sql-quote.ts

@@ -0,0 +1,287 @@
+/**
+ * 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.
+ */
+
+/**
+ * T-SQL identifier and literal quoting helpers, ported from dbgate-mssql-dumper
+ * (src/security/identifiers.ts, src/security/literals.ts). Used wherever the plugin
+ * builds raw SQL by hand (e.g. the CONTAINS() full-text operator) so that column
+ * names and search values cannot break out of their quoting context.
+ */
+
+/** Regular (unquoted) T-SQL identifiers must match this shape. */
+const SAFE_UNQUOTED_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * A subset of the ODBC/ISO reserved T-SQL keywords that commonly appear as
+ * column names. When in doubt we bracket-quote anyway, so this list only needs
+ * to catch the words that would otherwise be emitted bare.
+ */
+const RESERVED_KEYWORDS = new Set(
+  [
+    'ADD',
+    'ALL',
+    'ALTER',
+    'AND',
+    'ANY',
+    'AS',
+    'ASC',
+    'AUTHORIZATION',
+    'BACKUP',
+    'BEGIN',
+    'BETWEEN',
+    'BREAK',
+    'BROWSE',
+    'BULK',
+    'BY',
+    'CASCADE',
+    'CASE',
+    'CHECK',
+    'CHECKPOINT',
+    'CLOSE',
+    'CLUSTERED',
+    'COALESCE',
+    'COLLATE',
+    'COLUMN',
+    'COMMIT',
+    'COMPUTE',
+    'CONSTRAINT',
+    'CONTAINS',
+    'CONTAINSTABLE',
+    'CONTINUE',
+    'CONVERT',
+    'CREATE',
+    'CROSS',
+    'CURRENT',
+    'CURRENT_DATE',
+    'CURRENT_TIME',
+    'CURRENT_TIMESTAMP',
+    'CURRENT_USER',
+    'CURSOR',
+    'DATABASE',
+    'DBCC',
+    'DEALLOCATE',
+    'DECLARE',
+    'DEFAULT',
+    'DELETE',
+    'DENY',
+    'DESC',
+    'DISK',
+    'DISTINCT',
+    'DISTRIBUTED',
+    'DOUBLE',
+    'DROP',
+    'DUMP',
+    'ELSE',
+    'END',
+    'ERRLVL',
+    'ESCAPE',
+    'EXCEPT',
+    'EXEC',
+    'EXECUTE',
+    'EXISTS',
+    'EXIT',
+    'EXTERNAL',
+    'FETCH',
+    'FILE',
+    'FILLFACTOR',
+    'FOR',
+    'FOREIGN',
+    'FREETEXT',
+    'FREETEXTTABLE',
+    'FROM',
+    'FULL',
+    'FUNCTION',
+    'GOTO',
+    'GRANT',
+    'GROUP',
+    'HAVING',
+    'HOLDLOCK',
+    'IDENTITY',
+    'IDENTITY_INSERT',
+    'IDENTITYCOL',
+    'IF',
+    'IN',
+    'INDEX',
+    'INNER',
+    'INSERT',
+    'INTERSECT',
+    'INTO',
+    'IS',
+    'JOIN',
+    'KEY',
+    'KILL',
+    'LEFT',
+    'LIKE',
+    'LINENO',
+    'LOAD',
+    'MERGE',
+    'NATIONAL',
+    'NOCHECK',
+    'NONCLUSTERED',
+    'NOT',
+    'NULL',
+    'NULLIF',
+    'OF',
+    'OFF',
+    'OFFSETS',
+    'ON',
+    'OPEN',
+    'OPENDATASOURCE',
+    'OPENQUERY',
+    'OPENROWSET',
+    'OPENXML',
+    'OPTION',
+    'OR',
+    'ORDER',
+    'OUTER',
+    'OVER',
+    'PERCENT',
+    'PIVOT',
+    'PLAN',
+    'PRECISION',
+    'PRIMARY',
+    'PRINT',
+    'PROC',
+    'PROCEDURE',
+    'PUBLIC',
+    'RAISERROR',
+    'READ',
+    'READTEXT',
+    'RECONFIGURE',
+    'REFERENCES',
+    'REPLICATION',
+    'RESTORE',
+    'RESTRICT',
+    'RETURN',
+    'REVERT',
+    'REVOKE',
+    'RIGHT',
+    'ROLLBACK',
+    'ROWCOUNT',
+    'ROWGUIDCOL',
+    'RULE',
+    'SAVE',
+    'SCHEMA',
+    'SECURITYAUDIT',
+    'SELECT',
+    'SEMANTICKEYPHRASETABLE',
+    'SEMANTICSIMILARITYDETAILSTABLE',
+    'SEMANTICSIMILARITYTABLE',
+    'SESSION_USER',
+    'SET',
+    'SETUSER',
+    'SHUTDOWN',
+    'SOME',
+    'STATISTICS',
+    'SYSTEM_USER',
+    'TABLE',
+    'TABLESAMPLE',
+    'TEXTSIZE',
+    'THEN',
+    'TO',
+    'TOP',
+    'TRAN',
+    'TRANSACTION',
+    'TRIGGER',
+    'TRUNCATE',
+    'TRY_CONVERT',
+    'TSEQUAL',
+    'UNION',
+    'UNIQUE',
+    'UNPIVOT',
+    'UPDATE',
+    'UPDATETEXT',
+    'USE',
+    'USER',
+    'VALUES',
+    'VARYING',
+    'VIEW',
+    'WAITFOR',
+    'WHEN',
+    'WHERE',
+    'WHILE',
+    'WITH',
+    'WITHIN GROUP',
+    'WRITETEXT',
+  ].map((word) => word.toUpperCase()),
+);
+
+/**
+ * True when `value` may appear unbracketed in generated SQL: it matches the
+ * regular-identifier grammar and is not a reserved keyword.
+ */
+export function isSafeUnquotedIdentifier(value: string): boolean {
+  return SAFE_UNQUOTED_IDENTIFIER.test(value) && !RESERVED_KEYWORDS.has(value.toUpperCase());
+}
+
+/**
+ * Quotes one identifier part with brackets, doubling embedded `]` characters.
+ * `]` is the only character that can terminate a bracket-quoted identifier, so
+ * escaping it (as `]]`) is sufficient to keep any value inside its quoting context.
+ */
+export function quoteIdentifier(value: string, policy: 'quote-when-needed' | 'always-quote' = 'always-quote'): string {
+  if (policy === 'quote-when-needed' && isSafeUnquotedIdentifier(value)) {
+    return value;
+  }
+  return `[${value.replace(/]/g, ']]')}]`;
+}
+
+/** Quotes and joins a dotted identifier path, e.g. `["dbo", "Orders"]` -> `[dbo].[Orders]`. */
+export function quoteQualifiedIdentifier(
+  parts: readonly string[],
+  policy: 'quote-when-needed' | 'always-quote' = 'always-quote',
+): string {
+  return parts.map((part) => quoteIdentifier(part, policy)).join('.');
+}
+
+/** Escapes and single-quotes a Unicode (`N'...'`) string literal, for `nchar`/`nvarchar` targets. */
+export function quoteUnicodeStringLiteral(value: string): string {
+  return `N'${value.replace(/'/g, "''")}'`;
+}
+
+/**
+ * A `Date` read by tedious for a `datetime2`/`datetimeoffset` column may carry a
+ * non-enumerable `nanosecondsDelta` property: the fractional-second remainder beyond
+ * JS Date's millisecond precision. Absent for values from any other source.
+ */
+export interface DateWithNanosecondsDelta extends Date {
+  readonly nanosecondsDelta?: number;
+}
+
+function readNanosecondsDelta(value: Date): number | undefined {
+  const delta = (value as DateWithNanosecondsDelta).nanosecondsDelta;
+  return typeof delta === 'number' && Number.isFinite(delta) ? delta : undefined;
+}
+
+/**
+ * Formats a `Date` as the `YYYY-MM-DD HH:mm:ss.SSS[SSSS]` text SQL Server expects for
+ * `datetime`/`datetime2` parameters. Unlike `Date#toISOString().slice(0, 23)`, this
+ * recovers sub-millisecond precision from tedious's `nanosecondsDelta` (up to 7
+ * fractional digits) instead of silently truncating to milliseconds. When no delta is
+ * present the result matches the plain millisecond form.
+ *
+ * Note: this keeps the space-separated form (not ISO-8601 `T`) because the value is
+ * bound to a typed `datetime`/`datetime2` parameter by tedious, not parsed from a
+ * free-text literal, so the unambiguous-format concern does not apply here.
+ */
+export function formatDateTimeParameter(value: Date): string {
+  const iso = value.toISOString(); // '2024-01-02T03:04:05.678Z'
+  let text = iso.replace('T', ' ').replace('Z', ''); // '2024-01-02 03:04:05.678'
+
+  const nanosecondsDelta = readNanosecondsDelta(value);
+  if (nanosecondsDelta !== undefined && nanosecondsDelta > 0) {
+    // nanosecondsDelta is a fraction of a millisecond; convert to up to 4 extra digits
+    // (100ns ticks) appended after the millisecond part.
+    const extraTicks = Math.min(9999, Math.max(0, Math.round(nanosecondsDelta * 1e4)));
+    if (extraTicks > 0) {
+      text += String(extraTicks).padStart(4, '0');
+    }
+  }
+  return text;
+}

package/src/server/selection.ts

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Database, Model } from '@nocobase/database';
+import { Transaction } from 'sequelize';
+
+/** Serialize selection edits with datasource configuration updates on the main database. */
+export async function withLockedDataSource<T>(
+  db: Database,
+  key: string,
+  work: (model: Model, transaction: Transaction) => Promise<T>,
+): Promise<T> {
+  let transaction: Transaction;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      transaction =
+        db.sequelize.getDialect() === 'sqlite'
+          ? await db.sequelize.transaction({ type: Transaction.TYPES.IMMEDIATE })
+          : await db.sequelize.transaction();
+      break;
+    } catch (error) {
+      const detail = error as { code?: string; original?: { code?: string }; parent?: { code?: string } };
+      if (![detail?.code, detail?.original?.code, detail?.parent?.code].includes('SQLITE_BUSY') || attempt >= 7) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(25 * 2 ** attempt, 400)));
+    }
+  }
+
+  let result: T;
+  try {
+    const model = await db.getRepository('dataSources').findOne({
+      filterByTk: key,
+      transaction,
+      lock: transaction.LOCK.UPDATE,
+    });
+    if (!model) throw new Error(`Data source ${key} not found`);
+    result = await work(model, transaction);
+  } catch (error) {
+    await transaction.rollback();
+    throw error;
+  }
+  await transaction.commit();
+  return result;
+}

package/dist/client-v2/768.85b62c2d73161eff.js

@@ -1,10 +0,0 @@
-/**
- * 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.
- */
-
-"use strict";(self.webpackChunkplugin_data_source_mssql_client_v2=self.webpackChunkplugin_data_source_mssql_client_v2||[]).push([["768"],{59:function(e,t,r){r.d(t,{MssqlConfigForm:function(){return s}});var n=r(155),l=r.n(n),a=r(440),o=r(953);function u(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,n=Array(t);r<t;r++)n[r]=e[r];return n}function i(e,t,r,n,l,a,o){try{var u=e[a](o),i=u.value}catch(e){r(e);return}u.done?t(i):Promise.resolve(i).then(n,l)}function c(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){var r,n,l=null==e?null:"u">typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(null!=l){var a=[],o=!0,u=!1;try{for(l=l.call(e);!(o=(r=l.next()).done)&&(a.push(r.value),!t||a.length!==t);o=!0);}catch(e){u=!0,n=e}finally{try{o||null==l.return||l.return()}finally{if(u)throw n}}return a}}(e,t)||function(e,t){if(e){if("string"==typeof e)return u(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);if("Object"===r&&e.constructor&&(r=e.constructor.name),"Map"===r||"Set"===r)return Array.from(r);if("Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return u(e,t)}}(e,t)||function(){throw TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}var s=function(e){var t=e.initialValues,r=e.loadCollections,u=(0,o.useTranslation)().t,s=a.Form.useFormInstance(),m=a.Form.useWatch("addAllCollections",s),p=c((0,n.useState)([]),2),f=p[0],b=p[1],d=c((0,n.useState)(!1),2),y=d[0],h=d[1],v=(0,n.useCallback)(function(){var e;return(e=function(){return function(e,t){var r,n,l,a={label:0,sent:function(){if(1&l[0])throw l[1];return l[1]},trys:[],ops:[]},o=Object.create(("function"==typeof Iterator?Iterator:Object).prototype),u=Object.defineProperty;return u(o,"next",{value:i(0)}),u(o,"throw",{value:i(1)}),u(o,"return",{value:i(2)}),"function"==typeof Symbol&&u(o,Symbol.iterator,{value:function(){return this}}),o;function i(u){return function(i){var c=[u,i];if(r)throw TypeError("Generator is already executing.");for(;o&&(o=0,c[0]&&(a=0)),a;)try{if(r=1,n&&(l=2&c[0]?n.return:c[0]?n.throw||((l=n.return)&&l.call(n),0):n.next)&&!(l=l.call(n,c[1])).done)return l;switch(n=0,l&&(c=[2&c[0],l.value]),c[0]){case 0:case 1:l=c;break;case 4:return a.label++,{value:c[1],done:!1};case 5:a.label++,n=c[1],c=[0];continue;case 7:c=a.ops.pop(),a.trys.pop();continue;default:if(!(l=(l=a.trys).length>0&&l[l.length-1])&&(6===c[0]||2===c[0])){a=0;continue}if(3===c[0]&&(!l||c[1]>l[0]&&c[1]<l[3])){a.label=c[1];break}if(6===c[0]&&a.label<l[1]){a.label=l[1],l=c;break}if(l&&a.label<l[2]){a.label=l[2],a.ops.push(c);break}l[2]&&a.ops.pop(),a.trys.pop();continue}c=t.call(e,a)}catch(e){c=[6,e],n=0}finally{r=l=0}if(5&c[0])throw c[1];return{value:c[0]?c[1]:void 0,done:!0}}}}(this,function(e){switch(e.label){case 0:h(!0),e.label=1;case 1:return e.trys.push([1,,3,4]),[4,r(null==t?void 0:t.key)];case 2:var n,l,a,o,u,i;return b(Array.isArray(i=null!=(l=null!=(a=null!=(o=null==(n=e.sent())||null==(u=n.data)?void 0:u.data)?o:null==n?void 0:n.data)?a:n)?l:[])?i.map(function(e){var t="string"==typeof e?e:null==e?void 0:e.name;return{label:t,value:t}}):[]),[3,4];case 3:return h(!1),[7];case 4:return[2]}})},function(){var t=this,r=arguments;return new Promise(function(n,l){var a=e.apply(t,r);function o(e){i(a,n,l,o,u,"next",e)}function u(e){i(a,n,l,o,u,"throw",e)}o(void 0)})})()},[r,null==t?void 0:t.key]);return l().createElement(l().Fragment,null,l().createElement(a.Form.Item,{name:["options","host"],label:u("Host"),rules:[{required:!0}]},l().createElement(a.Input,{placeholder:"localhost"})),l().createElement(a.Form.Item,{name:["options","port"],label:u("Port"),rules:[{required:!0}],initialValue:1433},l().createElement(a.InputNumber,{min:1,max:65535,style:{width:"100%"}})),l().createElement(a.Form.Item,{name:["options","database"],label:u("Database"),rules:[{required:!0}]},l().createElement(a.Input,null)),l().createElement(a.Form.Item,{name:["options","schema"],label:u("Schema")},l().createElement(a.Input,null)),l().createElement(a.Form.Item,{name:["options","username"],label:u("Username"),rules:[{required:!0}]},l().createElement(a.Input,null)),l().createElement(a.Form.Item,{name:["options","password"],label:u("Password")},l().createElement(a.Input.Password,null)),l().createElement(a.Form.Item,{name:["options","encrypt"],label:u("Encrypt"),valuePropName:"checked"},l().createElement(a.Checkbox,null)),l().createElement(a.Form.Item,{name:["options","tablePrefix"],label:u("Table prefix")},l().createElement(a.Input,null)),l().createElement(a.Form.Item,{name:"addAllCollections",label:u("Load all collections"),valuePropName:"checked",initialValue:!0},l().createElement(a.Checkbox,null)),m?null:l().createElement(a.Form.Item,{name:"collections",label:u("Collections")},l().createElement(a.Select,{mode:"multiple",allowClear:!0,loading:y,options:f,onFocus:v,optionFilterProp:"label"})))}}}]);