@tachybase/module-data-source 0.23.8

package/dist/server/models/data-source.d.ts

@@ -0,0 +1,18 @@
+import { ACL } from '@tachybase/acl';
+import { Model, Transaction } from '@tachybase/database';
+import { Application } from '@tachybase/server';
+export declare class DataSourceModel extends Model {
+    isMainRecord(): boolean;
+    loadIntoACL(options: {
+        app: Application;
+        acl: ACL;
+        transaction?: Transaction;
+        loadAtAfterStart?: boolean;
+    }): Promise<void>;
+    loadIntoApplication(options: {
+        app: Application;
+        transaction?: Transaction;
+        loadAtAfterStart?: boolean;
+    }): Promise<void>;
+    private loadLocalData;
+}

package/dist/server/models/data-source.js

@@ -0,0 +1,170 @@
+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_source_exports = {};
+__export(data_source_exports, {
+  DataSourceModel: () => DataSourceModel
+});
+module.exports = __toCommonJS(data_source_exports);
+var import_database = require("@tachybase/database");
+var import_module_acl = require("@tachybase/module-acl");
+const availableActions = {
+  create: {
+    displayName: '{{t("Add new")}}',
+    type: "new-data",
+    onNewRecord: true,
+    allowConfigureFields: true
+  },
+  // import: {
+  //   displayName: '{{t("Import")}}',
+  //   type: 'new-data',
+  //   scope: false,
+  // },
+  // export: {
+  //   displayName: '{{t("Export")}}',
+  //   type: 'old-data',
+  //   allowConfigureFields: true,
+  // },
+  view: {
+    displayName: '{{t("View")}}',
+    type: "old-data",
+    aliases: ["get", "list"],
+    allowConfigureFields: true
+  },
+  update: {
+    displayName: '{{t("Edit")}}',
+    type: "old-data",
+    aliases: ["update", "move"],
+    allowConfigureFields: true
+  },
+  destroy: {
+    displayName: '{{t("Delete")}}',
+    type: "old-data"
+  }
+};
+class DataSourceModel extends import_database.Model {
+  isMainRecord() {
+    return this.get("type") === "main";
+  }
+  async loadIntoACL(options) {
+    const { app, acl } = options;
+    const loadRoleIntoACL = async (model) => {
+      const pluginACL = app.pm.get("acl");
+      const params = {
+        grantHelper: pluginACL.grantHelper,
+        associationFieldsActions: pluginACL.associationFieldsActions,
+        acl
+      };
+      if (!options.loadAtAfterStart) {
+        params.app = app;
+      }
+      await model.writeToAcl(params);
+    };
+    const rolesModel = await app.db.getRepository("dataSourcesRoles").find({
+      transaction: options.transaction,
+      filter: {
+        dataSourceKey: this.get("key")
+      }
+    });
+    for (const roleModel of rolesModel) {
+      await loadRoleIntoACL(roleModel);
+    }
+  }
+  async loadIntoApplication(options) {
+    const { app, loadAtAfterStart } = options;
+    const dataSourceKey = this.get("key");
+    const pluginDataSourceManagerServer = app.pm.get("data-source");
+    if (pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] === "loaded") {
+      pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] = "reloading";
+    } else {
+      pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] = "loading";
+    }
+    const type = this.get("type");
+    const createOptions = this.get("options");
+    const dataSource = app.dataSourceManager.factory.create(type, {
+      ...createOptions,
+      name: this.get("key")
+    });
+    if (loadAtAfterStart) {
+      dataSource.on("loadMessage", ({ message }) => {
+        app.setMaintainingMessage(`${message} in data source ${this.get("displayName")}`);
+      });
+    }
+    const acl = dataSource.acl;
+    for (const [actionName, actionParams] of Object.entries(availableActions)) {
+      acl.setAvailableAction(actionName, actionParams);
+    }
+    acl.allow("*", "*", (ctx) => {
+      return ctx.state.currentRole === "root";
+    });
+    dataSource.resourceManager.use(import_module_acl.setCurrentRole, { tag: "setCurrentRole", before: "acl", after: "auth" });
+    await this.loadIntoACL({ app, acl, transaction: options.transaction });
+    try {
+      await app.dataSourceManager.add(dataSource, {
+        localData: await this.loadLocalData()
+      });
+    } catch (e) {
+      app.logger.error(`load data source failed, ${e}`);
+      if (pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] === "loading") {
+        pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] = "loading-failed";
+      }
+      if (pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] === "reloading") {
+        pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] = "reloading-failed";
+      }
+      pluginDataSourceManagerServer.dataSourceErrors[dataSourceKey] = e;
+      return;
+    }
+    pluginDataSourceManagerServer.dataSourceStatus[dataSourceKey] = "loaded";
+  }
+  async loadLocalData() {
+    const dataSourceKey = this.get("key");
+    const remoteCollections = await this.db.getRepository("dataSourcesCollections").find({
+      filter: {
+        dataSourceKey
+      }
+    });
+    const remoteFields = await this.db.getRepository("dataSourcesFields").find({
+      filter: {
+        dataSourceKey
+      }
+    });
+    const localData = {};
+    for (const remoteCollection of remoteCollections) {
+      const remoteCollectionOptions = remoteCollection.toJSON();
+      localData[remoteCollectionOptions.name] = remoteCollectionOptions;
+    }
+    for (const remoteField of remoteFields) {
+      const remoteFieldOptions = remoteField.toJSON();
+      const collectionName = remoteFieldOptions.collectionName;
+      if (!localData[collectionName]) {
+        localData[collectionName] = {
+          name: collectionName,
+          fields: []
+        };
+      }
+      if (!localData[collectionName].fields) {
+        localData[collectionName].fields = [];
+      }
+      localData[collectionName].fields.push(remoteFieldOptions);
+    }
+    return localData;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSourceModel
+});

package/dist/server/models/data-sources-collection-model.d.ts

@@ -0,0 +1,7 @@
+import { MagicAttributeModel } from '@tachybase/database';
+import { Application } from '@tachybase/server';
+export declare class DataSourcesCollectionModel extends MagicAttributeModel {
+    load(loadOptions: {
+        app: Application;
+    }): void;
+}

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

@@ -0,0 +1,37 @@
+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_collection_model_exports = {};
+__export(data_sources_collection_model_exports, {
+  DataSourcesCollectionModel: () => DataSourcesCollectionModel
+});
+module.exports = __toCommonJS(data_sources_collection_model_exports);
+var import_database = require("@tachybase/database");
+class DataSourcesCollectionModel extends import_database.MagicAttributeModel {
+  load(loadOptions) {
+    const { app } = loadOptions;
+    const collectionOptions = this.get();
+    const dataSourceName = this.get("dataSourceKey");
+    const dataSource = app.dataSourceManager.dataSources.get(dataSourceName);
+    const collection = dataSource.collectionManager.getCollection(collectionOptions.name);
+    collection.updateOptions(collectionOptions);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSourcesCollectionModel
+});

package/dist/server/models/data-sources-field-model.d.ts

@@ -0,0 +1,10 @@
+import { MagicAttributeModel } from '@tachybase/database';
+import { Application } from '@tachybase/server';
+type LoadOptions = {
+    app: Application;
+};
+export declare class DataSourcesFieldModel extends MagicAttributeModel {
+    load(loadOptions: LoadOptions): void;
+    unload(loadOptions: LoadOptions): void;
+}
+export {};

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

@@ -0,0 +1,54 @@
+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("@tachybase/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,13 @@
+import { ACL } from '@tachybase/acl';
+import { Model } from '@tachybase/database';
+import Application from '@tachybase/server';
+import { Transaction } from 'sequelize';
+export declare class DataSourcesRolesModel extends Model {
+    writeToAcl(options: {
+        acl: ACL;
+        transaction?: Transaction;
+        associationFieldsActions: any;
+        grantHelper: any;
+        app?: Application;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,58 @@
+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("@tachybase/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,
+        grantHelper: options.grantHelper,
+        associationFieldsActions: options.associationFieldsActions,
+        app: options.app
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSourcesRolesModel
+});

package/dist/server/plugin.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from '@tachybase/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;