metal-orm 1.0.49 → 1.0.51

package/scripts/inflection/pt-br.mjs

@@ -0,0 +1,391 @@
+import {
+  applyToCompoundHead,
+  normalizeLookup,
+  stripDiacritics
+} from './compound.mjs';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PATTERNS
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Precompiled regex patterns for performance.
+ * @type {Readonly<Record<string, RegExp>>}
+ */
+const PATTERNS = Object.freeze({
+  consonantEnding: /[rzn]$/,
+  consonantEsEnding: /[rzn]es$/,
+  endsInX: /x$/,
+  vowelBeforeS: /[aeiou]s$/,
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// IRREGULAR DICTIONARIES (all normalized - no diacritics)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Default irregular plurals for Brazilian Portuguese.
+ * Keys AND values are normalized (no diacritics, lowercase).
+ * @type {Readonly<Record<string, string>>}
+ */
+export const PT_BR_DEFAULT_IRREGULARS = Object.freeze({
+  // ─────────────────────────────────────────────────────────────────────────
+  // -ão → -ães (irregular, must memorize)
+  // ─────────────────────────────────────────────────────────────────────────
+  'pao': 'paes',
+  'cao': 'caes',
+  'alemao': 'alemaes',
+  'capitao': 'capitaes',
+  'charlatao': 'charlataes',
+  'escrivao': 'escrivaes',
+  'tabeliao': 'tabeliaes',
+  'guardiao': 'guardiaes',
+  'sacristao': 'sacristaes',
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // -ão → -ãos (irregular, must memorize)
+  // ─────────────────────────────────────────────────────────────────────────
+  'mao': 'maos',
+  'cidadao': 'cidadaos',
+  'cristao': 'cristaos',
+  'irmao': 'irmaos',
+  'orgao': 'orgaos',
+  'bencao': 'bencaos',
+  'grao': 'graos',
+  'orfao': 'orfaos',
+  'sotao': 'sotaos',
+  'acordao': 'acordaos',
+  'cortesao': 'cortesaos',
+  'pagao': 'pagaos',
+  'chao': 'chaos',
+  'vao': 'vaos',
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // -l special cases
+  // ─────────────────────────────────────────────────────────────────────────
+  'mal': 'males',
+  'consul': 'consules',
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Unstressed -il → -eis (paroxytones)
+  // ─────────────────────────────────────────────────────────────────────────
+  'fossil': 'fosseis',
+  'reptil': 'repteis',
+  'facil': 'faceis',
+  'dificil': 'dificeis',
+  'util': 'uteis',
+  'inutil': 'inuteis',
+  'agil': 'ageis',
+  'fragil': 'frageis',
+  'projetil': 'projeteis',
+  'volatil': 'volateis',
+  'docil': 'doceis',
+  'portatil': 'portateis',
+  'textil': 'texteis',
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Invariable words (paroxytone/proparoxytone ending in -s/-x)
+  // ─────────────────────────────────────────────────────────────────────────
+  'onibus': 'onibus',
+  'lapis': 'lapis',
+  'virus': 'virus',
+  'atlas': 'atlas',
+  'pires': 'pires',
+  'cais': 'cais',
+  'torax': 'torax',
+  'fenix': 'fenix',
+  'xerox': 'xerox',
+  'latex': 'latex',
+  'index': 'index',
+  'duplex': 'duplex',
+  'telex': 'telex',
+  'climax': 'climax',
+  'simples': 'simples',
+  'oasis': 'oasis',
+  'tenis': 'tenis',
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // -ês → -eses (nationalities, months, etc.)
+  // ─────────────────────────────────────────────────────────────────────────
+  'portugues': 'portugueses',
+  'ingles': 'ingleses',
+  'frances': 'franceses',
+  'holandes': 'holandeses',
+  'japones': 'japoneses',
+  'chines': 'chineses',
+  'irlandes': 'irlandeses',
+  'escoces': 'escoceses',
+  'mes': 'meses',
+  'burges': 'burgueses',
+  'fregues': 'fregueses',
+  'marques': 'marqueses',
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Other irregulars
+  // ─────────────────────────────────────────────────────────────────────────
+  'qualquer': 'quaisquer',
+  'carater': 'caracteres',
+  'junior': 'juniores',
+  'senior': 'seniores',
+});
+
+/**
+ * Builds reverse irregular mapping (plural → singular).
+ * @param {Record<string, string>} irregulars
+ * @returns {Record<string, string>}
+ */
+const buildSingularIrregulars = (irregulars) => {
+  const result = {};
+  for (const [singular, plural] of Object.entries(irregulars)) {
+    if (plural !== singular) {
+      result[plural] = singular;
+    }
+  }
+  return result;
+};
+
+/**
+ * Default irregular singulars (auto-generated reverse mapping).
+ * @type {Readonly<Record<string, string>>}
+ */
+export const PT_BR_DEFAULT_SINGULAR_IRREGULARS = Object.freeze(
+  buildSingularIrregulars(PT_BR_DEFAULT_IRREGULARS)
+);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CONNECTORS
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Portuguese connector words used in compound expressions.
+ * @type {ReadonlySet<string>}
+ */
+export const PT_BR_CONNECTORS = Object.freeze(new Set(
+  [
+    'de', 'da', 'do', 'das', 'dos',
+    'em', 'na', 'no', 'nas', 'nos',
+    'a', 'ao', 'as', 'aos',
+    'com', 'sem', 'sob', 'sobre',
+    'para', 'por', 'pela', 'pelo', 'pelas', 'pelos',
+    'entre', 'contra', 'perante',
+    'e', 'ou'
+  ].map(normalizeLookup)
+));
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INFLECTION RULES
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Pluralization rules for Portuguese words.
+ * Format: [suffix, replacement, suffixLength]
+ * @type {ReadonlyArray<Readonly<[string, string, number]>>}
+ */
+const PLURAL_RULES = Object.freeze([
+  // -ão → -ões (default; -ães and -ãos handled via irregulars)
+  ['ao', 'oes', 2],
+  // -m → -ns
+  ['m', 'ns', 1],
+  // -l endings
+  ['al', 'ais', 2],
+  ['el', 'eis', 2],
+  ['ol', 'ois', 2],
+  ['ul', 'uis', 2],
+  ['il', 'is', 2], // Stressed -il; unstressed in irregulars
+]);
+
+/**
+ * Singularization rules for Portuguese words.
+ * Format: [suffix, replacement, suffixLength]
+ * @type {ReadonlyArray<Readonly<[string, string, number]>>}
+ */
+const SINGULAR_RULES = Object.freeze([
+  // -ões/-ães/-ãos → -ão
+  ['oes', 'ao', 3],
+  ['aes', 'ao', 3],
+  ['aos', 'ao', 3],
+  // -ns → -m
+  ['ns', 'm', 2],
+  // -l endings reverse
+  ['ais', 'al', 3],
+  ['eis', 'el', 3],
+  ['ois', 'ol', 3],
+  ['uis', 'ul', 3],
+  ['is', 'il', 2],
+  // -eses → -es
+  ['eses', 'es', 4],
+]);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// UTILITY FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Normalizes a word for rule matching and irregular lookup.
+ * @param {string} word - The word to normalize
+ * @returns {string} Normalized word (lowercase, no diacritics)
+ */
+const normalizeWord = (word) =>
+  stripDiacritics((word ?? '').toString()).toLowerCase().trim();
+
+/**
+ * Applies suffix rules to a word.
+ * @param {string} word - Normalized word
+ * @param {ReadonlyArray<Readonly<[string, string, number]>>} rules
+ * @returns {string|null} Transformed word or null if no rule matched
+ */
+const applyRules = (word, rules) => {
+  for (const [suffix, replacement, length] of rules) {
+    if (word.endsWith(suffix)) {
+      return word.slice(0, -length) + replacement;
+    }
+  }
+  return null;
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PLURALIZATION
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Converts a Portuguese word to its plural form.
+ * Output is normalized (no diacritics, lowercase).
+ *
+ * @param {string} word - The word to pluralize
+ * @param {Record<string, string>} [irregulars=PT_BR_DEFAULT_IRREGULARS]
+ * @returns {string} The pluralized word (normalized)
+ */
+export const pluralizeWordPtBr = (
+  word,
+  irregulars = PT_BR_DEFAULT_IRREGULARS
+) => {
+  const normalized = normalizeWord(word);
+  if (!normalized) return '';
+
+  // 1. Check irregulars first
+  const irregular = irregulars[normalized];
+  if (irregular !== undefined) {
+    return irregular;
+  }
+
+  // 2. Apply suffix-based rules
+  const ruleResult = applyRules(normalized, PLURAL_RULES);
+  if (ruleResult !== null) {
+    return ruleResult;
+  }
+
+  // 3. Words ending in -x are typically invariable
+  if (PATTERNS.endsInX.test(normalized)) {
+    return normalized;
+  }
+
+  // 4. Consonants r, z, n require -es
+  if (PATTERNS.consonantEnding.test(normalized)) {
+    return normalized + 'es';
+  }
+
+  // 5. Words ending in -s (invariable or already plural)
+  if (normalized.endsWith('s')) {
+    return normalized;
+  }
+
+  // 6. Default: add -s
+  return normalized + 's';
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SINGULARIZATION
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Converts a Portuguese word to its singular form.
+ * Output is normalized (no diacritics, lowercase).
+ *
+ * @param {string} word - The word to singularize
+ * @param {Record<string, string>} [irregulars=PT_BR_DEFAULT_SINGULAR_IRREGULARS]
+ * @returns {string} The singularized word (normalized)
+ */
+export const singularizeWordPtBr = (
+  word,
+  irregulars = PT_BR_DEFAULT_SINGULAR_IRREGULARS
+) => {
+  const normalized = normalizeWord(word);
+  if (!normalized) return '';
+
+  // 1. Check irregulars first
+  const irregular = irregulars[normalized];
+  if (irregular !== undefined) {
+    return irregular;
+  }
+
+  // 2. Apply suffix-based rules
+  const ruleResult = applyRules(normalized, SINGULAR_RULES);
+  if (ruleResult !== null) {
+    return ruleResult;
+  }
+
+  // 3. Handle consonant + es pattern
+  if (PATTERNS.consonantEsEnding.test(normalized)) {
+    return normalized.slice(0, -2);
+  }
+
+  // 4. Words ending in vowel+s: remove s
+  if (PATTERNS.vowelBeforeS.test(normalized)) {
+    return normalized.slice(0, -1);
+  }
+
+  // 5. Already singular or invariable
+  return normalized;
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// COMPOUND TERM HANDLING
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Pluralizes a compound property/relation name in Portuguese.
+ */
+export const pluralizeRelationPropertyPtBr = (
+  term,
+  { pluralizeWord = pluralizeWordPtBr, connectors = PT_BR_CONNECTORS } = {}
+) => applyToCompoundHead(term, { connectors, transformWord: pluralizeWord });
+
+/**
+ * Singularizes a compound property/relation name in Portuguese.
+ */
+export const singularizeRelationPropertyPtBr = (
+  term,
+  { singularizeWord = singularizeWordPtBr, connectors = PT_BR_CONNECTORS } = {}
+) => applyToCompoundHead(term, { connectors, transformWord: singularizeWord });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INFLECTOR FACTORY
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Creates a Brazilian Portuguese inflector instance.
+ */
+export const createPtBrInflector = ({ customIrregulars = {} } = {}) => {
+  const irregularPlurals = Object.freeze({
+    ...PT_BR_DEFAULT_IRREGULARS,
+    ...customIrregulars
+  });
+
+  const irregularSingulars = Object.freeze({
+    ...PT_BR_DEFAULT_SINGULAR_IRREGULARS,
+    ...buildSingularIrregulars(customIrregulars)
+  });
+
+  return Object.freeze({
+    locale: 'pt-BR',
+    irregularPlurals,
+    irregularSingulars,
+    pluralizeWord: (w) => pluralizeWordPtBr(w, irregularPlurals),
+    singularizeWord: (w) => singularizeWordPtBr(w, irregularSingulars),
+    pluralizeRelationProperty: pluralizeRelationPropertyPtBr,
+    singularizeRelationProperty: singularizeRelationPropertyPtBr,
+    normalizeForLookup: normalizeWord
+  });
+};
+
+export default createPtBrInflector;

package/scripts/naming-strategy.mjs

@@ -1,18 +1,23 @@
+import { resolveInflector } from './inflection/index.mjs';
+
 export class BaseNamingStrategy {
-  constructor(irregulars = {}) {
+  constructor(irregulars = {}, inflector = resolveInflector('en')) {
     this.irregulars = new Map();
     this.inverseIrregulars = new Map();
+    this.inflector = inflector;
     for (const [singular, plural] of Object.entries(irregulars)) {
       if (!singular || !plural) continue;
-      const singularKey = singular.toLowerCase();
-      const pluralValue = plural.toLowerCase();
+      const normalize = this.inflector.normalizeForIrregularKey || (value => String(value).toLowerCase());
+      const singularKey = normalize(singular);
+      const pluralValue = normalize(plural);
       this.irregulars.set(singularKey, pluralValue);
       this.inverseIrregulars.set(pluralValue, singularKey);
     }
   }
 
   applyIrregular(word, direction) {
-    const lower = word.toLowerCase();
+    const normalize = this.inflector.normalizeForIrregularKey || (value => String(value).toLowerCase());
+    const lower = normalize(word);
     if (direction === 'plural' && this.irregulars.has(lower)) {
       return this.irregulars.get(lower);
     }
@@ -49,20 +54,13 @@ export class BaseNamingStrategy {
   pluralize(word) {
     const irregular = this.applyIrregular(word, 'plural');
     if (irregular) return irregular;
-    const lower = word.toLowerCase();
-    if (lower.endsWith('y')) return `${lower.slice(0, -1)}ies`;
-    if (lower.endsWith('s')) return `${lower}es`;
-    return `${lower}s`;
+    return this.inflector.pluralizeWord(word);
   }
 
   singularize(word) {
     const irregular = this.applyIrregular(word, 'singular');
     if (irregular) return irregular;
-    const lower = word.toLowerCase();
-    if (lower.endsWith('ies')) return `${lower.slice(0, -3)}y`;
-    if (lower.endsWith('ses')) return lower.slice(0, -2);
-    if (lower.endsWith('s')) return lower.slice(0, -1);
-    return lower;
+    return this.inflector.singularizeWord(word);
   }
 
   classNameFromTable(tableName) {
@@ -76,7 +74,11 @@ export class BaseNamingStrategy {
   }
 
   hasManyProperty(targetTable) {
-    return this.toCamelCase(this.pluralize(this.singularize(targetTable)));
+    const base = this.singularize(targetTable);
+    const plural = this.inflector.pluralizeRelationProperty
+      ? this.inflector.pluralizeRelationProperty(base, { pluralizeWord: word => this.pluralize(word) })
+      : this.pluralize(base);
+    return this.toCamelCase(plural);
   }
 
   hasOneProperty(targetTable) {
@@ -84,7 +86,7 @@ export class BaseNamingStrategy {
   }
 
   belongsToManyProperty(targetTable) {
-    return this.toCamelCase(this.pluralize(this.singularize(targetTable)));
+    return this.hasManyProperty(targetTable);
   }
 
   defaultTableNameFromClass(className) {
@@ -94,59 +96,21 @@ export class BaseNamingStrategy {
   }
 }
 
-export class EnglishNamingStrategy extends BaseNamingStrategy {}
-
-const DEFAULT_PT_IRREGULARS = {
-  mao: 'maos',
-  pao: 'paes',
-  cao: 'caes',
-  mal: 'males',
-  consul: 'consules'
-};
-
-export class PortugueseNamingStrategy extends BaseNamingStrategy {
+export class EnglishNamingStrategy extends BaseNamingStrategy {
   constructor(irregulars = {}) {
-    super({ ...DEFAULT_PT_IRREGULARS, ...irregulars });
-  }
-
-  pluralize(word) {
-    const irregular = this.applyIrregular(word, 'plural');
-    if (irregular) return irregular;
-    const lower = word.toLowerCase();
-    if (lower.endsWith('cao')) return `${lower.slice(0, -3)}coes`;
-    if (lower.endsWith('ao')) return `${lower.slice(0, -2)}oes`;
-    if (lower.endsWith('m')) return `${lower.slice(0, -1)}ns`;
-    if (lower.endsWith('al')) return `${lower.slice(0, -2)}ais`;
-    if (lower.endsWith('el')) return `${lower.slice(0, -2)}eis`;
-    if (lower.endsWith('ol')) return `${lower.slice(0, -2)}ois`;
-    if (lower.endsWith('ul')) return `${lower.slice(0, -2)}uis`;
-    if (lower.endsWith('il')) return `${lower.slice(0, -2)}is`;
-    if (/[rznsx]$/.test(lower)) return `${lower}es`;
-    if (lower.endsWith('s')) return lower;
-    return `${lower}s`;
+    super(irregulars, resolveInflector('en'));
   }
+}
 
-  singularize(word) {
-    const irregular = this.applyIrregular(word, 'singular');
-    if (irregular) return irregular;
-    const lower = word.toLowerCase();
-    if (lower.endsWith('coes')) return `${lower.slice(0, -4)}cao`;
-    if (lower.endsWith('oes')) return `${lower.slice(0, -3)}ao`;
-    if (lower.endsWith('ns')) return `${lower.slice(0, -2)}m`;
-    if (lower.endsWith('ais')) return `${lower.slice(0, -3)}al`;
-    if (lower.endsWith('eis')) return `${lower.slice(0, -3)}el`;
-    if (lower.endsWith('ois')) return `${lower.slice(0, -3)}ol`;
-    if (lower.endsWith('uis')) return `${lower.slice(0, -3)}ul`;
-    if (lower.endsWith('is')) return `${lower.slice(0, -2)}il`;
-    if (/[rznsx]es$/.test(lower)) return lower.replace(/es$/, '');
-    if (lower.endsWith('s')) return lower.slice(0, -1);
-    return lower;
+export class PortugueseNamingStrategy extends BaseNamingStrategy {
+  constructor(irregulars = {}) {
+    const inflector = resolveInflector('pt-BR');
+    super({ ...inflector.defaultIrregulars, ...irregulars }, inflector);
   }
 }
 
 export const createNamingStrategy = (locale = 'en', irregulars) => {
-  const normalized = (locale || 'en').toLowerCase();
-  if (normalized.startsWith('pt')) return new PortugueseNamingStrategy(irregulars);
-  if (normalized.startsWith('en')) return new EnglishNamingStrategy(irregulars);
-  return new EnglishNamingStrategy(irregulars);
+  const inflector = resolveInflector(locale);
+  const mergedIrregulars = { ...(inflector.defaultIrregulars || {}), ...(irregulars || {}) };
+  return new BaseNamingStrategy(mergedIrregulars, inflector);
 };

package/scripts/pt-pluralizer.mjs

@@ -0,0 +1,19 @@
+export {
+  stripDiacritics,
+  normalizeLookup,
+  detectTextFormat,
+  splitIntoWords,
+  rebuildFromWords,
+  applyToCompoundHead
+} from './inflection/compound.mjs';
+
+import {
+  PT_BR_CONNECTORS as DEFAULT_CONNECTORS,
+  pluralizeWordPtBr,
+  pluralizeRelationPropertyPtBr as pluralizeCompoundHead
+} from './inflection/pt-br.mjs';
+
+export { DEFAULT_CONNECTORS, pluralizeWordPtBr, pluralizeCompoundHead };
+
+export const pluralizeTerm = pluralizeCompoundHead;
+export default pluralizeTerm;

package/src/core/ddl/introspect/mssql.ts

@@ -1,6 +1,6 @@
 import type { ReferentialAction } from '../../../schema/column-types.js';
 import { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { shouldIncludeTable } from './utils.js';
+import { shouldIncludeTable, queryRows } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
 import type { IntrospectContext } from './context.js';
 import { runSelectNode } from './run-select.js';
@@ -67,6 +67,19 @@ type MssqlForeignKeyRow = {
   update_rule: string | null;
 };
 
+type MssqlTableCommentRow = {
+  table_schema: string;
+  table_name: string;
+  comment: string | null;
+};
+
+type MssqlColumnCommentRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  comment: string | null;
+};
+
 type ForeignKeyEntry = {
   table: string;
   column: string;
@@ -107,6 +120,60 @@ export const mssqlIntrospector: SchemaIntrospector = {
   async introspect(ctx: IntrospectContext, options: IntrospectOptions): Promise<DatabaseSchema> {
     const schema = options.schema;
     const schemaCondition = schema ? eq(columnNode('sch', 'name'), schema) : undefined;
+    const schemaFilter = schema ? 'AND sch.name = @p1' : '';
+    const schemaParams = schema ? [schema] : [];
+    const tableCommentRows = (await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        CONVERT(nvarchar(4000), ep.value) AS comment
+      FROM sys.extended_properties ep
+      JOIN sys.tables t ON t.object_id = ep.major_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE ep.class = 1
+        AND ep.minor_id = 0
+        AND ep.name = 'MS_Description'
+        ${schemaFilter}
+      `,
+      schemaParams
+    )) as MssqlTableCommentRow[];
+    const columnCommentRows = (await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        col.name AS column_name,
+        CONVERT(nvarchar(4000), ep.value) AS comment
+      FROM sys.extended_properties ep
+      JOIN sys.columns col ON col.object_id = ep.major_id AND col.column_id = ep.minor_id
+      JOIN sys.tables t ON t.object_id = col.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE ep.class = 1
+        AND ep.minor_id > 0
+        AND ep.name = 'MS_Description'
+        ${schemaFilter}
+      `,
+      schemaParams
+    )) as MssqlColumnCommentRow[];
+    const tableComments = new Map<string, string>();
+    tableCommentRows.forEach(r => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!r.comment) return;
+      const trimmed = r.comment.trim();
+      if (!trimmed) return;
+      tableComments.set(`${r.table_schema}.${r.table_name}`, trimmed);
+    });
+    const columnComments = new Map<string, string>();
+    columnCommentRows.forEach(r => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!r.comment) return;
+      const trimmed = r.comment.trim();
+      if (!trimmed) return;
+      columnComments.set(`${r.table_schema}.${r.table_name}.${r.column_name}`, trimmed);
+    });
 
     const dataTypeExpression = buildMssqlDataType(
       { table: 'ty', name: 'name' },
@@ -425,7 +492,8 @@ export const mssqlIntrospector: SchemaIntrospector = {
           schema: r.table_schema,
           columns: [],
           primaryKey: pkMap.get(key) || [],
-          indexes: []
+          indexes: [],
+          comment: tableComments.get(key)
         });
       }
       const table = tablesByKey.get(key)!;
@@ -436,6 +504,10 @@ export const mssqlIntrospector: SchemaIntrospector = {
         default: r.column_default ?? undefined,
         autoIncrement: !!r.is_identity
       };
+      const columnComment = columnComments.get(`${key}.${r.column_name}`);
+      if (columnComment) {
+        column.comment = columnComment;
+      }
       const fk = fkMap.get(`${key}.${r.column_name}`)?.[0];
       if (fk) {
         column.references = {