plugin-data-source-mssql 2.0.6 → 2.0.8

package/src/server/data-source/MssqlIntrospector.ts

@@ -0,0 +1,275 @@
+/**
+ * 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 { DatabaseIntrospector } from '@nocobase/data-source-manager';
+import { tableInfo } from '@nocobase/data-source-manager';
+
+/**
+ * MSSQL field type → NocoBase field type mapping.
+ * Keys are lowercase SQL Server type names (without length/precision).
+ */
+const mssqlFieldTypeMap: Record<string, string | string[]> = {
+  // String types
+  varchar: ['string', 'uuid', 'nanoid'],
+  nvarchar: ['string', 'uuid', 'nanoid'],
+  char: ['string', 'uuid', 'nanoid'],
+  nchar: ['string', 'uuid', 'nanoid'],
+  text: 'text',
+  ntext: 'text',
+
+  // Numeric types
+  int: ['integer', 'sort'],
+  smallint: ['integer', 'boolean', 'sort'],
+  tinyint: ['integer', 'boolean', 'sort'],
+  bigint: ['bigInt', 'sort'],
+  decimal: 'decimal',
+  numeric: 'decimal',
+  float: 'float',
+  real: 'float',
+  money: 'decimal',
+  smallmoney: 'decimal',
+
+  // Date/time types
+  datetime: 'datetimeNoTz',
+  datetime2: 'datetimeNoTz',
+  smalldatetime: 'datetimeNoTz',
+  datetimeoffset: 'datetimeTz',
+  date: 'dateOnly',
+  time: 'time',
+
+  // Boolean
+  bit: 'boolean',
+
+  // UUID
+  uniqueidentifier: 'uuid',
+
+  // Binary
+  varbinary: 'string',
+  binary: 'string',
+  image: 'string',
+
+  // XML
+  xml: 'text',
+};
+
+export class MssqlIntrospector extends DatabaseIntrospector {
+  /** Cache of { tableName → pk column names[] } loaded by preloadAllPrimaryKeys() */
+  private primaryKeyCache: Map<string, string[]> | null = 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).
+   */
+  private ftsColumnCache: Map<string, Set<string>> | null = null;
+
+  protected getFieldTypeMap(): Record<string, string | string[]> {
+    return mssqlFieldTypeMap;
+  }
+
+  /**
+   * Load primary key info for ALL tables in one query and cache the result.
+   * Call this once before starting the parallel introspection loop so that
+   * getTableColumnsInfo() can use the cache instead of querying sys.indexes per table.
+   */
+  async preloadAllPrimaryKeys(schemaName = 'dbo'): Promise<void> {
+    try {
+      const sql = `
+        SELECT o.name AS table_name, c.name AS column_name
+        FROM sys.indexes i
+        INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        INNER JOIN sys.columns c ON ic.object_id = c.object_id AND c.column_id = ic.column_id
+        INNER JOIN sys.objects o ON i.object_id = o.object_id
+        INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+        WHERE i.is_primary_key = 1
+          AND s.name = ${this.db.sequelize.escape(schemaName)}
+        ORDER BY o.name, ic.key_ordinal
+      `;
+      const rows = (await this.db.sequelize.query(sql, { type: 'SELECT' })) as any[];
+
+      const cache = new Map<string, string[]>();
+      for (const row of rows) {
+        const tbl = row.table_name as string;
+        if (!cache.has(tbl)) cache.set(tbl, []);
+        cache.get(tbl).push(row.column_name as string);
+      }
+      this.primaryKeyCache = cache;
+      this.db.logger.debug(`[MSSQL] Preloaded PK info for ${cache.size} tables`);
+    } catch (err) {
+      this.db.logger.warn('[MSSQL] Failed to preload primary keys, will fall back to per-table query:', err);
+      this.primaryKeyCache = 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'): Promise<void> {
+    try {
+      const sql = `
+        SELECT t.name AS table_name, c.name AS column_name
+        FROM sys.fulltext_index_columns fic
+        INNER JOIN sys.columns c ON fic.object_id = c.object_id AND fic.column_id = c.column_id
+        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)}
+      `;
+      const rows = (await this.db.sequelize.query(sql, { type: 'SELECT' })) as any[];
+
+      const cache = new Map<string, Set<string>>();
+      for (const row of rows) {
+        const tbl = row.table_name as string;
+        if (!cache.has(tbl)) cache.set(tbl, new Set<string>());
+        cache.get(tbl).add(row.column_name as string);
+      }
+      this.ftsColumnCache = cache;
+      this.db.logger.debug(`[MSSQL] Preloaded FTS index info for ${cache.size} tables`);
+    } catch (err) {
+      // FTS may not be installed on this SQL Server instance — that's fine, fall back to LIKE
+      this.db.logger.debug('[MSSQL] FTS preload skipped (FTS not installed or insufficient permissions):', err);
+      this.ftsColumnCache = new Map(); // empty = no FTS columns
+    }
+  }
+
+  /**
+   * Returns true if the given column has a Full-Text Search index.
+   * Used by text operators to decide between CONTAINS() and LIKE.
+   */
+  hasFTSIndex(tableName: string, columnName: string): boolean {
+    if (!this.ftsColumnCache) return false;
+    return this.ftsColumnCache.get(tableName)?.has(columnName) ?? false;
+  }
+
+  /**
+   * Override getTableList to handle MSSQL's object-format table names.
+   * MSSQL's showAllTables() may return {tableName: 'Name', schema: 'dbo'} objects.
+   */
+  async getTableList(): Promise<string[]> {
+    const tables = await this.db.sequelize.getQueryInterface().showAllTables();
+    return tables.map((table: any) => {
+      if (typeof table === 'string') {
+        return table;
+      }
+      // Object format: {tableName: 'TableName', schema: 'dbo'}
+      if (table && typeof table === 'object') {
+        return table.tableName || table.name || String(Object.values(table).find((v) => typeof v === 'string'));
+      }
+      return String(table);
+    });
+  }
+
+  /**
+   * Override getTableColumnsInfo to handle MSSQL-specific column metadata.
+   * Adds PK detection fallback via sys.indexes query.
+   */
+  async getTableColumnsInfo(tableInfo: tableInfo) {
+    const columns = await this.db.sequelize.getQueryInterface().describeTable(tableInfo);
+
+    // Check if any column is already marked as PK
+    let hasPrimaryKey = Object.values(columns).some((col: any) => col.primaryKey);
+
+    if (!hasPrimaryKey) {
+      const tableName = typeof tableInfo === 'string' ? tableInfo : tableInfo.tableName;
+      const schemaName = typeof tableInfo === 'string' ? 'dbo' : tableInfo.schema || 'dbo';
+      let pkColumns: string[] | undefined;
+
+      if (this.primaryKeyCache !== null) {
+        // Use bulk-loaded cache (no extra query per table)
+        pkColumns = this.primaryKeyCache.get(tableName);
+      } else {
+        // No cache available — fall back to per-table sys.indexes query
+        try {
+          const pkSql = `
+            SELECT c.name AS column_name
+            FROM sys.indexes i
+            INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+            INNER JOIN sys.columns c ON ic.object_id = c.object_id AND c.column_id = ic.column_id
+            INNER JOIN sys.objects o ON i.object_id = o.object_id
+            INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+            WHERE i.is_primary_key = 1
+              AND o.name = ${this.db.sequelize.escape(tableName)}
+              AND s.name = ${this.db.sequelize.escape(schemaName)}
+          `;
+          const pkResult = (await this.db.sequelize.query(pkSql, { type: 'SELECT' })) as any[];
+          pkColumns = pkResult?.map((row) => row.column_name as string);
+        } catch (err) {
+          this.db.logger.warn(`[MSSQL] Failed to query PK for ${tableName}:`, err);
+        }
+      }
+
+      if (pkColumns?.length) {
+        for (const colName of pkColumns) {
+          if (columns[colName]) {
+            (columns[colName] as any).primaryKey = true;
+            hasPrimaryKey = true;
+          }
+        }
+      }
+    }
+
+    // If still no PK, try 'id' column as fallback
+    if (!hasPrimaryKey && columns['id']) {
+      (columns['id'] as any).primaryKey = true;
+    }
+
+    // Clean up MSSQL-specific default values (SQL expressions like (newid()), ((0)))
+    for (const [name, col] of Object.entries(columns)) {
+      const rawDefault = (col as any).defaultValue;
+      if (rawDefault && typeof rawDefault === 'string' && rawDefault.startsWith('(') && rawDefault.endsWith(')')) {
+        // SQL expression default — clear it so Sequelize doesn't try to use it as a literal
+        (col as any).defaultValue = undefined;
+      }
+    }
+
+    return columns;
+  }
+
+  /**
+   * Override getTableConstraints to handle MSSQL-specific index format.
+   */
+  async getTableConstraints(tableInfo: tableInfo) {
+    try {
+      const tableName = typeof tableInfo === 'string' ? tableInfo : tableInfo.tableName;
+      return await this.db.sequelize.getQueryInterface().showIndex(tableName);
+    } catch (err) {
+      // MSSQL may not support showIndex well for all table types
+      this.db.logger.warn(
+        `[MSSQL] Failed to get indexes for ${typeof tableInfo === 'string' ? tableInfo : tableInfo.tableName}:`,
+        err,
+      );
+      return [];
+    }
+  }
+
+  /**
+   * Override to handle MSSQL auto-increment detection.
+   * MSSQL uses IDENTITY columns, not serial/nextval sequences.
+   */
+  protected columnAttribute(columnsInfo: any, columnName: string, indexes: any) {
+    const attr = super.columnAttribute(columnsInfo, columnName, indexes);
+
+    // MSSQL IDENTITY columns are already detected by Sequelize as autoIncrement
+    // No need for nextval/uuid_generate_v4 checks (those are PostgreSQL-specific)
+
+    return attr;
+  }
+
+  /**
+   * Override getViewList — MSSQL view listing support
+   */
+  async getViewList(): Promise<string[]> {
+    try {
+      const views = await this.db.queryInterface.listViews();
+      return views.map((view: any) => (typeof view === 'string' ? view : view.name || String(view)));
+    } catch {
+      // View listing may not be supported
+      return [];
+    }
+  }
+}

package/src/server/data-source/MssqlRepository.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { Repository, Collection, FindOptions, Model } from '@nocobase/database';
+import { MssqlSmartCursorBuilder } from './MssqlSmartCursorBuilder';
+
+/**
+ * MSSQL-specific Repository with optimized cursor-based pagination support
+ */
+export class MssqlRepository<
+  TModelAttributes extends {} = any,
+  TCreationAttributes extends {} = TModelAttributes,
+> extends Repository<TModelAttributes, TCreationAttributes> {
+  private mssqlCursorBuilder: MssqlSmartCursorBuilder;
+
+  constructor(collection: Collection) {
+    super(collection);
+
+    // Initialize MSSQL-specific cursor builder
+    this.mssqlCursorBuilder = new MssqlSmartCursorBuilder(
+      (this as any).database.sequelize,
+      (this as any).model.tableName,
+      collection,
+    );
+  }
+
+  /**
+   * Cursor-based pagination query function optimized for MSSQL.
+   * Ideal for large datasets (e.g., millions of rows)
+   *
+   * Note:
+   *  1. Does not support jumping to arbitrary pages (e.g., "Page 5")
+   *  2. Requires a stable, indexed sort field (e.g. ID, createdAt)
+   *  3. If custom orderBy is used, it must match the cursor field(s) and direction
+   *
+   * @param options - Query options
+   */
+  async chunkWithCursor(
+    options: FindOptions & {
+      chunkSize: number;
+      callback: (rows: Model[], options: FindOptions) => Promise<void>;
+      beforeFind?: (options: FindOptions) => Promise<void>;
+      afterFind?: (rows: Model[], options: FindOptions) => Promise<void>;
+    },
+  ) {
+    return await this.mssqlCursorBuilder.chunk({
+      ...options,
+      find: (this as any).find.bind(this),
+    });
+  }
+}

package/src/server/data-source/MssqlSmartCursorBuilder.ts

@@ -0,0 +1,327 @@
+/**
+ * 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 { Sequelize, QueryTypes, Op } from 'sequelize';
+import { Model } from '@nocobase/database';
+import _ from 'lodash';
+
+interface IndexInfo {
+  name: string;
+  columns: string[];
+  isPrimary: boolean;
+  isUnique: boolean;
+}
+
+interface FindOptions {
+  chunkSize?: number;
+  callback?: (rows: Model[], options: FindOptions) => Promise<void>;
+  find?: (options: FindOptions) => Promise<any[]>;
+  beforeFind?: (options: FindOptions) => Promise<void>;
+  afterFind?: (rows: Model[], options: FindOptions) => Promise<void>;
+  where?: any;
+  order?: any;
+  limit?: number;
+  [key: string]: any;
+}
+
+/**
+ * Cursor-based pagination strategy interface
+ */
+interface CursorStrategy {
+  buildWhere(baseWhere: any, record?: Model): any;
+  buildSort(): any;
+}
+
+/**
+ * Single column cursor strategy - for tables with single-column primary key or unique index
+ */
+class SingleColumnCursorStrategy implements CursorStrategy {
+  public columnName: string;
+
+  constructor(columnName: string) {
+    this.columnName = columnName;
+  }
+
+  buildSort() {
+    return [[this.columnName, 'ASC']];
+  }
+
+  buildWhere(baseWhere: any, record?: Model): any {
+    if (!record) {
+      return baseWhere;
+    }
+    return { ...baseWhere, [this.columnName]: { [Op.gt]: record[this.columnName] } };
+  }
+}
+
+/**
+ * Composite key cursor strategy - for tables with composite primary key or multi-column unique index
+ */
+class CompositeKeyCursorStrategy implements CursorStrategy {
+  private columns: string[];
+  private directions: string[];
+
+  constructor(columns: string[], directions?: string[]) {
+    this.columns = columns;
+    this.directions = directions || Array(columns.length).fill('ASC');
+  }
+
+  buildSort() {
+    const orderBy = [];
+    for (let i = 0; i < this.columns.length; i++) {
+      orderBy.push([this.columns[i], this.directions[i]]);
+    }
+    return orderBy;
+  }
+
+  buildWhere(baseWhere: any, record?: any): any {
+    if (!record) {
+      return baseWhere;
+    }
+    const whereConditions = [];
+
+    for (let i = 0; i < this.columns.length; i++) {
+      const column = this.columns[i];
+
+      if (i > 0) {
+        const equalConditions = {};
+        for (let j = 0; j < i; j++) {
+          equalConditions[this.columns[j]] = record[this.columns[j]];
+        }
+
+        whereConditions.push({
+          ...equalConditions,
+          [column]: {
+            [Op.gt]: record[column],
+          },
+        });
+      } else {
+        whereConditions.push({
+          [column]: {
+            [Op.gt]: record[column],
+          },
+        });
+      }
+    }
+    const cursorCondition = {
+      [Op.or]: whereConditions,
+    };
+
+    return baseWhere ? { [Op.and]: [baseWhere, cursorCondition] } : cursorCondition;
+  }
+}
+
+/**
+ * MSSQL-specific SmartCursorBuilder
+ * Provides cursor-based pagination for efficient large dataset processing
+ */
+export class MssqlSmartCursorBuilder {
+  private sequelize: Sequelize;
+  private tableName: string;
+  private collection: { filterTargetKey: string | string[] };
+
+  constructor(sequelize: Sequelize, tableName: string, collection: { filterTargetKey: string | string[] }) {
+    this.sequelize = sequelize;
+    this.tableName = tableName;
+    this.collection = collection;
+  }
+
+  /**
+   * Auto-detect the best cursor strategy based on table structure
+   * Uses MSSQL system views to find optimal index for cursor pagination
+   */
+  private async getBestCursorStrategy(): Promise<CursorStrategy> {
+    const indexInfoSql = `
+      SELECT 
+        i.name AS INDEX_NAME,
+        c.name AS COLUMN_NAME,
+        ic.key_ordinal AS SEQ_IN_INDEX,
+        CASE 
+          WHEN i.is_primary_key = 1 THEN 1
+          WHEN i.is_unique = 1 THEN 2
+          ELSE 3 
+        END as INDEX_TYPE,
+        CASE WHEN ic.is_descending_key = 1 THEN 'DESC' ELSE 'ASC' END as DIRECTION
+      FROM 
+        sys.indexes i
+        INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        INNER JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+      WHERE 
+        i.object_id = OBJECT_ID(?)
+        AND i.type > 0
+        AND ic.is_included_column = 0
+      ORDER BY 
+        i.name, 
+        ic.key_ordinal
+    `;
+
+    try {
+      const indexRows = (await this.sequelize.query(indexInfoSql, {
+        type: QueryTypes.SELECT,
+        replacements: [this.tableName],
+        raw: true,
+      })) as any[];
+
+      const indexes: Map<string, IndexInfo> = new Map();
+      const indexDirections: Map<string, Map<string, string>> = new Map();
+
+      // If no indexes found, fallback to filterTargetKey
+      if (!indexRows || indexRows.length === 0) {
+        return this.getFallbackStrategy();
+      }
+
+      // Parse index information
+      for (const row of indexRows) {
+        const indexName = row.INDEX_NAME;
+        const columnName = row.COLUMN_NAME;
+        const indexType = row.INDEX_TYPE;
+        const direction = row.DIRECTION;
+
+        // Store direction info
+        if (!indexDirections.has(indexName)) {
+          indexDirections.set(indexName, new Map());
+        }
+        indexDirections.get(indexName).set(columnName, direction);
+
+        // Build index info
+        if (!indexes.has(indexName)) {
+          indexes.set(indexName, {
+            name: indexName,
+            columns: [],
+            isPrimary: indexType === 1,
+            isUnique: indexType < 3,
+          });
+        }
+        const seqInIndex = row.SEQ_IN_INDEX;
+        const index = indexes.get(indexName);
+        index.columns[seqInIndex - 1] = columnName;
+      }
+
+      // 1. First, look for primary key
+      for (const index of indexes.values()) {
+        if (index.isPrimary) {
+          if (index.columns.length === 1) {
+            return new SingleColumnCursorStrategy(index.columns[0]);
+          } else {
+            const directions = index.columns.map((col) => indexDirections.get(index.name)?.get(col) || 'ASC');
+            return new CompositeKeyCursorStrategy(index.columns, directions);
+          }
+        }
+      }
+
+      // 2. Look for unique index (prefer single column)
+      let singleColumnUniqueIndex = null;
+      let multiColumnUniqueIndex = null;
+
+      for (const index of indexes.values()) {
+        if (index.isUnique && !index.isPrimary) {
+          if (index.columns.length === 1 && !singleColumnUniqueIndex) {
+            singleColumnUniqueIndex = index;
+          } else if (index.columns.length > 1 && !multiColumnUniqueIndex) {
+            multiColumnUniqueIndex = index;
+          }
+        }
+      }
+
+      if (singleColumnUniqueIndex) {
+        return new SingleColumnCursorStrategy(singleColumnUniqueIndex.columns[0]);
+      }
+
+      if (multiColumnUniqueIndex) {
+        const directions = multiColumnUniqueIndex.columns.map(
+          (col) => indexDirections.get(multiColumnUniqueIndex.name)?.get(col) || 'ASC',
+        );
+        return new CompositeKeyCursorStrategy(multiColumnUniqueIndex.columns, directions);
+      }
+
+      // 3. Use any available index
+      let anyIndex = null;
+      for (const index of indexes.values()) {
+        if (index.columns.length > 0 && !index.isPrimary && !index.isUnique) {
+          anyIndex = index;
+          break;
+        }
+      }
+
+      if (anyIndex) {
+        if (anyIndex.columns.length === 1) {
+          return new SingleColumnCursorStrategy(anyIndex.columns[0]);
+        } else {
+          return new CompositeKeyCursorStrategy(anyIndex.columns);
+        }
+      }
+
+      // Fallback to filterTargetKey
+      return this.getFallbackStrategy();
+    } catch (error) {
+      console.error('[MssqlSmartCursorBuilder] Error getting index info:', error);
+      return this.getFallbackStrategy();
+    }
+  }
+
+  /**
+   * Fallback strategy when no index information is available
+   */
+  private getFallbackStrategy(): CursorStrategy {
+    if (Array.isArray(this.collection.filterTargetKey)) {
+      return new CompositeKeyCursorStrategy(this.collection.filterTargetKey);
+    }
+    return new SingleColumnCursorStrategy(this.collection.filterTargetKey || 'id');
+  }
+
+  /**
+   * Cursor-based pagination query function.
+   * Ideal for large datasets (e.g., millions of rows)
+   *
+   * Note:
+   *  1. Does not support jumping to arbitrary pages (e.g., "Page 5")
+   *  2. Requires a stable, indexed sort field (e.g. ID, createdAt)
+   *  3. If custom orderBy is used, it must match the cursor field(s) and direction
+   *
+   * @param options - Query options including chunkSize, callback, and find function
+   */
+  async chunk(options: FindOptions) {
+    const cursorStrategy = await this.getBestCursorStrategy();
+    let cursorRecord = null;
+    let hasMoreData = true;
+    let isFirst = true;
+
+    options.order = cursorStrategy.buildSort();
+    options['parseSort'] = false;
+
+    while (hasMoreData) {
+      if (!isFirst) {
+        options.where = cursorStrategy.buildWhere(options.where, cursorRecord);
+      }
+      if (isFirst) {
+        isFirst = false;
+      }
+
+      options.limit = options.chunkSize || 1000;
+
+      if (options.beforeFind) {
+        await options.beforeFind(options);
+      }
+
+      const records = await options.find(_.omit(options, 'callback', 'beforeFind', 'afterFind', 'chunkSize', 'find'));
+
+      if (options.afterFind) {
+        await options.afterFind(records, options);
+      }
+
+      if (records.length === 0) {
+        hasMoreData = false;
+        continue;
+      }
+
+      await options.callback(records, options);
+      cursorRecord = records[records.length - 1];
+    }
+  }
+}

package/src/server/dialects/mssql-dialect.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { BaseDialect, DatabaseOptions } from '@nocobase/database';
+
+export class MssqlDialect extends BaseDialect {
+  static dialectName = 'mssql';
+
+  getVersionGuard() {
+    return {
+      sql: "SELECT CAST(SERVERPROPERTY('ProductVersion') AS VARCHAR) AS version",
+      get: (v: string) => {
+        const m = /([\d.]+)/.exec(v);
+        return m?.[0] || v;
+      },
+      version: '>=12.0.0',
+    };
+  }
+
+  getSequelizeOptions(options: DatabaseOptions) {
+    const dialectOptions = options.dialectOptions || {};
+    const encrypt = (options as DatabaseOptions & { encrypt?: boolean }).encrypt;
+    const dialectInnerOptions = (dialectOptions as { options?: Record<string, unknown> } | undefined)?.options || {};
+
+    options.dialectOptions = {
+      ...dialectOptions,
+      options: {
+        ...dialectInnerOptions,
+        ...(encrypt === undefined ? {} : { encrypt }),
+      },
+    };
+
+    return options;
+  }
+}