@tachybase/module-data-source 0.23.8

package/dist/server/plugin.js

@@ -0,0 +1,448 @@
+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_path = require("path");
+var import_server = require("@tachybase/server");
+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_collection_model = require("./models/data-sources-collection-model");
+var import_data_sources_field_model = require("./models/data-sources-field-model");
+var import_data_sources_roles_model = require("./models/data-sources-roles-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");
+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);
+          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;
+            })
+          );
+        }
+      },
+      { tag: "processDataSourcesList" }
+    );
+    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();
+      },
+      { tag: "defaultSorting" }
+    );
+    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);
+          }
+        }
+      },
+      { tag: "dataSourcesget" }
+    );
+    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, loadAtAfterStart: true });
+        }
+        return dataSourceRecord.loadIntoApplication({ app: app2, loadAtAfterStart: true });
+      });
+      this.app.setMaintainingMessage("Loading data sources...");
+      Promise.allSettled(loadPromises).then(() => {
+        return this.app.emitAsync("dataSourceAfterStart");
+      });
+    });
+    this.app.db.on("dataSourcesRolesResources.afterSaveWithAssociations", async (model, options) => {
+      const { transaction } = options;
+      const pluginACL = this.app.pm.get("acl");
+      const dataSource = this.app.dataSourceManager.dataSources.get(model.get("dataSourceKey"));
+      await model.writeToACL({
+        acl: dataSource.acl,
+        associationFieldsActions: pluginACL.associationFieldsActions,
+        transaction,
+        grantHelper: pluginACL.grantHelper,
+        app: this.app
+      });
+    });
+    this.app.db.on("dataSourcesRolesResourcesActions.afterUpdateWithAssociations", async (model, options) => {
+      const { transaction } = options;
+      const resource = await model.getResource({
+        transaction
+      });
+      const pluginACL = this.app.pm.get("acl");
+      const dataSource = this.app.dataSourceManager.dataSources.get(resource.get("dataSourceKey"));
+      await resource.writeToACL({
+        acl: dataSource.acl,
+        associationFieldsActions: pluginACL.associationFieldsActions,
+        transaction,
+        grantHelper: pluginACL.grantHelper,
+        app: this.app
+      });
+    });
+    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 pluginACL = this.app.pm.get("acl");
+      const dataSource = this.app.dataSourceManager.dataSources.get(model.get("dataSourceKey"));
+      await model.writeToAcl({
+        grantHelper: pluginACL.grantHelper,
+        associationFieldsActions: pluginACL.associationFieldsActions,
+        acl: dataSource.acl,
+        transaction,
+        app: this.app
+      });
+    });
+    this.app.on("acl:writeResources", async ({ roleName, transaction }) => {
+      const dataSource = this.app.dataSourceManager.dataSources.get("main");
+      const pluginACL = this.app.pm.get("acl");
+      const dataSourceRole = await this.app.db.getRepository("dataSourcesRoles").findOne({
+        filter: {
+          dataSourceKey: "main",
+          roleName
+        },
+        transaction
+      });
+      await dataSourceRole.writeToAcl({
+        grantHelper: pluginACL.grantHelper,
+        associationFieldsActions: pluginACL.associationFieldsActions,
+        acl: dataSource.acl,
+        transaction,
+        app: this.app
+      });
+    });
+    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;
+            }, {})
+          };
+        }
+      },
+      { tag: "dataSourceAccessCheck" }
+    );
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}`,
+      actions: [
+        "dataSources:*",
+        "roles.dataSourceResources",
+        "collections:*",
+        "collections.fields:*",
+        "dbViews:*",
+        "collectionCategories:*",
+        "sqlCollection:*"
+      ]
+    });
+    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,11 @@
+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;

package/dist/server/resourcers/data-sources-collections-fields.js

@@ -0,0 +1,131 @@
+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 data_sources_collections_fields_exports = {};
+__export(data_sources_collections_fields_exports, {
+  default: () => data_sources_collections_fields_default
+});
+module.exports = __toCommonJS(data_sources_collections_fields_exports);
+var import_lodash = __toESM(require("lodash"));
+var data_sources_collections_fields_default = {
+  name: "dataSourcesCollections.fields",
+  actions: {
+    async list(ctx, next) {
+      const { associatedIndex: collectionNameWithDataSourceKey } = ctx.action.params;
+      const [dataSourceKey, collectionName] = collectionNameWithDataSourceKey.split(".");
+      const dataSource = ctx.app.dataSourceManager.dataSources.get(dataSourceKey);
+      const collection = dataSource.collectionManager.getCollection(collectionName);
+      const fields = collection.getFields();
+      ctx.body = import_lodash.default.sortBy(
+        fields.map((field) => field.options),
+        "name"
+      );
+      await next();
+    },
+    async get(ctx, next) {
+      const { associatedIndex: collectionNameWithDataSourceKey, filterByTk: name } = ctx.action.params;
+      const [dataSourceKey, collectionName] = collectionNameWithDataSourceKey.split(".");
+      const dataSource = ctx.app.dataSourceManager.dataSources.get(dataSourceKey);
+      const collection = dataSource.collectionManager.getCollection(collectionName);
+      const field = collection.getField(name);
+      ctx.body = field.options;
+      await next();
+    },
+    async update(ctx, next) {
+      const { associatedIndex: collectionNameWithDataSourceKey, filterByTk: name, values } = ctx.action.params;
+      const [dataSourceKey, collectionName] = collectionNameWithDataSourceKey.split(".");
+      const mainDb = ctx.app.db;
+      let fieldRecord = await mainDb.getRepository("dataSourcesFields").findOne({
+        filter: {
+          name,
+          collectionName,
+          dataSourceKey
+        }
+      });
+      if (!fieldRecord) {
+        fieldRecord = await mainDb.getRepository("dataSourcesFields").create({
+          values: {
+            ...values,
+            name,
+            collectionName,
+            dataSourceKey
+          }
+        });
+      } else {
+        await fieldRecord.update({
+          ...values
+        });
+      }
+      const field = ctx.app.dataSourceManager.dataSources.get(dataSourceKey).collectionManager.getCollection(collectionName).getField(name);
+      ctx.body = field.options;
+      await next();
+    },
+    async create(ctx, next) {
+      const { associatedIndex: collectionNameWithDataSourceKey, values } = ctx.action.params;
+      const [dataSourceKey, collectionName] = collectionNameWithDataSourceKey.split(".");
+      const mainDb = ctx.app.db;
+      const name = values.name;
+      if (await mainDb.getRepository("dataSourcesFields").findOne({
+        filter: {
+          name,
+          collectionName,
+          dataSourceKey
+        }
+      })) {
+        throw new Error(
+          `Field name ${name} already exists in collection ${collectionName} of data source ${dataSourceKey}`
+        );
+      }
+      const fieldRecord = await mainDb.getRepository("dataSourcesFields").create({
+        values: {
+          ...values,
+          collectionName,
+          dataSourceKey
+        }
+      });
+      ctx.body = fieldRecord.toJSON();
+      await next();
+    },
+    async destroy(ctx, next) {
+      const { associatedIndex: collectionNameWithDataSourceKey, filterByTk: name } = ctx.action.params;
+      const [dataSourceKey, collectionName] = collectionNameWithDataSourceKey.split(".");
+      const mainDb = ctx.app.db;
+      const fieldRecord = await mainDb.getRepository("dataSourcesFields").findOne({
+        filter: {
+          name,
+          collectionName,
+          dataSourceKey
+        }
+      });
+      if (fieldRecord) {
+        await fieldRecord.destroy();
+      }
+      ctx.body = "ok";
+      await next();
+    }
+  }
+};

package/dist/server/resourcers/data-sources-collections.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    name: string;
+    actions: {
+        list(ctx: any, next: any): Promise<void>;
+        update(ctx: any, next: any): Promise<void>;
+    };
+};
+export default _default;