@nocobase/database 0.15.0-alpha.3 → 0.15.0-alpha.5

package/lib/collection-factory.d.ts

@@ -1,9 +1,16 @@
 import { Collection, CollectionOptions } from './collection';
 import Database from './database';
+import { Model } from './model';
+type CollectionTypeOptions = {
+    condition: (options: CollectionOptions) => boolean;
+    onSync?: (model: typeof Model, options: any) => Promise<void>;
+};
 export declare class CollectionFactory {
     private database;
-    private collectionTypes;
+    collectionTypes: Map<typeof Collection, CollectionTypeOptions>;
     constructor(database: Database);
-    registerCollectionType(collectionClass: typeof Collection, condition: (options: CollectionOptions) => boolean): void;
-    createCollection<T extends Collection>(options: CollectionOptions): T;
+    registerCollectionType(collectionClass: typeof Collection, // Using the collection class as the key
+    options: CollectionTypeOptions): void;
+    createCollection<T extends Collection>(collectionOptions: CollectionOptions): T;
 }
+export {};

package/lib/collection-factory.js

@@ -26,19 +26,20 @@ const _CollectionFactory = class _CollectionFactory {
   constructor(database) {
     this.database = database;
   }
-  collectionTypes = [];
-  registerCollectionType(collectionClass, condition) {
-    this.collectionTypes.push({ ctor: collectionClass, condition });
+  // Using a Map with the collection subclass as the key and options as the value
+  collectionTypes = /* @__PURE__ */ new Map();
+  registerCollectionType(collectionClass, options) {
+    this.collectionTypes.set(collectionClass, options);
   }
-  createCollection(options) {
+  createCollection(collectionOptions) {
     let klass = import_collection.Collection;
-    for (const { ctor, condition } of this.collectionTypes) {
-      if (condition(options)) {
+    for (const [ctor, options] of this.collectionTypes) {
+      if (options.condition(collectionOptions)) {
         klass = ctor;
         break;
       }
     }
-    return new klass(options, {
+    return new klass(collectionOptions, {
       database: this.database
     });
   }

package/lib/collection.js

@@ -64,10 +64,6 @@ function EnsureAtomicity(target, propertyKey, descriptor) {
       }
       const afterRawAttributes = Object.keys(model.rawAttributes);
       const createdRawAttributes = import_lodash.default.difference(afterRawAttributes, beforeRawAttributes);
-      console.log({
-        beforeRawAttributes,
-        afterRawAttributes
-      });
       for (const key of createdRawAttributes) {
         delete this.model.rawAttributes[key];
       }

package/lib/database.d.ts

@@ -65,6 +65,10 @@ export declare const DialectVersionAccessors: {
         sql: string;
         get: (v: string) => string;
     };
+    mariadb: {
+        sql: string;
+        get: (v: string) => string;
+    };
     postgres: {
         sql: string;
         get: (v: string) => string;
@@ -116,6 +120,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     addMigration(item: MigrationItem): void;
     addMigrations(options: AddMigrationsOptions): void;
     inDialect(...dialect: string[]): boolean;
+    isMySQLCompatibleDialect(): boolean;
     /**
      * Add collection to database
      * @param options
@@ -151,6 +156,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     auth(options?: Omit<QueryOptions, 'retry'> & {
         retry?: number | Pick<QueryOptions, 'retry'>;
     }): Promise<void>;
+    checkVersion(): Promise<boolean>;
     prepare(): Promise<void>;
     reconnect(): Promise<void>;
     closed(): any;

package/lib/database.js

@@ -64,6 +64,8 @@ var import_utils2 = require("./utils");
 var import_value_parsers = require("./value-parsers");
 var import_view_collection = require("./view-collection");
 var import_collection_factory = require("./collection-factory");
+var import_chalk = __toESM(require("chalk"));
+var import_helpers = require("./helpers");
 const DialectVersionAccessors = {
   sqlite: {
     sql: "select sqlite_version() as version",
@@ -72,9 +74,13 @@ const DialectVersionAccessors = {
   mysql: {
     sql: "select version() as version",
     get: (v) => {
-      if (v.toLowerCase().includes("mariadb")) {
-        return "";
-      }
+      const m = /([\d+.]+)/.exec(v);
+      return m[0];
+    }
+  },
+  mariadb: {
+    sql: "select version() as version",
+    get: (v) => {
       const m = /([\d+.]+)/.exec(v);
       return m[0];
     }
@@ -101,7 +107,11 @@ const _DatabaseVersion = class _DatabaseVersion {
           return false;
         }
         const [result] = await this.db.sequelize.query(accessors[dialect].sql);
-        return import_semver.default.satisfies(accessors[dialect].get((_a = result == null ? void 0 : result[0]) == null ? void 0 : _a.version), versions[dialect]);
+        const versionResult = accessors[dialect].get((_a = result == null ? void 0 : result[0]) == null ? void 0 : _a.version);
+        if (import_lodash.default.isPlainObject(versionResult) && versionResult.dialect) {
+          return import_semver.default.satisfies(versionResult.version, versions[versionResult.dialect]);
+        }
+        return import_semver.default.satisfies(versionResult, versions[dialect]);
       }
     }
     return false;
@@ -231,14 +241,20 @@ const _Database = class _Database extends import_events.EventEmitter {
     return this._instanceId;
   }
   registerCollectionType() {
-    this.collectionFactory.registerCollectionType(import_inherited_collection.InheritedCollection, (options) => {
-      return options.inherits && import_lodash.default.castArray(options.inherits).length > 0;
+    this.collectionFactory.registerCollectionType(import_inherited_collection.InheritedCollection, {
+      condition: (options) => {
+        return options.inherits && import_lodash.default.castArray(options.inherits).length > 0;
+      }
     });
-    this.collectionFactory.registerCollectionType(import_view_collection.ViewCollection, (options) => {
-      return options.viewName || options.view;
+    this.collectionFactory.registerCollectionType(import_view_collection.ViewCollection, {
+      condition: (options) => {
+        return options.viewName || options.view;
+      }
     });
-    this.collectionFactory.registerCollectionType(import_sql_collection.SqlCollection, (options) => {
-      return options.sql;
+    this.collectionFactory.registerCollectionType(import_sql_collection.SqlCollection, {
+      condition: (options) => {
+        return options.sql;
+      }
     });
   }
   setContext(context) {
@@ -354,6 +370,9 @@ const _Database = class _Database extends import_events.EventEmitter {
   inDialect(...dialect) {
     return dialect.includes(this.sequelize.getDialect());
   }
+  isMySQLCompatibleDialect() {
+    return this.inDialect("mysql", "mariadb");
+  }
   /**
    * Add collection to database
    * @param options
@@ -502,7 +521,7 @@ const _Database = class _Database extends import_events.EventEmitter {
     return new Field2(options, context);
   }
   async sync(options) {
-    const isMySQL = this.sequelize.getDialect() === "mysql";
+    const isMySQL = this.isMySQLCompatibleDialect();
     if (isMySQL) {
       await this.sequelize.query("SET FOREIGN_KEY_CHECKS = 0", null);
     }
@@ -572,7 +591,19 @@ const _Database = class _Database extends import_events.EventEmitter {
       throw new Error("Connection failed, please check your database connection credentials and try again.");
     }
   }
+  async checkVersion() {
+    return await (0, import_helpers.checkDatabaseVersion)(this);
+  }
   async prepare() {
+    if (this.isMySQLCompatibleDialect()) {
+      const result = await this.sequelize.query(`SHOW VARIABLES LIKE 'lower_case_table_names'`, { plain: true });
+      if ((result == null ? void 0 : result.Value) === "1" && !this.options.underscored) {
+        console.log(
+          `Your database lower_case_table_names=1, please add ${import_chalk.default.yellow("DB_UNDERSCORED=true")} to the .env file`
+        );
+        process.exit();
+      }
+    }
     if (this.inDialect("postgres") && this.options.schema && this.options.schema != "public") {
       await this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${this.options.schema}"`, null);
     }

package/lib/fields/field.js

@@ -151,7 +151,7 @@ const _Field = class _Field {
       sql = `SELECT *
              from pragma_table_info('${this.collection.model.tableName}')
              WHERE name = '${this.columnName()}'`;
-    } else if (this.database.inDialect("mysql")) {
+    } else if (this.database.inDialect("mysql", "mariadb")) {
       sql = `
         select column_name
         from INFORMATION_SCHEMA.COLUMNS

package/lib/fields/has-many-field.js

@@ -85,6 +85,16 @@ const _HasManyField = class _HasManyField extends import_relation_field.Relation
       tcoll.addIndex([this.options.foreignKey]);
     }
     this.database.referenceMap.addReference(this.reference(association));
+    if (this.options.sortable) {
+      const targetCollection = database.modelCollection.get(this.TargetModel);
+      const sortFieldName = `${this.options.foreignKey}Sort`;
+      targetCollection.setField(sortFieldName, {
+        type: "sort",
+        hidden: true,
+        scopeKey: this.options.foreignKey
+      });
+      this.options.sortBy = sortFieldName;
+    }
     return true;
   }
   unbind() {

package/lib/fields/sort-field.js

@@ -87,41 +87,52 @@ const _SortField = class _SortField extends import_field.Field {
     const doInit = /* @__PURE__ */ __name(async (scopeKey2 = null, scopeValue = null) => {
       const queryInterface = this.collection.db.sequelize.getQueryInterface();
       if (scopeKey2) {
-        const scopeField = this.collection.getField(scopeKey2);
-        if (!scopeField) {
+        const scopeAttribute = this.collection.model.rawAttributes[scopeKey2];
+        if (!scopeAttribute) {
           throw new Error(`can not find scope field ${scopeKey2} for collection ${this.collection.name}`);
         }
-        scopeKey2 = this.collection.model.rawAttributes[scopeKey2].field;
+        scopeKey2 = scopeAttribute.field;
       }
       const quotedOrderField = queryInterface.quoteIdentifier(orderField);
-      const sortColumnName = this.collection.model.rawAttributes[this.name].field;
-      const sql = `
-        WITH ordered_table AS (
-          SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
-          FROM ${this.collection.quotedTableName()}
-          ${(() => {
-        if (scopeKey2 && scopeValue) {
-          const hasNull = scopeValue.includes(null);
-          return `WHERE ${queryInterface.quoteIdentifier(scopeKey2)} IN (${scopeValue.filter((v) => v !== null).map((v) => `'${v}'`).join(",")}) ${hasNull ? `OR ${queryInterface.quoteIdentifier(scopeKey2)} IS NULL` : ""} `;
-        }
-        return "";
-      })()}
-
-        )
-        ${this.collection.db.inDialect("mysql") ? `
-             UPDATE ${this.collection.quotedTableName()}, ordered_table
-             SET ${this.collection.quotedTableName()}.${sortColumnName} = ordered_table.new_sequence_number
-             WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField}
-            ` : `
-          UPDATE ${this.collection.quotedTableName()}
-        SET ${queryInterface.quoteIdentifier(sortColumnName)} = ordered_table.new_sequence_number
-        FROM ordered_table
-        WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ${queryInterface.quoteIdentifier(
-        "ordered_table"
-      )}.${quotedOrderField};
-        `}
-
-      `;
+      const sortColumnName = queryInterface.quoteIdentifier(this.collection.model.rawAttributes[this.name].field);
+      let sql;
+      const whereClause = scopeKey2 && scopeValue ? `
+  WHERE ${queryInterface.quoteIdentifier(scopeKey2)} IN (${scopeValue.filter((v) => v !== null).map((v) => `'${v}'`).join(", ")})${scopeValue.includes(null) ? ` OR ${queryInterface.quoteIdentifier(scopeKey2)} IS NULL` : ""}` : "";
+      if (this.collection.db.inDialect("postgres")) {
+        sql = `
+    UPDATE ${this.collection.quotedTableName()}
+    SET ${sortColumnName} = ordered_table.new_sequence_number
+    FROM (
+      SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
+      FROM ${this.collection.quotedTableName()}
+      ${whereClause}
+    ) AS ordered_table
+    WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField};
+  `;
+      } else if (this.collection.db.inDialect("sqlite")) {
+        sql = `
+    UPDATE ${this.collection.quotedTableName()}
+    SET ${sortColumnName} = (
+      SELECT new_sequence_number
+      FROM (
+        SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
+        FROM ${this.collection.quotedTableName()}
+        ${whereClause}
+      ) AS ordered_table
+      WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField}
+    );
+  `;
+      } else if (this.collection.db.inDialect("mysql") || this.collection.db.inDialect("mariadb")) {
+        sql = `
+    UPDATE ${this.collection.quotedTableName()}
+    JOIN (
+      SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
+      FROM ${this.collection.quotedTableName()}
+      ${whereClause}
+    ) AS ordered_table ON ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField}
+    SET ${this.collection.quotedTableName()}.${sortColumnName} = ordered_table.new_sequence_number;
+  `;
+      }
       await this.collection.db.sequelize.query(sql, {
         transaction
       });

package/lib/helpers.d.ts

@@ -1,2 +1,3 @@
-import { IDatabaseOptions } from './database';
+import { Database, IDatabaseOptions } from './database';
 export declare function parseDatabaseOptionsFromEnv(): Promise<IDatabaseOptions>;
+export declare function checkDatabaseVersion(db: Database): Promise<boolean>;

package/lib/helpers.js

@@ -28,10 +28,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var helpers_exports = {};
 __export(helpers_exports, {
+  checkDatabaseVersion: () => checkDatabaseVersion,
   parseDatabaseOptionsFromEnv: () => parseDatabaseOptionsFromEnv
 });
 module.exports = __toCommonJS(helpers_exports);
 var import_fs = __toESM(require("fs"));
+var import_semver = __toESM(require("semver"));
 function getEnvValue(key, defaultValue) {
   return process.env[key] || defaultValue;
 }
@@ -114,7 +116,57 @@ function customLogger(queryString, queryObject) {
   }
 }
 __name(customLogger, "customLogger");
+const dialectVersionAccessors = {
+  sqlite: {
+    sql: "select sqlite_version() as version",
+    get: (v) => v,
+    version: "3.x"
+  },
+  mysql: {
+    sql: "select version() as version",
+    get: (v) => {
+      const m = /([\d+.]+)/.exec(v);
+      return m[0];
+    },
+    version: ">=8.0.17"
+  },
+  mariadb: {
+    sql: "select version() as version",
+    get: (v) => {
+      const m = /([\d+.]+)/.exec(v);
+      return m[0];
+    },
+    version: ">=10.9"
+  },
+  postgres: {
+    sql: "select version() as version",
+    get: (v) => {
+      const m = /([\d+.]+)/.exec(v);
+      return import_semver.default.minVersion(m[0]).version;
+    },
+    version: ">=10"
+  }
+};
+async function checkDatabaseVersion(db) {
+  var _a;
+  const dialect = db.sequelize.getDialect();
+  const accessor = dialectVersionAccessors[dialect];
+  if (!accessor) {
+    throw new Error(`unsupported dialect ${dialect}`);
+  }
+  const result = await db.sequelize.query(accessor.sql, {
+    type: "SELECT"
+  });
+  const version = accessor.get((_a = result == null ? void 0 : result[0]) == null ? void 0 : _a.version);
+  const versionResult = import_semver.default.satisfies(version, accessor.version);
+  if (!versionResult) {
+    throw new Error(`to use ${dialect}, please ensure the version is ${accessor.version}`);
+  }
+  return true;
+}
+__name(checkDatabaseVersion, "checkDatabaseVersion");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  checkDatabaseVersion,
   parseDatabaseOptionsFromEnv
 });

package/lib/model.d.ts

@@ -10,6 +10,7 @@ export declare class Model<TModelAttributes extends {} = any, TCreationAttribute
     [key: string]: any;
     protected _changedWithAssociations: Set<unknown>;
     protected _previousDataValuesWithAssociations: {};
+    static sync(options: any): Promise<any>;
     toChangedWithAssociations(): void;
     changedWithAssociations(key?: string, value?: any): boolean | unknown[] | this;
     clearChangedWithAssociations(): void;
@@ -17,6 +18,5 @@ export declare class Model<TModelAttributes extends {} = any, TCreationAttribute
     private hiddenObjKey;
     private sortAssociations;
     private sortArray;
-    static sync(options: any): Promise<any>;
 }
 export {};

package/lib/model.js

@@ -43,6 +43,54 @@ const _ = import_lodash.default;
 const _Model = class _Model extends import_sequelize.Model {
   _changedWithAssociations = /* @__PURE__ */ new Set();
   _previousDataValuesWithAssociations = {};
+  static async sync(options) {
+    var _a;
+    if (this.collection.isView()) {
+      return;
+    }
+    if (this.collection.options.sync === false) {
+      return;
+    }
+    const collectionSyncOptions = (_a = this.database.collectionFactory.collectionTypes.get(this.collection.constructor)) == null ? void 0 : _a.onSync;
+    if (collectionSyncOptions) {
+      await collectionSyncOptions(this, options);
+      return;
+    }
+    const model = this;
+    const _schema = model._schema;
+    if (_schema && _schema != "public") {
+      await this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${_schema}";`, {
+        raw: true,
+        transaction: options == null ? void 0 : options.transaction
+      });
+    }
+    if (Object.keys(model.tableAttributes).length === 0) {
+      if (this.database.inDialect("sqlite", "mysql", "mariadb")) {
+        console.error(`Zero-column tables aren't supported in ${this.database.sequelize.getDialect()}`);
+        return;
+      }
+      const queryInterface = this.sequelize.queryInterface;
+      if (!queryInterface.patched) {
+        const oldDescribeTable = queryInterface.describeTable;
+        queryInterface.describeTable = async function(...args) {
+          try {
+            return await oldDescribeTable.call(this, ...args);
+          } catch (err) {
+            if (err.message.includes("No description found for")) {
+              return [];
+            } else {
+              throw err;
+            }
+          }
+        };
+        queryInterface.patched = true;
+      }
+    }
+    if (this.collection.isInherited()) {
+      return import_sync_runner.SyncRunner.syncInheritModel(model, options);
+    }
+    return import_sequelize.Model.sync.call(this, options);
+  }
   // TODO
   toChangedWithAssociations() {
     this._changedWithAssociations = /* @__PURE__ */ new Set([...this._changedWithAssociations, ...this._changed]);
@@ -137,48 +185,6 @@ const _Model = class _Model extends import_sequelize.Model {
     });
     return import_lodash.default.orderBy(data, orderItems, orderDirections);
   }
-  static async sync(options) {
-    if (this.collection.isView()) {
-      return;
-    }
-    if (this.collection.options.sync === false) {
-      return;
-    }
-    const model = this;
-    const _schema = model._schema;
-    if (_schema && _schema != "public") {
-      await this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${_schema}";`, {
-        raw: true,
-        transaction: options == null ? void 0 : options.transaction
-      });
-    }
-    if (Object.keys(model.tableAttributes).length === 0) {
-      if (this.database.inDialect("sqlite", "mysql")) {
-        console.error(`Zero-column tables aren't supported in ${this.database.sequelize.getDialect()}`);
-        return;
-      }
-      const queryInterface = this.sequelize.queryInterface;
-      if (!queryInterface.patched) {
-        const oldDescribeTable = queryInterface.describeTable;
-        queryInterface.describeTable = async function(...args) {
-          try {
-            return await oldDescribeTable.call(this, ...args);
-          } catch (err) {
-            if (err.message.includes("No description found for")) {
-              return [];
-            } else {
-              throw err;
-            }
-          }
-        };
-        queryInterface.patched = true;
-      }
-    }
-    if (this.collection.isInherited()) {
-      return import_sync_runner.SyncRunner.syncInheritModel(model, options);
-    }
-    return import_sequelize.Model.sync.call(this, options);
-  }
 };
 __name(_Model, "Model");
 __publicField(_Model, "database");

package/lib/operators/utils.js

@@ -30,7 +30,7 @@ const isPg = /* @__PURE__ */ __name((ctx) => {
   return getDialect(ctx) === "postgres";
 }, "isPg");
 const isMySQL = /* @__PURE__ */ __name((ctx) => {
-  return getDialect(ctx) === "mysql";
+  return getDialect(ctx) === "mysql" || getDialect(ctx) === "mariadb";
 }, "isMySQL");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/options-parser.js

@@ -132,7 +132,7 @@ const _OptionsParser = class _OptionsParser {
         sortField[0] = (rawField == null ? void 0 : rawField.field) || sortField[0];
       }
       sortField.push(direction);
-      if (this.database.inDialect("mysql")) {
+      if (this.database.isMySQLCompatibleDialect()) {
         orderParams.push([import_sequelize.Sequelize.fn("ISNULL", import_sequelize.Sequelize.col(`${this.model.name}.${sortField[0]}`))]);
       }
       orderParams.push(sortField);

package/lib/query-interface/mysql-query-interface.d.ts

@@ -17,4 +17,8 @@ export default class MysqlQueryInterface extends QueryInterface {
     }>;
     parseSQL(sql: string): any;
     viewDef(viewName: string): Promise<string>;
+    showTableDefinition(tableInfo: {
+        name: string;
+        schema?: string;
+    }): Promise<any>;
 }

package/lib/query-interface/mysql-query-interface.js

@@ -88,6 +88,12 @@ const _MysqlQueryInterface = class _MysqlQueryInterface extends import_query_int
     const sql = match[0];
     return sql;
   }
+  async showTableDefinition(tableInfo) {
+    const { name } = tableInfo;
+    const sql = `SHOW CREATE TABLE ${name}`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT" });
+    return results[0]["Create Table"];
+  }
 };
 __name(_MysqlQueryInterface, "MysqlQueryInterface");
 let MysqlQueryInterface = _MysqlQueryInterface;

package/lib/query-interface/postgres-query-interface.d.ts

@@ -13,4 +13,8 @@ export default class PostgresQueryInterface extends QueryInterface {
             table_schema?: string;
         };
     }>;
+    showTableDefinition(tableInfo: {
+        name: string;
+        schema?: string;
+    }): Promise<any>;
 }

package/lib/query-interface/postgres-query-interface.js

@@ -108,6 +108,33 @@ const _PostgresQueryInterface = class _PostgresQueryInterface extends import_que
       return {};
     }
   }
+  async showTableDefinition(tableInfo) {
+    const showFunc = `
+CREATE OR REPLACE FUNCTION show_create_table(p_schema text, p_table_name text)
+RETURNS text AS
+$BODY$
+SELECT 'CREATE TABLE ' || p_schema || '.' || p_table_name || ' (' || E'\\n' || '' ||
+    string_agg(column_list.column_expr, ', ' || E'\\n' || '') ||
+    '' || E'\\n' || ');'
+FROM (
+  SELECT '    ' || column_name || ' ' || data_type ||
+       coalesce('(' || character_maximum_length || ')', '') ||
+       case when is_nullable = 'YES' then '' else ' NOT NULL' end as column_expr
+  FROM information_schema.columns
+  WHERE table_schema = p_schema AND table_name = p_table_name
+  ORDER BY ordinal_position) column_list;
+$BODY$
+  LANGUAGE SQL STABLE;
+    `;
+    await this.db.sequelize.query(showFunc, { type: "RAW" });
+    const res = await this.db.sequelize.query(
+      `SELECT show_create_table('${tableInfo.schema}', '${tableInfo.name || "public"}')`,
+      {
+        type: "SELECT"
+      }
+    );
+    return res[0]["show_create_table"];
+  }
 };
 __name(_PostgresQueryInterface, "PostgresQueryInterface");
 let PostgresQueryInterface = _PostgresQueryInterface;

package/lib/query-interface/query-interface-builder.js

@@ -37,6 +37,7 @@ var import_sqlite_query_interface = __toESM(require("./sqlite-query-interface"))
 function buildQueryInterface(db) {
   const map = {
     mysql: import_mysql_query_interface.default,
+    mariadb: import_mysql_query_interface.default,
     postgres: import_postgres_query_interface.default,
     sqlite: import_sqlite_query_interface.default
   };

package/lib/query-interface/query-interface.d.ts

@@ -19,5 +19,9 @@ export default abstract class QueryInterface {
         };
     }>;
     abstract parseSQL(sql: string): any;
+    abstract showTableDefinition(tableInfo: {
+        name: string;
+        schema?: string;
+    }): Promise<any>;
     dropAll(options: any): Promise<void>;
 }

package/lib/query-interface/sqlite-query-interface.d.ts

@@ -16,4 +16,8 @@ export default class SqliteQueryInterface extends QueryInterface {
     }>;
     parseSQL(sql: string): any;
     viewDef(viewName: string): Promise<string>;
+    showTableDefinition(tableInfo: {
+        name: string;
+        schema?: string;
+    }): Promise<any>;
 }

package/lib/query-interface/sqlite-query-interface.js

@@ -98,6 +98,9 @@ const _SqliteQueryInterface = class _SqliteQueryInterface extends import_query_i
     const sql = match[0];
     return sql;
   }
+  showTableDefinition(tableInfo) {
+    return Promise.resolve(void 0);
+  }
 };
 __name(_SqliteQueryInterface, "SqliteQueryInterface");
 let SqliteQueryInterface = _SqliteQueryInterface;

package/lib/view/field-type-map.d.ts

@@ -45,5 +45,19 @@ declare const _default: {
         numeric: string;
         json: string[];
     };
+    mariadb: {
+        varchar: string;
+        text: string;
+        int: string;
+        integer: string;
+        bigint: string;
+        float: string;
+        double: string;
+        boolean: string;
+        tinyint: string;
+        datetime: string;
+        timestamp: string;
+        json: string[];
+    };
 };
 export default _default;

package/lib/view/field-type-map.js

@@ -66,4 +66,4 @@ const sqlite = {
   numeric: "decimal",
   json: ["json", "array"]
 };
-var field_type_map_default = { postgres, mysql, sqlite };
+var field_type_map_default = { postgres, mysql, sqlite, mariadb: mysql };

package/lib/view/view-inference.d.ts

@@ -14,9 +14,9 @@ export declare class ViewFieldInference {
         viewSchema?: string;
     }): Promise<InferredFieldResult>;
     static inferToFieldType(options: {
-        db: Database;
         name: string;
         type: string;
+        dialect: string;
     }): {
         possibleTypes: string[];
         type?: undefined;

package/lib/view/view-inference.js

@@ -99,15 +99,21 @@ const _ViewFieldInference = class _ViewFieldInference {
         }
       }
       if (!inferResult.type) {
-        Object.assign(inferResult, this.inferToFieldType({ db, name, type: column.type }));
+        Object.assign(
+          inferResult,
+          this.inferToFieldType({
+            dialect: db.sequelize.getDialect(),
+            name,
+            type: column.type
+          })
+        );
       }
       rawFields.push([name, inferResult]);
     }
     return Object.fromEntries(rawFields);
   }
   static inferToFieldType(options) {
-    const { db } = options;
-    const dialect = db.sequelize.getDialect();
+    const { dialect } = options;
     const fieldTypeMap = import_field_type_map.default[dialect];
     if (!options.type) {
       return {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.15.0-alpha.3",
+  "version": "0.15.0-alpha.5",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.15.0-alpha.3",
-    "@nocobase/utils": "0.15.0-alpha.3",
+    "@nocobase/logger": "0.15.0-alpha.5",
+    "@nocobase/utils": "0.15.0-alpha.5",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "dayjs": "^1.11.8",
@@ -33,5 +33,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "8f39868bd613a465efb20123094ebbc2390c1eef"
+  "gitHead": "4713b1a887dad4dadf27b65e3b3e2a46c6986cbf"
 }