@tachybase/plugin-data-source-common 0.23.8

package/dist/server/mysql/type-interface-map.js

@@ -0,0 +1,257 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_interface_map_exports = {};
+__export(type_interface_map_exports, {
+  default: () => type_interface_map_default
+});
+module.exports = __toCommonJS(type_interface_map_exports);
+const typeInterfaceMap = {
+  array: "",
+  belongsTo: "",
+  belongsToMany: "",
+  boolean: () => {
+    return {
+      interface: "checkbox",
+      uiSchema: {
+        type: "boolean",
+        "x-component": "Checkbox"
+      }
+    };
+  },
+  context: "",
+  date: () => {
+    return {
+      interface: "datetime",
+      uiSchema: {
+        "x-component": "DatePicker",
+        "x-component-props": {
+          dateFormat: "YYYY-MM-DD",
+          showTime: false
+        }
+      }
+    };
+  },
+  hasMany: "",
+  hasOne: "",
+  json: () => {
+    return {
+      interface: "json",
+      uiSchema: {
+        "x-component": "Input.JSON",
+        "x-component-props": {
+          autoSize: {
+            minRows: 5
+            // maxRows: 20,
+          }
+        },
+        default: null
+      }
+    };
+  },
+  jsonb: () => {
+    return {
+      interface: "json",
+      uiSchema: {
+        "x-component": "Input.JSON",
+        "x-component-props": {
+          autoSize: {
+            minRows: 5
+            // maxRows: 20,
+          }
+        },
+        default: null
+      }
+    };
+  },
+  integer: () => ({
+    interface: "integer",
+    // name,
+    uiSchema: {
+      type: "number",
+      // title,
+      "x-component": "InputNumber",
+      "x-component-props": {
+        stringMode: true,
+        step: "1"
+      },
+      "x-validator": "integer"
+    }
+  }),
+  bigInt: (columnInfo) => {
+    return {
+      interface: "integer",
+      uiSchema: {
+        "x-component": "InputNumber",
+        "x-component-props": {
+          style: {
+            width: "100%"
+          }
+        }
+      }
+    };
+  },
+  float: () => {
+    return {
+      interface: "number",
+      uiSchema: {
+        type: "number",
+        // title,
+        "x-component": "InputNumber",
+        "x-component-props": {
+          stringMode: true,
+          step: "1"
+        }
+      }
+    };
+  },
+  double: () => {
+    return {
+      interface: "number",
+      uiSchema: {
+        type: "number",
+        // title,
+        "x-component": "InputNumber",
+        "x-component-props": {
+          stringMode: true,
+          step: "1"
+        }
+      }
+    };
+  },
+  real: () => {
+    return {
+      interface: "number",
+      uiSchema: {
+        type: "number",
+        // title,
+        "x-component": "InputNumber",
+        "x-component-props": {
+          stringMode: true,
+          step: "1"
+        }
+      }
+    };
+  },
+  decimal: () => {
+    return {
+      interface: "number",
+      uiSchema: {
+        type: "number",
+        // title,
+        "x-component": "InputNumber",
+        "x-component-props": {
+          stringMode: true,
+          step: "1"
+        }
+      }
+    };
+  },
+  password: () => ({
+    interface: "password",
+    hidden: true,
+    // name,
+    uiSchema: {
+      type: "string",
+      // title,
+      "x-component": "Password"
+    }
+  }),
+  radio: "",
+  set: "",
+  sort: "",
+  string: (columnInfo) => {
+    const type = columnInfo.type;
+    if (type.startsWith("ENUM")) {
+      return {
+        interface: "select",
+        uiSchema: {
+          type: "string",
+          "x-component": "Select",
+          enum: type.replace("ENUM(", "").replace(")", "").replace(/'/g, "").split(",").map((item) => ({
+            label: item,
+            value: item
+          }))
+        }
+      };
+    }
+    return {
+      interface: "input",
+      uiSchema: {
+        "x-component": "Input",
+        "x-component-props": {
+          style: {
+            width: "100%"
+          }
+        }
+      }
+    };
+  },
+  text: () => {
+    return {
+      interface: "textarea",
+      // name,
+      uiSchema: {
+        type: "string",
+        "x-component": "Input.TextArea"
+      }
+    };
+  },
+  time: () => ({
+    interface: "time",
+    // name,
+    uiSchema: {
+      type: "string",
+      "x-component": "TimePicker",
+      "x-component-props": {
+        format: "HH:mm:ss"
+      }
+    }
+  }),
+  uid: () => {
+    return {
+      interface: "input",
+      uiSchema: {
+        "x-component": "Input",
+        "x-component-props": {
+          style: {
+            width: "100%"
+          }
+        }
+      }
+    };
+  },
+  uuid: () => {
+    return {
+      interface: "uuid",
+      uiSchema: {
+        "x-component": "Input",
+        "x-component-props": {
+          style: {
+            width: "100%"
+          }
+        }
+      }
+    };
+  },
+  virtual: "",
+  point: "",
+  polygon: "",
+  lineString: "",
+  circle: ""
+};
+var type_interface_map_default = typeInterfaceMap;

package/dist/server/pg/database-introspector.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from 'events';
+export declare class DatabaseIntrospector extends EventEmitter {
+    db: any;
+    typeInterfaceMap: any;
+    constructor(options: any);
+    getCollections(options?: {}): Promise<any[]>;
+    getPrimaryKeysOfTable(tableInfo: any): Promise<any>;
+    getCollection(options: any): Promise<any>;
+    loadCollection(options: any): void;
+    loadCollections(options: any): void;
+    tableInfoToCollectionOptions(tableInfo: any): {
+        name: any;
+        title: any;
+        schema: any;
+        tableName: any;
+    };
+    collectionOptionsByFields(fields: any): {
+        timestamps: boolean;
+        autoGenId: boolean;
+        filterTargetKey: any;
+    };
+    mergeLocalDataIntoCollectionOptions(collectionOptions: any, localData: any): any;
+    columnInfoToFieldOptions(columnsInfo: any, columnName: any, indexes: any): {
+        rawType: any;
+        name: any;
+        type: any;
+        possibleTypes: any[];
+        allowNull: any;
+        primaryKey: any;
+        unique: boolean;
+        autoIncrement: boolean;
+    } | {
+        rawType: any;
+        name: any;
+        type: any;
+        possibleTypes?: undefined;
+        allowNull: any;
+        primaryKey: any;
+        unique: boolean;
+        autoIncrement: boolean;
+    } | {
+        rawType: any;
+        name: any;
+        supported: boolean;
+    };
+    getDefaultInterfaceByType(columnsInfo: any, columnName: any, type: any): any;
+    columnAttribute(columnsInfo: any, columnName: any, indexes: any): {
+        type: any;
+        allowNull: any;
+        primaryKey: any;
+        unique: boolean;
+        autoIncrement: boolean;
+    };
+}

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

@@ -0,0 +1,286 @@
+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_events = require("events");
+var import_database = require("@tachybase/database");
+var import_module_data_source = require("@tachybase/module-data-source");
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("./utils");
+class DatabaseIntrospector extends import_events.EventEmitter {
+  db;
+  typeInterfaceMap;
+  constructor(options) {
+    super();
+    this.db = options.db;
+    this.typeInterfaceMap = options.typeInterfaceMap;
+  }
+  async getCollections(options = {}) {
+    let tableList = await this.db.sequelize.getQueryInterface().showAllTables();
+    const views = (await this.db.queryInterface.listViews()).map((view) => view.name);
+    tableList = tableList.concat(views);
+    if (this.db.options.tablePrefix) {
+      tableList = tableList.filter((tableName) => {
+        return tableName.startsWith(this.db.options.tablePrefix);
+      });
+    }
+    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
+          };
+          this.emit("loadMessage", {
+            message: `load table ${tableName}`
+          });
+          const collectionOptions = this.tableInfoToCollectionOptions(tableInfo);
+          const localOptions = (_a = options.localData) == null ? void 0 : _a[collectionOptions.name];
+          try {
+            return await this.getCollection({
+              tableInfo,
+              localOptions,
+              mergedOptions: views.includes(tableName) ? { view: true, template: "view" } : {}
+            });
+          } catch (e) {
+            if (e.message.includes("No description found for")) {
+              return false;
+            }
+            this.db.logger.error(`load table ${tableName} failed, ${e.message}`);
+            return false;
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return results.filter(Boolean);
+  }
+  async getPrimaryKeysOfTable(tableInfo) {
+    const sql = `
+      SELECT
+        pg_attribute.attname,
+        format_type(pg_attribute.atttypid, pg_attribute.atttypmod)
+      FROM pg_index, pg_class, pg_attribute, pg_namespace
+      WHERE
+        pg_class.oid = '"${tableInfo.tableName}"'::regclass AND
+  indrelid = pg_class.oid AND
+  nspname = '${tableInfo.schema || "public"}' AND
+  pg_class.relnamespace = pg_namespace.oid AND
+  pg_attribute.attrelid = pg_class.oid AND
+  pg_attribute.attnum = any(pg_index.indkey)
+ AND indisprimary
+    `;
+    return await this.db.sequelize.query(sql, {
+      type: "SELECT"
+    });
+  }
+  async getCollection(options) {
+    const { tableInfo } = options;
+    const columnsInfo = await this.db.sequelize.getQueryInterface().describeTable(tableInfo);
+    const primaryKeys = await this.getPrimaryKeysOfTable(tableInfo);
+    Object.keys(columnsInfo).forEach((columnName) => {
+      const columnInfo = columnsInfo[columnName];
+      const primaryKey = primaryKeys.find((key) => key.attname === columnName);
+      if (primaryKey) {
+        columnInfo.primaryKey = true;
+      }
+    });
+    const collectionOptions = this.tableInfoToCollectionOptions(tableInfo);
+    const constraints = await this.db.sequelize.query((0, import_utils.showUniqueIndexes)(tableInfo), {
+      type: "SELECT"
+    });
+    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,
+        ...options == null ? void 0 : options.mergedOptions,
+        ...this.collectionOptionsByFields(supportFields),
+        fields: [...supportFields]
+      };
+      if (unsupportedFields.length) {
+        remoteCollectionInfo.unsupportedFields = unsupportedFields;
+      }
+      const finalOptions = this.mergeLocalDataIntoCollectionOptions(remoteCollectionInfo, options.localOptions);
+      if (finalOptions.view && !finalOptions.filterTargetKey && supportFields.find((field) => field.name === "id")) {
+        finalOptions.filterTargetKey = "id";
+      }
+      return finalOptions;
+    } 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) {
+    const tableName = tableInfo.tableName;
+    let name = tableName;
+    if (this.db.options.tablePrefix) {
+      name = tableName.replace(this.db.options.tablePrefix, "");
+    }
+    return {
+      name,
+      title: name,
+      schema: tableInfo.schema,
+      tableName
+    };
+  }
+  collectionOptionsByFields(fields) {
+    const options = {
+      timestamps: false,
+      autoGenId: false,
+      filterTargetKey: void 0
+    };
+    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 (0, import_module_data_source.mergeOptions)(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 = this.typeInterfaceMap[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,
+      autoIncrement: 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.autoIncrement = true;
+      }
+    }
+    for (const index of indexes) {
+      if (index["is_single_column"] && index["column_name"] === columnName) {
+        attr.unique = true;
+      }
+    }
+    return attr;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseIntrospector
+});

package/dist/server/pg/postgres-collection-manager.d.ts

@@ -0,0 +1,3 @@
+import { SequelizeCollectionManager } from '@tachybase/data-source';
+export declare class PostgresCollectionManager extends SequelizeCollectionManager {
+}

package/dist/server/pg/postgres-collection-manager.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var postgres_collection_manager_exports = {};
+__export(postgres_collection_manager_exports, {
+  PostgresCollectionManager: () => PostgresCollectionManager
+});
+module.exports = __toCommonJS(postgres_collection_manager_exports);
+var import_data_source = require("@tachybase/data-source");
+class PostgresCollectionManager extends import_data_source.SequelizeCollectionManager {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresCollectionManager
+});

package/dist/server/pg/postgres-data-source.d.ts

@@ -0,0 +1,8 @@
+import { DataSource } from '@tachybase/data-source';
+import { type IDatabaseOptions } from '@tachybase/database';
+import { PostgresCollectionManager } from './postgres-collection-manager';
+export declare class PostgresDataSource extends DataSource {
+    static testConnection(options: IDatabaseOptions): Promise<boolean>;
+    load(options: any): Promise<void>;
+    createCollectionManager(options: any): PostgresCollectionManager;
+}