metal-orm 1.0.50 → 1.0.51

package/dist/index.cjs

@@ -379,6 +379,10 @@ var col = {
    * @returns ColumnDef with VARCHAR type
    */
   varchar: (length2) => ({ name: "", type: "VARCHAR", args: [length2] }),
+  /**
+   * Creates a text column definition
+   */
+  text: () => ({ name: "", type: "TEXT" }),
   /**
    * Creates a fixed precision decimal column definition
    */
@@ -6887,6 +6891,29 @@ var postgresIntrospector = {
       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]
+    );
+    const tableComments = /* @__PURE__ */ new Map();
+    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);
+    });
     const qbPk = new SelectQueryBuilder(PgKeyColumnUsage).select({
       table_schema: PgKeyColumnUsage.columns.table_schema,
       table_name: PgKeyColumnUsage.columns.table_name,
@@ -7027,7 +7054,8 @@ var postgresIntrospector = {
           schema: r.table_schema,
           columns: [],
           primaryKey: pkMap.get(key) || [],
-          indexes: []
+          indexes: [],
+          comment: tableComments.get(key)
         });
       }
       const cols = tablesByKey.get(key);
@@ -7412,6 +7440,53 @@ var runPragma = async (name, table, alias, columnAliases, ctx) => {
   const query = buildPragmaQuery(name, table, alias, columnAliases);
   return await runSelectNode(query, ctx);
 };
+var loadSqliteSchemaComments = async (ctx) => {
+  const tableComments = /* @__PURE__ */ new Map();
+  const columnComments = /* @__PURE__ */ new Map();
+  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
+  };
+};
 var sqliteIntrospector = {
   async introspect(ctx, options) {
     const alias = "sqlite_master";
@@ -7425,6 +7500,7 @@ var sqliteIntrospector = {
         notLike(columnNode2(alias, "name"), "sqlite_%")
       )
     };
+    const { tableComments, columnComments } = await loadSqliteSchemaComments(ctx);
     const tableRows = await runSelectNode(tablesQuery, ctx);
     const tables = [];
     for (const row of tableRows) {
@@ -7451,15 +7527,26 @@ var sqliteIntrospector = {
         ["seq", "name", "unique"],
         ctx
       );
-      const tableEntry = { name: tableName, columns: [], primaryKey: [], indexes: [] };
+      const tableEntry = {
+        name: tableName,
+        columns: [],
+        primaryKey: [],
+        indexes: [],
+        comment: tableComments.get(tableName)
+      };
       tableInfo.forEach((info) => {
-        tableEntry.columns.push({
+        const column = {
           name: info.name,
           type: info.type,
           notNull: info.notnull === 1,
           default: info.dflt_value ?? void 0,
           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);
@@ -7731,6 +7818,60 @@ var mssqlIntrospector = {
   async introspect(ctx, options) {
     const schema = options.schema;
     const schemaCondition = schema ? eq(columnNode3("sch", "name"), schema) : void 0;
+    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
+    );
+    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
+    );
+    const tableComments = /* @__PURE__ */ new Map();
+    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 = /* @__PURE__ */ new Map();
+    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" },
       { table: "c", name: "max_length" },
@@ -8036,7 +8177,8 @@ var mssqlIntrospector = {
           schema: r.table_schema,
           columns: [],
           primaryKey: pkMap.get(key) || [],
-          indexes: []
+          indexes: [],
+          comment: tableComments.get(key)
         });
       }
       const table = tablesByKey.get(key);
@@ -8047,6 +8189,10 @@ var mssqlIntrospector = {
         default: r.column_default ?? void 0,
         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 = {