@tachybase/plugin-data-source-common 0.23.8

package/dist/server/pg/postgres-data-source.js

@@ -0,0 +1,127 @@
+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 postgres_data_source_exports = {};
+__export(postgres_data_source_exports, {
+  PostgresDataSource: () => PostgresDataSource
+});
+module.exports = __toCommonJS(postgres_data_source_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_database = require("@tachybase/database");
+var import_database_introspector = require("./database-introspector");
+var import_postgres_collection_manager = require("./postgres-collection-manager");
+var import_type_interface_map = __toESM(require("./type-interface-map"));
+class PostgresDataSource extends import_data_source.DataSource {
+  static async testConnection(options) {
+    const database = new import_database.Database({
+      dialect: "postgres",
+      ...options
+    });
+    try {
+      await database.sequelize.authenticate();
+      if (options.schema) {
+        const queryRes = await database.sequelize.query(
+          `
+SELECT schema_name
+FROM information_schema.schemata
+WHERE schema_name = $1;
+          `,
+          {
+            bind: [options.schema],
+            type: "SELECT"
+          }
+        );
+        if (queryRes.length === 0) {
+          throw new Error(`schema ${options.schema} not exists`);
+        }
+      }
+    } catch (e) {
+      throw e;
+    } finally {
+      await database.close();
+    }
+    return true;
+  }
+  async load(options) {
+    const db = this.collectionManager.db;
+    const introspector = new import_database_introspector.DatabaseIntrospector({
+      db,
+      typeInterfaceMap: import_type_interface_map.default
+    });
+    introspector.on("loadMessage", ({ message }) => {
+      this.emit("loadMessage", { message });
+    });
+    const { localData } = options;
+    const collections = await introspector.getCollections({
+      localData
+    });
+    const delayFields = /* @__PURE__ */ new Map();
+    for (const collection of collections) {
+      try {
+        const fields = collection.fields;
+        for (const field of fields) {
+          if (field.type === "belongsToMany") {
+            if (!delayFields.has(collection.name)) {
+              delayFields.set(collection.name, []);
+            }
+            delayFields.get(collection.name).push(field);
+          }
+        }
+        this.collectionManager.defineCollection({
+          ...collection,
+          fields: fields.filter((field) => field.type !== "belongsToMany"),
+          introspected: true
+        });
+      } catch (e) {
+        db.logger.error(`load collection failed, ${e}`);
+        delayFields.delete(collection.name);
+      }
+    }
+    for (const [name, fields] of delayFields.entries()) {
+      try {
+        for (const field of fields) {
+          this.collectionManager.getCollection(name).setField(field.name, field);
+        }
+      } catch (e) {
+        db.logger.error(`load belongs to many field failed, ${e}`);
+      }
+    }
+  }
+  createCollectionManager(options) {
+    const database = new import_database.Database({
+      dialect: "postgres",
+      ...options
+    });
+    return new import_postgres_collection_manager.PostgresCollectionManager({
+      database
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresDataSource
+});

package/dist/server/pg/type-interface-map.d.ts

@@ -0,0 +1,183 @@
+declare const typeInterfaceMap: {
+    array: string;
+    belongsTo: string;
+    belongsToMany: string;
+    boolean: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+        };
+    };
+    context: string;
+    date: () => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                dateFormat: string;
+                showTime: boolean;
+            };
+        };
+    };
+    hasMany: string;
+    hasOne: string;
+    json: () => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                autoSize: {
+                    minRows: number;
+                };
+            };
+            default: any;
+        };
+    };
+    jsonb: () => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                autoSize: {
+                    minRows: number;
+                };
+            };
+            default: any;
+        };
+    };
+    integer: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {
+                stringMode: boolean;
+                step: string;
+            };
+            'x-validator': string;
+        };
+    };
+    bigInt: (columnInfo: any) => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                style: {
+                    width: string;
+                };
+            };
+        };
+    };
+    float: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {
+                stringMode: boolean;
+                step: string;
+            };
+        };
+    };
+    double: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {
+                stringMode: boolean;
+                step: string;
+            };
+        };
+    };
+    real: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {
+                stringMode: boolean;
+                step: string;
+            };
+        };
+    };
+    decimal: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {
+                stringMode: boolean;
+                step: string;
+            };
+        };
+    };
+    password: () => {
+        interface: string;
+        hidden: boolean;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+        };
+    };
+    radio: string;
+    set: string;
+    sort: string;
+    string: () => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                style: {
+                    width: string;
+                };
+            };
+        };
+    };
+    text: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+        };
+    };
+    time: () => {
+        interface: string;
+        uiSchema: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {
+                format: string;
+            };
+        };
+    };
+    uid: () => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                style: {
+                    width: string;
+                };
+            };
+        };
+    };
+    uuid: () => {
+        interface: string;
+        uiSchema: {
+            'x-component': string;
+            'x-component-props': {
+                style: {
+                    width: string;
+                };
+            };
+        };
+    };
+    virtual: string;
+    point: string;
+    polygon: string;
+    lineString: string;
+    circle: string;
+};
+export default typeInterfaceMap;

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

@@ -0,0 +1,243 @@
+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: () => {
+    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/utils.d.ts

@@ -0,0 +1 @@
+export declare function showUniqueIndexes(tableInfo2: any): string;

package/dist/server/pg/utils.js

@@ -0,0 +1,48 @@
+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 utils_exports = {};
+__export(utils_exports, {
+  showUniqueIndexes: () => showUniqueIndexes
+});
+module.exports = __toCommonJS(utils_exports);
+function showUniqueIndexes(tableInfo2) {
+  return `
+  SELECT
+  tc.constraint_schema,
+  tc.constraint_name,
+  tc.table_name,
+  kcu.column_name,
+  CASE WHEN (SELECT COUNT(*)
+             FROM information_schema.key_column_usage kcu2
+             WHERE kcu2.constraint_name = tc.constraint_name
+               AND kcu2.table_schema = tc.constraint_schema) = 1 THEN TRUE
+       ELSE FALSE END AS is_single_column
+FROM information_schema.table_constraints AS tc
+JOIN information_schema.key_column_usage AS kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+WHERE tc.constraint_type = 'UNIQUE'
+  AND tc.table_name = '"${tableInfo2.tableName}"'
+  AND tc.table_schema = '${tableInfo2.schema || "public"}'
+ORDER BY tc.constraint_name, kcu.column_name;
+  `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  showUniqueIndexes
+});

package/dist/server/plugin.d.ts

@@ -0,0 +1,13 @@
+import Application, { Plugin, PluginOptions } from '@tachybase/server';
+export declare class PluginExternalDataSourceServer extends Plugin {
+    constructor(app: Application, options?: PluginOptions);
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    beforeEnable(): Promise<void>;
+    load(): Promise<void>;
+    install(): Promise<void>;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+}
+export default PluginExternalDataSourceServer;

package/dist/server/plugin.js

@@ -0,0 +1,60 @@
+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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginExternalDataSourceServer: () => PluginExternalDataSourceServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@tachybase/server");
+var import_plugin = require("./http/plugin");
+var import_mysql_data_source = require("./mysql/mysql-data-source");
+var import_postgres_data_source = require("./pg/postgres-data-source");
+class PluginExternalDataSourceServer extends import_server.Plugin {
+  constructor(app, options) {
+    super(app, options);
+    this.addFeature(import_plugin.PluginHttpDatasource);
+  }
+  async afterAdd() {
+  }
+  async beforeLoad() {
+    this.app.dataSourceManager.factory.register("postgres", import_postgres_data_source.PostgresDataSource);
+    this.app.dataSourceManager.factory.register("mysql", import_mysql_data_source.MySQLDataSource);
+  }
+  async beforeEnable() {
+    const plugin = this.pm.get("data-source");
+    if (!plugin.enabled) {
+      throw new Error(`${this.name} plugin need data source module enabled`);
+    }
+  }
+  async load() {
+  }
+  async install() {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginExternalDataSourceServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginExternalDataSourceServer
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@tachybase/plugin-data-source-common",
+  "version": "0.23.8",
+  "main": "dist/server/index.js",
+  "dependencies": {
+    "@ant-design/icons": "^5.5.2",
+    "antd": "5.22.5",
+    "lodash": "^4.17.21",
+    "mysql2": "^3.11.5",
+    "pg": "^8.13.1",
+    "react-i18next": "^15.2.0",
+    "react-router-dom": "6.28.1"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.13"
+  },
+  "peerDependencies": {
+    "@tachybase/client": "0.23.8",
+    "@tachybase/schema": "0.23.8",
+    "@tachybase/database": "0.23.8",
+    "@tachybase/components": "0.23.8",
+    "@tachybase/utils": "0.23.8",
+    "@tachybase/test": "0.23.8",
+    "@tachybase/server": "0.23.8",
+    "@tachybase/data-source": "0.23.8"
+  },
+  "description.zh-CN": "支持更多的数据源",
+  "displayName.zh-CN": "外部数据源支持",
+  "scripts": {
+    "build": "tachybase-build --no-dts @tachybase/plugin-data-source-common"
+  }
+}