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

package/src/server/plugin.ts

@@ -0,0 +1,236 @@
+/**
+ * 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.
+ */
+
+import { InstallOptions, Plugin } from '@nocobase/server';
+import _ from 'lodash';
+import flowModelTemplates from './resources/flowModelTemplates';
+import flowModelTemplateUsages from './resources/flowModelTemplateUsages';
+import { FlowModelRepository } from '@nocobase/plugin-flow-engine';
+import { uid } from '@nocobase/utils';
+export class PluginBlockReferenceServer extends Plugin {
+  async load() {
+    this.app.resourceManager.define(flowModelTemplates);
+    this.app.resourceManager.define(flowModelTemplateUsages);
+
+    this.app.acl.allow('flowModelTemplates', '*', 'loggedIn');
+    this.app.acl.allow('flowModelTemplateUsages', '*', 'loggedIn');
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.templates`,
+      actions: ['flowModelTemplates:*', 'flowModelTemplateUsages:*'],
+    });
+
+    this.app.auditManager?.registerActions([
+      'flowModelTemplates:create',
+      'flowModelTemplates:update',
+      'flowModelTemplates:destroy',
+      'flowModelTemplateUsages:create',
+      'flowModelTemplateUsages:destroy',
+    ]);
+
+    const parseOptions = (value: any) => FlowModelRepository.optionsToJson(value || {});
+    const omitSubModels = (value: any) => {
+      if (!value || typeof value !== 'object') return value;
+      const { subModels, ...rest } = value;
+      return rest;
+    };
+    const collectFlowModelsFromTree = (value: any) => {
+      const result: Array<any> = [];
+      const ensureNodeUid = (node: any): string => {
+        const existing = node?.uid;
+        if (typeof existing === 'string' && existing) return existing;
+        if (typeof existing === 'undefined' || existing === null || existing === '') {
+          const next = uid();
+          node.uid = next;
+          return next;
+        }
+        throw new Error('[block-reference] flowModels uid must be a non-empty string');
+      };
+      const walk = (node: any, inheritedParentId?: string) => {
+        if (!node || typeof node !== 'object') return;
+        const nodeUid = ensureNodeUid(node);
+        const nextNode = omitSubModels(node);
+        if (inheritedParentId && nextNode && typeof nextNode === 'object' && !nextNode.parentId) {
+          nextNode.parentId = inheritedParentId;
+        }
+        if (nodeUid) {
+          result.push(nextNode);
+        }
+        const subModels = node?.subModels;
+        if (!subModels || typeof subModels !== 'object') return;
+        for (const val of Object.values(subModels)) {
+          const items = Array.isArray(val) ? val : [val];
+          for (const child of items) {
+            walk(child, nodeUid || inheritedParentId);
+          }
+        }
+      };
+      walk(value);
+      return result;
+    };
+    const extractTemplateUids = (options: any) => {
+      const stepParams = options?.stepParams || {};
+      const uids = new Set<string>();
+
+      // 模板引用（不限定 use；后续其它模型也可复用 referenceSettings.useTemplate ）
+      const mode = _.get(stepParams, ['referenceSettings', 'useTemplate', 'mode']) || 'reference';
+      const tplUid = _.get(stepParams, ['referenceSettings', 'useTemplate', 'templateUid']);
+      if (tplUid && mode !== 'copy') {
+        uids.add(String(tplUid));
+      }
+
+      // openView（弹窗模板引用）
+      // 兼容：openView step key 可能不是 "openView"，这里扫描 popupSettings 下所有 stepParams
+      const popupSettings = _.get(stepParams, ['popupSettings']);
+      if (popupSettings && typeof popupSettings === 'object') {
+        for (const val of Object.values(popupSettings)) {
+          if (!val || typeof val !== 'object') continue;
+          const step = val as Record<string, unknown>;
+          const tplUidRaw = step['popupTemplateUid'];
+          const tplMode = String(step['popupTemplateMode'] || '') || 'reference';
+          if (tplUidRaw !== null && typeof tplUidRaw !== 'undefined' && String(tplUidRaw) && tplMode !== 'copy') {
+            uids.add(String(tplUidRaw));
+          }
+        }
+      }
+
+      return Array.from(uids);
+    };
+
+    const syncUsages = async (instanceUid: string, options: any, { transaction }: { transaction?: any } = {}) => {
+      const usageRepo = this.db.getRepository('flowModelTemplateUsages');
+      const currentUids = _.uniq(extractTemplateUids(options).map(String));
+
+      await usageRepo.destroy({
+        filter: { modelUid: instanceUid },
+        transaction,
+      });
+
+      for (const templateUid of currentUids) {
+        await usageRepo.updateOrCreate({
+          filterKeys: ['templateUid', 'modelUid'],
+          values: { uid: uid(), templateUid, modelUid: instanceUid },
+          transaction,
+          context: { disableAfterDestroy: true },
+        });
+      }
+    };
+
+    const removeUsagesByInstance = async (
+      instanceUid: string,
+      _options: any,
+      { transaction }: { transaction?: any } = {},
+    ) => {
+      const usageRepo = this.db.getRepository('flowModelTemplateUsages');
+      await usageRepo.destroy({ filter: { modelUid: instanceUid }, transaction });
+    };
+
+    // 区块删除时自动清理 usage 记录，避免垃圾数据
+    this.db.on('flowModels.afterDestroy', async (instance: any, { transaction }: any = {}) => {
+      const instanceUid = instance?.get?.('uid') || instance?.uid;
+      if (!instanceUid) return;
+      const options = parseOptions(instance?.get?.('options') || instance?.options);
+      await removeUsagesByInstance(instanceUid, options, { transaction });
+    });
+
+    // 区块保存时维护 usage：
+    // - referenceSettings.useTemplate.templateUid（且 mode!==copy）
+    // - popupSettings.openView.popupTemplateUid + popupTemplateMode!==copy
+    const handleFlowModelSave = async (instance: any, { transaction }: any = {}) => {
+      const instanceUid = instance?.get?.('uid') || instance?.uid;
+      if (!instanceUid) return;
+
+      const options = parseOptions(instance?.get?.('options') || instance?.options);
+      await syncUsages(instanceUid, options, { transaction });
+    };
+
+    this.db.on('flowModels.afterSaveWithAssociations', handleFlowModelSave);
+
+    // flowModels:save/destroy 等自定义 action 不会触发 afterSaveWithAssociations/afterDestroy（FlowModelRepository 使用 hooks:false + raw SQL）
+    // 这里通过 resourcer middleware 补齐 usages 维护，保持“后端自动维护”为主的设计。
+    this.app.resourceManager.use(async (ctx: any, next) => {
+      const isFlowModels = ctx?.action?.resourceName === 'flowModels';
+      if (!isFlowModels) {
+        return next();
+      }
+
+      const actionName = ctx?.action?.actionName;
+
+      if (actionName === 'save') {
+        const values = ctx?.action?.params?.values;
+        if (!values || typeof values !== 'object') {
+          ctx.throw(400, {
+            code: 'INVALID_PAYLOAD',
+            message: 'values is required',
+          });
+        }
+        const nodes = collectFlowModelsFromTree(values);
+
+        await next();
+
+        for (const node of nodes) {
+          const instanceUid = node?.uid;
+          if (!instanceUid) continue;
+          const currentOptions = parseOptions(node);
+          await syncUsages(instanceUid, currentOptions, { transaction: ctx.transaction });
+        }
+        return;
+      }
+
+      if (actionName === 'destroy') {
+        const rootUid = ctx?.action?.params?.filterByTk;
+        if (!rootUid || typeof rootUid !== 'string') {
+          ctx.throw(400, {
+            code: 'INVALID_PAYLOAD',
+            message: 'filterByTk is required',
+          });
+        }
+        const flowRepo = ctx.db.getRepository('flowModels') as FlowModelRepository;
+        const nodes = (await flowRepo.findNodesById(rootUid, {
+          includeAsyncNode: true,
+          transaction: ctx.transaction,
+        })) as Array<{ uid?: string; options?: unknown; parent?: string | null }>;
+
+        await next();
+
+        for (const node of nodes) {
+          const instanceUid = node?.uid;
+          if (!instanceUid) continue;
+          const options = parseOptions(node?.options || {});
+          if (node?.parent && !options?.parentId) {
+            options.parentId = node.parent;
+          }
+          await removeUsagesByInstance(instanceUid, options, { transaction: ctx.transaction });
+        }
+        return;
+      }
+
+      if (actionName === 'duplicate') {
+        await next();
+        const raw = ctx.body?.data ?? ctx.body;
+        const nodes = collectFlowModelsFromTree(raw);
+        for (const node of nodes) {
+          const instanceUid = node?.uid;
+          if (!instanceUid) continue;
+          const currentOptions = parseOptions(node);
+          await syncUsages(instanceUid, currentOptions, { transaction: ctx.transaction });
+        }
+        return;
+      }
+
+      return next();
+    });
+  }
+
+  async install(options?: InstallOptions) {}
+  async afterEnable() {}
+  async afterDisable() {}
+  async remove() {}
+}
+
+export default PluginBlockReferenceServer;

package/src/server/resources/flowModelTemplateUsages.ts

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+import actions, { Context } from '@nocobase/actions';
+import { uid } from '@nocobase/utils';
+
+export default {
+  name: 'flowModelTemplateUsages',
+  actions: {
+    async list(ctx: Context, next) {
+      await actions.list(ctx, next);
+    },
+
+    async get(ctx: Context, next) {
+      await actions.get(ctx, next);
+    },
+
+    async create(ctx: Context, next) {
+      const values = ctx.action.params?.values || {};
+      const templateUid = values.templateUid;
+      const modelUid = values.modelUid;
+      if (!templateUid || !modelUid) {
+        return ctx.throw(400, 'templateUid and modelUid are required');
+      }
+      const usageRepo = ctx.db.getRepository('flowModelTemplateUsages');
+      const record = await usageRepo.updateOrCreate({
+        filterKeys: ['templateUid', 'modelUid'],
+        values: {
+          uid: values.uid || uid(),
+          templateUid,
+          modelUid,
+        },
+        context: ctx,
+      });
+      ctx.body = record;
+      await next();
+    },
+
+    async destroy(ctx: Context, next) {
+      const params = ctx.action?.params || {};
+      const { filterByTk, values = {}, filter } = params;
+      const templateUid = values.templateUid;
+      const modelUid = values.modelUid;
+      if (!filterByTk && templateUid && modelUid && !filter) {
+        ctx.action.mergeParams({
+          filter: {
+            templateUid,
+            modelUid,
+          },
+        });
+      }
+      await actions.destroy(ctx, next);
+    },
+  },
+};

package/src/server/resources/flowModelTemplates.ts

@@ -0,0 +1,251 @@
+/**
+ * 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.
+ */
+
+import actions, { Context } from '@nocobase/actions';
+import _ from 'lodash';
+import { uid } from '@nocobase/utils';
+import FlowModelRepository from '@nocobase/plugin-flow-engine/src/server/repository';
+
+type PlainRow = Record<string, any>;
+
+const toPlain = (row: any): PlainRow => {
+  if (!row) return row;
+  if (typeof row.toJSON === 'function') return row.toJSON();
+  return row;
+};
+
+const buildSearchFilter = (existing: any, search?: string) => {
+  const filters = [];
+  if (existing) {
+    filters.push(existing);
+  }
+  if (search) {
+    filters.push({
+      $or: [{ name: { $includes: search } }, { description: { $includes: search } }],
+    });
+  }
+  if (!filters.length) return undefined;
+  if (filters.length === 1) return filters[0];
+  return { $and: filters };
+};
+
+const withUsageCounts = async (ctx: Context, rows: PlainRow[]) => {
+  const data = rows.map(toPlain).filter(Boolean);
+  const uids = data.map((item) => 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 = new Map<string, number>();
+  for (const row of usageRows as any[]) {
+    usageMap.set(row.templateUid, Number(row.count) || 0);
+  }
+  return data.map((item) => ({
+    ...item,
+    usageCount: usageMap.get(item.uid) || 0,
+  }));
+};
+
+const resolveTemplateUid = (ctx: Context): string | undefined => {
+  const params = ctx.action?.params || {};
+  if (params.filterByTk) return params.filterByTk;
+  if (typeof params?.filter?.uid === 'string') return params.filter.uid;
+  if (params.values?.uid) return params.values.uid;
+  return undefined;
+};
+
+const normalizeOptions = (options: any) => {
+  if (!options) return {};
+  if (typeof options === 'string') {
+    try {
+      return JSON.parse(options);
+    } catch (e) {
+      return {};
+    }
+  }
+  return options;
+};
+
+const syncTemplateMetaToReferenceBlocks = async (
+  ctx: Context,
+  template: { uid: string; name: string; description: any; targetUid?: string },
+) => {
+  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 = _.uniq(usages.map((u: any) => u?.modelUid).filter(Boolean));
+  if (!modelUids.length) return;
+
+  const flowRepo = ctx.db.getRepository('flowModels') as FlowModelRepository;
+
+  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?.use !== 'ReferenceBlockModel') continue;
+    const stepParams = options?.stepParams || {};
+    const useTemplate = _.get(stepParams, ['referenceSettings', 'useTemplate']);
+    if (!useTemplate || useTemplate.templateUid !== template.uid) continue;
+    const nextOptions = _.cloneDeep(options);
+    _.set(nextOptions, ['stepParams', 'referenceSettings', 'useTemplate'], {
+      ...useTemplate,
+      templateName: template.name,
+      templateDescription: template.description,
+    });
+    if (template.targetUid) {
+      const currentTarget = _.get(nextOptions, ['stepParams', 'referenceSettings', 'target', 'targetUid']);
+      if (!currentTarget) {
+        _.set(nextOptions, ['stepParams', 'referenceSettings', 'target', 'targetUid'], template.targetUid);
+      }
+    }
+    await flowRepo.update({
+      filter: { uid: modelUid },
+      values: {
+        options: nextOptions,
+      },
+      transaction: ctx.transaction,
+      context: ctx,
+    });
+  }
+};
+
+export default {
+  name: 'flowModelTemplates',
+  actions: {
+    async list(ctx: Context, next) {
+      const search = ctx.action?.params?.search as string | undefined;
+      const mergedFilter = buildSearchFilter(ctx.action.params?.filter, search);
+      if (mergedFilter) {
+        ctx.action.mergeParams({ filter: mergedFilter });
+      }
+      await actions.list(ctx, next);
+      if (Array.isArray(ctx.body)) {
+        ctx.body = await withUsageCounts(ctx, ctx.body);
+        return;
+      }
+      const rows = Array.isArray(ctx.body?.rows) ? ctx.body.rows : [];
+      const rowsWithCount = await withUsageCounts(ctx, rows);
+      ctx.body = {
+        ...ctx.body,
+        rows: rowsWithCount,
+      };
+    },
+
+    async get(ctx: Context, next) {
+      await actions.get(ctx, next);
+      if (!ctx.body) return;
+      const [rowWithCount] = await withUsageCounts(ctx, [ctx.body]);
+      ctx.body = rowWithCount;
+    },
+
+    async create(ctx: Context, next) {
+      const values = ctx.action.params?.values || {};
+      const detachParent = !!values.detachParent || !!values.detachFromParent;
+      if (!values.uid) {
+        values.uid = uid();
+      }
+      if (values.targetUid && typeof values.targetUid === 'object') {
+        values.targetUid = values.targetUid.uid || values.targetUid.data?.uid || String(values.targetUid);
+      }
+      ctx.action.mergeParams({
+        values: _.pick(values, [
+          'uid',
+          'name',
+          'description',
+          'targetUid',
+          'useModel',
+          'type',
+          'dataSourceKey',
+          'collectionName',
+          'associationName',
+          'filterByTk',
+          'sourceId',
+        ]),
+      });
+      await actions.create(ctx, next);
+      if (ctx.body) {
+        ctx.body = {
+          ...toPlain(ctx.body),
+          usageCount: 0,
+        };
+        if (detachParent && ctx.body.targetUid) {
+          const flowRepo = ctx.db.getRepository('flowModels') as FlowModelRepository;
+          await flowRepo.clearAncestor(ctx.body.targetUid, { transaction: ctx.transaction });
+        }
+      }
+    },
+
+    async update(ctx: Context, next) {
+      const values = ctx.action.params?.values || {};
+      ctx.action.mergeParams({
+        values: _.pick(values, ['name', 'description']),
+      });
+      await actions.update(ctx, next);
+      if (ctx.body) {
+        const rawData = ctx.body?.data ?? ctx.body;
+        const rows = Array.isArray(rawData) ? rawData : [rawData];
+        const rowsWithCount = await withUsageCounts(ctx, rows);
+        const normalizedRow = Array.isArray(rawData) ? rowsWithCount : rowsWithCount?.[0];
+        ctx.body = ctx.body?.data ? { ...ctx.body, data: normalizedRow } : normalizedRow;
+        const templateRow = (Array.isArray(rowsWithCount) ? rowsWithCount[0] : rowsWithCount) as PlainRow;
+        const templateUid = resolveTemplateUid(ctx) || templateRow?.uid;
+        await syncTemplateMetaToReferenceBlocks(ctx, {
+          uid: templateUid,
+          name: templateRow?.name,
+          description: templateRow?.description,
+          targetUid: templateRow?.targetUid,
+        });
+      }
+    },
+
+    async destroy(ctx: Context, 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 actions.destroy(ctx, next);
+      // 兜底清理孤立 usage（正常情况下 usageCount 已为 0）
+      await usageRepo.destroy({
+        filter: {
+          templateUid,
+        },
+        context: ctx,
+      });
+    },
+  },
+};