@nocobase/plugin-collection-fdw 2.0.3

package/dist/server/foreign-data-collection.js

@@ -0,0 +1,118 @@
+/**
+ * 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 __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 foreign_data_collection_exports = {};
+__export(foreign_data_collection_exports, {
+  ForeignDataCollection: () => ForeignDataCollection
+});
+module.exports = __toCommonJS(foreign_data_collection_exports);
+var import_database = require("@nocobase/database");
+var import_remote_local_bridge = require("./bridges/remote-local-bridge");
+class ForeignDataCollection extends import_database.Collection {
+  constructor(options, context) {
+    if (!options.autoGenId) {
+      options.autoGenId = false;
+    }
+    if (!options.timestamps) {
+      options.timestamps = false;
+    }
+    options.underscored = false;
+    super(options, context);
+  }
+  static registerOptions(plugin) {
+    return {
+      condition(options) {
+        return options.remoteServerName && options.remoteTableInfo;
+      },
+      async onDump() {
+        return;
+      },
+      async onSync(model, options) {
+        const transaction = options == null ? void 0 : options.transaction;
+        const { remoteServerName, remoteTableInfo } = model.collection.options;
+        const remoteServerInstance = await model.database.getRepository("databaseServers").findOne({
+          filterByTk: remoteServerName,
+          transaction
+        });
+        if (!remoteServerInstance) {
+          throw new Error(`remoteServer ${remoteServerName} not found`);
+        }
+        remoteServerInstance.setApp(plugin.app);
+        await remoteServerInstance.createServer({
+          transaction
+        });
+        const remoteLocalBridge = import_remote_local_bridge.RemoteLocalBridgeFactory.createBridge({
+          remoteDatabase: remoteServerInstance.getRemoteDatabaseInstance(),
+          localDatabase: model.database
+        });
+        await remoteLocalBridge.createTable({
+          remoteServerName,
+          remoteTableDefinition: await remoteServerInstance.showTableDefinition(remoteTableInfo),
+          remoteTableInfo,
+          localModel: model,
+          transaction
+        });
+      }
+    };
+  }
+  async removeFieldFromDb(name, options) {
+    const field = this.getField(name);
+    if (field) {
+      field.remove();
+    }
+  }
+  async removeFromDb(options) {
+    const transaction = options == null ? void 0 : options.transaction;
+    if (this.db.inDialect("postgres")) {
+      let sql = `DROP FOREIGN TABLE IF EXISTS ${this.getTableNameWithSchemaAsString()}`;
+      if (options == null ? void 0 : options.cascade) {
+        sql += " CASCADE";
+      }
+      await this.db.sequelize.query(sql, {
+        transaction
+      });
+      return this.remove();
+    } else {
+      await super.removeFromDb(options);
+    }
+  }
+  bindFieldEventListener() {
+    super.bindFieldEventListener();
+    this.on("field.afterAdd", (field) => {
+      const interfaceOption = field.options.interface;
+      if (interfaceOption === "updatedAt") {
+        this.model._timestampAttributes.createdAt = field.name;
+      }
+      if (interfaceOption === "createdAt") {
+        this.model._timestampAttributes.updatedAt = field.name;
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForeignDataCollection
+});

package/dist/server/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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>
+ */
+export { default } from './plugin';

package/dist/server/index.js

@@ -0,0 +1,42 @@
+/**
+ * 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 __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 server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/models/database-server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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, { MagicAttributeModel, Transactionable } from '@nocobase/database';
+import { Application } from '@nocobase/server';
+type TableInfo = {
+    tableName: string;
+    schema?: string;
+};
+export declare class DatabaseServerModel extends MagicAttributeModel {
+    protected app: Application;
+    setApp(app: Application): void;
+    renderJsonTemplate(options: any): any;
+    getRemoteDatabaseInstance(): Database;
+    getOptions(): any;
+    listRemoteTables(): Promise<[unknown[], unknown]>;
+    describeTable(table: TableInfo): Promise<import("sequelize").ColumnsDescription>;
+    showIndexes(table: TableInfo): Promise<object>;
+    showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    updateServer(options?: Transactionable): Promise<void>;
+    destroyServer(options?: Transactionable): Promise<void>;
+    createServer(options?: Transactionable): Promise<void>;
+}
+export {};

package/dist/server/models/database-server.js

@@ -0,0 +1,226 @@
+/**
+ * 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 __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_server_exports = {};
+__export(database_server_exports, {
+  DatabaseServerModel: () => DatabaseServerModel
+});
+module.exports = __toCommonJS(database_server_exports);
+var import_database = __toESM(require("@nocobase/database"));
+var import_remote_local_bridge = require("../bridges/remote-local-bridge");
+class DatabaseServerModel extends import_database.MagicAttributeModel {
+  app;
+  setApp(app) {
+    this.app = app;
+  }
+  renderJsonTemplate(options) {
+    var _a;
+    if (!((_a = this.app) == null ? void 0 : _a.environment)) {
+      return options;
+    }
+    return this.app.environment.renderJsonTemplate(options);
+  }
+  getRemoteDatabaseInstance() {
+    return new import_database.default(
+      this.renderJsonTemplate({
+        ...this.toJSON()
+      })
+    );
+  }
+  getOptions() {
+    return this.renderJsonTemplate({
+      ...this.toJSON()
+    });
+  }
+  async listRemoteTables() {
+    const remoteDB = this.getRemoteDatabaseInstance();
+    if (remoteDB.inDialect("postgres")) {
+      const results = await remoteDB.sequelize.query(
+        `
+          SELECT table_name as name, table_schema as schema
+          FROM information_schema.tables
+          WHERE table_schema NOT IN ('information_schema', 'pg_catalog')
+        `,
+        {
+          type: "SELECT"
+        }
+      );
+      await remoteDB.close();
+      return results;
+    } else {
+      const options = this.getOptions();
+      const results = await remoteDB.sequelize.query(
+        `
+          SELECT table_name as name
+          FROM information_schema.tables
+          WHERE table_schema = '${options.database}'
+        `,
+        {
+          type: "SELECT"
+        }
+      );
+      await remoteDB.close();
+      return results;
+    }
+  }
+  async describeTable(table) {
+    const remoteDB = this.getRemoteDatabaseInstance();
+    const columns = await remoteDB.sequelize.getQueryInterface().describeTable(table);
+    await remoteDB.close();
+    return columns;
+  }
+  async showIndexes(table) {
+    const remoteDB = this.getRemoteDatabaseInstance();
+    const queryOptions = (() => {
+      if (remoteDB.inDialect("postgres")) {
+        return table;
+      }
+      return table.tableName;
+    })();
+    const constraints = await remoteDB.sequelize.getQueryInterface().showIndex(queryOptions);
+    await remoteDB.close();
+    return constraints;
+  }
+  async showTableDefinition(tableInfo) {
+    const remoteDB = this.getRemoteDatabaseInstance();
+    const def = await remoteDB.queryInterface.showTableDefinition(tableInfo);
+    await remoteDB.close();
+    return def;
+  }
+  async updateServer(options) {
+    const { transaction } = options;
+    const db = this.app.db;
+    const remoteInstance = this.getRemoteDatabaseInstance();
+    try {
+      await remoteInstance.sequelize.authenticate();
+    } catch (error) {
+      throw new Error(`Unable to connect to the remote database: ${error.message}`);
+    }
+    const replacements = this.renderJsonTemplate({
+      serverName: this.get("name"),
+      host: this.get("host"),
+      port: this.get("port"),
+      database: this.get("database"),
+      user: this.get("username"),
+      password: this.get("password")
+    });
+    if (db.inDialect("postgres")) {
+      await db.sequelize.query(
+        `
+        ALTER SERVER ${this.get("name")}
+        OPTIONS (SET host :host, SET port :port, SET dbname :database);
+
+        ALTER USER MAPPING FOR ${db.options.username}
+        SERVER ${this.get("name")}
+        OPTIONS (SET user :user, SET password :password);
+        `,
+        {
+          replacements,
+          type: "RAW",
+          transaction
+        }
+      );
+    }
+    if (db.inDialect("mysql", "mariadb")) {
+      await db.sequelize.query(
+        `
+        ALTER SERVER ${this.get("name")}
+        OPTIONS (USER :user, HOST :host, PORT ${replacements.port}, DATABASE :database, PASSWORD :password);
+        `,
+        {
+          replacements,
+          transaction
+        }
+      );
+    }
+  }
+  async destroyServer(options) {
+    const { transaction } = options;
+    const db = this.app.db;
+    if (db.inDialect("postgres")) {
+      await db.sequelize.query(
+        `
+        DROP SERVER IF EXISTS ${this.get("name")} CASCADE;
+        `,
+        {
+          transaction,
+          type: "RAW"
+        }
+      );
+    }
+    if (db.inDialect("mysql", "mariadb")) {
+      await db.sequelize.query(
+        `
+        DROP SERVER IF EXISTS ${this.get("name")};
+        `,
+        {
+          transaction,
+          type: "RAW"
+        }
+      );
+    }
+  }
+  async createServer(options) {
+    const { transaction } = options;
+    const db = this.app.db;
+    const remoteInstance = this.getRemoteDatabaseInstance();
+    try {
+      await remoteInstance.sequelize.authenticate();
+    } catch (error) {
+      throw new Error(`Unable to connect to the remote database: ${error.message}`);
+    }
+    const remoteLocalBridge = import_remote_local_bridge.RemoteLocalBridgeFactory.createBridge({
+      remoteDatabase: remoteInstance,
+      localDatabase: db
+    });
+    const opts = this.renderJsonTemplate({
+      serverName: this.get("name"),
+      host: this.get("host"),
+      port: this.get("port"),
+      database: this.get("database"),
+      user: this.get("username"),
+      password: this.get("password")
+    });
+    await remoteLocalBridge.createServer({
+      ...opts,
+      transaction
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseServerModel
+});

package/dist/server/plugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { Plugin } from '@nocobase/server';
+export default class PluginCollectionFDWServer extends Plugin {
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    beforeEnable(): Promise<void>;
+}

package/dist/server/plugin.js

@@ -0,0 +1,111 @@
+/**
+ * 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 __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 plugin_exports = {};
+__export(plugin_exports, {
+  default: () => PluginCollectionFDWServer
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_database = require("@nocobase/database");
+var import_server = require("@nocobase/server");
+var import_mariadb_to_mariadb = require("./bridges/mariadb-to-mariadb");
+var import_mysql_to_mysql = require("./bridges/mysql-to-mysql");
+var import_pg_to_pg = require("./bridges/pg-to-pg");
+var import_remote_local_bridge = require("./bridges/remote-local-bridge");
+var import_foreign_data_collection = require("./foreign-data-collection");
+var import_database_server = require("./models/database-server");
+var import_tables = __toESM(require("./resourcers/tables"));
+class PluginCollectionFDWServer extends import_server.Plugin {
+  async beforeLoad() {
+    import_remote_local_bridge.RemoteLocalBridgeFactory.registerBridge("postgres", "postgres", import_pg_to_pg.PgToPgBridge);
+    import_remote_local_bridge.RemoteLocalBridgeFactory.registerBridge("mariadb", "mariadb", import_mariadb_to_mariadb.MariadbToMariadbBridge);
+    import_remote_local_bridge.RemoteLocalBridgeFactory.registerBridge("mysql", "mysql", import_mysql_to_mysql.MySQLToMySQLBridge);
+    const app = this.app;
+    this.app.db.registerModels({
+      DatabaseServerModel: import_database_server.DatabaseServerModel
+    });
+    this.app.db.on("databaseServers.beforeCreate", async (model, options) => {
+      if (!model.get("dialect")) {
+        const dialect = this.db.options.dialect;
+        model.set("dialect", dialect);
+      }
+      model.setApp(this.app);
+      await model.createServer(options);
+    });
+    this.app.db.on("databaseServers.afterUpdate", async (model, options) => {
+      model.setApp(this.app);
+      await model.updateServer(options);
+    });
+    this.app.db.on("databaseServers.afterDestroy", async (model, options) => {
+      model.setApp(this.app);
+      await model.destroyServer(options);
+    });
+    this.app.resourceManager.define(import_tables.default);
+    this.app.db.collectionFactory.registerCollectionType(
+      import_foreign_data_collection.ForeignDataCollection,
+      import_foreign_data_collection.ForeignDataCollection.registerOptions(this)
+    );
+    this.app.resourceManager.registerActionHandlers({
+      async ["databaseServers:testConnection"](ctx, next) {
+        const values = ctx.app.environment.renderJsonTemplate(ctx.action.params.values || {});
+        const db = new import_database.Database({
+          dialect: app.db.options.dialect,
+          ...values
+        });
+        try {
+          await db.sequelize.authenticate();
+        } catch (error) {
+          throw new Error(`Unable to connect to the remote database: ${error.message}`);
+        }
+        ctx.body = {
+          success: true
+        };
+        await next();
+      }
+    });
+  }
+  async load() {
+    this.app.acl.registerSnippet({
+      name: "pm.data-source-manager.collection-fdw",
+      actions: ["databaseServers:*", "databaseServers.tables:*"]
+    });
+  }
+  async beforeEnable() {
+    if (this.db.inDialect("sqlite")) {
+      throw new Error("sqlite does not support foreign data wrapper");
+    }
+  }
+}

package/dist/server/resourcers/tables.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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>
+ */
+declare const _default: {
+    name: string;
+    actions: {
+        list(ctx: any, next: any): Promise<void>;
+        get(ctx: any, next: any): Promise<void>;
+        query(ctx: any, next: any): Promise<void>;
+    };
+};
+export default _default;