@nocobase/plugin-data-source-manager 1.3.0-alpha.20240710084543 → 1.3.0-alpha.20240710155619

package/dist/server/models/data-sources-field-model.js

@@ -0,0 +1,63 @@
+/**
+ * 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 data_sources_field_model_exports = {};
+__export(data_sources_field_model_exports, {
+  DataSourcesFieldModel: () => DataSourcesFieldModel
+});
+module.exports = __toCommonJS(data_sources_field_model_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("../utils");
+class DataSourcesFieldModel extends import_database.MagicAttributeModel {
+  load(loadOptions) {
+    const { app } = loadOptions;
+    const options = this.get();
+    const { collectionName, name, dataSourceKey } = options;
+    const dataSource = app.dataSourceManager.dataSources.get(dataSourceKey);
+    const collection = dataSource.collectionManager.getCollection(collectionName);
+    const oldField = collection.getField(name);
+    const newOptions = (0, import_utils.mergeOptions)(oldField ? oldField.options : {}, options);
+    collection.setField(name, newOptions);
+  }
+  unload(loadOptions) {
+    const { app } = loadOptions;
+    const options = this.get();
+    const { collectionName, name, dataSourceKey } = options;
+    const dataSource = app.dataSourceManager.dataSources.get(dataSourceKey);
+    if (!dataSource) {
+      return;
+    }
+    const collection = dataSource.collectionManager.getCollection(collectionName);
+    if (!collection) {
+      return;
+    }
+    collection.removeField(name);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSourcesFieldModel
+});

package/dist/server/models/data-sources-roles-model.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 project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Model } from '@nocobase/database';
+import { ACL } from '@nocobase/acl';
+import { Transaction } from 'sequelize';
+export declare class DataSourcesRolesModel extends Model {
+    writeToAcl(options: {
+        acl: ACL;
+        transaction?: Transaction;
+    }): Promise<void>;
+}

package/dist/server/models/data-sources-roles-model.js

@@ -0,0 +1,64 @@
+/**
+ * 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 data_sources_roles_model_exports = {};
+__export(data_sources_roles_model_exports, {
+  DataSourcesRolesModel: () => DataSourcesRolesModel
+});
+module.exports = __toCommonJS(data_sources_roles_model_exports);
+var import_database = require("@nocobase/database");
+class DataSourcesRolesModel extends import_database.Model {
+  async writeToAcl(options) {
+    const { acl, transaction } = options;
+    const roleName = this.get("roleName");
+    let role = acl.getRole(roleName);
+    if (!role) {
+      role = acl.define({
+        role: roleName
+      });
+    }
+    role.setStrategy({
+      ...this.get("strategy") || {}
+    });
+    const resources = await this.db.getRepository("dataSourcesRolesResources").find({
+      filter: {
+        roleName,
+        dataSourceKey: this.get("dataSourceKey")
+      },
+      transaction
+    });
+    for (const resource of resources) {
+      await resource.writeToACL({
+        acl,
+        transaction
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSourcesRolesModel
+});

package/dist/server/plugin.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { Plugin } from '@nocobase/server';
+type DataSourceState = 'loading' | 'loaded' | 'loading-failed' | 'reloading' | 'reloading-failed';
+export declare class PluginDataSourceManagerServer extends Plugin {
+    dataSourceErrors: {
+        [dataSourceKey: string]: Error;
+    };
+    dataSourceStatus: {
+        [dataSourceKey: string]: DataSourceState;
+    };
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+}
+export default PluginDataSourceManagerServer;

package/dist/server/plugin.js

@@ -0,0 +1,443 @@
+/**
+ * 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, {
+  PluginDataSourceManagerServer: () => PluginDataSourceManagerServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@nocobase/server");
+var import_path = require("path");
+var import_data_sources_collection_model = require("./models/data-sources-collection-model");
+var import_data_sources_field_model = require("./models/data-sources-field-model");
+var import_data_sources_collections = __toESM(require("./resourcers/data-sources-collections"));
+var import_data_sources_collections_fields = __toESM(require("./resourcers/data-sources-collections-fields"));
+var import_data_sources_resources = __toESM(require("./resourcers/data-sources-resources"));
+var import_data_sources_roles = __toESM(require("./resourcers/data-sources-roles"));
+var import_roles_data_sources_collections = require("./resourcers/roles-data-sources-collections");
+var import_lodash = __toESM(require("lodash"));
+var import_connections_roles_resources = require("./models/connections-roles-resources");
+var import_connections_roles_resources_action = require("./models/connections-roles-resources-action");
+var import_data_source = require("./models/data-source");
+var import_data_sources_roles_model = require("./models/data-sources-roles-model");
+const canRefreshStatus = ["loaded", "loading-failed", "reloading-failed"];
+class PluginDataSourceManagerServer extends import_server.Plugin {
+  dataSourceErrors = {};
+  dataSourceStatus = {};
+  async beforeLoad() {
+    this.app.db.registerModels({
+      DataSourcesCollectionModel: import_data_sources_collection_model.DataSourcesCollectionModel,
+      DataSourcesFieldModel: import_data_sources_field_model.DataSourcesFieldModel,
+      DataSourcesRolesModel: import_data_sources_roles_model.DataSourcesRolesModel,
+      DataSourcesRolesResourcesModel: import_connections_roles_resources.DataSourcesRolesResourcesModel,
+      DataSourcesRolesResourcesActionModel: import_connections_roles_resources_action.DataSourcesRolesResourcesActionModel,
+      DataSourceModel: import_data_source.DataSourceModel
+    });
+    this.app.db.on("dataSourcesFields.beforeCreate", async (model, options) => {
+      const validatePresent = (name) => {
+        if (!model.get(name)) {
+          throw new Error(`"${name}" is required`);
+        }
+      };
+      const validatePresents = (names) => {
+        names.forEach((name) => validatePresent(name));
+      };
+      const type = model.get("type");
+      if (type === "belongsTo") {
+        validatePresents(["foreignKey", "targetKey", "target"]);
+      }
+      if (type === "hasMany") {
+        validatePresents(["foreignKey", "sourceKey", "target"]);
+      }
+      if (type == "hasOne") {
+        validatePresents(["foreignKey", "sourceKey", "target"]);
+      }
+      if (type === "belongsToMany") {
+        validatePresents(["foreignKey", "otherKey", "sourceKey", "targetKey", "through", "target"]);
+      }
+    });
+    this.app.db.on("dataSources.beforeCreate", async (model, options) => {
+      this.dataSourceStatus[model.get("key")] = "loading";
+    });
+    this.app.db.on("dataSources.beforeSave", async (model) => {
+      if (model.changed("options") && !model.isMainRecord()) {
+        const dataSourceOptions = model.get("options");
+        const type = model.get("type");
+        const klass = this.app.dataSourceManager.factory.getClass(type);
+        try {
+          await klass.testConnection(dataSourceOptions);
+        } catch (error) {
+          throw new Error(`Test connection failed: ${error.message}`);
+        }
+      }
+    });
+    this.app.db.on("dataSources.afterSave", async (model, options) => {
+      if (model.changed("options") && !model.isMainRecord()) {
+        model.loadIntoApplication({
+          app: this.app
+        });
+      }
+    });
+    this.app.db.on("dataSources.afterCreate", async (model, options) => {
+      if (model.isMainRecord()) {
+        return;
+      }
+      const { transaction } = options;
+      await this.app.db.getRepository("dataSourcesRolesResourcesScopes").create({
+        values: {
+          dataSourceKey: model.get("key"),
+          key: "all",
+          name: '{{t("All records")}}',
+          scope: {}
+        },
+        transaction
+      });
+    });
+    const app = this.app;
+    this.app.use(async (ctx, next) => {
+      await next();
+      if (!ctx.action) {
+        return;
+      }
+      const { actionName, resourceName, params } = ctx.action;
+      if (resourceName === "dataSources" && actionName == "list") {
+        let dataPath = "body";
+        if (Array.isArray(ctx.body["data"])) {
+          dataPath = "body.data";
+        }
+        const items = import_lodash.default.get(ctx, dataPath);
+        if (!Array.isArray(items)) {
+          return;
+        }
+        import_lodash.default.set(
+          ctx,
+          dataPath,
+          items.map((item) => {
+            const data = item.toJSON();
+            if (item.isMainRecord()) {
+              data["status"] = "loaded";
+              return data;
+            }
+            const dataSourceStatus = this.dataSourceStatus[item.get("key")];
+            data["status"] = dataSourceStatus;
+            if (dataSourceStatus === "loading-failed" || dataSourceStatus === "reloading-failed") {
+              data["errorMessage"] = this.dataSourceErrors[item.get("key")].message;
+            }
+            return data;
+          })
+        );
+      }
+    });
+    const plugin = this;
+    const mapDataSourceWithCollection = (dataSourceModel, appendCollections = true) => {
+      const dataSource = app.dataSourceManager.dataSources.get(dataSourceModel.get("key"));
+      const dataSourceStatus = plugin.dataSourceStatus[dataSourceModel.get("key")];
+      const item = {
+        key: dataSourceModel.get("key"),
+        displayName: dataSourceModel.get("displayName"),
+        status: dataSourceStatus,
+        type: dataSourceModel.get("type"),
+        // @ts-ignore
+        isDBInstance: !!(dataSource == null ? void 0 : dataSource.collectionManager.db)
+      };
+      if (dataSourceStatus === "loading-failed" || dataSourceStatus === "reloading-failed") {
+        item["errorMessage"] = plugin.dataSourceErrors[dataSourceModel.get("key")].message;
+      }
+      if (!dataSource) {
+        return item;
+      }
+      if (appendCollections) {
+        const collections = dataSource.collectionManager.getCollections();
+        item.collections = collections.map((collection) => {
+          const collectionOptions = collection.options;
+          const fields = [...collection.fields.values()].map((field) => field.options);
+          return {
+            ...collectionOptions,
+            fields
+          };
+        });
+      }
+      return item;
+    };
+    this.app.resourcer.use(async (ctx, next) => {
+      if (!ctx.action) {
+        await next();
+        return;
+      }
+      const { actionName, resourceName, params } = ctx.action;
+      if (resourceName === "dataSources" && actionName == "list") {
+        if (!params.sort) {
+          params.sort = ["-fixed", "createdAt"];
+        }
+      }
+      await next();
+    });
+    this.app.use(async (ctx, next) => {
+      await next();
+      if (!ctx.action) {
+        return;
+      }
+      const { actionName, resourceName, params } = ctx.action;
+      if (resourceName === "dataSources" && actionName == "get") {
+        let appendCollections = false;
+        const appends = ctx.action.params.appends;
+        if (appends && appends.includes("collections")) {
+          appendCollections = true;
+        }
+        if (ctx.body.data) {
+          ctx.body.data = mapDataSourceWithCollection(ctx.body.data, appendCollections);
+        } else {
+          ctx.body = mapDataSourceWithCollection(ctx.body, appendCollections);
+        }
+      }
+    });
+    this.app.actions({
+      async ["dataSources:listEnabled"](ctx, next) {
+        const dataSources = await ctx.db.getRepository("dataSources").find({
+          filter: {
+            enabled: true,
+            "type.$ne": "main"
+          }
+        });
+        ctx.body = dataSources.map((dataSourceModel) => {
+          return mapDataSourceWithCollection(dataSourceModel);
+        });
+        await next();
+      },
+      async ["dataSources:testConnection"](ctx, next) {
+        const { values } = ctx.action.params;
+        const { options, type } = values;
+        const klass = ctx.app.dataSourceManager.factory.getClass(type);
+        try {
+          await klass.testConnection(options);
+        } catch (error) {
+          throw new Error(`Test connection failed: ${error.message}`);
+        }
+        ctx.body = {
+          success: true
+        };
+        await next();
+      },
+      async ["dataSources:refresh"](ctx, next) {
+        const { filterByTk, clientStatus } = ctx.action.params;
+        const dataSourceModel = await ctx.db.getRepository("dataSources").findOne({
+          filter: {
+            key: filterByTk
+          }
+        });
+        const currentStatus = plugin.dataSourceStatus[filterByTk];
+        if (canRefreshStatus.includes(currentStatus) && (clientStatus ? clientStatus && canRefreshStatus.includes(clientStatus) : true)) {
+          dataSourceModel.loadIntoApplication({
+            app: ctx.app
+          });
+        }
+        ctx.body = {
+          status: plugin.dataSourceStatus[filterByTk]
+        };
+        await next();
+      }
+    });
+    this.app.resourcer.define(import_data_sources_collections.default);
+    this.app.resourcer.define(import_data_sources_collections_fields.default);
+    this.app.resourcer.define(import_roles_data_sources_collections.rolesRemoteCollectionsResourcer);
+    this.app.resourcer.define(import_data_sources_roles.default);
+    this.app.resourcer.define(import_data_sources_resources.default);
+    this.app.resourcer.define({
+      name: "dataSources"
+    });
+    this.app.db.on("dataSourcesFields.afterSave", async (model) => {
+      model.load({
+        app: this.app
+      });
+    });
+    this.app.db.on("dataSourcesFields.afterDestroy", async (model) => {
+      model.unload({
+        app: this.app
+      });
+    });
+    this.app.db.on("dataSourcesCollections.afterSave", async (model) => {
+      model.load({
+        app: this.app
+      });
+    });
+    this.app.db.on("dataSources.afterDestroy", async (model) => {
+      this.app.dataSourceManager.dataSources.delete(model.get("key"));
+    });
+    this.app.on("afterStart", async (app2) => {
+      const dataSourcesRecords = await this.app.db.getRepository("dataSources").find({
+        filter: {
+          enabled: true
+        }
+      });
+      const loadPromises = dataSourcesRecords.map((dataSourceRecord) => {
+        if (dataSourceRecord.isMainRecord()) {
+          return dataSourceRecord.loadIntoACL({ app: app2, acl: app2.acl });
+        }
+        return dataSourceRecord.loadIntoApplication({ app: app2, loadAtAfterStart: true });
+      });
+      this.app.setMaintainingMessage("Loading data sources...");
+      await Promise.all(loadPromises);
+    });
+    this.app.db.on(
+      "dataSourcesRolesResources.afterSaveWithAssociations",
+      async (model, options) => {
+        const { transaction } = options;
+        const dataSource = this.app.dataSourceManager.dataSources.get(model.get("dataSourceKey"));
+        await model.writeToACL({
+          acl: dataSource.acl,
+          transaction
+        });
+      }
+    );
+    this.app.db.on(
+      "dataSourcesRolesResourcesActions.afterUpdateWithAssociations",
+      async (model, options) => {
+        const { transaction } = options;
+        const resource = await model.getResource({
+          transaction
+        });
+        const dataSource = this.app.dataSourceManager.dataSources.get(resource.get("dataSourceKey"));
+        await resource.writeToACL({
+          acl: dataSource.acl,
+          transaction
+        });
+      }
+    );
+    this.app.db.on("dataSourcesRolesResources.afterDestroy", async (model, options) => {
+      const dataSource = this.app.dataSourceManager.dataSources.get(model.get("dataSourceKey"));
+      const roleName = model.get("roleName");
+      const role = dataSource.acl.getRole(roleName);
+      if (role) {
+        role.revokeResource(model.get("name"));
+      }
+    });
+    this.app.db.on("dataSourcesRoles.afterSave", async (model, options) => {
+      const { transaction } = options;
+      const dataSource = this.app.dataSourceManager.dataSources.get(model.get("dataSourceKey"));
+      await model.writeToAcl({
+        acl: dataSource.acl,
+        transaction
+      });
+      await this.app.db.getRepository("roles").update({
+        filter: {
+          name: model.get("roleName")
+        },
+        values: {
+          strategy: model.get("strategy")
+        },
+        hooks: false,
+        transaction
+      });
+    });
+    this.app.on("acl:writeResources", async ({ roleName, transaction }) => {
+      const dataSource = this.app.dataSourceManager.dataSources.get("main");
+      const dataSourceRole = await this.app.db.getRepository("dataSourcesRoles").findOne({
+        filter: {
+          dataSourceKey: "main",
+          roleName
+        },
+        transaction
+      });
+      await dataSourceRole.writeToAcl({
+        acl: dataSource.acl,
+        transaction
+      });
+    });
+    this.app.resourcer.use(async (ctx, next) => {
+      const action = ctx.action;
+      await next();
+      const { resourceName, actionName } = action.params;
+      if (resourceName === "roles" && actionName == "check") {
+        const roleName = ctx.state.currentRole;
+        const dataSources = await ctx.db.getRepository("dataSources").find();
+        ctx.bodyMeta = {
+          dataSources: dataSources.reduce((carry, dataSourceModel) => {
+            const dataSource = this.app.dataSourceManager.dataSources.get(dataSourceModel.get("key"));
+            if (!dataSource) {
+              return carry;
+            }
+            const dataSourceStatus = this.dataSourceStatus[dataSourceModel.get("key")];
+            if (dataSourceStatus !== "loaded") {
+              return carry;
+            }
+            const aclInstance = dataSource.acl;
+            const roleInstance = aclInstance.getRole(roleName);
+            const dataObj = {
+              strategy: {},
+              resources: roleInstance ? [...roleInstance.resources.keys()] : [],
+              actions: {}
+            };
+            if (roleInstance) {
+              const data = roleInstance.toJSON();
+              dataObj["name"] = data["name"];
+              dataObj["strategy"] = data["strategy"];
+              dataObj["actions"] = data["actions"];
+            }
+            carry[dataSourceModel.get("key")] = dataObj;
+            return carry;
+          }, {})
+        };
+      }
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.data-source-manager`,
+      actions: [
+        "dataSources:*",
+        "dataSources.collections:*",
+        "dataSourcesCollections.fields:*",
+        "roles.dataSourceResources"
+      ]
+    });
+    this.app.acl.allow("dataSources", "listEnabled", "loggedIn");
+    this.app.acl.allow("dataSources", "get", "loggedIn");
+    this.app.acl.addFixedParams("dataSources", "destroy", () => {
+      return {
+        filter: {
+          "key.$ne": "main"
+        }
+      };
+    });
+  }
+  async load() {
+    await this.importCollections((0, import_path.resolve)(__dirname, "collections"));
+  }
+}
+var plugin_default = PluginDataSourceManagerServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginDataSourceManagerServer
+});

package/dist/server/resourcers/data-sources-collections-fields.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.
+ */
+declare const _default: {
+    name: string;
+    actions: {
+        list(ctx: any, next: any): Promise<void>;
+        get(ctx: any, next: any): Promise<void>;
+        update(ctx: any, next: any): Promise<void>;
+        create(ctx: any, next: any): Promise<void>;
+        destroy(ctx: any, next: any): Promise<void>;
+    };
+};
+export default _default;