metal-orm 1.0.49 → 1.0.51

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

@@ -54,12 +54,18 @@ type ForeignKeyEntry = {
   onUpdate?: ReferentialAction;
 };
 
-type ColumnCommentRow = {
-  table_schema: string;
-  table_name: string;
-  column_name: string;
-  description: string | null;
-};
+type ColumnCommentRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  description: string | null;
+};
+
+type TableCommentRow = {
+  table_schema: string;
+  table_name: string;
+  description: string | null;
+};
 
 /** Row type for PostgreSQL index query results from pg_catalog tables. */
 type IndexQueryRow = {
@@ -111,32 +117,55 @@ export const postgresIntrospector: SchemaIntrospector = {
       .orderBy(PgInformationSchemaColumns.columns.ordinal_position);
 
     const columnRows = await runSelect<ColumnIntrospectRow>(qbColumns, ctx);
-    const columnCommentRows = (await queryRows(
-      ctx.executor,
-      `
-      SELECT
-        ns.nspname AS table_schema,
-        cls.relname AS table_name,
-        att.attname AS column_name,
-        pg_catalog.col_description(cls.oid, att.attnum) AS description
-      FROM pg_catalog.pg_attribute att
-      JOIN pg_catalog.pg_class cls ON cls.oid = att.attrelid
-      JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
-      WHERE ns.nspname = $1
-        AND att.attnum > 0
-        AND NOT att.attisdropped
-      `,
-      [schema]
-    )) as ColumnCommentRow[];
-    const columnComments = new Map<string, string>();
-    columnCommentRows.forEach(r => {
-      if (!shouldIncludeTable(r.table_name, options)) return;
-      if (!r.description) return;
-      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
-      const trimmed = r.description.trim();
-      if (!trimmed) return;
-      columnComments.set(key, trimmed);
-    });
+    const columnCommentRows = (await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        cls.relname AS table_name,
+        att.attname AS column_name,
+        pg_catalog.col_description(cls.oid, att.attnum) AS description
+      FROM pg_catalog.pg_attribute att
+      JOIN pg_catalog.pg_class cls ON cls.oid = att.attrelid
+      JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+      WHERE ns.nspname = $1
+        AND att.attnum > 0
+        AND NOT att.attisdropped
+      `,
+      [schema]
+    )) as ColumnCommentRow[];
+    const columnComments = new Map<string, string>();
+    columnCommentRows.forEach(r => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!r.description) return;
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const trimmed = r.description.trim();
+      if (!trimmed) return;
+      columnComments.set(key, trimmed);
+    });
+    const tableCommentRows = (await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        cls.relname AS table_name,
+        pg_catalog.obj_description(cls.oid) AS description
+      FROM pg_catalog.pg_class cls
+      JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+      WHERE ns.nspname = $1
+        AND cls.relkind IN ('r', 'p')
+      `,
+      [schema]
+    )) as TableCommentRow[];
+    const tableComments = new Map<string, string>();
+    tableCommentRows.forEach(r => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!r.description) return;
+      const key = `${r.table_schema}.${r.table_name}`;
+      const trimmed = r.description.trim();
+      if (!trimmed) return;
+      tableComments.set(key, trimmed);
+    });
 
     // Primary key columns query
     const qbPk = new SelectQueryBuilder(PgKeyColumnUsage)
@@ -303,13 +332,14 @@ export const postgresIntrospector: SchemaIntrospector = {
         return;
       }
       if (!tablesByKey.has(key)) {
-        tablesByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
-          columns: [],
-          primaryKey: pkMap.get(key) || [],
-          indexes: []
-        });
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: [],
+          comment: tableComments.get(key)
+        });
       }
       const cols = tablesByKey.get(key)!;
       const commentKey = `${r.table_schema}.${r.table_name}.${r.column_name}`;

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

@@ -1,6 +1,6 @@
 import { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { shouldIncludeTable } from './utils.js';
-import { DatabaseSchema, DatabaseTable, DatabaseIndex } from '../schema-types.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';
 import type { SelectQueryNode, TableNode } from '../../ast/query.js';
@@ -89,6 +89,58 @@ const runPragma = async <T>(
   return (await runSelectNode<T>(query, ctx)) as T[];
 };
 
+const loadSqliteSchemaComments = async (ctx: IntrospectContext) => {
+  const tableComments = new Map<string, string>();
+  const columnComments = new Map<string, string>();
+  const tableExists = await queryRows(
+    ctx.executor,
+    `SELECT name FROM sqlite_master WHERE type='table' AND name='schema_comments' LIMIT 1`
+  );
+  if (!tableExists.length) {
+    return { tableComments, columnComments };
+  }
+
+  const commentRows = await queryRows(
+    ctx.executor,
+    `SELECT object_type, schema_name, table_name, column_name, comment FROM schema_comments`
+  );
+  for (const row of commentRows) {
+    const objectType = typeof row.object_type === 'string' ? row.object_type.toLowerCase() : '';
+    const tableName = typeof row.table_name === 'string' ? row.table_name : '';
+    if (!tableName) continue;
+    const columnName = typeof row.column_name === 'string' ? row.column_name : '';
+    const schemaName = typeof row.schema_name === 'string' ? row.schema_name : '';
+    const rawComment = row.comment;
+    if (rawComment == null) continue;
+    const commentText = String(rawComment).trim();
+    if (!commentText) continue;
+
+    const addTableComment = () => {
+      tableComments.set(tableName, commentText);
+      if (schemaName) {
+        tableComments.set(`${schemaName}.${tableName}`, commentText);
+      }
+    };
+    const addColumnComment = () => {
+      columnComments.set(`${tableName}.${columnName}`, commentText);
+      if (schemaName) {
+        columnComments.set(`${schemaName}.${tableName}.${columnName}`, commentText);
+      }
+    };
+
+    if (objectType === 'table') {
+      addTableComment();
+    } else if (objectType === 'column' && columnName) {
+      addColumnComment();
+    }
+  }
+
+  return {
+    tableComments,
+    columnComments
+  };
+};
+
 export const sqliteIntrospector: SchemaIntrospector = {
   async introspect(ctx: IntrospectContext, options: IntrospectOptions): Promise<DatabaseSchema> {
     const alias = 'sqlite_master';
@@ -103,6 +155,7 @@ export const sqliteIntrospector: SchemaIntrospector = {
       )
     };
 
+    const { tableComments, columnComments } = await loadSqliteSchemaComments(ctx);
     const tableRows = (await runSelectNode<SqliteTableRow>(tablesQuery, ctx)) as SqliteTableRow[];
     const tables: DatabaseTable[] = [];
 
@@ -134,16 +187,27 @@ export const sqliteIntrospector: SchemaIntrospector = {
         ctx
       );
 
-      const tableEntry: DatabaseTable = { name: tableName, columns: [], primaryKey: [], indexes: [] };
+      const tableEntry: DatabaseTable = {
+        name: tableName,
+        columns: [],
+        primaryKey: [],
+        indexes: [],
+        comment: tableComments.get(tableName)
+      };
 
       tableInfo.forEach(info => {
-        tableEntry.columns.push({
+        const column: DatabaseColumn = {
           name: info.name,
           type: info.type,
           notNull: info.notnull === 1,
           default: info.dflt_value ?? undefined,
           autoIncrement: false
-        });
+        };
+        const columnComment = columnComments.get(`${tableName}.${info.name}`);
+        if (columnComment) {
+          column.comment = columnComment;
+        }
+        tableEntry.columns.push(column);
         if (info.pk && info.pk > 0) {
           tableEntry.primaryKey = tableEntry.primaryKey || [];
           tableEntry.primaryKey.push(info.name);

package/src/schema/column-types.ts

@@ -134,15 +134,20 @@ export const col = {
 
   /**
    * Creates a variable character column definition
-   * @param length - Maximum length of the string
-   * @returns ColumnDef with VARCHAR type
-   */
-  varchar: (length: number): ColumnDef<'VARCHAR'> => ({ name: '', type: 'VARCHAR', args: [length] }),
-
-  /**
-   * Creates a fixed precision decimal column definition
-   */
-  decimal: (precision: number, scale = 0): ColumnDef<'DECIMAL'> => ({
+   * @param length - Maximum length of the string
+   * @returns ColumnDef with VARCHAR type
+   */
+  varchar: (length: number): ColumnDef<'VARCHAR'> => ({ name: '', type: 'VARCHAR', args: [length] }),
+
+  /**
+   * Creates a text column definition
+   */
+  text: (): ColumnDef<'TEXT'> => ({ name: '', type: 'TEXT' }),
+
+  /**
+   * Creates a fixed precision decimal column definition
+   */
+  decimal: (precision: number, scale = 0): ColumnDef<'DECIMAL'> => ({
     name: '',
     type: 'DECIMAL',
     args: [precision, scale]