metal-orm 1.0.46 → 1.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/scripts/generate-entities.mjs

@@ -23,6 +23,7 @@ import {
   createSqliteExecutor,
   createMssqlExecutor
 } from '../dist/index.js';
+import { createNamingStrategy } from './naming-strategy.mjs';
 
 const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 
@@ -41,6 +42,8 @@ const parseArgs = () => {
       include: { type: 'string' },
       exclude: { type: 'string' },
       out: { type: 'string' },
+      locale: { type: 'string' },
+      'naming-overrides': { type: 'string' },
       'dry-run': { type: 'boolean' },
       help: { type: 'boolean', short: 'h' },
       version: { type: 'boolean' }
@@ -70,6 +73,10 @@ const parseArgs = () => {
     include: values.include ? values.include.split(',').map(v => v.trim()).filter(Boolean) : undefined,
     exclude: values.exclude ? values.exclude.split(',').map(v => v.trim()).filter(Boolean) : undefined,
     out: values.out ? path.resolve(process.cwd(), values.out) : path.join(process.cwd(), 'generated-entities.ts'),
+    locale: (values.locale || 'en').toLowerCase(),
+    namingOverrides: values['naming-overrides']
+      ? path.resolve(process.cwd(), values['naming-overrides'])
+      : undefined,
     dryRun: Boolean(values['dry-run'])
   };
 
@@ -102,6 +109,8 @@ Usage:
 Flags:
   --include=tbl1,tbl2   Only include these tables
   --exclude=tbl3,tbl4   Exclude these tables
+  --locale=pt-BR        Naming locale for class/relation names (default: en)
+  --naming-overrides    Path to JSON map of irregular plurals { "singular": "plural" }
   --dry-run             Print to stdout instead of writing a file
   --help                Show this help
 `
@@ -110,56 +119,26 @@ Flags:
 
 const escapeJsString = value => value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 
-const toPascalCase = value =>
-  value
-    .split(/[^a-zA-Z0-9]+/)
-    .filter(Boolean)
-    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-    .join('') || 'Entity';
-
-const toCamelCase = value => {
-  const pascal = toPascalCase(value);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-};
-
-const singularize = name => {
-  if (name.endsWith('ies')) return name.slice(0, -3) + 'y';
-  if (name.endsWith('ses')) return name.slice(0, -2);
-  if (name.endsWith('s')) return name.slice(0, -1);
-  return name;
-};
-
-const pluralize = name => {
-  if (name.endsWith('y')) return `${name.slice(0, -1)}ies`;
-  if (name.endsWith('s')) return `${name}es`;
-  return `${name}s`;
-};
-
-const deriveClassName = tableName => toPascalCase(singularize(tableName));
-
-const toSnakeCase = value =>
-  value
-    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-    .replace(/[^a-z0-9_]+/gi, '_')
-    .replace(/__+/g, '_')
-    .replace(/^_|_$/g, '')
-    .toLowerCase();
-
-const deriveDefaultTableNameFromClass = className => {
-  const normalized = toSnakeCase(className);
-  if (!normalized) return 'unknown';
-  return normalized.endsWith('s') ? normalized : `${normalized}s`;
-};
-
-const deriveBelongsToName = (fkName, targetTable) => {
-  const trimmed = fkName.replace(/_?id$/i, '');
-  const base = trimmed && trimmed !== fkName ? trimmed : singularize(targetTable);
-  return toCamelCase(base);
+const loadIrregulars = async filePath => {
+  const raw = await fs.readFile(filePath, 'utf8');
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse naming overrides at ${filePath}: ${err.message || err}`);
+  }
+  const irregulars =
+    parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed.irregulars && typeof parsed.irregulars === 'object' && !Array.isArray(parsed.irregulars)
+        ? parsed.irregulars
+        : parsed
+      : undefined;
+  if (!irregulars) {
+    throw new Error(`Naming overrides at ${filePath} must be an object or { "irregulars": { ... } }`);
+  }
+  return irregulars;
 };
 
-const deriveHasManyName = targetTable => toCamelCase(pluralize(targetTable));
-const deriveBelongsToManyName = targetTable => toCamelCase(pluralize(targetTable));
-
 const parseColumnType = colTypeRaw => {
   const type = (colTypeRaw || '').toLowerCase();
   const lengthMatch = type.match(/\((\d+)(?:\s*,\s*(\d+))?\)/);
@@ -266,7 +245,8 @@ const renderColumnExpression = (column, tablePk) => {
   };
 };
 
-const mapRelations = tables => {
+const mapRelations = (tables, naming) => {
+  const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
   const relationMap = new Map();
   const relationKeys = new Map();
   const fkIndex = new Map();
@@ -283,12 +263,15 @@ const mapRelations = tables => {
     }
   }
 
-  const findTable = name => tables.find(t => t.name === name);
+  const findTable = name => {
+    const norm = normalizeName(name);
+    return tables.find(t => t.name === name || t.name === norm);
+  };
 
   const pivotTables = new Set();
   for (const table of tables) {
     const fkCols = fkIndex.get(table.name) || [];
-    const distinctTargets = Array.from(new Set(fkCols.map(c => c.references.table)));
+    const distinctTargets = Array.from(new Set(fkCols.map(c => normalizeName(c.references.table))));
     if (fkCols.length === 2 && distinctTargets.length === 2) {
       const [a, b] = fkCols;
       pivotTables.add(table.name);
@@ -297,8 +280,8 @@ const mapRelations = tables => {
       if (targetA && targetB) {
         const aKey = relationKeys.get(targetA.name);
         const bKey = relationKeys.get(targetB.name);
-        const aProp = deriveBelongsToManyName(targetB.name);
-        const bProp = deriveBelongsToManyName(targetA.name);
+        const aProp = naming.belongsToManyProperty(targetB.name);
+        const bProp = naming.belongsToManyProperty(targetA.name);
         if (!aKey.has(aProp)) {
           aKey.add(aProp);
           relationMap.get(targetA.name)?.push({
@@ -329,10 +312,13 @@ const mapRelations = tables => {
     const fkCols = fkIndex.get(table.name) || [];
     for (const fk of fkCols) {
       const targetTable = fk.references.table;
+      const targetKey = normalizeName(targetTable);
       const belongsKey = relationKeys.get(table.name);
-      const hasManyKey = relationKeys.get(targetTable);
+      const hasManyKey = targetKey ? relationKeys.get(targetKey) : undefined;
 
-      const belongsProp = deriveBelongsToName(fk.name, targetTable);
+      if (!belongsKey || !hasManyKey) continue;
+
+      const belongsProp = naming.belongsToProperty(fk.name, targetTable);
       if (!belongsKey.has(belongsProp)) {
         belongsKey.add(belongsProp);
         relationMap.get(table.name)?.push({
@@ -343,10 +329,10 @@ const mapRelations = tables => {
         });
       }
 
-      const hasManyProp = deriveHasManyName(table.name);
+      const hasManyProp = naming.hasManyProperty(table.name);
       if (!hasManyKey.has(hasManyProp)) {
         hasManyKey.add(hasManyProp);
-        relationMap.get(targetTable)?.push({
+        relationMap.get(targetKey)?.push({
           kind: 'hasMany',
           property: hasManyProp,
           target: table.name,
@@ -360,16 +346,37 @@ const mapRelations = tables => {
 };
 
 const renderEntityFile = (schema, options) => {
+  const naming = options.naming || createNamingStrategy('en');
   const tables = schema.tables.map(t => ({
     name: t.name,
+    schema: t.schema,
     columns: t.columns,
     primaryKey: t.primaryKey || []
   }));
 
   const classNames = new Map();
-  tables.forEach(t => classNames.set(t.name, deriveClassName(t.name)));
+  tables.forEach(t => {
+    const className = naming.classNameFromTable(t.name);
+    classNames.set(t.name, className);
+    if (t.schema) {
+      const qualified = `${t.schema}.${t.name}`;
+      if (!classNames.has(qualified)) {
+        classNames.set(qualified, className);
+      }
+    }
+  });
+
+  const resolveClassName = target => {
+    if (!target) return undefined;
+    if (classNames.has(target)) return classNames.get(target);
+    const fallback = target.split('.').pop();
+    if (fallback && classNames.has(fallback)) {
+      return classNames.get(fallback);
+    }
+    return undefined;
+  };
 
-  const relations = mapRelations(tables);
+  const relations = mapRelations(tables, naming);
 
   const usage = {
     needsCol: false,
@@ -454,7 +461,7 @@ const renderEntityFile = (schema, options) => {
 
   for (const table of tables) {
     const className = classNames.get(table.name);
-    const derivedDefault = deriveDefaultTableNameFromClass(className);
+    const derivedDefault = naming.defaultTableNameFromClass(className);
     const needsTableNameOption = table.name !== derivedDefault;
     const entityOpts = needsTableNameOption ? `{ tableName: '${escapeJsString(table.name)}' }` : '';
     lines.push(`@Entity(${entityOpts})`);
@@ -469,7 +476,7 @@ const renderEntityFile = (schema, options) => {
 
     const rels = relations.get(table.name) || [];
     for (const rel of rels) {
-      const targetClass = classNames.get(rel.target);
+      const targetClass = resolveClassName(rel.target);
       if (!targetClass) continue;
       switch (rel.kind) {
         case 'belongsTo':
@@ -487,10 +494,10 @@ const renderEntityFile = (schema, options) => {
           lines.push('');
           break;
         case 'belongsToMany':
+          const pivotClass = resolveClassName(rel.pivotTable);
+          if (!pivotClass) break;
           lines.push(
-            `  @BelongsToMany({ target: () => ${targetClass}, pivotTable: () => ${classNames.get(
-              rel.pivotTable
-            )}, pivotForeignKeyToRoot: '${escapeJsString(rel.pivotForeignKeyToRoot)}', pivotForeignKeyToTarget: '${escapeJsString(rel.pivotForeignKeyToTarget)}' })`
+            `  @BelongsToMany({ target: () => ${targetClass}, pivotTable: () => ${pivotClass}, pivotForeignKeyToRoot: '${escapeJsString(rel.pivotForeignKeyToRoot)}', pivotForeignKeyToTarget: '${escapeJsString(rel.pivotForeignKeyToTarget)}' })`
           );
           lines.push(`  ${rel.property}!: ManyToManyCollection<${targetClass}>;`);
           lines.push('');
@@ -708,6 +715,8 @@ const loadDriver = async (dialect, url, dbPath) => {
 
 const main = async () => {
   const opts = parseArgs();
+  const irregulars = opts.namingOverrides ? await loadIrregulars(opts.namingOverrides) : undefined;
+  const naming = createNamingStrategy(opts.locale, irregulars);
 
   const { executor, cleanup } = await loadDriver(opts.dialect, opts.url, opts.dbPath);
   let schema;
@@ -721,7 +730,7 @@ const main = async () => {
     await cleanup?.();
   }
 
-  const code = renderEntityFile(schema, opts);
+  const code = renderEntityFile(schema, { ...opts, naming });
 
   if (opts.dryRun) {
     console.log(code);

package/scripts/naming-strategy.mjs

@@ -0,0 +1,148 @@
+export class BaseNamingStrategy {
+  constructor(irregulars = {}) {
+    this.irregulars = new Map();
+    this.inverseIrregulars = new Map();
+    for (const [singular, plural] of Object.entries(irregulars)) {
+      if (!singular || !plural) continue;
+      const singularKey = singular.toLowerCase();
+      const pluralValue = plural.toLowerCase();
+      this.irregulars.set(singularKey, pluralValue);
+      this.inverseIrregulars.set(pluralValue, singularKey);
+    }
+  }
+
+  applyIrregular(word, direction) {
+    const lower = word.toLowerCase();
+    if (direction === 'plural' && this.irregulars.has(lower)) {
+      return this.irregulars.get(lower);
+    }
+    if (direction === 'singular' && this.inverseIrregulars.has(lower)) {
+      return this.inverseIrregulars.get(lower);
+    }
+    return undefined;
+  }
+
+  toPascalCase(value) {
+    return (
+      value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('') || 'Entity'
+    );
+  }
+
+  toCamelCase(value) {
+    const pascal = this.toPascalCase(value);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  }
+
+  toSnakeCase(value) {
+    return value
+      .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+      .replace(/[^a-z0-9_]+/gi, '_')
+      .replace(/__+/g, '_')
+      .replace(/^_|_$/g, '')
+      .toLowerCase();
+  }
+
+  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`;
+  }
+
+  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;
+  }
+
+  classNameFromTable(tableName) {
+    return this.toPascalCase(this.singularize(tableName));
+  }
+
+  belongsToProperty(foreignKeyName, targetTable) {
+    const trimmed = foreignKeyName.replace(/_?id$/i, '');
+    const base = trimmed && trimmed !== foreignKeyName ? trimmed : this.singularize(targetTable);
+    return this.toCamelCase(base);
+  }
+
+  hasManyProperty(targetTable) {
+    return this.toCamelCase(this.pluralize(targetTable));
+  }
+
+  belongsToManyProperty(targetTable) {
+    return this.toCamelCase(this.pluralize(targetTable));
+  }
+
+  defaultTableNameFromClass(className) {
+    const normalized = this.toSnakeCase(className);
+    if (!normalized) return 'unknown';
+    return this.pluralize(normalized);
+  }
+}
+
+export class EnglishNamingStrategy extends BaseNamingStrategy {}
+
+const DEFAULT_PT_IRREGULARS = {
+  mao: 'maos',
+  pao: 'paes',
+  cao: 'caes',
+  mal: 'males',
+  consul: 'consules'
+};
+
+export class PortugueseNamingStrategy 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`;
+  }
+
+  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 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);
+};

package/src/codegen/typescript.ts

@@ -17,6 +17,7 @@ import {
   LiteralNode,
   FunctionNode,
   AliasRefNode,
+  CastExpressionNode,
   ExpressionVisitor,
   OperandVisitor,
   visitExpression,
@@ -41,7 +42,8 @@ type SelectionColumn =
   | FunctionNode
   | ScalarSubqueryNode
   | CaseExpressionNode
-  | WindowFunctionNode;
+  | WindowFunctionNode
+  | CastExpressionNode;
 
 export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
   constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) { }
@@ -181,15 +183,16 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
         return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
       case 'AliasRef':
         return this.visitAliasRef(term);
-      case 'Literal':
-      case 'Function':
-      case 'JsonPath':
-      case 'ScalarSubquery':
-      case 'CaseExpression':
-      case 'WindowFunction':
-        return this.printOperand(term);
-      default:
-        return this.printExpression(term);
+    case 'Literal':
+    case 'Function':
+    case 'JsonPath':
+    case 'ScalarSubquery':
+    case 'CaseExpression':
+    case 'WindowFunction':
+    case 'Cast':
+      return this.printOperand(term);
+    default:
+      return this.printExpression(term);
     }
   }
 
@@ -263,6 +266,10 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return this.printWindowFunctionOperand(node);
   }
 
+  public visitCast(node: CastExpressionNode): string {
+    return this.printCastOperand(node);
+  }
+
   public visitAliasRef(node: AliasRefNode): string {
     return `aliasRef('${node.name}')`;
   }
@@ -454,6 +461,11 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return result;
   }
 
+  private printCastOperand(node: CastExpressionNode): string {
+    const typeLiteral = node.castType.replace(/'/g, "\\'");
+    return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
+  }
+
   /**
    * Converts method chain lines to inline format
    * @param lines - Method chain lines

package/src/core/ast/expression-builders.ts

@@ -7,6 +7,7 @@ import {
   JsonPathNode,
   OperandNode,
   CaseExpressionNode,
+  CastExpressionNode,
   BinaryExpressionNode,
   ExpressionNode,
   LogicalExpressionNode,
@@ -407,6 +408,18 @@ export const caseWhen = (
   else: elseValue !== undefined ? toOperand(elseValue) : undefined
 });
 
+/**
+ * Builds a CAST expression node for casting values to SQL types.
+ */
+export const cast = (
+  expression: OperandNode | ColumnRef | string | number | boolean | null,
+  castType: string
+): CastExpressionNode => ({
+  type: 'Cast',
+  expression: toOperand(expression),
+  castType
+});
+
 /**
  * Creates an EXISTS expression
  * @param subquery - Subquery to check for existence

package/src/core/ast/expression-nodes.ts

@@ -95,6 +95,19 @@ export interface CaseExpressionNode {
   alias?: string;
 }
 
+/**
+ * AST node representing a CAST expression (CAST(value AS type)).
+ */
+export interface CastExpressionNode {
+  type: 'Cast';
+  /** Expression being cast */
+  expression: OperandNode;
+  /** SQL type literal, e.g. "varchar(255)" */
+  castType: string;
+  /** Optional alias for the result */
+  alias?: string;
+}
+
 /**
  * AST node representing a window function
  */
@@ -133,7 +146,9 @@ export type OperandNode =
   | JsonPathNode
   | ScalarSubqueryNode
   | CaseExpressionNode
-  | WindowFunctionNode;
+  | CastExpressionNode
+  | WindowFunctionNode
+  | ArithmeticExpressionNode;
 
 const operandTypes = new Set<OperandNode['type']>([
   'AliasRef',
@@ -143,7 +158,9 @@ const operandTypes = new Set<OperandNode['type']>([
   'JsonPath',
   'ScalarSubquery',
   'CaseExpression',
-  'WindowFunction'
+  'Cast',
+  'WindowFunction',
+  'ArithmeticExpression'
 ]);
 
 const hasTypeProperty = (value: unknown): value is { type?: string } =>
@@ -158,12 +175,15 @@ export const isFunctionNode = (node: unknown): node is FunctionNode =>
   isOperandNode(node) && node.type === 'Function';
 export const isCaseExpressionNode = (node: unknown): node is CaseExpressionNode =>
   isOperandNode(node) && node.type === 'CaseExpression';
+
+export const isCastExpressionNode = (node: unknown): node is CastExpressionNode =>
+  isOperandNode(node) && node.type === 'Cast';
 export const isWindowFunctionNode = (node: unknown): node is WindowFunctionNode =>
   isOperandNode(node) && node.type === 'WindowFunction';
 export const isExpressionSelectionNode = (
-  node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode
-): node is FunctionNode | CaseExpressionNode | WindowFunctionNode =>
-  isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
+  node: ColumnRef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode
+): node is FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode =>
+  isFunctionNode(node) || isCaseExpressionNode(node) || isCastExpressionNode(node) || isWindowFunctionNode(node);
 
 /**
  * AST node representing a binary expression (e.g., column = value)

package/src/core/ast/expression-visitor.ts

@@ -14,6 +14,7 @@ import {
   JsonPathNode,
   ScalarSubqueryNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode,
   AliasRefNode
 } from './expression-nodes.js';
@@ -42,6 +43,7 @@ export interface OperandVisitor<R> {
   visitJsonPath?(node: JsonPathNode): R;
   visitScalarSubquery?(node: ScalarSubqueryNode): R;
   visitCaseExpression?(node: CaseExpressionNode): R;
+  visitCast?(node: CastExpressionNode): R;
   visitWindowFunction?(node: WindowFunctionNode): R;
   visitAliasRef?(node: AliasRefNode): R;
   otherwise?(node: OperandNode): R;
@@ -196,6 +198,9 @@ export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>):
     case 'AliasRef':
       if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
       break;
+    case 'Cast':
+      if (visitor.visitCast) return visitor.visitCast(node);
+      break;
     default:
       break;
   }

package/src/core/ast/query.ts

@@ -1,6 +1,7 @@
 import {
   AliasRefNode,
   CaseExpressionNode,
+  CastExpressionNode,
   ColumnNode,
   ExpressionNode,
   FunctionNode,
@@ -121,7 +122,14 @@ export interface SelectQueryNode {
   /** FROM clause table (either a Table or a FunctionTable) */
   from: TableSourceNode;
   /** SELECT clause columns */
-  columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
+  columns: (
+    ColumnNode |
+    FunctionNode |
+    ScalarSubqueryNode |
+    CaseExpressionNode |
+    CastExpressionNode |
+    WindowFunctionNode
+  )[];
   /** JOIN clauses */
   joins: JoinNode[];
   /** Optional WHERE clause */

package/src/core/ddl/introspect/catalogs/index.ts

@@ -1,2 +1,5 @@
-/** Re-exports for PostgreSQL catalog definitions. */
+/** Re-exports for supported catalog definitions. */
 export * from './postgres.js';
+export * from './mssql.js';
+export * from './mysql.js';
+export * from './sqlite.js';