@nocobase/plugin-data-source-main 2.1.0-beta.9 → 2.2.0-alpha.1

package/dist/server/modeling/service.js

@@ -0,0 +1,170 @@
+/**
+ * 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 service_exports = {};
+__export(service_exports, {
+  applyCollectionDefinition: () => applyCollectionDefinition,
+  applyFieldDefinition: () => applyFieldDefinition,
+  findCollection: () => findCollection,
+  pickCollectionApplyValues: () => pickCollectionApplyValues,
+  upsertFieldDefinition: () => upsertFieldDefinition
+});
+module.exports = __toCommonJS(service_exports);
+var import_capabilities = require("./capabilities");
+var import_collections = require("./collections");
+var import_constants = require("./constants");
+var import_fields = require("./fields");
+function mergeSettings(input = {}) {
+  const { settings, ...rest } = input;
+  return {
+    ...settings || {},
+    ...rest
+  };
+}
+function validateApplyFieldInputs(fields) {
+  if (!Array.isArray(fields)) {
+    return;
+  }
+  fields.forEach((field) => (0, import_fields.validateChoiceFieldInput)(field));
+}
+async function findCollection(ctx, collectionName) {
+  return ctx.app.db.getRepository("collections").findOne({
+    filter: {
+      name: collectionName
+    },
+    appends: ["fields"]
+  });
+}
+function pickCollectionApplyValues(values) {
+  const normalized = { ...values };
+  delete normalized.fields;
+  delete normalized.name;
+  delete normalized.replaceFields;
+  delete normalized.verify;
+  delete normalized.settings;
+  return normalized;
+}
+async function upsertFieldDefinition(ctx, rawInput) {
+  const input = mergeSettings(rawInput);
+  const collectionName = input.collectionName;
+  if (!collectionName) {
+    throw new Error("field apply requires collectionName");
+  }
+  (0, import_fields.validateChoiceFieldInput)(input);
+  const values = (0, import_fields.normalizeFieldInput)(input, { collectionName });
+  await (0, import_capabilities.assertModelingSupport)(ctx.app, { fields: [values] });
+  const repository = ctx.app.db.getRepository("fields");
+  const existing = await repository.findOne({
+    filter: {
+      collectionName,
+      name: values.name
+    }
+  });
+  if (existing) {
+    await repository.update({
+      filterByTk: existing.key,
+      values,
+      context: ctx
+    });
+  } else {
+    await repository.create({
+      values,
+      context: ctx
+    });
+  }
+  return repository.findOne({
+    filter: {
+      collectionName,
+      name: values.name
+    }
+  });
+}
+async function applyFieldDefinition(ctx, rawInput, options = {}) {
+  const input = mergeSettings(rawInput);
+  if (options.relationOnly && !import_constants.RELATION_INTERFACES.has(input.interface)) {
+    throw new Error(`fields:apply relation mode requires relation interface, got ${input.interface || "empty"}`);
+  }
+  return upsertFieldDefinition(ctx, input);
+}
+async function applyCollectionDefinition(ctx, rawInput, syncCollectionFields) {
+  const input = mergeSettings(rawInput);
+  const collectionName = input.name || ctx.action.params.filterByTk;
+  const replaceFields = input.replaceFields === true;
+  const shouldVerify = input.verify !== false;
+  const repository = ctx.app.db.getRepository("collections");
+  if (!collectionName) {
+    throw new Error("collections:apply requires name");
+  }
+  validateApplyFieldInputs(input.fields);
+  const existing = await findCollection(ctx, collectionName);
+  if (!existing) {
+    const values = (0, import_collections.composeCollectionDefinition)({ ...input, name: collectionName }, { mode: "create" });
+    await (0, import_capabilities.assertModelingSupport)(ctx.app, values);
+    await repository.create({
+      values,
+      context: ctx
+    });
+  } else {
+    const values = (0, import_collections.normalizeCollectionInput)({ ...input, name: collectionName }, { mode: "update" });
+    await (0, import_capabilities.assertModelingSupport)(ctx.app, values);
+    const collectionValues = pickCollectionApplyValues(values);
+    if (Object.keys(collectionValues).length > 0) {
+      await repository.update({
+        filterByTk: collectionName,
+        values: collectionValues,
+        context: ctx
+      });
+    }
+    if (Array.isArray(values.fields) && values.fields.length > 0) {
+      if (replaceFields) {
+        await syncCollectionFields(ctx, collectionName, {
+          fields: (0, import_fields.normalizeFieldList)(values.fields, collectionName)
+        });
+      } else {
+        for (const field of values.fields) {
+          await upsertFieldDefinition(ctx, {
+            ...field,
+            collectionName
+          });
+        }
+      }
+    }
+  }
+  const collection = await findCollection(ctx, collectionName);
+  const verify = shouldVerify ? (0, import_capabilities.verifyCollectionDefinition)(ctx.app, collectionName) : void 0;
+  return {
+    data: collection,
+    verify
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyCollectionDefinition,
+  applyFieldDefinition,
+  findCollection,
+  pickCollectionApplyValues,
+  upsertFieldDefinition
+});

package/dist/server/models/collection.js

@@ -41,6 +41,7 @@ __export(collection_exports, {
 module.exports = __toCommonJS(collection_exports);
 var import_database = require("@nocobase/database");
 var import_lodash = __toESM(require("lodash"));
+const databaseSyncedCollectionSources = ["db2cm", "dbsync"];
 class CollectionModel extends import_database.MagicAttributeModel {
   get db() {
     return this.constructor.database;
@@ -72,7 +73,7 @@ class CollectionModel extends import_database.MagicAttributeModel {
     if (!this.db.inDialect("postgres") && collectionOptions.schema) {
       delete collectionOptions.schema;
     }
-    if (this.db.inDialect("postgres") && !collectionOptions.schema && collectionOptions.from !== "db2cm") {
+    if (this.db.inDialect("postgres") && !collectionOptions.schema && !databaseSyncedCollectionSources.includes(collectionOptions.from)) {
       collectionOptions.schema = process.env.COLLECTION_MANAGER_SCHEMA || this.db.options.schema || "public";
     }
     if (this.db.hasCollection(name)) {

package/dist/server/repositories/collection-repository.js

@@ -85,6 +85,9 @@ class CollectionRepository extends import_database.Repository {
           return true;
         }
         const fields = nameMap[instanceName].get("fields");
+        if (!Array.isArray(fields)) {
+          return [];
+        }
         return fields.filter((field) => field["type"] === "belongsTo" || field["type"] === "belongsToMany").map((field) => field.get("name"));
       })();
       if (import_lodash.default.isArray(skipField) && skipField.length) {
@@ -106,6 +109,9 @@ class CollectionRepository extends import_database.Repository {
       });
       const skipField = (() => {
         const fields = nameMap[viewCollectionName].get("fields");
+        if (!Array.isArray(fields)) {
+          return [];
+        }
         return fields.filter((field) => {
           var _a;
           if (((_a = field.options) == null ? void 0 : _a.source) && (field["type"] === "belongsTo" || field["type"] === "belongsToMany")) {

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

@@ -6,8 +6,13 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+export declare function syncCollectionFields(ctx: any, filterByTk: string, values: {
+    fields?: any[];
+}): Promise<void>;
 declare const _default: {
     "collections:listMeta"(ctx: any, next: any): Promise<void>;
     "collections:setFields"(ctx: any, next: any): Promise<void>;
+    "collections:apply"(ctx: any, next: any): Promise<void>;
+    "fields:apply"(ctx: any, next: any): Promise<void>;
 };
 export default _default;

package/dist/server/resourcers/collections.js

@@ -36,10 +36,79 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var collections_exports = {};
 __export(collections_exports, {
-  default: () => collections_default
+  default: () => collections_default,
+  syncCollectionFields: () => syncCollectionFields
 });
 module.exports = __toCommonJS(collections_exports);
 var import_lodash = __toESM(require("lodash"));
+var import_service = require("../modeling/service");
+async function syncCollectionFields(ctx, filterByTk, values) {
+  var _a;
+  const transaction = await ctx.app.db.sequelize.transaction();
+  try {
+    const fields = (_a = values.fields) == null ? void 0 : _a.map((f) => {
+      delete f.key;
+      return f;
+    });
+    const db = ctx.app.db;
+    const collectionModel = await db.getRepository("collections").findOne({
+      filter: {
+        name: filterByTk
+      },
+      transaction
+    });
+    const existFields = await collectionModel.getFields({
+      transaction
+    });
+    const needUpdateFields = fields.filter((f) => {
+      return existFields.find((ef) => ef.name === f.name);
+    }).map((f) => {
+      return {
+        ...f,
+        key: existFields.find((ef) => ef.name === f.name).key
+      };
+    });
+    const needDestroyFields = existFields.filter((ef) => {
+      return !fields.find((f) => f.name === ef.name);
+    });
+    const needCreatedFields = fields.filter((f) => {
+      return !existFields.find((ef) => ef.name === f.name);
+    });
+    if (needDestroyFields.length) {
+      await db.getRepository("fields").destroy({
+        filterByTk: needDestroyFields.map((f) => f.key),
+        transaction
+      });
+    }
+    if (needUpdateFields.length) {
+      await db.getRepository("fields").updateMany({
+        records: needUpdateFields,
+        transaction
+      });
+    }
+    if (needCreatedFields.length) {
+      await db.getRepository("collections.fields", filterByTk).create({
+        values: needCreatedFields,
+        transaction
+      });
+    }
+    await collectionModel.loadFields({
+      transaction
+    });
+    const collection = db.getCollection(filterByTk);
+    await collection.sync({
+      force: false,
+      alter: {
+        drop: false
+      },
+      transaction
+    });
+    await transaction.commit();
+  } catch (e) {
+    await transaction.rollback();
+    throw e;
+  }
+}
 var collections_default = {
   async ["collections:listMeta"](ctx, next) {
     const db = ctx.app.db;
@@ -69,72 +138,24 @@ var collections_default = {
     await next();
   },
   async ["collections:setFields"](ctx, next) {
-    var _a;
     const { filterByTk, values } = ctx.action.params;
-    const transaction = await ctx.app.db.sequelize.transaction();
-    try {
-      const fields = (_a = values.fields) == null ? void 0 : _a.map((f) => {
-        delete f.key;
-        return f;
-      });
-      const db = ctx.app.db;
-      const collectionModel = await db.getRepository("collections").findOne({
-        filter: {
-          name: filterByTk
-        },
-        transaction
-      });
-      const existFields = await collectionModel.getFields({
-        transaction
-      });
-      const needUpdateFields = fields.filter((f) => {
-        return existFields.find((ef) => ef.name === f.name);
-      }).map((f) => {
-        return {
-          ...f,
-          key: existFields.find((ef) => ef.name === f.name).key
-        };
-      });
-      const needDestroyFields = existFields.filter((ef) => {
-        return !fields.find((f) => f.name === ef.name);
-      });
-      const needCreatedFields = fields.filter((f) => {
-        return !existFields.find((ef) => ef.name === f.name);
-      });
-      if (needDestroyFields.length) {
-        await db.getRepository("fields").destroy({
-          filterByTk: needDestroyFields.map((f) => f.key),
-          transaction
-        });
-      }
-      if (needUpdateFields.length) {
-        await db.getRepository("fields").updateMany({
-          records: needUpdateFields,
-          transaction
-        });
-      }
-      if (needCreatedFields.length) {
-        await db.getRepository("collections.fields", filterByTk).create({
-          values: needCreatedFields,
-          transaction
-        });
-      }
-      await collectionModel.loadFields({
-        transaction
-      });
-      const collection = db.getCollection(filterByTk);
-      await collection.sync({
-        force: false,
-        alter: {
-          drop: false
-        },
-        transaction
-      });
-      await transaction.commit();
-    } catch (e) {
-      await transaction.rollback();
-      throw e;
-    }
+    await syncCollectionFields(ctx, filterByTk, values);
+    await next();
+  },
+  async ["collections:apply"](ctx, next) {
+    const rawValues = ctx.action.params.values || ctx.request.body || {};
+    ctx.body = await (0, import_service.applyCollectionDefinition)(ctx, rawValues, syncCollectionFields);
+    await next();
+  },
+  async ["fields:apply"](ctx, next) {
+    const rawValues = ctx.action.params.values || ctx.request.body || {};
+    ctx.body = {
+      data: await (0, import_service.applyFieldDefinition)(ctx, rawValues)
+    };
     await next();
   }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  syncCollectionFields
+});

package/dist/server/server.js

@@ -56,6 +56,7 @@ var import_models = require("./models");
 var import_collections = __toESM(require("./resourcers/collections"));
 var import_views = __toESM(require("./resourcers/views"));
 var import_main_data_source = __toESM(require("./resourcers/main-data-source"));
+var import_mcp_post_processors = require("./mcp-post-processors");
 var import_constants = require("./constants");
 var import_json_schema = require("@formily/json-schema");
 var import_lodash2 = __toESM(require("lodash"));
@@ -109,7 +110,7 @@ class PluginDataSourceMainServer extends import_server.Plugin {
     });
     this.app.db.on("collections.beforeCreate", (0, import_beforeCreateForViewCollection.beforeCreateForViewCollection)(this.db));
     this.app.db.on("collections.beforeCreate", async (model, options) => {
-      if (this.app.db.getCollection(model.get("name")) && model.get("from") !== "db2cm" && !model.get("isThrough")) {
+      if (this.app.db.getCollection(model.get("name")) && !["db2cm", "dbsync"].includes(model.get("from")) && !model.get("isThrough")) {
         throw new Error(`Collection named ${model.get("name")} already exists`);
       }
     });
@@ -378,7 +379,7 @@ class PluginDataSourceMainServer extends import_server.Plugin {
     this.app.acl.allow("collectionCategories", "list", "loggedIn");
     this.app.acl.registerSnippet({
       name: `pm.data-source-manager.data-source-main`,
-      actions: ["collections:*", "collections.fields:*", "collectionCategories:*", "mainDataSource:*"]
+      actions: ["collections:*", "collections.fields:*", "fields:*", "collectionCategories:*", "mainDataSource:*"]
     });
     this.app.acl.registerSnippet({
       name: `pm.data-source-manager.collection-view `,
@@ -404,6 +405,8 @@ class PluginDataSourceMainServer extends import_server.Plugin {
   async load() {
     this.db.getRepository("collections").setApp(this.app);
     this.registerErrorHandler();
+    (0, import_mcp_post_processors.registerDataSourceMainMcpPostProcessors)(this.ai.mcpToolsManager);
+    this.app.auditManager.registerActions(["collections:apply", "fields:apply"]);
     this.app.resourceManager.use(async function mergeReverseFieldWhenSaveCollectionField(ctx, next) {
       if (ctx.action.resourceName === "collections.fields" && ["create", "update"].includes(ctx.action.actionName)) {
         ctx.action.mergeParams({