@nocobase/plugin-data-source-manager 0.21.0-alpha.9 → 1.0.0-alpha.10

package/dist/server/services/database-introspector.js

@@ -1,235 +0,0 @@
-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 __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_lodash = __toESM(require("lodash"));
-var import_type_interface_map = __toESM(require("./type-interface-map"));
-class DatabaseIntrospector {
-  constructor(db) {
-    this.db = db;
-  }
-  async getCollections(options = {}) {
-    const tableList = await this.db.sequelize.getQueryInterface().showAllTables();
-    const batchSize = 5;
-    const results = [];
-    for (let i = 0; i < tableList.length; i += batchSize) {
-      const batch = tableList.slice(i, i + batchSize);
-      const batchResults = await Promise.all(
-        batch.map(async (tableName) => {
-          var _a;
-          const tableInfo = {
-            tableName
-          };
-          const collectionOptions = this.tableInfoToCollectionOptions(tableInfo);
-          const localOptions = (_a = options.localData) == null ? void 0 : _a[collectionOptions.name];
-          try {
-            return await this.getCollection({
-              tableInfo,
-              localOptions
-            });
-          } catch (e) {
-            if (e.message.includes("No description found for")) {
-              return false;
-            }
-            throw e;
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return results.filter(Boolean);
-  }
-  async getCollection(options) {
-    const { tableInfo } = options;
-    const columnsInfo = await this.db.sequelize.getQueryInterface().describeTable(tableInfo);
-    const collectionOptions = this.tableInfoToCollectionOptions(tableInfo);
-    const constraints = await this.db.sequelize.getQueryInterface().showIndex(this.db.inDialect("postgres") ? tableInfo : tableInfo.tableName);
-    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;
-      });
-      const remoteCollectionInfo = {
-        ...collectionOptions,
-        ...this.collectionOptionsByFields(supportFields),
-        fields: supportFields
-      };
-      if (unsupportedFields.length) {
-        remoteCollectionInfo.unsupportedFields = unsupportedFields;
-      }
-      return this.mergeLocalDataIntoCollectionOptions(remoteCollectionInfo, options.localOptions);
-    } catch (e) {
-      throw new Error(`table ${tableInfo.tableName} introspection error: ${e.message}`);
-    }
-  }
-  loadCollection(options) {
-    this.db.collection({
-      ...options,
-      introspected: true
-    });
-  }
-  loadCollections(options) {
-    options.collections.forEach((collection) => {
-      this.loadCollection(collection);
-    });
-  }
-  tableInfoToCollectionOptions(tableInfo) {
-    return {
-      name: tableInfo.tableName,
-      title: tableInfo.tableName,
-      schema: tableInfo.schema,
-      tableName: tableInfo.tableName
-    };
-  }
-  collectionOptionsByFields(fields) {
-    const options = {
-      timestamps: false
-    };
-    const autoIncrementField = fields.find((field) => field.autoIncrement);
-    if (autoIncrementField) {
-      options.filterTargetKey = autoIncrementField.name;
-    }
-    const primaryKeys = fields.filter((field) => field.primaryKey);
-    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;
-  }
-  mergeLocalDataIntoCollectionOptions(collectionOptions, localData) {
-    var _a;
-    if (!localData) {
-      return collectionOptions;
-    }
-    const collectionFields = collectionOptions.fields || [];
-    const localFieldsAsObject = import_lodash.default.keyBy(localData.fields, "name");
-    const newFields = collectionFields.map((field) => {
-      const localField = localFieldsAsObject[field.name];
-      if (!localField) {
-        return field;
-      }
-      return {
-        ...field,
-        ...localField
-      };
-    });
-    const localAssociationFields = (_a = localData.fields) == null ? void 0 : _a.filter((field) => {
-      return ["belongsTo", "belongsToMany", "hasMany", "hasOne"].includes(field.type);
-    });
-    if (localAssociationFields) {
-      newFields.push(...localAssociationFields);
-    }
-    return {
-      ...collectionOptions,
-      ...import_lodash.default.omit(localData, ["fields"]),
-      fields: newFields
-    };
-  }
-  columnInfoToFieldOptions(columnsInfo, columnName, indexes) {
-    const columnInfo = columnsInfo[columnName];
-    let fieldOptions = {
-      ...this.columnAttribute(columnsInfo, columnName, indexes),
-      ...import_database.ViewFieldInference.inferToFieldType({
-        dialect: this.db.options.dialect,
-        type: columnInfo.type,
-        name: columnName
-      }),
-      rawType: columnInfo.type,
-      name: columnName
-    };
-    const interfaceConfig = this.getDefaultInterfaceByType(columnsInfo, columnName, fieldOptions.type);
-    if (typeof interfaceConfig === "string") {
-      fieldOptions.interface = interfaceConfig;
-    } else {
-      fieldOptions = {
-        ...fieldOptions,
-        ...interfaceConfig
-      };
-    }
-    if (!fieldOptions.type) {
-      return {
-        rawType: columnInfo.type,
-        name: columnName,
-        supported: false
-      };
-    }
-    import_lodash.default.set(fieldOptions, "uiSchema.title", columnName);
-    return fieldOptions;
-  }
-  getDefaultInterfaceByType(columnsInfo, columnName, type) {
-    const interfaceConfig = import_type_interface_map.default[type];
-    if (typeof interfaceConfig === "function") {
-      return interfaceConfig(columnsInfo[columnName]);
-    }
-    return interfaceConfig;
-  }
-  columnAttribute(columnsInfo, columnName, indexes) {
-    const columnInfo = columnsInfo[columnName];
-    const attr = {
-      type: columnInfo.type,
-      allowNull: columnInfo.allowNull,
-      primaryKey: columnInfo.primaryKey,
-      unique: false
-    };
-    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.defaultValue = columnInfo.defaultValue;
-      }
-      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;
-      }
-    }
-    if (attr.primaryKey && columnName == "id") {
-      attr.autoIncrement = true;
-    }
-    return attr;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DatabaseIntrospector
-});