metal-orm 1.0.14 → 1.0.15

package/src/core/ast/join.ts

@@ -1,4 +1,4 @@
-import { TableNode } from './query.js';
+import { TableNode, FunctionTableNode } from './query.js';
 import { ExpressionNode } from './expression.js';
 import { JoinKind } from '../sql/sql.js';
 
@@ -10,9 +10,9 @@ export interface JoinNode {
   /** Type of join (INNER, LEFT, RIGHT, etc.) */
   kind: JoinKind;
   /** Table to join */
-  table: TableNode;
-  /** Join condition expression */
+  table: TableNode | FunctionTableNode;
+ /** Join condition expression */
   condition: ExpressionNode;
-  /** Optional relation name for code generation */
-  relationName?: string;
+  /** Optional metadata for non-SQL concerns (e.g., relation name) */
+  meta?: Record<string, unknown>;
 }

package/src/core/ast/query.ts

@@ -8,7 +8,6 @@ import {
   OperandNode
 } from './expression.js';
 import { JoinNode } from './join.js';
-import { RelationType } from '../../schema/relation.js';
 import { OrderDirection } from '../sql/sql.js';
 
 /**
@@ -24,6 +23,27 @@ export interface TableNode {
   alias?: string;
 }
 
+/**
+ * AST node representing a function used as a table source (table-valued function)
+ */
+export interface FunctionTableNode {
+  type: 'FunctionTable';
+  /** Function name */
+  name: string;
+  /** Optional schema for the function (some dialects) */
+  schema?: string;
+  /** Function arguments as operand nodes */
+  args?: any[]; // use any to avoid circular import here; caller should supply OperandNode
+  /** Optional alias for the function table */
+  alias?: string;
+  /** LATERAL flag */
+  lateral?: boolean;
+  /** WITH ORDINALITY flag */
+  withOrdinality?: boolean;
+  /** Optional column aliases */
+  columnAliases?: string[];
+}
+
 /**
  * AST node representing an ORDER BY clause
  */
@@ -36,101 +56,45 @@ export interface OrderByNode {
 }
 
 /**
- * Plan describing pivot columns needed for hydration
- */
-export interface HydrationPivotPlan {
-  table: string;
-  primaryKey: string;
-  aliasPrefix: string;
-  columns: string[];
-}
-
-/**
- * Plan for hydrating relationship data
+ * AST node representing a Common Table Expression (CTE)
  */
-export interface HydrationRelationPlan {
-  /** Name of the relationship */
+export interface CommonTableExpressionNode {
+  type: 'CommonTableExpression';
+  /** CTE name */
   name: string;
-  /** Alias prefix for the relationship */
-  aliasPrefix: string;
-  /** Type of relationship */
-  type: RelationType;
-  /** Target table name */
-  targetTable: string;
-  /** Target table primary key */
-  targetPrimaryKey: string;
-  /** Foreign key column */
-  foreignKey: string;
-  /** Local key column */
-  localKey: string;
-  /** Columns to include */
-  columns: string[];
-  /** Optional pivot plan for many-to-many relationships */
-  pivot?: HydrationPivotPlan;
+  /** Optional column names */
+  columns?: string[];
+  /** CTE query */
+  query: SelectQueryNode;
+  /** Whether the CTE is recursive */
+  recursive: boolean;
 }
 
 /**
- * Complete hydration plan for a query
+ * Supported set operation kinds for compound SELECT queries
  */
-export interface HydrationPlan {
-  /** Root table name */
-  rootTable: string;
-  /** Root table primary key */
-  rootPrimaryKey: string;
-  /** Root table columns */
-  rootColumns: string[];
-  /** Relationship hydration plans */
-  relations: HydrationRelationPlan[];
-}
+export type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
 
 /**
- * Query metadata including hydration information
+ * AST node representing a set operation (UNION, INTERSECT, etc.)
  */
-export interface QueryMetadata {
-  /** Optional hydration plan */
-  hydration?: HydrationPlan;
+export interface SetOperationNode {
+  type: 'SetOperation';
+  /** Operator to combine queries */
+  operator: SetOperationKind;
+  /** Right-hand query in the compound expression */
+  query: SelectQueryNode;
 }
 
 /**
- * AST node representing a Common Table Expression (CTE)
+ * AST node representing a complete SELECT query
  */
-export interface CommonTableExpressionNode {
-  type: 'CommonTableExpression';
-  /** CTE name */
-  name: string;
-  /** Optional column names */
-  columns?: string[];
-  /** CTE query */
-  query: SelectQueryNode;
-  /** Whether the CTE is recursive */
-  recursive: boolean;
-}
-
-/**
- * Supported set operation kinds for compound SELECT queries
- */
-export type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
-
-/**
- * AST node representing a set operation (UNION, INTERSECT, etc.)
- */
-export interface SetOperationNode {
-  type: 'SetOperation';
-  /** Operator to combine queries */
-  operator: SetOperationKind;
-  /** Right-hand query in the compound expression */
-  query: SelectQueryNode;
-}
-
-/**
- * AST node representing a complete SELECT query
- */
-export interface SelectQueryNode {
-  type: 'SelectQuery';
+export interface SelectQueryNode {
+  type: 'SelectQuery';
   /** Optional CTEs (WITH clauses) */
   ctes?: CommonTableExpressionNode[];
-  /** FROM clause table */
-  from: TableNode;
+  /** FROM clause table (either a Table or a FunctionTable) */
+  from: TableNode | FunctionTableNode;
   /** SELECT clause columns */
   columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
   /** JOIN clauses */
@@ -147,13 +111,13 @@ export interface SelectQueryNode {
   limit?: number;
   /** Optional OFFSET clause */
   offset?: number;
-  /** Optional query metadata */
-  meta?: QueryMetadata;
-  /** Optional DISTINCT clause */
-  distinct?: ColumnNode[];
-  /** Optional set operations chaining this query with others */
-  setOps?: SetOperationNode[];
-}
+  /** Optional query metadata */
+  meta?: Record<string, unknown>;
+  /** Optional DISTINCT clause */
+  distinct?: ColumnNode[];
+  /** Optional set operations chaining this query with others */
+  setOps?: SetOperationNode[];
+}
 
 export interface InsertQueryNode {
   type: 'InsertQuery';

package/src/core/ast/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Minimal column reference used by AST builders.
+ * Accepts any object with a name and optional table/alias fields
+ * (schema ColumnDef/TableDef remain structurally compatible).
+ */
+export interface ColumnRef {
+  name: string;
+  table?: string;
+  alias?: string;
+}
+
+/**
+ * Minimal table reference used by AST builders.
+ * Keeps AST decoupled from full schema TableDef shape.
+ */
+export interface TableRef {
+  name: string;
+  schema?: string;
+  alias?: string;
+}

package/src/core/ast/window-functions.ts

@@ -1,8 +1,8 @@
-import { ColumnDef } from '../../schema/column.js';
-import { ColumnNode, LiteralNode, JsonPathNode, WindowFunctionNode } from './expression-nodes.js';
-import { columnOperand } from './expression-builders.js';
-import { OrderDirection } from '../sql/sql.js';
-import { OrderByNode } from './query.js';
+import { ColumnNode, LiteralNode, JsonPathNode, WindowFunctionNode } from './expression-nodes.js';
+import { columnOperand } from './expression-builders.js';
+import { OrderDirection } from '../sql/sql.js';
+import { OrderByNode } from './query.js';
+import { ColumnRef } from './types.js';
 
 const buildWindowFunction = (
   name: string,
@@ -50,21 +50,21 @@ export const denseRank = (): WindowFunctionNode => buildWindowFunction('DENSE_RA
  * @param n - Number of buckets
  * @returns Window function node for NTILE
  */
-export const ntile = (n: number): WindowFunctionNode =>
-  buildWindowFunction('NTILE', [{ type: 'Literal', value: n }]);
+export const ntile = (n: number): WindowFunctionNode =>
+  buildWindowFunction('NTILE', [{ type: 'Literal', value: n }]);
 
 /**
  * Creates a LAG window function
  * @param col - Column to lag
  * @param offset - Offset (defaults to 1)
- * @param defaultValue - Default value if no row exists
- * @returns Window function node for LAG
- */
-export const lag = (col: ColumnDef | ColumnNode, offset: number = 1, defaultValue?: any): WindowFunctionNode => {
-  const args: (ColumnNode | LiteralNode | JsonPathNode)[] = [
-    columnOperand(col),
-    { type: 'Literal', value: offset }
-  ];
+ * @param defaultValue - Default value if no row exists
+ * @returns Window function node for LAG
+ */
+export const lag = (col: ColumnRef | ColumnNode, offset: number = 1, defaultValue?: any): WindowFunctionNode => {
+  const args: (ColumnNode | LiteralNode | JsonPathNode)[] = [
+    columnOperand(col),
+    { type: 'Literal', value: offset }
+  ];
   if (defaultValue !== undefined) {
     args.push({ type: 'Literal', value: defaultValue });
   }
@@ -75,14 +75,14 @@ export const lag = (col: ColumnDef | ColumnNode, offset: number = 1, defaultValu
  * Creates a LEAD window function
  * @param col - Column to lead
  * @param offset - Offset (defaults to 1)
- * @param defaultValue - Default value if no row exists
- * @returns Window function node for LEAD
- */
-export const lead = (col: ColumnDef | ColumnNode, offset: number = 1, defaultValue?: any): WindowFunctionNode => {
-  const args: (ColumnNode | LiteralNode | JsonPathNode)[] = [
-    columnOperand(col),
-    { type: 'Literal', value: offset }
-  ];
+ * @param defaultValue - Default value if no row exists
+ * @returns Window function node for LEAD
+ */
+export const lead = (col: ColumnRef | ColumnNode, offset: number = 1, defaultValue?: any): WindowFunctionNode => {
+  const args: (ColumnNode | LiteralNode | JsonPathNode)[] = [
+    columnOperand(col),
+    { type: 'Literal', value: offset }
+  ];
   if (defaultValue !== undefined) {
     args.push({ type: 'Literal', value: defaultValue });
   }
@@ -91,19 +91,19 @@ export const lead = (col: ColumnDef | ColumnNode, offset: number = 1, defaultVal
 
 /**
  * Creates a FIRST_VALUE window function
- * @param col - Column to get first value from
- * @returns Window function node for FIRST_VALUE
- */
-export const firstValue = (col: ColumnDef | ColumnNode): WindowFunctionNode =>
-  buildWindowFunction('FIRST_VALUE', [columnOperand(col)]);
+ * @param col - Column to get first value from
+ * @returns Window function node for FIRST_VALUE
+ */
+export const firstValue = (col: ColumnRef | ColumnNode): WindowFunctionNode =>
+  buildWindowFunction('FIRST_VALUE', [columnOperand(col)]);
 
 /**
  * Creates a LAST_VALUE window function
- * @param col - Column to get last value from
- * @returns Window function node for LAST_VALUE
- */
-export const lastValue = (col: ColumnDef | ColumnNode): WindowFunctionNode =>
-  buildWindowFunction('LAST_VALUE', [columnOperand(col)]);
+ * @param col - Column to get last value from
+ * @returns Window function node for LAST_VALUE
+ */
+export const lastValue = (col: ColumnRef | ColumnNode): WindowFunctionNode =>
+  buildWindowFunction('LAST_VALUE', [columnOperand(col)]);
 
 /**
  * Creates a custom window function
@@ -113,28 +113,28 @@ export const lastValue = (col: ColumnDef | ColumnNode): WindowFunctionNode =>
  * @param orderBy - Optional ORDER BY clauses
  * @returns Window function node
  */
-export const windowFunction = (
-  name: string,
-  args: (ColumnDef | ColumnNode | LiteralNode | JsonPathNode)[] = [],
-  partitionBy?: (ColumnDef | ColumnNode)[],
-  orderBy?: { column: ColumnDef | ColumnNode; direction: OrderDirection }[]
-): WindowFunctionNode => {
-  const nodeArgs = args.map(arg => {
-    if (typeof (arg as LiteralNode).value !== 'undefined') {
-      return arg as LiteralNode;
-    }
-    if ('path' in arg) {
-      return arg as JsonPathNode;
-    }
-    return columnOperand(arg as ColumnDef | ColumnNode);
-  });
-
-  const partitionNodes = partitionBy?.map(col => columnOperand(col)) ?? undefined;
-  const orderNodes: OrderByNode[] | undefined = orderBy?.map(o => ({
-    type: 'OrderBy',
-    column: columnOperand(o.column),
-    direction: o.direction
-  }));
+export const windowFunction = (
+  name: string,
+  args: (ColumnRef | ColumnNode | LiteralNode | JsonPathNode)[] = [],
+  partitionBy?: (ColumnRef | ColumnNode)[],
+  orderBy?: { column: ColumnRef | ColumnNode; direction: OrderDirection }[]
+): WindowFunctionNode => {
+  const nodeArgs = args.map(arg => {
+    if (typeof (arg as LiteralNode).value !== 'undefined') {
+      return arg as LiteralNode;
+    }
+    if ('path' in arg) {
+      return arg as JsonPathNode;
+    }
+    return columnOperand(arg as ColumnRef | ColumnNode);
+  });
+
+  const partitionNodes = partitionBy?.map(col => columnOperand(col)) ?? undefined;
+  const orderNodes: OrderByNode[] | undefined = orderBy?.map(o => ({
+    type: 'OrderBy',
+    column: columnOperand(o.column),
+    direction: o.direction
+  }));
 
   return buildWindowFunction(name, nodeArgs, partitionNodes, orderNodes);
 };

package/src/core/ddl/dialects/base-schema-dialect.ts

@@ -1,7 +1,8 @@
-import { SchemaDialect, DialectName, formatLiteral, quoteQualified } from '../schema-generator.js';
+import { SchemaDialect, DialectName } from '../schema-dialect.js';
+import { formatLiteral, quoteQualified, createLiteralFormatter, LiteralFormatter } from '../sql-writing.js';
 import { ColumnDef, ForeignKeyReference } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { DatabaseTable, DatabaseColumn, ColumnDiff } from '../schema-types.js';
 
 type TableLike = { name: string; schema?: string };
 
@@ -10,7 +11,7 @@ type TableLike = { name: string; schema?: string };
  * Concrete dialects only override the small surface area instead of reimplementing everything.
  */
 export abstract class BaseSchemaDialect implements SchemaDialect {
-  abstract name: DialectName;
+  abstract readonly name: DialectName;
   abstract quoteIdentifier(id: string): string;
   abstract renderColumnType(column: ColumnDef): string;
   abstract renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
@@ -24,8 +25,11 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
     }
     return this.quoteIdentifier(table.name);
   }
+  // Each dialect should provide its own formatter
+  abstract get literalFormatter(): LiteralFormatter;
+
   renderDefault(value: unknown, _column: ColumnDef): string {
-    return formatLiteral(value, this.name);
+    return formatLiteral(this.literalFormatter, value);
   }
   renderReference(ref: ForeignKeyReference, _table: TableDef): string {
     const parts = ['REFERENCES', quoteQualified(this, ref.table), `(${this.quoteIdentifier(ref.column)})`];
@@ -40,9 +44,19 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
   dropTableSql(table: DatabaseTable): string[] {
     return [`DROP TABLE IF EXISTS ${this.formatTableName(table)};`];
   }
-  abstract dropColumnSql(table: DatabaseTable, column: string): string[];
-  abstract dropIndexSql(table: DatabaseTable, index: string): string[];
+  dropColumnSql(table: DatabaseTable, column: string): string[] {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table: DatabaseTable, index: string): string[] {
+    return [`DROP INDEX ${this.quoteIdentifier(index)};`];
+  }
   warnDropColumn(_table: DatabaseTable, _column: string): string | undefined {
     return undefined;
   }
+  alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
+    return [];
+  }
+  warnAlterColumn?(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
+    return undefined;
+  }
 }

package/src/core/ddl/dialects/mssql-schema-dialect.ts

@@ -1,17 +1,23 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName,
-  formatLiteral
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class MSSqlSchemaDialect extends BaseSchemaDialect {
   name: DialectName = 'mssql';
 
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: '1',
+    booleanFalse: '0',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
+
   quoteIdentifier(id: string): string {
     return `[${id.replace(/]/g, ']]')}]`;
   }
@@ -68,7 +74,7 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   }
 
   renderDefault(value: unknown): string {
-    return formatLiteral(value, this.name);
+    return this.literalFormatter.formatLiteral(value);
   }
 
   renderAutoIncrement(column: ColumnDef): string | undefined {
@@ -94,4 +100,22 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   dropIndexSql(table: DatabaseTable, index: string): string[] {
     return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
   }
+
+  alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string[] {
+    const stmts: string[] = [];
+    if (diff.typeChanged || diff.nullabilityChanged) {
+      const nullability = column.notNull ? 'NOT NULL' : 'NULL';
+      stmts.push(
+        `ALTER TABLE ${this.formatTableName(table)} ALTER COLUMN ${this.quoteIdentifier(column.name)} ${this.renderColumnType(column)} ${nullability};`
+      );
+    }
+    return stmts;
+  }
+
+  warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
+    if (diff.defaultChanged || diff.autoIncrementChanged) {
+      return 'Altering defaults or identity on MSSQL is not automated (requires dropping/adding default or identity constraints manually).';
+    }
+    return undefined;
+  }
 }

package/src/core/ddl/dialects/mysql-schema-dialect.ts

@@ -1,18 +1,24 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName,
-  formatLiteral,
-  escapeLiteral
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, escapeSqlString, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { renderColumnDefinition } from '../schema-generator.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class MySqlSchemaDialect extends BaseSchemaDialect {
   name: DialectName = 'mysql';
 
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: '1',
+    booleanFalse: '0',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
+
   quoteIdentifier(id: string): string {
     return `\`${id}\``;
   }
@@ -66,7 +72,7 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
       case 'ENUM':
       case 'enum':
         return column.args && Array.isArray(column.args) && column.args.length
-          ? `ENUM(${column.args.map((v: string) => `'${escapeLiteral(v)}'`).join(',')})`
+          ? `ENUM(${column.args.map((v: string) => `'${escapeSqlString(v)}'`).join(',')})`
           : 'ENUM';
       default:
         return String(column.type).toUpperCase();
@@ -74,7 +80,7 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
   }
 
   renderDefault(value: unknown): string {
-    return formatLiteral(value, this.name);
+    return this.literalFormatter.formatLiteral(value);
   }
 
   renderAutoIncrement(column: ColumnDef): string | undefined {
@@ -106,4 +112,9 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
   dropIndexSql(table: DatabaseTable, index: string): string[] {
     return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
   }
+
+  alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
+    const rendered = renderColumnDefinition(table, column, this);
+    return [`ALTER TABLE ${this.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
+  }
 }

package/src/core/ddl/dialects/postgres-schema-dialect.ts

@@ -1,15 +1,22 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class PostgresSchemaDialect extends BaseSchemaDialect {
-  name: DialectName = 'postgres';
+  readonly name: DialectName = 'postgres';
+
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: 'TRUE',
+    booleanFalse: 'FALSE',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
 
   quoteIdentifier(id: string): string {
     return `"${id}"`;
@@ -96,4 +103,42 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
       : this.quoteIdentifier(index);
     return [`DROP INDEX IF EXISTS ${qualified};`];
   }
+
+  alterColumnSql(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
+    const stmts: string[] = [];
+    const tableName = this.formatTableName(table);
+    const colName = this.quoteIdentifier(column.name);
+
+    if (diff.typeChanged) {
+      stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} TYPE ${this.renderColumnType(column)};`);
+    }
+    if (diff.defaultChanged) {
+      if (column.default === undefined) {
+        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} DROP DEFAULT;`);
+      } else {
+        stmts.push(
+          `ALTER TABLE ${tableName} ALTER COLUMN ${colName} SET DEFAULT ${this.renderDefault(column.default, column)};`
+        );
+      }
+    }
+    if (diff.nullabilityChanged) {
+      stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} ${column.notNull ? 'SET' : 'DROP'} NOT NULL;`);
+    }
+    if (diff.autoIncrementChanged) {
+      if (column.autoIncrement) {
+        const strategy = column.generated === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} ADD GENERATED ${strategy} AS IDENTITY;`);
+      } else {
+        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} DROP IDENTITY IF EXISTS;`);
+      }
+    }
+    return stmts;
+  }
+
+  warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
+    if (diff.autoIncrementChanged) {
+      return 'Altering identity properties may fail if an existing sequence is attached; verify generated column state.';
+    }
+    return undefined;
+  }
 }

package/src/core/ddl/dialects/sqlite-schema-dialect.ts

@@ -1,18 +1,23 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName,
-  formatLiteral,
-  resolvePrimaryKey
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, resolvePrimaryKey, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class SQLiteSchemaDialect extends BaseSchemaDialect {
   name: DialectName = 'sqlite';
 
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: '1',
+    booleanFalse: '0',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
+
   quoteIdentifier(id: string): string {
     return `"${id}"`;
   }
@@ -75,7 +80,7 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
   }
 
   renderDefault(value: unknown): string {
-    return formatLiteral(value, this.name);
+    return this.literalFormatter.formatLiteral(value);
   }
 
   renderIndex(table: TableDef, index: IndexDef): string {
@@ -100,4 +105,13 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
     const key = table.schema ? `${table.schema}.${table.name}` : table.name;
     return `Dropping columns on SQLite requires table rebuild (column ${column} on ${key}).`;
   }
+
+  alterColumnSql(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
+    return [];
+  }
+
+  warnAlterColumn(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
+    const key = table.schema ? `${table.schema}.${table.name}` : table.name;
+    return `SQLite ALTER COLUMN is not supported; rebuild table ${key} to change column ${column.name}.`;
+  }
 }