feat: improve default value parsing

packages/core/src/dialects/abstract/query-interface.types.ts

@@ -23,10 +23,15 @@ export interface DatabaseDescription {
   name: string;
 }
 
+export interface DefaultValueDescription {
+  raw: string;
+  parsed: string;
+}
+
 export interface ColumnDescription {
   type: string;
   allowNull: boolean;
-  defaultValue: string;
+  defaultValue: DefaultValueDescription;
   primaryKey: boolean;
   autoIncrement: boolean;
   comment: string | null;

packages/core/src/dialects/db2/query.js

@@ -206,14 +206,17 @@ export class Db2Query extends AbstractQuery {
     if (this.isDescribeQuery()) {
       result = {};
       for (const _result of data) {
-        if (_result.Default) {
-          _result.Default = _result.Default.replace("('", '').replace("')", '').replaceAll("'", '');
-        }
+        const defaultValue = {
+          raw: _result.Default,
+          parsed: _result.Default
+            ? _result.Default.replace("('", '').replace("')", '').replaceAll("'", '')
+            : undefined,
+        };
 
         result[_result.Name] = {
           type: _result.Type.toUpperCase(),
           allowNull: _result.IsNull === 'Y',
-          defaultValue: _result.Default,
+          defaultValue,
           primaryKey: _result.KeySeq > 0,
           autoIncrement: _result.IsIdentity === 'Y',
           comment: _result.Comment,

packages/core/src/dialects/ibmi/query.js

@@ -110,7 +110,10 @@ export class IBMiQuery extends AbstractQuery {
             ? _result.Type.replace(enumRegex, 'ENUM')
             : _result.DATA_TYPE.toUpperCase(),
           allowNull: _result.IS_NULLABLE === 'Y',
-          defaultValue: _result.COLUMN_DEFAULT,
+          defaultValue: {
+            raw: _result.COLUMN_DEFAULT,
+            parsed: _result.COLUMN_DEFAULT,
+          },
           primaryKey: _result.CONSTRAINT_TYPE === 'PRIMARY KEY',
           autoIncrement: _result.IS_GENERATED !== 'IDENTITY_GENERATION',
         };

packages/core/src/dialects/mariadb/query.js

@@ -159,7 +159,10 @@ export class MariaDbQuery extends AbstractQuery {
             ? _result.Type.replace(/^enum/i, 'ENUM')
             : _result.Type.toUpperCase(),
           allowNull: _result.Null === 'YES',
-          defaultValue: _result.Default,
+          defaultValue: {
+            raw: _result.Default,
+            parsed: _result.Default,
+          },
           primaryKey: _result.Key === 'PRI',
           autoIncrement:
             Object.hasOwn(_result, 'Extra') && _result.Extra.toLowerCase() === 'auto_increment',

packages/core/src/dialects/mssql/query.js

@@ -174,14 +174,17 @@ export class MsSqlQuery extends AbstractQuery {
     if (this.isDescribeQuery()) {
       const result = {};
       for (const _result of data) {
-        if (_result.Default) {
-          _result.Default = _result.Default.replace("('", '').replace("')", '').replaceAll("'", '');
-        }
+        const defaultValue = {
+          raw: _result.Default,
+          parsed: _result.Default
+            ? _result.Default.replace("('", '').replace("')", '').replaceAll("'", '')
+            : undefined,
+        };
 
         result[_result.Name] = {
           type: _result.Type.toUpperCase(),
           allowNull: _result.IsNull === 'YES',
-          defaultValue: _result.Default,
+          defaultValue,
           primaryKey: _result.Constraint === 'PRIMARY KEY',
           autoIncrement: _result.IsIdentity === 1,
           comment: _result.Comment,

packages/core/src/dialects/mysql/default-value-parser-internal.ts

@@ -0,0 +1,25 @@
+const NUMBER_TYPES = ['INT', 'TINYINT', 'SMALLINT', 'MEDIUMINT', 'BIGINT', 'FLOAT', 'DOUBLE'];
+
+export function parseDefaultValue(
+  rawDefaultValue: string | null,
+  columnType: string,
+  extra: string,
+): unknown {
+  if (extra?.includes('DEFAULT_GENERATED') || extra?.includes('AUTO_INCREMENT')) {
+    return undefined;
+  }
+
+  if (rawDefaultValue === null) {
+    return null;
+  }
+
+  if (
+    NUMBER_TYPES.includes(columnType) &&
+    rawDefaultValue &&
+    !Number.isNaN(Number(rawDefaultValue))
+  ) {
+    return Number(rawDefaultValue);
+  }
+
+  return rawDefaultValue;
+}

packages/core/src/dialects/mysql/query.js

@@ -5,6 +5,7 @@ import NodeUtil from 'node:util';
 import forOwn from 'lodash/forOwn';
 import map from 'lodash/map';
 import zipObject from 'lodash/zipObject';
+import { parseDefaultValue } from './default-value-parser-internal';
 
 const { AbstractQuery } = require('../abstract/query');
 const sequelizeErrors = require('../../errors');
@@ -136,12 +137,17 @@ export class MySqlQuery extends AbstractQuery {
 
       for (const _result of data) {
         const enumRegex = /^enum/i;
+        const type = enumRegex.test(_result.Type)
+          ? _result.Type.replace(enumRegex, 'ENUM')
+          : _result.Type.toUpperCase();
+
         result[_result.Field] = {
-          type: enumRegex.test(_result.Type)
-            ? _result.Type.replace(enumRegex, 'ENUM')
-            : _result.Type.toUpperCase(),
+          type,
           allowNull: _result.Null === 'YES',
-          defaultValue: _result.Default,
+          defaultValue: {
+            raw: _result.Default,
+            parsed: parseDefaultValue(_result.Default, type, _result.Extra),
+          },
           primaryKey: _result.Key === 'PRI',
           autoIncrement:
             Object.hasOwn(_result, 'Extra') && _result.Extra.toLowerCase() === 'auto_increment',

packages/core/src/dialects/postgres/default-value-parser-internal.ts

@@ -0,0 +1,50 @@
+export function parseDefaultValue(rawDefaultValue: string | null, columnType: string): unknown {
+  if (rawDefaultValue === null || rawDefaultValue.startsWith('NULL::')) {
+    return null;
+  }
+
+  if (['true', 'false'].includes(rawDefaultValue) && columnType === 'BOOLEAN') {
+    return rawDefaultValue === 'true';
+  }
+
+  if (columnType !== 'NUMERIC') {
+    if (rawDefaultValue && !Number.isNaN(Number(rawDefaultValue))) {
+      return Number(rawDefaultValue);
+    }
+
+    if (rawDefaultValue.endsWith('::numeric') || rawDefaultValue.endsWith('::integer')) {
+      const unQuote = rawDefaultValue.replace(/^'/, '').replace(/'?::.*$/, '');
+
+      return Number(unQuote);
+    }
+  } else if (!rawDefaultValue.startsWith("'")) {
+    return rawDefaultValue;
+  }
+
+  if (rawDefaultValue.startsWith("'")) {
+    return parseStringValue(rawDefaultValue);
+  }
+
+  return undefined;
+}
+
+function parseStringValue(rawDefaultValue: string): string | undefined {
+  let buffer = '';
+
+  for (let i = 1; i < rawDefaultValue.length; i += 1) {
+    const char = rawDefaultValue[i];
+
+    if (char === "'") {
+      if (rawDefaultValue[i + 1] === "'") {
+        i += 1;
+      } else {
+        return buffer;
+      }
+    }
+
+    buffer += char;
+  }
+
+  // Unable to parse string, return undefined
+  return undefined;
+}

packages/core/src/dialects/postgres/query.js

@@ -12,6 +12,7 @@ const { AbstractQuery } = require('../abstract/query');
 const { QueryTypes } = require('../../query-types');
 const sequelizeErrors = require('../../errors');
 const { logger } = require('../../utils/logger');
+const { parseDefaultValue } = require('./default-value-parser-internal');
 
 const debug = logger.debugContext('sql:pg');
 
@@ -225,32 +226,14 @@ export class PostgresQuery extends AbstractQuery {
         result[row.Field] = {
           type: row.Type.toUpperCase(),
           allowNull: row.Null === 'YES',
-          defaultValue: row.Default,
+          defaultValue: {
+            raw: row.Default,
+            parsed: parseDefaultValue(row.Default, row.Type.toUpperCase()),
+          },
           comment: row.Comment,
           special: row.special ? this.sequelize.queryGenerator.fromArray(row.special) : [],
           primaryKey: row.Constraint === 'PRIMARY KEY',
         };
-
-        if (result[row.Field].type === 'BOOLEAN') {
-          result[row.Field].defaultValue = { false: false, true: true }[
-            result[row.Field].defaultValue
-          ];
-
-          if (result[row.Field].defaultValue === undefined) {
-            result[row.Field].defaultValue = null;
-          }
-        }
-
-        if (typeof result[row.Field].defaultValue === 'string') {
-          result[row.Field].defaultValue = result[row.Field].defaultValue.replaceAll("'", '');
-
-          if (result[row.Field].defaultValue.includes('::')) {
-            const split = result[row.Field].defaultValue.split('::');
-            if (split[1].toLowerCase() !== 'regclass)') {
-              result[row.Field].defaultValue = split[0];
-            }
-          }
-        }
       }
 
       return result;

packages/core/src/dialects/snowflake/query.js

@@ -153,7 +153,10 @@ export class SnowflakeQuery extends AbstractQuery {
         result[_result.Field] = {
           type: _result.Type.toUpperCase(),
           allowNull: _result.Null === 'YES',
-          defaultValue: _result.Default,
+          defaultValue: {
+            raw: _result.Default,
+            parsed: _result.Default,
+          },
           primaryKey: _result.Key === 'PRI',
           autoIncrement:
             Object.hasOwn(_result, 'Extra') && _result.Extra.toLowerCase() === 'auto_increment',

packages/core/src/dialects/sqlite/query.js

@@ -99,16 +99,20 @@ export class SqliteQuery extends AbstractQuery {
       // this is the sqlite way of getting the metadata of a table
       result = {};
 
-      let defaultValue;
       for (const _result of results) {
-        if (_result.dflt_value === null) {
+        const defaultValue = {
+          raw: _result.dflt_value,
+          parsed: _result.dflt_value,
+        };
+
+        if (defaultValue.raw === null) {
           // Column schema omits any "DEFAULT ..."
-          defaultValue = undefined;
-        } else if (_result.dflt_value === 'NULL') {
+          defaultValue.parsed = undefined;
+        } else if (defaultValue.raw === 'NULL') {
           // Column schema is a "DEFAULT NULL"
-          defaultValue = null;
+          defaultValue.parsed = null;
         } else {
-          defaultValue = _result.dflt_value;
+          defaultValue.parsed = defaultValue.raw;
         }
 
         result[_result.name] = {
@@ -119,13 +123,11 @@ export class SqliteQuery extends AbstractQuery {
         };
 
         if (result[_result.name].type === 'TINYINT(1)') {
-          result[_result.name].defaultValue = { 0: false, 1: true }[
-            result[_result.name].defaultValue
-          ];
+          defaultValue.parsed = { 0: false, 1: true }[defaultValue.raw];
         }
 
-        if (typeof result[_result.name].defaultValue === 'string') {
-          result[_result.name].defaultValue = result[_result.name].defaultValue.replaceAll("'", '');
+        if (typeof defaultValue.parsed === 'string') {
+          defaultValue.parsed = defaultValue.raw.replaceAll("'", '');
         }
       }