metal-orm 1.1.10 → 1.1.11

package/dist/index.cjs

@@ -12353,6 +12353,25 @@ var databaseFunction = {
   fn: "DATABASE",
   args: []
 };
+var readMysqlField = (row, field) => {
+  const record = row;
+  if (Object.prototype.hasOwnProperty.call(record, field)) {
+    return record[field];
+  }
+  const lower2 = field.toLowerCase();
+  if (lower2 !== field && Object.prototype.hasOwnProperty.call(record, lower2)) {
+    return record[lower2];
+  }
+  const upper2 = field.toUpperCase();
+  if (upper2 !== field && Object.prototype.hasOwnProperty.call(record, upper2)) {
+    return record[upper2];
+  }
+  return void 0;
+};
+var readMysqlStringField = (row, field) => {
+  const value = readMysqlField(row, field);
+  return typeof value === "string" ? value : void 0;
+};
 var mysqlIntrospector = {
   async introspect(ctx, options) {
     const schema = options.schema;
@@ -12494,39 +12513,68 @@ var mysqlIntrospector = {
     const indexRows = await runSelectNode(indexQuery, ctx);
     const tableComments = /* @__PURE__ */ new Map();
     tableRows.forEach((r) => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      if (r.table_comment) {
-        tableComments.set(key, r.table_comment);
+      const tableSchema = readMysqlStringField(r, "table_schema");
+      const tableName = readMysqlStringField(r, "table_name");
+      const tableComment = readMysqlStringField(r, "table_comment");
+      if (!tableSchema || !tableName) return;
+      const key = `${tableSchema}.${tableName}`;
+      if (tableComment) {
+        tableComments.set(key, tableComment);
       }
     });
     const pkMap = /* @__PURE__ */ new Map();
     pkRows.forEach((r) => {
-      const key = `${r.table_schema}.${r.table_name}`;
+      const tableSchema = readMysqlStringField(r, "table_schema");
+      const tableName = readMysqlStringField(r, "table_name");
+      const columnName = readMysqlStringField(r, "column_name");
+      if (!tableSchema || !tableName || !columnName) return;
+      const key = `${tableSchema}.${tableName}`;
       const list = pkMap.get(key) || [];
-      list.push(r.column_name);
+      list.push(columnName);
       pkMap.set(key, list);
     });
     const fkMap = /* @__PURE__ */ new Map();
     fkRows.forEach((r) => {
-      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const tableSchema = readMysqlStringField(r, "table_schema");
+      const tableName = readMysqlStringField(r, "table_name");
+      const columnName = readMysqlStringField(r, "column_name");
+      const constraintName = readMysqlStringField(r, "constraint_name");
+      const referencedTableSchema = readMysqlStringField(r, "referenced_table_schema");
+      const referencedTableName = readMysqlStringField(r, "referenced_table_name");
+      const referencedColumnName = readMysqlStringField(r, "referenced_column_name");
+      const deleteRule = readMysqlStringField(r, "delete_rule");
+      const updateRule = readMysqlStringField(r, "update_rule");
+      if (!tableSchema || !tableName || !columnName || !constraintName || !referencedTableSchema || !referencedTableName || !referencedColumnName) {
+        return;
+      }
+      const key = `${tableSchema}.${tableName}.${columnName}`;
       const list = fkMap.get(key) || [];
       list.push({
-        table: `${r.referenced_table_schema}.${r.referenced_table_name}`,
-        column: r.referenced_column_name,
-        onDelete: r.delete_rule,
-        onUpdate: r.update_rule,
-        name: r.constraint_name
+        table: `${referencedTableSchema}.${referencedTableName}`,
+        column: referencedColumnName,
+        onDelete: deleteRule,
+        onUpdate: updateRule,
+        name: constraintName
       });
       fkMap.set(key, list);
     });
     const tablesByKey = /* @__PURE__ */ new Map();
     columnRows.forEach((r) => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      if (!shouldIncludeTable(r.table_name, options)) return;
+      const tableSchema = readMysqlStringField(r, "table_schema");
+      const tableName = readMysqlStringField(r, "table_name");
+      const columnName = readMysqlStringField(r, "column_name");
+      const columnType = readMysqlStringField(r, "column_type") || readMysqlStringField(r, "data_type");
+      const isNullable = readMysqlStringField(r, "is_nullable");
+      const columnDefault = readMysqlField(r, "column_default");
+      const extra = readMysqlStringField(r, "extra");
+      const columnComment = readMysqlStringField(r, "column_comment");
+      if (!tableSchema || !tableName || !columnName || !columnType || !isNullable) return;
+      const key = `${tableSchema}.${tableName}`;
+      if (!shouldIncludeTable(tableName, options)) return;
       if (!tablesByKey.has(key)) {
         tablesByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
+          name: tableName,
+          schema: tableSchema,
           columns: [],
           primaryKey: pkMap.get(key) || [],
           indexes: [],
@@ -12534,17 +12582,16 @@ var mysqlIntrospector = {
         });
       }
       const table = tablesByKey.get(key);
-      const columnType = r.column_type || r.data_type;
-      const comment = r.column_comment?.trim() ? r.column_comment : void 0;
+      const comment = columnComment?.trim() ? columnComment : void 0;
       const column = {
-        name: r.column_name,
+        name: columnName,
         type: columnType,
-        notNull: r.is_nullable === "NO",
-        default: r.column_default ?? void 0,
-        autoIncrement: typeof r.extra === "string" && r.extra.includes("auto_increment"),
+        notNull: isNullable === "NO",
+        default: columnDefault ?? void 0,
+        autoIncrement: typeof extra === "string" && extra.includes("auto_increment"),
         comment
       };
-      const fk = fkMap.get(`${key}.${r.column_name}`)?.[0];
+      const fk = fkMap.get(`${key}.${columnName}`)?.[0];
       if (fk) {
         column.references = {
           table: fk.table,
@@ -12557,14 +12604,20 @@ var mysqlIntrospector = {
       table.columns.push(column);
     });
     indexRows.forEach((r) => {
-      const key = `${r.table_schema}.${r.table_name}`;
+      const tableSchema = readMysqlStringField(r, "table_schema");
+      const tableName = readMysqlStringField(r, "table_name");
+      const indexName = readMysqlStringField(r, "index_name");
+      const nonUnique = readMysqlField(r, "non_unique");
+      const colsValue = readMysqlField(r, "cols");
+      if (!tableSchema || !tableName || !indexName) return;
+      const key = `${tableSchema}.${tableName}`;
       const table = tablesByKey.get(key);
       if (!table) return;
-      const cols = (typeof r.cols === "string" ? r.cols.split(",") : []).map((c) => ({ column: c.trim() }));
+      const cols = (typeof colsValue === "string" ? colsValue.split(",") : []).map((c) => ({ column: c.trim() }));
       const idx = {
-        name: r.index_name,
+        name: indexName,
         columns: cols,
-        unique: r.non_unique === 0
+        unique: Number(nonUnique) === 0
       };
       table.indexes = table.indexes || [];
       table.indexes.push(idx);
@@ -12626,25 +12679,35 @@ var mysqlIntrospector = {
       const viewColumnRows = await runSelectNode(viewColumnsQuery, ctx);
       const viewsByKey = /* @__PURE__ */ new Map();
       for (const r of viewRows) {
-        if (!shouldIncludeView(r.table_name, options)) continue;
-        const key = `${r.table_schema}.${r.table_name}`;
+        const tableSchema = readMysqlStringField(r, "table_schema");
+        const tableName = readMysqlStringField(r, "table_name");
+        const viewDefinition = readMysqlStringField(r, "view_definition");
+        if (!tableSchema || !tableName) continue;
+        if (!shouldIncludeView(tableName, options)) continue;
+        const key = `${tableSchema}.${tableName}`;
         viewsByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
+          name: tableName,
+          schema: tableSchema,
           columns: [],
-          definition: r.view_definition || void 0
+          definition: viewDefinition || void 0
         });
       }
       for (const r of viewColumnRows) {
-        const key = `${r.table_schema}.${r.table_name}`;
+        const tableSchema = readMysqlStringField(r, "table_schema");
+        const tableName = readMysqlStringField(r, "table_name");
+        const columnName = readMysqlStringField(r, "column_name");
+        const columnType = readMysqlStringField(r, "column_type") || readMysqlStringField(r, "data_type");
+        const isNullable = readMysqlStringField(r, "is_nullable");
+        const columnComment = readMysqlStringField(r, "column_comment");
+        if (!tableSchema || !tableName || !columnName || !columnType || !isNullable) continue;
+        const key = `${tableSchema}.${tableName}`;
         const view = viewsByKey.get(key);
         if (!view) continue;
-        const columnType = r.column_type || r.data_type;
         const column = {
-          name: r.column_name,
+          name: columnName,
           type: columnType,
-          notNull: r.is_nullable === "NO",
-          comment: r.column_comment?.trim() || void 0
+          notNull: isNullable === "NO",
+          comment: columnComment?.trim() || void 0
         };
         view.columns.push(column);
       }
@@ -21710,21 +21773,21 @@ var BulkInsertExecutor = class extends BulkBaseExecutor {
   constructor(session, table, rows, options = {}) {
     super(session, table, rows, options);
   }
-  async executeChunk(chunk, chunkIndex) {
+  async executeChunk(chunk, _chunkIndex) {
     const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
     let builder = new InsertQueryBuilder(this.table).values(chunk);
     if (this.options.onConflict) {
       const conflictColumns = this.options.onConflict.target?.columns ?? [];
-      builder = builder.onConflict(conflictColumns);
+      const conflictBuilder = builder.onConflict(conflictColumns);
       if (this.options.onConflict.action.type === "DoNothing") {
-        builder = builder.doNothing();
+        builder = conflictBuilder.doNothing();
       } else if (this.options.onConflict.action.type === "DoUpdate" && this.options.onConflict.action.set) {
         const setMap = {};
         for (const assignment of this.options.onConflict.action.set) {
           const colName = typeof assignment.column === "object" ? assignment.column.name : assignment.column;
           setMap[colName] = assignment.value;
         }
-        builder = builder.doUpdate(setMap);
+        builder = conflictBuilder.doUpdate(setMap);
       }
     }
     const finalBuilder = builder;
@@ -21759,7 +21822,7 @@ var BulkUpdateExecutor = class extends BulkBaseExecutor {
     super(session, table, rows, options);
     this.byColumns = resolveByColumns(table, options.by);
   }
-  async executeChunk(chunk, chunkIndex) {
+  async executeChunk(chunk, _chunkIndex) {
     const allReturning = [];
     const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
     const extraWhere = this.options.where;
@@ -21879,7 +21942,7 @@ var BulkDeleteExecutor = class extends BulkBaseExecutor {
     super(session, table, ids, options);
     this.byColumnName = options.by ?? findPrimaryKey(table);
   }
-  async executeChunk(chunk, chunkIndex) {
+  async executeChunk(chunk, _chunkIndex) {
     const byColumn = this.table.columns[this.byColumnName];
     if (!byColumn) {
       throw new Error(
@@ -21935,7 +21998,7 @@ var BulkUpsertExecutor = class extends BulkBaseExecutor {
     const conflictSet = new Set(conflictTargetNames);
     this.updateColumns = options.updateColumns ?? Object.keys(rows[0] ?? {}).filter((col2) => !conflictSet.has(col2) && col2 in table.columns);
   }
-  async executeChunk(chunk, chunkIndex) {
+  async executeChunk(chunk, _chunkIndex) {
     const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
     const set = {};
     for (const col2 of this.updateColumns) {