plugin-data-source-mssql 2.0.10 → 2.0.12

package/src/client-v2/components/MssqlConfigForm.tsx

@@ -0,0 +1,173 @@
+/**
+ * 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.
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { Checkbox, Form, Input, InputNumber, Select } from 'antd';
+import { useFlowContext } from '@nocobase/flow-engine';
+import type { DataSourceSettingsFormProps } from '@nocobase/plugin-data-source-manager/client-v2';
+import { useTranslation } from 'react-i18next';
+
+const CONNECTION_FIELDS = [
+  'host',
+  'port',
+  'database',
+  'schema',
+  'username',
+  'password',
+  'encrypt',
+  'tablePrefix',
+] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export function toCollectionOptions(result: unknown): { label: string; value: string }[] {
+  const data = isRecord(result) ? result.data : result;
+  const list = isRecord(data) ? data.data : data;
+  if (!Array.isArray(list)) return [];
+  return list.flatMap((item: unknown) => {
+    const name = typeof item === 'string' ? item : isRecord(item) ? item.name : undefined;
+    return typeof name === 'string' ? [{ label: name, value: name }] : [];
+  });
+}
+
+export const MssqlConfigForm: React.FC<DataSourceSettingsFormProps> = ({ mode, initialValues, loadCollections }) => {
+  const { t } = useTranslation();
+  const form = Form.useFormInstance();
+  const ctx = useFlowContext();
+  const addAllCollections = Form.useWatch(['options', 'addAllCollections'], form);
+  const host = Form.useWatch(['options', 'host'], form);
+  const port = Form.useWatch(['options', 'port'], form);
+  const database = Form.useWatch(['options', 'database'], form);
+  const schema = Form.useWatch(['options', 'schema'], form);
+  const username = Form.useWatch(['options', 'username'], form);
+  const password = Form.useWatch(['options', 'password'], form);
+  const encrypt = Form.useWatch(['options', 'encrypt'], form);
+  const tablePrefix = Form.useWatch(['options', 'tablePrefix'], form);
+  const [collectionOptions, setCollectionOptions] = useState<{ label: string; value: string }[]>([]);
+  const [loading, setLoading] = useState(false);
+  const requestGeneration = useRef(0);
+  const hasLoaded = useRef(false);
+  const isLoading = useRef(false);
+  const cachedConnection = useRef<unknown[]>();
+  const savedSelection = initialValues?.options?.selectedCollections;
+  const preserveLegacySelection =
+    mode === 'edit' && initialValues?.options?.addAllCollections === false && !Array.isArray(savedSelection);
+
+  useEffect(() => {
+    if (mode === 'edit' && Array.isArray(savedSelection) && form.getFieldValue('collections') === undefined) {
+      form.setFieldValue('collections', savedSelection);
+    }
+  }, [form, mode, savedSelection]);
+
+  useEffect(() => {
+    requestGeneration.current += 1;
+    hasLoaded.current = false;
+    isLoading.current = false;
+    cachedConnection.current = undefined;
+    setCollectionOptions([]);
+    setLoading(false);
+  }, [host, port, database, schema, username, password, encrypt, tablePrefix]);
+
+  const handleLoadCollections = useCallback(async () => {
+    const values = form.getFieldsValue(true);
+    const connection = [values.key, ...CONNECTION_FIELDS.map((field) => values.options?.[field])];
+    const sameConnection = cachedConnection.current?.every((value, index) => value === connection[index]);
+    if (sameConnection && (hasLoaded.current || isLoading.current)) return;
+    if (!sameConnection) {
+      requestGeneration.current += 1;
+      hasLoaded.current = false;
+      cachedConnection.current = connection;
+    }
+    isLoading.current = true;
+    const generation = requestGeneration.current;
+    setLoading(true);
+    try {
+      const connectionChanged = CONNECTION_FIELDS.some(
+        (field) => values.options?.[field] !== initialValues?.options?.[field],
+      );
+      const result =
+        mode === 'create' || connectionChanged
+          ? (
+              await ctx.api
+                .resource('dataSources')
+                .readTables({ values: { dataSourceKey: values.key, dbOptions: { ...values.options, type: 'mssql' } } })
+            ).data
+          : await loadCollections(String(initialValues.key));
+      if (generation === requestGeneration.current) {
+        setCollectionOptions(toCollectionOptions(result));
+        hasLoaded.current = true;
+      }
+    } catch {
+      if (generation === requestGeneration.current) {
+        ctx.message.error(String(t('Unable to load collections')));
+      }
+    } finally {
+      if (generation === requestGeneration.current) {
+        isLoading.current = false;
+        setLoading(false);
+      }
+    }
+  }, [ctx, form, loadCollections, initialValues, mode, t]);
+
+  return (
+    <>
+      <Form.Item name={['options', 'host']} label={t('Host')} rules={[{ required: true }]}>
+        <Input placeholder="localhost" />
+      </Form.Item>
+      <Form.Item name={['options', 'port']} label={t('Port')} rules={[{ required: true }]} initialValue={1433}>
+        <InputNumber min={1} max={65535} style={{ width: '100%' }} />
+      </Form.Item>
+      <Form.Item name={['options', 'database']} label={t('Database')} rules={[{ required: true }]}>
+        <Input />
+      </Form.Item>
+      <Form.Item name={['options', 'schema']} label={t('Schema')}>
+        <Input />
+      </Form.Item>
+      <Form.Item name={['options', 'username']} label={t('Username')} rules={[{ required: true }]}>
+        <Input />
+      </Form.Item>
+      <Form.Item name={['options', 'password']} label={t('Password')}>
+        <Input.Password />
+      </Form.Item>
+      <Form.Item name={['options', 'encrypt']} label={t('Encrypt')} valuePropName="checked">
+        <Checkbox />
+      </Form.Item>
+      <Form.Item name={['options', 'tablePrefix']} label={t('Table prefix')}>
+        <Input />
+      </Form.Item>
+      <Form.Item
+        name={['options', 'addAllCollections']}
+        label={t('Load all collections')}
+        valuePropName="checked"
+        initialValue={initialValues?.options?.addAllCollections ?? initialValues?.addAllCollections ?? true}
+      >
+        <Checkbox />
+      </Form.Item>
+      <Form.Item name="__mssqlPreserveLegacySelection" initialValue={preserveLegacySelection} hidden>
+        <input type="hidden" />
+      </Form.Item>
+      {!addAllCollections ? (
+        <Form.Item name="collections" label={t('Collections')}>
+          <Select
+            mode="multiple"
+            allowClear
+            loading={loading}
+            options={collectionOptions}
+            onFocus={handleLoadCollections}
+            onChange={() => form.setFieldValue('__mssqlPreserveLegacySelection', false)}
+            optionFilterProp="label"
+          />
+        </Form.Item>
+      ) : null}
+    </>
+  );
+};
+
+export default MssqlConfigForm;

package/src/client-v2/index.tsx

@@ -1 +1 @@
-export { default } from './plugin';
+export { default } from './plugin';

package/src/client-v2/plugin.tsx

@@ -1,19 +1,47 @@
-import { Plugin, Application } from '@nocobase/client-v2';
-import PluginDataSourceManagerClientV2 from '@nocobase/plugin-data-source-manager/client-v2';
-import React from 'react';
-
-export class PluginDataSourceMssqlClient extends Plugin<Record<string, never>, Application> {
-  async load() {
-    const manager = this.app.pm.get(PluginDataSourceManagerClientV2);
-    if (manager) {
-      manager.registerType('mssql', {
-        label: 'External MSSQL',
-        SettingsForm: React.lazy(() => import('../client/components/MssqlConfigForm').then(m => ({ default: m.MssqlConfigForm }))),
-        disableTestConnection: false,
-        disableAddFields: false,
-      });
-    }
-  }
-}
-
-export default PluginDataSourceMssqlClient;
+/**
+ * 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.
+ */
+
+import { Plugin, Application } from '@nocobase/client-v2';
+import PluginDataSourceManagerClientV2 from '@nocobase/plugin-data-source-manager/client-v2';
+import React from 'react';
+import { MssqlDeleteCollection } from './MssqlDeleteCollection';
+
+export class PluginDataSourceMssqlClient extends Plugin<Record<string, never>, Application> {
+  async load() {
+    const manager = this.app.pm.get(PluginDataSourceManagerClientV2);
+    if (manager) {
+      manager.registerType('mssql', {
+        label: String(this.t('External MSSQL')),
+        SettingsForm: React.lazy(() =>
+          import('./components/MssqlConfigForm').then((m) => ({ default: m.MssqlConfigForm })),
+        ),
+        disableTestConnection: false,
+        allowCollectionDeletion: true,
+        DeleteCollection: MssqlDeleteCollection,
+        disableAddFields: false,
+        normalizeValues: (values) => {
+          const { __mssqlPreserveLegacySelection, ...normalized } = values;
+          const addAllCollections = values.options?.addAllCollections ?? values.addAllCollections ?? true;
+          if (__mssqlPreserveLegacySelection && addAllCollections === false) {
+            delete normalized.collections;
+          }
+          return {
+            ...normalized,
+            options: {
+              ...values.options,
+              addAllCollections,
+            },
+          };
+        },
+      });
+    }
+  }
+}
+
+export default PluginDataSourceMssqlClient;

package/src/locale/en-US.json

@@ -0,0 +1,20 @@
+{
+  "Host": "Host",
+  "Port": "Port",
+  "Database": "Database",
+  "Schema": "Schema",
+  "Username": "Username",
+  "Password": "Password",
+  "Encrypt": "Encrypt",
+  "Table prefix": "Table prefix",
+  "Load all collections": "Load all collections",
+  "Collections": "Collections",
+  "Delete collection": "Delete collection",
+  "Delete": "Delete",
+  "Are you sure you want to delete it?": "Are you sure you want to delete it?",
+  "Automatically drop objects that depend on the collection (such as views), and in turn all objects that depend on those objects": "Automatically drop objects that depend on the collection (such as views), and in turn all objects that depend on those objects",
+  "Collection name is missing": "Collection name is missing",
+  "Collection deleted successfully": "Collection deleted successfully",
+  "Failed to delete collection": "Failed to delete collection",
+  "Unable to load collections": "Unable to load collections"
+}

package/src/locale/zh-CN.json

@@ -0,0 +1,20 @@
+{
+  "Host": "主机",
+  "Port": "端口",
+  "Database": "数据库",
+  "Schema": "架构",
+  "Username": "用户名",
+  "Password": "密码",
+  "Encrypt": "加密",
+  "Table prefix": "表前缀",
+  "Load all collections": "加载所有数据表",
+  "Collections": "数据表",
+  "Delete collection": "删除数据表",
+  "Delete": "删除",
+  "Are you sure you want to delete it?": "确定要删除吗？",
+  "Automatically drop objects that depend on the collection (such as views), and in turn all objects that depend on those objects": "自动删除依赖于该数据表的对象（如视图），以及依赖于这些对象的所有对象",
+  "Collection name is missing": "缺少数据表名称",
+  "Collection deleted successfully": "数据表删除成功",
+  "Failed to delete collection": "删除数据表失败",
+  "Unable to load collections": "无法加载数据表"
+}

package/src/server/__tests__/data-source-collections-api.test.ts

@@ -11,6 +11,18 @@ import { createMockServer, MockServer, waitSecond } from '@nocobase/test';
 import { SequelizeDataSource, SequelizeCollectionManager } from '@nocobase/data-source-manager';
 import { Database } from '@nocobase/database';
 
+/**
+ * KNOWN LIMITATION: Integration tests using createMockServer with short plugin name
+ * 'data-source-mssql' currently fail because the package is unscoped ('plugin-data-source-mssql')
+ * while PluginManager.parseName() only tries '@nocobase/plugin-' and '@nocobase/preset-' prefixes.
+ * This is a pre-existing architectural limitation. To fix, either:
+ *   1. Rename the package to '@nocobase/plugin-data-source-mssql', OR
+ *   2. Set PLUGIN_PACKAGE_PREFIX env var to include an empty prefix, OR
+ *   3. Enhance PluginManager.parseName() to try the bare package name as a fallback
+ *
+ * Unit tests (mssql-dialect.test.ts, mssql-format-options.test.ts, sql-quote.test.ts,
+ * mssql-bulk-introspection.test.ts) provide coverage without requiring the mock server.
+ */
 describe('mssql data source collection api', () => {
   let app: MockServer;
 

package/src/server/__tests__/mssql-bulk-introspection.test.ts

@@ -0,0 +1,114 @@
+/**
+ * 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.
+ */
+
+import {
+  buildBulkColumnsSql,
+  formatColumnType,
+  groupColumnsByTable,
+  MssqlBulkColumnRow,
+} from '../data-source/mssql-bulk-introspection';
+
+describe('mssql-bulk-introspection', () => {
+  describe('buildBulkColumnsSql', () => {
+    it('targets the requested schema as a Unicode literal', () => {
+      const sql = buildBulkColumnsSql('dbo');
+      expect(sql).toContain("u.name = N'dbo'");
+    });
+
+    it('never interpolates a hostile schema name raw', () => {
+      const sql = buildBulkColumnsSql("dbo'; DROP TABLE users; --");
+      // The quote is doubled, so it stays inside the string literal
+      expect(sql).toContain("u.name = N'dbo''; DROP TABLE users; --'");
+      expect(sql).not.toContain("N'dbo';");
+    });
+
+    it('excludes system tables', () => {
+      expect(buildBulkColumnsSql('dbo')).toContain('o.is_ms_shipped = 0');
+    });
+
+    it('reads from sys catalog, not INFORMATION_SCHEMA, for identity/default metadata', () => {
+      const sql = buildBulkColumnsSql('dbo');
+      expect(sql).toContain('sys.columns');
+      expect(sql).toContain('sys.default_constraints');
+      expect(sql).toContain('c.is_identity');
+    });
+  });
+
+  describe('formatColumnType', () => {
+    it('formats varchar with length', () => {
+      expect(formatColumnType('varchar', 50)).toBe('VARCHAR(50)');
+    });
+
+    it('halves max_length for nchar/nvarchar (byte count -> char count)', () => {
+      expect(formatColumnType('nvarchar', 100)).toBe('NVARCHAR(50)');
+      expect(formatColumnType('nchar', 20)).toBe('NCHAR(10)');
+    });
+
+    it('renders MAX for -1 length', () => {
+      expect(formatColumnType('nvarchar', -1)).toBe('NVARCHAR(MAX)');
+      expect(formatColumnType('varchar', -1)).toBe('VARCHAR(MAX)');
+      expect(formatColumnType('varbinary', -1)).toBe('VARBINARY(MAX)');
+    });
+
+    it('leaves non-char types untouched', () => {
+      expect(formatColumnType('int', 4)).toBe('INT');
+      expect(formatColumnType('datetime2', 8)).toBe('DATETIME2');
+      expect(formatColumnType('decimal', 9)).toBe('DECIMAL');
+    });
+  });
+
+  describe('groupColumnsByTable', () => {
+    const row = (over: Partial<MssqlBulkColumnRow>): MssqlBulkColumnRow => ({
+      table_name: 'Users',
+      column_name: 'id',
+      data_type: 'int',
+      max_length: 4,
+      is_nullable: false,
+      is_identity: true,
+      default_value: null,
+      column_comment: null,
+      ...over,
+    });
+
+    it('groups columns under their table in describeTable shape', () => {
+      const map = groupColumnsByTable([
+        row({}),
+        row({ column_name: 'email', data_type: 'nvarchar', max_length: 200, is_identity: false, is_nullable: true }),
+        row({ table_name: 'Orders', column_name: 'orderId', is_identity: false }),
+      ]);
+
+      expect(map.size).toBe(2);
+      expect(map.get('Users').id).toEqual({
+        type: 'INT',
+        allowNull: false,
+        defaultValue: undefined,
+        primaryKey: false,
+        autoIncrement: true,
+        comment: null,
+      });
+      expect(map.get('Users').email.type).toBe('NVARCHAR(100)');
+      expect(map.get('Users').email.allowNull).toBe(true);
+      expect(map.get('Orders').orderId.autoIncrement).toBe(false);
+    });
+
+    it('converts a null default to undefined', () => {
+      const map = groupColumnsByTable([row({ default_value: null })]);
+      expect(map.get('Users').id.defaultValue).toBeUndefined();
+    });
+
+    it('keeps a defined default value', () => {
+      const map = groupColumnsByTable([row({ default_value: '((0))' })]);
+      expect(map.get('Users').id.defaultValue).toBe('((0))');
+    });
+
+    it('returns an empty map for no rows', () => {
+      expect(groupColumnsByTable([]).size).toBe(0);
+    });
+  });
+});

package/src/server/__tests__/mssql-data-source.test.ts

@@ -10,6 +10,7 @@
 import { createMockServer, MockServer, waitSecond } from '@nocobase/test';
 import { CollectionManager, DataSource } from '@nocobase/data-source-manager';
 import { ICollectionManager, IRepository, IModel } from '@nocobase/data-source-manager/src/types';
+import { MssqlIntrospector } from '../data-source/MssqlIntrospector';
 
 /**
  * Test suite for MSSQL Data Source Plugin
@@ -23,6 +24,14 @@ import { ICollectionManager, IRepository, IModel } from '@nocobase/data-source-m
  *
  * Note: Tests use mock patterns since actual MSSQL server connection
  * is not available in CI environment.
+ *
+ * KNOWN LIMITATION: Integration tests using createMockServer with short plugin name
+ * 'data-source-mssql' currently fail because the package is unscoped ('plugin-data-source-mssql')
+ * while PluginManager.parseName() only tries '@nocobase/plugin-' and '@nocobase/preset-' prefixes.
+ * This is a pre-existing architectural limitation. To fix, either:
+ *   1. Rename the package to '@nocobase/plugin-data-source-mssql', OR
+ *   2. Set PLUGIN_PACKAGE_PREFIX env var to include an empty prefix, OR
+ *   3. Enhance PluginManager.parseName() to try the bare package name as a fallback
  */
 
 describe('MSSQL Data Source Plugin', () => {
@@ -43,98 +52,80 @@ describe('MSSQL Data Source Plugin', () => {
       const factory = app.dataSourceManager.factory;
       const mssqlClass = factory.getClass('mssql');
       expect(mssqlClass).toBeDefined();
-    });
-
-    it('should have external-mssql resource defined', () => {
-      const resourcer = app.resourcer;
-      expect(resourcer.isDefined('external-mssql')).toBe(true);
+      expect(mssqlClass.name).toBe('MssqlExternalDataSource');
     });
   });
 
   describe('Test Connection Endpoint', () => {
+    // Connection validation is dispatched through the core `dataSources:testConnection`
+    // action, which invokes `MssqlExternalDataSource.testConnection(options)` via the factory.
+    const testConnection = (values: Record<string, unknown>) =>
+      app.agent().resource('dataSources').testConnection({ values });
+
     it('should return error when options are missing', async () => {
-      const res = await app.agent().resource('external-mssql').testConnection({
-        values: {},
-      });
+      const res = await testConnection({ type: 'mssql' });
 
       expect(res.status).toBe(400);
-      expect(res.body.message).toContain('required');
     });
 
     it('should return error when host is missing', async () => {
-      const res = await app
-        .agent()
-        .resource('external-mssql')
-        .testConnection({
-          values: {
-            options: {
-              port: 1433,
-              username: 'sa',
-              password: 'password',
-              database: 'TestDB',
-            },
-          },
-        });
+      const res = await testConnection({
+        type: 'mssql',
+        options: {
+          port: 1433,
+          username: 'sa',
+          password: 'password',
+          database: 'TestDB',
+        },
+      });
 
       expect(res.status).toBe(400);
-      expect(res.body.message).toContain('Host');
+      expect(res.text).toContain('Host');
     });
 
     it('should return error when database is missing', async () => {
-      const res = await app
-        .agent()
-        .resource('external-mssql')
-        .testConnection({
-          values: {
-            options: {
-              host: 'localhost',
-              port: 1433,
-              username: 'sa',
-              password: 'password',
-            },
-          },
-        });
+      const res = await testConnection({
+        type: 'mssql',
+        options: {
+          host: 'localhost',
+          port: 1433,
+          username: 'sa',
+          password: 'password',
+        },
+      });
 
       expect(res.status).toBe(400);
-      expect(res.body.message).toContain('Database');
+      expect(res.text).toContain('Database');
     });
 
     it('should return error when username is missing', async () => {
-      const res = await app
-        .agent()
-        .resource('external-mssql')
-        .testConnection({
-          values: {
-            options: {
-              host: 'localhost',
-              port: 1433,
-              password: 'password',
-              database: 'TestDB',
-            },
-          },
-        });
+      const res = await testConnection({
+        type: 'mssql',
+        options: {
+          host: 'localhost',
+          port: 1433,
+          password: 'password',
+          database: 'TestDB',
+        },
+      });
 
       expect(res.status).toBe(400);
-      expect(res.body.message).toContain('Username');
+      expect(res.text).toContain('Username');
     });
 
     it('should return error when password is missing', async () => {
-      const res = await app
-        .agent()
-        .resource('external-mssql')
-        .testConnection({
-          values: {
-            options: {
-              host: 'localhost',
-              port: 1433,
-              username: 'sa',
-              database: 'TestDB',
-            },
-          },
-        });
+      const res = await testConnection({
+        type: 'mssql',
+        options: {
+          host: 'localhost',
+          port: 1433,
+          username: 'sa',
+          database: 'TestDB',
+        },
+      });
 
       expect(res.status).toBe(400);
-      expect(res.body.message).toContain('Password');
+      expect(res.text).toContain('Password');
     });
   });
 
@@ -174,51 +165,25 @@ describe('MSSQL Data Source Plugin', () => {
 
 describe('MssqlExternalDataSource Unit Tests', () => {
   describe('Type Mapping', () => {
-    // Test the type inference logic
-    const testCases = [
-      { input: 'varchar(255)', expectedType: 'string', expectedInterface: 'input' },
-      { input: 'nvarchar(max)', expectedType: 'string', expectedInterface: 'input' },
-      { input: 'int', expectedType: 'integer', expectedInterface: 'integer' },
-      { input: 'bigint', expectedType: 'bigInt', expectedInterface: 'number' },
-      { input: 'decimal(18,2)', expectedType: 'decimal', expectedInterface: 'number' },
-      { input: 'datetime', expectedType: 'datetime', expectedInterface: 'datetime' },
-      { input: 'datetime2', expectedType: 'datetime', expectedInterface: 'datetime' },
-      { input: 'bit', expectedType: 'boolean', expectedInterface: 'checkbox' },
-      { input: 'uniqueidentifier', expectedType: 'uuid', expectedInterface: 'uuid' },
-      { input: 'text', expectedType: 'text', expectedInterface: 'textarea' },
-      { input: 'unknown_type', expectedType: 'string', expectedInterface: 'input' },
-    ];
-
-    testCases.forEach(({ input, expectedType, expectedInterface }) => {
-      it(`should map ${input} to type: ${expectedType}, interface: ${expectedInterface}`, () => {
-        // Note: This test requires importing the actual inferFieldType method
-        // For now, this documents the expected behavior
-        expect(true).toBe(true);
-      });
-    });
-  });
-
-  describe('Collection Name Normalization', () => {
-    it('should replace dots with underscores in collection names', () => {
-      const fullTableName = 'dbo.Features';
-      const collectionName = fullTableName.replace(/\./g, '_');
-      expect(collectionName).toBe('dbo_Features');
-    });
-
-    it('should handle multiple dots in schema names', () => {
-      const fullTableName = 'catalog.schema.table';
-      const collectionName = fullTableName.replace(/\./g, '_');
-      expect(collectionName).toBe('catalog_schema_table');
-    });
-
-    it('should handle names without dots', () => {
-      const fullTableName = 'SimpleTable';
-      const collectionName = fullTableName.replace(/\./g, '_');
-      expect(collectionName).toBe('SimpleTable');
+    // Access the protected getFieldTypeMap() via a minimal introspector instance.
+    // The Database constructor is never exercised: we only call the pure map lookup,
+    // so passing a stub keeps this a real unit test with no DB connection.
+    const introspector = new MssqlIntrospector({ db: {} as any });
+    const typeMap = (introspector as any).getFieldTypeMap() as Record<string, string | string[]>;
+
+    it('maps core MSSQL types to NocoBase field types', () => {
+      expect(typeMap['int']).toEqual(['integer', 'sort']);
+      expect(typeMap['bigint']).toEqual(['bigInt', 'sort']);
+      expect(typeMap['decimal']).toBe('decimal');
+      expect(typeMap['datetime2']).toBe('datetimeNoTz');
+      expect(typeMap['datetimeoffset']).toBe('datetimeTz');
+      expect(typeMap['bit']).toBe('boolean');
+      expect(typeMap['uniqueidentifier']).toBe('uuid');
+      expect(typeMap['nvarchar']).toContain('string');
+      expect(typeMap['text']).toBe('text');
     });
   });
 });
-
 describe('Mock MSSQL DataSource Integration', () => {
   let app: MockServer;