@nocobase/data-source-manager 2.0.0-alpha.21 → 2.0.0-alpha.23

package/lib/data-source-factory.d.ts

@@ -8,11 +8,12 @@
  */
 import { DataSource } from './data-source';
 import { DataSourceManager } from './data-source-manager';
+import { DataSourceConstructor } from './types';
 export declare class DataSourceFactory {
     protected dataSourceManager: DataSourceManager;
-    collectionTypes: Map<string, typeof DataSource>;
+    collectionTypes: Map<string, DataSourceConstructor>;
     constructor(dataSourceManager: DataSourceManager);
-    register(type: string, dataSourceClass: typeof DataSource): void;
-    getClass(type: string): typeof DataSource;
-    create(type: string, options?: any): DataSource;
+    register(type: string, dataSourceClass: DataSourceConstructor): void;
+    getClass<T extends DataSource = DataSource>(type: string): DataSourceConstructor<T>;
+    create<T extends DataSource = DataSource>(type: string, options?: any): T;
 }

package/lib/data-source-factory.js

@@ -43,7 +43,7 @@ const _DataSourceFactory = class _DataSourceFactory {
   }
   create(type, options = {}) {
     var _a;
-    const klass = this.collectionTypes.get(type);
+    const klass = this.getClass(type);
     if (!klass) {
       throw new Error(`Data source type "${type}" not found`);
     }

package/lib/data-source-manager.d.ts

@@ -10,6 +10,7 @@ import { Logger, LoggerOptions } from '@nocobase/logger';
 import { ToposortOptions } from '@nocobase/utils';
 import { DataSource } from './data-source';
 import { DataSourceFactory } from './data-source-factory';
+import { DataSourceConstructor } from './types';
 type DataSourceHook = (dataSource: DataSource) => void;
 type DataSourceManagerOptions = {
     logger?: LoggerOptions | Logger;
@@ -30,8 +31,8 @@ export declare class DataSourceManager {
     add(dataSource: DataSource, options?: any): Promise<void>;
     use(fn: any, options?: ToposortOptions): void;
     middleware(): (ctx: any, next: any) => Promise<void>;
-    registerDataSourceType(type: string, DataSourceClass: typeof DataSource): void;
-    getDataSourceType(type: string): typeof DataSource | undefined;
+    registerDataSourceType(type: string, DataSourceClass: DataSourceConstructor): void;
+    getDataSourceType(type: string): DataSourceConstructor | undefined;
     buildDataSourceByType(type: string, options?: any): DataSource;
     beforeAddDataSource(hook: DataSourceHook): void;
     afterAddDataSource(hook: DataSourceHook): void;

package/lib/database-data-source.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Database } from '@nocobase/database';
+import { DatabaseIntrospector } from './database-introspector/database-introspector';
+import { DataSource } from './data-source';
+import { Context } from '@nocobase/actions';
+import { CollectionOptions, FieldOptions } from './types';
+export declare abstract class DatabaseDataSource<T extends DatabaseIntrospector = DatabaseIntrospector> extends DataSource {
+    introspector: T;
+    createDatabaseIntrospector(db: Database): T;
+    abstract readTables(): Promise<any>;
+    abstract loadTables(ctx: Context, tables: string[]): Promise<any>;
+    mergeWithLoadedCollections(collections: CollectionOptions[], loadedCollections: {
+        [name: string]: {
+            name: string;
+            fields: FieldOptions[];
+        };
+    }): CollectionOptions[];
+    private mergeFieldOptions;
+}

package/lib/database-data-source.js

@@ -0,0 +1,106 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var database_data_source_exports = {};
+__export(database_data_source_exports, {
+  DatabaseDataSource: () => DatabaseDataSource
+});
+module.exports = __toCommonJS(database_data_source_exports);
+var import_database_introspector = require("./database-introspector/database-introspector");
+var import_postgres_introspector = require("./database-introspector/postgres-introspector");
+var import_mariadb_introspector = require("./database-introspector/mariadb-introspector");
+var import_data_source = require("./data-source");
+const _DatabaseDataSource = class _DatabaseDataSource extends import_data_source.DataSource {
+  createDatabaseIntrospector(db) {
+    if (db.isPostgresCompatibleDialect()) {
+      return new import_postgres_introspector.PostgresIntrospector({
+        db
+      });
+    }
+    const dialect = db.sequelize.getDialect();
+    switch (dialect) {
+      case "mariadb":
+        return new import_mariadb_introspector.MariaDBIntrospector({
+          db
+        });
+      default:
+        return new import_database_introspector.DatabaseIntrospector({
+          db
+        });
+    }
+  }
+  mergeWithLoadedCollections(collections, loadedCollections) {
+    return collections.map((collection) => {
+      const loadedCollection = loadedCollections[collection.name];
+      if (!loadedCollection) return collection;
+      const collectionFields = collection.fields || [];
+      const loadedFieldsObj = Object.fromEntries(
+        (loadedCollection.fields || []).map((f) => [f.columnName || f.field || f.name, f])
+      );
+      const newFields = collectionFields.map((field) => {
+        const loadedField = loadedFieldsObj[field.name];
+        if (!loadedField) return field;
+        if (loadedField.possibleTypes) {
+          loadedField.possibleTypes = field.possibleTypes;
+        }
+        return this.mergeFieldOptions(field, loadedField);
+      });
+      const loadedAssociationFields = (loadedCollection.fields || []).filter(
+        (field) => ["belongsTo", "belongsToMany", "hasMany", "hasOne", "belongsToArray"].includes(field.type)
+      );
+      newFields.push(...loadedAssociationFields);
+      return {
+        ...collection,
+        ...Object.fromEntries(Object.entries(loadedCollection).filter(([key]) => key !== "fields")),
+        fields: newFields
+      };
+    });
+  }
+  mergeFieldOptions(fieldOptions, modelOptions) {
+    const newOptions = {
+      ...fieldOptions,
+      ...modelOptions
+    };
+    if (fieldOptions.rawType && modelOptions.rawType && fieldOptions.rawType !== modelOptions.rawType) {
+      newOptions.type = fieldOptions.type;
+      newOptions.interface = fieldOptions.interface;
+      newOptions.rawType = fieldOptions.rawType;
+    }
+    for (const key of [.../* @__PURE__ */ new Set([...Object.keys(modelOptions), ...Object.keys(fieldOptions)])]) {
+      if (modelOptions[key] === null && fieldOptions[key]) {
+        newOptions[key] = fieldOptions[key];
+      }
+    }
+    return newOptions;
+  }
+};
+__name(_DatabaseDataSource, "DatabaseDataSource");
+let DatabaseDataSource = _DatabaseDataSource;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseDataSource
+});

package/lib/database-introspector/database-introspector.d.ts

@@ -0,0 +1,57 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/// <reference types="node" />
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This program is offered under a commercial license.
+ * For more information, see <https://www.nocobase.com/agreement>
+ */
+import { Database } from '@nocobase/database';
+import EventEmitter from 'events';
+import { ColumnsDescription } from 'sequelize';
+import { CollectionOptions, FieldInferResult, PartialCollectionOptions, tableInfo } from '../types';
+type GetCollectionOptions = {
+    tableInfo: tableInfo;
+    localOptions?: PartialCollectionOptions;
+    mergedOptions?: PartialCollectionOptions;
+};
+interface DatabaseIntrospectorOptions {
+    db: Database;
+    typeInterfaceMap?: any;
+}
+export declare class DatabaseIntrospector extends EventEmitter {
+    db: Database;
+    constructor(options: DatabaseIntrospectorOptions);
+    protected getFieldTypeMap(): Record<string, string | Array<string>>;
+    protected getTypeInterfaceConfig(type: string): Record<string, any>;
+    getTableList(): Promise<string[]>;
+    getTableColumnsInfo(tableInfo: tableInfo): Promise<ColumnsDescription>;
+    getTableConstraints(tableInfo: tableInfo): Promise<object>;
+    getViewList(): Promise<any>;
+    excludeViewsOrTables(): any[];
+    getTables(options?: any): Promise<string[]>;
+    getCollection(options: GetCollectionOptions): Promise<CollectionOptions>;
+    tableInfoToCollectionOptions(tableInfo: tableInfo): {
+        name: string;
+        title: string;
+        schema: string;
+        tableName: string;
+    };
+    protected extractTypeFromDefinition(rawType: string): string;
+    protected inferFieldTypeByRawType(rawType: string): any;
+    protected inferFieldOptionsByRawType(type: string, rawType: string): any;
+    protected columnInfoToFieldOptions(columnsInfo: ColumnsDescription, columnName: string, indexes: any): FieldInferResult;
+    protected columnAttribute(columnsInfo: ColumnsDescription, columnName: string, indexes: any): any;
+    private collectionOptionsByFields;
+    private getDefaultInterfaceByType;
+}
+export {};

package/lib/database-introspector/database-introspector.js

@@ -0,0 +1,278 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var database_introspector_exports = {};
+__export(database_introspector_exports, {
+  DatabaseIntrospector: () => DatabaseIntrospector
+});
+module.exports = __toCommonJS(database_introspector_exports);
+var import_database = require("@nocobase/database");
+var import_events = __toESM(require("events"));
+var import_lodash = __toESM(require("lodash"));
+var import_mathjs = require("mathjs");
+var import_type_interface_map = require("./type-interface-map");
+const _DatabaseIntrospector = class _DatabaseIntrospector extends import_events.default {
+  db;
+  constructor(options) {
+    super();
+    this.db = options.db;
+  }
+  getFieldTypeMap() {
+    return import_database.fieldTypeMap[this.db.sequelize.getDialect()];
+  }
+  getTypeInterfaceConfig(type) {
+    return import_type_interface_map.typeInterfaceMap[type] || {};
+  }
+  async getTableList() {
+    return await this.db.sequelize.getQueryInterface().showAllTables();
+  }
+  async getTableColumnsInfo(tableInfo2) {
+    return this.db.sequelize.getQueryInterface().describeTable(tableInfo2);
+  }
+  async getTableConstraints(tableInfo2) {
+    return this.db.sequelize.getQueryInterface().showIndex(tableInfo2.tableName);
+  }
+  async getViewList() {
+    return (await this.db.queryInterface.listViews()).map((view) => view.name);
+  }
+  excludeViewsOrTables() {
+    return [];
+  }
+  async getTables(options = {}) {
+    var _a;
+    let tableList = await this.getTableList();
+    const views = ((_a = options.views) == null ? void 0 : _a.length) ? options.views : await this.getViewList();
+    tableList = tableList.concat(views);
+    tableList = tableList.filter((tableName) => {
+      return !this.excludeViewsOrTables().includes(tableName);
+    });
+    if (this.db.options.tablePrefix) {
+      tableList = tableList.filter((tableName) => {
+        return tableName.startsWith(this.db.options.tablePrefix);
+      });
+    }
+    return tableList;
+  }
+  async getCollection(options) {
+    const { tableInfo: tableInfo2, localOptions = {}, mergedOptions = {} } = options;
+    const columnsInfo = await this.getTableColumnsInfo(tableInfo2);
+    const constraints = await this.getTableConstraints(tableInfo2);
+    const collectionOptions = this.tableInfoToCollectionOptions(tableInfo2);
+    try {
+      const fields = Object.keys(columnsInfo).map((columnName) => {
+        return this.columnInfoToFieldOptions(columnsInfo, columnName, constraints);
+      });
+      const unsupportedFields = fields.filter((field) => {
+        return field.supported === false;
+      });
+      const supportFields = fields.filter((field) => {
+        return field.supported !== false;
+      });
+      this.db.logger.debug("Processing collection fields", {
+        tableName: tableInfo2.tableName,
+        totalFields: fields.length,
+        supportedFields: supportFields.length,
+        unsupportedFields: unsupportedFields.length
+      });
+      const remoteCollectionInfo = {
+        ...collectionOptions,
+        ...this.collectionOptionsByFields(supportFields),
+        ...localOptions,
+        ...mergedOptions,
+        fields: supportFields
+      };
+      if (unsupportedFields.length) {
+        remoteCollectionInfo.unsupportedFields = unsupportedFields;
+        this.db.logger.debug("Found unsupported fields", {
+          tableName: tableInfo2.tableName,
+          fields: unsupportedFields.map((f) => ({ name: f.name, type: f.rawType }))
+        });
+      }
+      if (remoteCollectionInfo.view && !remoteCollectionInfo.filterTargetKey && supportFields.find((field) => field.name === "id")) {
+        remoteCollectionInfo.filterTargetKey = "id";
+        this.db.logger.debug("Set view filterTargetKey to id", {
+          tableName: tableInfo2.tableName
+        });
+      }
+      return remoteCollectionInfo;
+    } catch (e) {
+      this.db.logger.error("Collection introspection error", {
+        tableName: tableInfo2.tableName,
+        error: e.message,
+        stack: e.stack
+      });
+      throw new Error(`table ${tableInfo2.tableName} introspection error: ${e.message}`, { cause: e });
+    }
+  }
+  tableInfoToCollectionOptions(tableInfo2) {
+    const tableName = tableInfo2.tableName;
+    let name = tableName;
+    if (this.db.options.tablePrefix) {
+      name = tableName.replace(this.db.options.tablePrefix, "");
+    }
+    name = name.replace(/\./g, "_");
+    return {
+      name,
+      title: name,
+      schema: tableInfo2.schema,
+      tableName
+    };
+  }
+  extractTypeFromDefinition(rawType) {
+    const leftParenIndex = rawType.indexOf("(");
+    if (leftParenIndex === -1) {
+      return rawType.toLowerCase();
+    }
+    return rawType.substring(0, leftParenIndex).toLowerCase().trim();
+  }
+  inferFieldTypeByRawType(rawType) {
+    const fieldTypeMap2 = this.getFieldTypeMap();
+    const queryType = this.extractTypeFromDefinition(rawType);
+    const mappedType = fieldTypeMap2[queryType];
+    if ((0, import_mathjs.isArray)(mappedType)) {
+      return {
+        type: mappedType[0],
+        possibleTypes: mappedType
+      };
+    }
+    return {
+      type: mappedType
+    };
+  }
+  inferFieldOptionsByRawType(type, rawType) {
+    const fieldClass = this.db.fieldTypes.get(type);
+    if (!fieldClass) {
+      return {};
+    }
+    if (typeof fieldClass.optionsFromRawType === "function") {
+      return fieldClass.optionsFromRawType(rawType);
+    }
+    return {};
+  }
+  columnInfoToFieldOptions(columnsInfo, columnName, indexes) {
+    const columnInfo = columnsInfo[columnName];
+    const name = columnName;
+    let fieldOptions = {
+      ...this.columnAttribute(columnsInfo, columnName, indexes),
+      ...this.inferFieldTypeByRawType(columnInfo.type),
+      rawType: columnInfo.type,
+      name,
+      field: columnName
+    };
+    Object.assign(fieldOptions, this.inferFieldOptionsByRawType(fieldOptions.type, columnInfo.type));
+    if (!fieldOptions.type) {
+      return {
+        rawType: columnInfo.type,
+        name,
+        field: columnName,
+        supported: false
+      };
+    }
+    const interfaceConfig = this.getDefaultInterfaceByType(columnsInfo, columnName, fieldOptions.type);
+    if (typeof interfaceConfig === "string") {
+      fieldOptions.interface = interfaceConfig;
+    } else {
+      fieldOptions = {
+        ...fieldOptions,
+        ...interfaceConfig
+      };
+    }
+    import_lodash.default.set(fieldOptions, "uiSchema.title", columnName);
+    return fieldOptions;
+  }
+  columnAttribute(columnsInfo, columnName, indexes) {
+    const columnInfo = columnsInfo[columnName];
+    const attr = {
+      type: columnInfo.type,
+      allowNull: columnInfo.defaultValue ? true : columnInfo.allowNull,
+      primaryKey: columnInfo.primaryKey,
+      unique: false,
+      autoIncrement: columnInfo.autoIncrement,
+      description: columnInfo.comment,
+      elementType: columnInfo["elementType"]
+    };
+    if (columnInfo.defaultValue && typeof columnInfo.defaultValue === "string") {
+      const isSerial = columnInfo.defaultValue.match(/^nextval\(/);
+      const isUUID = columnInfo.defaultValue.match(/^uuid_generate_v4\(/);
+      if (isSerial || isUUID) {
+        attr.autoIncrement = true;
+      }
+    }
+    for (const index of indexes) {
+      if (index.fields.length == 1 && index.fields[0].attribute == columnName && index.unique) {
+        attr.unique = true;
+      }
+    }
+    return attr;
+  }
+  collectionOptionsByFields(fields) {
+    const options = {
+      timestamps: false,
+      autoGenId: false
+    };
+    const autoIncrementField = fields.find((field) => field.autoIncrement);
+    if (autoIncrementField) {
+      options.filterTargetKey = autoIncrementField.name;
+    }
+    const primaryKeys = fields.filter((field) => field.primaryKey);
+    if (primaryKeys.length > 1) {
+      options.filterTargetKey = primaryKeys.map((field) => field.name);
+    }
+    if (!options.filterTargetKey && primaryKeys.length == 1) {
+      options.filterTargetKey = primaryKeys[0].name;
+    }
+    const uniques = fields.filter((field) => field.unique);
+    if (!options.filterTargetKey && uniques.length == 1) {
+      options.filterTargetKey = uniques[0].name;
+    }
+    return options;
+  }
+  getDefaultInterfaceByType(columnsInfo, columnName, type) {
+    const interfaceConfig = this.getTypeInterfaceConfig(type);
+    let interfaceRes = interfaceConfig;
+    if (typeof interfaceConfig === "function") {
+      interfaceRes = interfaceConfig(columnsInfo[columnName]);
+    }
+    return interfaceRes;
+  }
+};
+__name(_DatabaseIntrospector, "DatabaseIntrospector");
+let DatabaseIntrospector = _DatabaseIntrospector;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseIntrospector
+});

package/lib/database-introspector/mariadb-introspector.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { DatabaseIntrospector } from './database-introspector';
+export declare class MariaDBIntrospector extends DatabaseIntrospector {
+    getTableList(): Promise<any[]>;
+}

package/lib/database-introspector/mariadb-introspector.js

@@ -0,0 +1,47 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mariadb_introspector_exports = {};
+__export(mariadb_introspector_exports, {
+  MariaDBIntrospector: () => MariaDBIntrospector
+});
+module.exports = __toCommonJS(mariadb_introspector_exports);
+var import_database_introspector = require("./database-introspector");
+const _MariaDBIntrospector = class _MariaDBIntrospector extends import_database_introspector.DatabaseIntrospector {
+  async getTableList() {
+    const tables = await this.db.sequelize.getQueryInterface().showAllTables();
+    return tables.map((table) => {
+      return table.tableName;
+    });
+  }
+};
+__name(_MariaDBIntrospector, "MariaDBIntrospector");
+let MariaDBIntrospector = _MariaDBIntrospector;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MariaDBIntrospector
+});

package/lib/database-introspector/postgres-introspector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { DatabaseIntrospector } from './database-introspector';
+import { ColumnsDescription } from 'sequelize';
+import { tableInfo } from '../types';
+export declare class PostgresIntrospector extends DatabaseIntrospector {
+    getTableConstraints(tableInfo: tableInfo): Promise<object>;
+    getTableColumnsInfo(tableInfo: tableInfo): Promise<ColumnsDescription>;
+    private getPrimaryKeysOfTable;
+    protected columnAttribute(columnsInfo: ColumnsDescription, columnName: string, indexes: any): any;
+    private getArrayColumnElementType;
+    private appendArrayColumnElementType;
+}