@nocobase/plugin-ui-templates 2.0.0-alpha.57

package/dist/server/resources/flowModelTemplates.js

@@ -0,0 +1,267 @@
+/**
+ * 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 flowModelTemplates_exports = {};
+__export(flowModelTemplates_exports, {
+  default: () => flowModelTemplates_default
+});
+module.exports = __toCommonJS(flowModelTemplates_exports);
+var import_actions = __toESM(require("@nocobase/actions"));
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("@nocobase/utils");
+const toPlain = (row) => {
+  if (!row) return row;
+  if (typeof row.toJSON === "function") return row.toJSON();
+  return row;
+};
+const buildSearchFilter = (existing, search) => {
+  const filters = [];
+  if (existing) {
+    filters.push(existing);
+  }
+  if (search) {
+    filters.push({
+      $or: [{ name: { $includes: search } }, { description: { $includes: search } }]
+    });
+  }
+  if (!filters.length) return void 0;
+  if (filters.length === 1) return filters[0];
+  return { $and: filters };
+};
+const withUsageCounts = async (ctx, rows) => {
+  const data = rows.map(toPlain).filter(Boolean);
+  const uids = data.map((item) => item == null ? void 0 : item.uid).filter(Boolean);
+  if (!uids.length) return data;
+  const UsageModel = ctx.db.getModel("flowModelTemplateUsages");
+  const usageRows = await UsageModel.findAll({
+    attributes: ["templateUid", [UsageModel.sequelize.fn("COUNT", "*"), "count"]],
+    where: {
+      templateUid: uids
+    },
+    group: ["templateUid"],
+    raw: true,
+    transaction: ctx.transaction
+  });
+  const usageMap = /* @__PURE__ */ new Map();
+  for (const row of usageRows) {
+    usageMap.set(row.templateUid, Number(row.count) || 0);
+  }
+  return data.map((item) => ({
+    ...item,
+    usageCount: usageMap.get(item.uid) || 0
+  }));
+};
+const resolveTemplateUid = (ctx) => {
+  var _a, _b, _c;
+  const params = ((_a = ctx.action) == null ? void 0 : _a.params) || {};
+  if (params.filterByTk) return params.filterByTk;
+  if (typeof ((_b = params == null ? void 0 : params.filter) == null ? void 0 : _b.uid) === "string") return params.filter.uid;
+  if ((_c = params.values) == null ? void 0 : _c.uid) return params.values.uid;
+  return void 0;
+};
+const normalizeOptions = (options) => {
+  if (!options) return {};
+  if (typeof options === "string") {
+    try {
+      return JSON.parse(options);
+    } catch (e) {
+      return {};
+    }
+  }
+  return options;
+};
+const syncTemplateMetaToReferenceBlocks = async (ctx, template) => {
+  const usageRepo = ctx.db.getRepository("flowModelTemplateUsages");
+  const usages = await usageRepo.find({
+    filter: { templateUid: template.uid },
+    fields: ["modelUid"],
+    transaction: ctx.transaction,
+    context: ctx
+  });
+  if (!Array.isArray(usages) || usages.length === 0) return;
+  const modelUids = import_lodash.default.uniq(usages.map((u) => u == null ? void 0 : u.modelUid).filter(Boolean));
+  if (!modelUids.length) return;
+  const flowRepo = ctx.db.getRepository("flowModels");
+  for (const modelUid of modelUids) {
+    const record = await flowRepo.findOne({
+      filter: { uid: modelUid },
+      transaction: ctx.transaction
+    });
+    if (!record) continue;
+    const options = normalizeOptions(record.get("options"));
+    if ((options == null ? void 0 : options.use) !== "ReferenceBlockModel") continue;
+    const stepParams = (options == null ? void 0 : options.stepParams) || {};
+    const useTemplate = import_lodash.default.get(stepParams, ["referenceSettings", "useTemplate"]);
+    if (!useTemplate || useTemplate.templateUid !== template.uid) continue;
+    const nextOptions = import_lodash.default.cloneDeep(options);
+    import_lodash.default.set(nextOptions, ["stepParams", "referenceSettings", "useTemplate"], {
+      ...useTemplate,
+      templateName: template.name,
+      templateDescription: template.description
+    });
+    if (template.targetUid) {
+      const currentTarget = import_lodash.default.get(nextOptions, ["stepParams", "referenceSettings", "target", "targetUid"]);
+      if (!currentTarget) {
+        import_lodash.default.set(nextOptions, ["stepParams", "referenceSettings", "target", "targetUid"], template.targetUid);
+      }
+    }
+    await flowRepo.update({
+      filter: { uid: modelUid },
+      values: {
+        options: nextOptions
+      },
+      transaction: ctx.transaction,
+      context: ctx
+    });
+  }
+};
+var flowModelTemplates_default = {
+  name: "flowModelTemplates",
+  actions: {
+    async list(ctx, next) {
+      var _a, _b, _c, _d;
+      const search = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.search;
+      const mergedFilter = buildSearchFilter((_c = ctx.action.params) == null ? void 0 : _c.filter, search);
+      if (mergedFilter) {
+        ctx.action.mergeParams({ filter: mergedFilter });
+      }
+      await import_actions.default.list(ctx, next);
+      if (Array.isArray(ctx.body)) {
+        ctx.body = await withUsageCounts(ctx, ctx.body);
+        return;
+      }
+      const rows = Array.isArray((_d = ctx.body) == null ? void 0 : _d.rows) ? ctx.body.rows : [];
+      const rowsWithCount = await withUsageCounts(ctx, rows);
+      ctx.body = {
+        ...ctx.body,
+        rows: rowsWithCount
+      };
+    },
+    async get(ctx, next) {
+      await import_actions.default.get(ctx, next);
+      if (!ctx.body) return;
+      const [rowWithCount] = await withUsageCounts(ctx, [ctx.body]);
+      ctx.body = rowWithCount;
+    },
+    async create(ctx, next) {
+      var _a, _b;
+      const values = ((_a = ctx.action.params) == null ? void 0 : _a.values) || {};
+      const detachParent = !!values.detachParent || !!values.detachFromParent;
+      if (!values.uid) {
+        values.uid = (0, import_utils.uid)();
+      }
+      if (values.targetUid && typeof values.targetUid === "object") {
+        values.targetUid = values.targetUid.uid || ((_b = values.targetUid.data) == null ? void 0 : _b.uid) || String(values.targetUid);
+      }
+      ctx.action.mergeParams({
+        values: import_lodash.default.pick(values, [
+          "uid",
+          "name",
+          "description",
+          "targetUid",
+          "useModel",
+          "type",
+          "dataSourceKey",
+          "collectionName",
+          "associationName",
+          "filterByTk",
+          "sourceId"
+        ])
+      });
+      await import_actions.default.create(ctx, next);
+      if (ctx.body) {
+        ctx.body = {
+          ...toPlain(ctx.body),
+          usageCount: 0
+        };
+        if (detachParent && ctx.body.targetUid) {
+          const flowRepo = ctx.db.getRepository("flowModels");
+          await flowRepo.clearAncestor(ctx.body.targetUid, { transaction: ctx.transaction });
+        }
+      }
+    },
+    async update(ctx, next) {
+      var _a, _b, _c;
+      const values = ((_a = ctx.action.params) == null ? void 0 : _a.values) || {};
+      ctx.action.mergeParams({
+        values: import_lodash.default.pick(values, ["name", "description"])
+      });
+      await import_actions.default.update(ctx, next);
+      if (ctx.body) {
+        const rawData = ((_b = ctx.body) == null ? void 0 : _b.data) ?? ctx.body;
+        const rows = Array.isArray(rawData) ? rawData : [rawData];
+        const rowsWithCount = await withUsageCounts(ctx, rows);
+        const normalizedRow = Array.isArray(rawData) ? rowsWithCount : rowsWithCount == null ? void 0 : rowsWithCount[0];
+        ctx.body = ((_c = ctx.body) == null ? void 0 : _c.data) ? { ...ctx.body, data: normalizedRow } : normalizedRow;
+        const templateRow = Array.isArray(rowsWithCount) ? rowsWithCount[0] : rowsWithCount;
+        const templateUid = resolveTemplateUid(ctx) || (templateRow == null ? void 0 : templateRow.uid);
+        await syncTemplateMetaToReferenceBlocks(ctx, {
+          uid: templateUid,
+          name: templateRow == null ? void 0 : templateRow.name,
+          description: templateRow == null ? void 0 : templateRow.description,
+          targetUid: templateRow == null ? void 0 : templateRow.targetUid
+        });
+      }
+    },
+    async destroy(ctx, next) {
+      const templateUid = resolveTemplateUid(ctx);
+      if (!templateUid) {
+        return ctx.throw(400, "template uid is required");
+      }
+      const usageRepo = ctx.db.getRepository("flowModelTemplateUsages");
+      const usageCount = await usageRepo.count({
+        filter: {
+          templateUid
+        },
+        context: ctx
+      });
+      if (usageCount > 0) {
+        return ctx.throw(400, {
+          code: "TEMPLATE_IN_USE",
+          message: "Template is in use and cannot be deleted",
+          data: { usageCount }
+        });
+      }
+      await import_actions.default.destroy(ctx, next);
+      await usageRepo.destroy({
+        filter: {
+          templateUid
+        },
+        context: ctx
+      });
+    }
+  }
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@nocobase/plugin-ui-templates",
+  "displayName": "UI templates",
+  "displayName.zh-CN": "界面模板",
+  "description": "Provides block templates and popup templates for UI reuse.",
+  "description.zh-CN": "提供区块模板和弹窗模板复用的能力。",
+  "version": "2.0.0-alpha.57",
+  "license": "AGPL-3.0",
+  "main": "./dist/server/index.js",
+  "types": "./dist/index.d.ts",
+  "devDependencies": {
+    "@formily/shared": "2.x",
+    "antd": "5.x",
+    "react": "^18.2.0"
+  },
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/flow-engine": "2.x",
+    "@nocobase/plugin-flow-engine": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/test": "2.x"
+  },
+  "nocobase": {
+    "supportedVersions": [
+      "2.x"
+    ]
+  },
+  "keywords": [
+    "nocobase",
+    "plugin",
+    "ui",
+    "templates",
+    "block",
+    "popup"
+  ],
+  "gitHead": "b9ec8bc83fd86a9cadfc4fb2f87a4e015061b289"
+}

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');