@nocobase/plugin-data-source-main 2.1.0-alpha.13 → 2.1.0-alpha.15

package/dist/server/modeling/service.js

@@ -0,0 +1,162 @@
+/**
+ * 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
+  };
+}
+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");
+  }
+  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");
+  }
+  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/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"));
@@ -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,7 @@ 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.resourceManager.use(async function mergeReverseFieldWhenSaveCollectionField(ctx, next) {
       if (ctx.action.resourceName === "collections.fields" && ["create", "update"].includes(ctx.action.actionName)) {
         ctx.action.mergeParams({

package/dist/swagger/index.d.ts

@@ -272,6 +272,43 @@ declare const _default: {
                 };
             };
         };
+        '/collections:apply': {
+            post: {
+                tags: string[];
+                summary: string;
+                description: string;
+                requestBody: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        data: {
+                                            $ref: string;
+                                        };
+                                        verify: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
         '/collections/{collectionName}/fields:get': {
             get: {
                 tags: string[];
@@ -446,6 +483,39 @@ declare const _default: {
                 };
             };
         };
+        '/fields:apply': {
+            post: {
+                tags: string[];
+                summary: string;
+                description: string;
+                requestBody: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    '200': {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        data: {
+                                            $ref: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
         '/collectionCategories:list': {
             post: {
                 tags: string[];
@@ -1030,6 +1100,64 @@ declare const _default: {
                     };
                     additionalProperties: boolean;
                 };
+                apply: {
+                    type: string;
+                    description: string;
+                    properties: {
+                        name: {
+                            type: string;
+                            description: string;
+                        };
+                        title: {
+                            type: string;
+                            description: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                        template: {
+                            type: string;
+                            description: string;
+                        };
+                        viewName: {
+                            type: string;
+                            description: string;
+                        };
+                        inherits: {
+                            oneOf: ({
+                                type: string;
+                                items?: undefined;
+                            } | {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            })[];
+                            description: string;
+                        };
+                        replaceFields: {
+                            type: string;
+                            description: string;
+                        };
+                        verify: {
+                            type: string;
+                            description: string;
+                        };
+                        fields: {
+                            type: string;
+                            description: string;
+                            items: {
+                                $ref: string;
+                            };
+                        };
+                        settings: {
+                            type: string;
+                            description: string;
+                            additionalProperties: boolean;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
                 update: {
                     type: string;
                     properties: {
@@ -1397,6 +1525,174 @@ declare const _default: {
                         $ref: string;
                     }[];
                 };
+                apply: {
+                    type: string;
+                    description: string;
+                    properties: {
+                        collectionName: {
+                            type: string;
+                            description: string;
+                        };
+                        name: {
+                            type: string;
+                        };
+                        title: {
+                            type: string;
+                        };
+                        interface: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                        target: {
+                            type: string;
+                        };
+                        defaultValue: {
+                            description: string;
+                        };
+                        enum: {
+                            type: string;
+                            description: string;
+                            items: {
+                                anyOf: ({
+                                    type: string;
+                                    properties?: undefined;
+                                    required?: undefined;
+                                    additionalProperties?: undefined;
+                                } | {
+                                    type: string;
+                                    properties: {
+                                        label: {
+                                            type: string;
+                                        };
+                                        value: {};
+                                        color: {
+                                            type: string;
+                                        };
+                                    };
+                                    required: string[];
+                                    additionalProperties: boolean;
+                                })[];
+                            };
+                        };
+                        reverseName: {
+                            type: string;
+                        };
+                        reverseTitle: {
+                            type: string;
+                        };
+                        reverseInterface: {
+                            type: string;
+                        };
+                        settings: {
+                            type: string;
+                            description: string;
+                            additionalProperties: boolean;
+                        };
+                        reverseField: {
+                            allOf: {
+                                $ref: string;
+                            }[];
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                applyShallow: {
+                    type: string;
+                    description: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        title: {
+                            type: string;
+                        };
+                        interface: {
+                            type: string;
+                        };
+                        target: {
+                            type: string;
+                        };
+                        settings: {
+                            type: string;
+                            additionalProperties: boolean;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
+                applyNested: {
+                    type: string;
+                    description: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        title: {
+                            type: string;
+                        };
+                        interface: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                        target: {
+                            type: string;
+                        };
+                        defaultValue: {
+                            description: string;
+                        };
+                        enum: {
+                            type: string;
+                            description: string;
+                            items: {
+                                anyOf: ({
+                                    type: string;
+                                    properties?: undefined;
+                                    required?: undefined;
+                                    additionalProperties?: undefined;
+                                } | {
+                                    type: string;
+                                    properties: {
+                                        label: {
+                                            type: string;
+                                        };
+                                        value: {};
+                                        color: {
+                                            type: string;
+                                        };
+                                    };
+                                    required: string[];
+                                    additionalProperties: boolean;
+                                })[];
+                            };
+                        };
+                        reverseName: {
+                            type: string;
+                        };
+                        reverseTitle: {
+                            type: string;
+                        };
+                        reverseInterface: {
+                            type: string;
+                        };
+                        settings: {
+                            type: string;
+                            description: string;
+                            additionalProperties: boolean;
+                        };
+                        reverseField: {
+                            allOf: {
+                                $ref: string;
+                            }[];
+                            description: string;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
                 update: {
                     allOf: {
                         $ref: string;