feat: 新增使用node创建规则节点

+import { join } from 'path';
+import { pathExists, ensureFile, writeFile } from 'fs-extra';
+import { NodeItemConfigType } from '/@/views/rule/designer/types/node';
+import { camelCase, upperFirst, snakeCase } from 'lodash-es';
+import { execSync } from 'child_process';
+
+type GroupNodeType = { [key: string]: NodeItemConfigType[] };
+
+const RULE_CHAIN_FILE_PATH = join(process.cwd(), '/src/views/rule/designer');
+
+const list: NodeItemConfigType[] = [
+  {
+    type: 'FLOW',
+    scope: 'TENANT',
+    name: 'acknowledge',
+    clazz: 'org.thingsboard.rule.engine.flow.TbAckNode',
+    configurationDescriptor: {
+      nodeDefinition: {
+        details:
+          "After acknowledgement, the message is pushed to related rule nodes. Useful if you don't care what happens to this message next.",
+        description: 'Acknowledges the incoming message',
+        inEnabled: true,
+        outEnabled: true,
+        relationTypes: ['Success', 'Failure'],
+        customRelations: false,
+        ruleChainNode: false,
+        defaultConfiguration: {
+          version: 0,
+        },
+        uiResources: ['static/rulenode/rulenode-core-config.js'],
+        configDirective: 'tbNodeEmptyConfig',
+        icon: '',
+        iconUrl: '',
+        docUrl: '',
+      },
+    },
+    actions: null,
+  },
+  {
+    createdTime: 1668743016418,
+    type: 'FILTER',
+    scope: 'TENANT',
+    name: 'check alarm status',
+    clazz: 'org.thingsboard.rule.engine.filter.TbCheckAlarmStatusNode',
+    configurationDescriptor: {
+      nodeDefinition: {
+        details:
+          'If the alarm status matches the specified one - msg is success if does not match - msg is failure.',
+        description: 'Checks alarm status.',
+        inEnabled: true,
+        outEnabled: true,
+        relationTypes: ['True', 'False', 'Failure'],
+        customRelations: false,
+        ruleChainNode: false,
+        defaultConfiguration: {
+          alarmStatusList: ['ACTIVE_ACK', 'ACTIVE_UNACK'],
+        },
+        uiResources: ['static/rulenode/rulenode-core-config.js'],
+        configDirective: 'tbFilterNodeCheckAlarmStatusConfig',
+        icon: '',
+        iconUrl: '',
+        docUrl: '',
+      },
+    },
+    actions: null,
+  },
+];
+
+const getCategoryConfigName = (name: string) => {
+  return `${upperFirst(camelCase(name))}CategoryConfig`;
+};
+
+const getNodeConfigName = (name: string) => {
+  return `${upperFirst(camelCase(name))}Config`;
+};
+
+const getCagegoryEnumName = (name: string) => {
+  return `${upperFirst(name.toLowerCase())}CategoryComponentEnum`;
+};
+
+const getEnumKeyName = (name: string) => {
+  return snakeCase(name).toUpperCase();
+};
+
+const createFile = async (fileName: string, fileContent?: string, replace = false) => {
+  const path = join(RULE_CHAIN_FILE_PATH, './packages', fileName);
+
+  const flag = await pathExists(path);
+
+  if (flag && !replace) return false;
+
+  await ensureFile(path);
+
+  fileContent && (await writeFile(path, fileContent, { encoding: 'utf-8' }));
+};
+
+const groupByType = () => {
+  const group: { [key: string]: NodeItemConfigType[] } = {};
+
+  list.forEach((item) => {
+    if (!group[item.type]) group[item.type] = [];
+    group[item.type].push(item);
+  });
+
+  return group;
+};
+
+const generateCategoryEnumFile = async (data: GroupNodeType) => {
+  const defaultContent = `
+export enum EntryCategoryComponentEnum {
+  INPUT = 'Input',
+}
+  `;
+
+  const fileContent = Object.keys(data).reduce((prev, next) => {
+    const enumName = getCagegoryEnumName(next);
+
+    const enumKeys = data[next].map((item) => getEnumKeyName(item.name));
+
+    const content = `export enum ${enumName} {
+        ${enumKeys.map((name) => `${name} = '${upperFirst(camelCase(name))}'`)}
+    }`;
+
+    return `${prev} \n ${content}`;
+  }, defaultContent);
+
+  createFile('../enum/category.ts', fileContent, true);
+  return fileContent;
+};
+
+const generateRuleNodeEnumFile = async (data: GroupNodeType) => {
+  const categoryKeys = Object.keys(data).map((type) => type.toUpperCase());
+  const filePath = join(RULE_CHAIN_FILE_PATH, './packages/index.type.ts');
+  const fileContent = `
+export enum RuleNodeTypeEnum {
+  ${categoryKeys.map((item) => `${item} = '${item}'`).join(',\n')}
+}  
+  `;
+
+  await writeFile(filePath, fileContent, {
+    encoding: 'utf-8',
+  });
+
+  return fileContent;
+};
+
+const generateCategoryIndexFile = async (type: string, data: NodeItemConfigType[]) => {
+  const getComponentsName = data.map((temp) => `${upperFirst(camelCase(temp.name))}`);
+  const importContent = getComponentsName.map(
+    (name) => `import { ${name}Config } from './${name}';\n`
+  );
+
+  const components = getComponentsName.map((item) => `${item}Config`);
+
+  const content = `import type { CategoryConfigType, NodeItemConfigType } from '../../types/node';
+import { RuleNodeTypeEnum } from '../index.type';
+${importContent.join('')}
+
+export const ${getCategoryConfigName(type)}: CategoryConfigType = {
+  category: RuleNodeTypeEnum.${type.toUpperCase()},
+  backgroundColor: '#ede550',
+  title: '筛选器',
+  icon: 'tabler:circuit-ground',
+  description: '使用配置条件筛选传入消息',
+};
+
+export const ${upperFirst(type.toLowerCase())}Components: NodeItemConfigType[] = [${components}];
+`;
+
+  createFile(`./${upperFirst(type.toLowerCase())}/index.ts`, content);
+
+  return content;
+};
+
+const generateNodeIndexFile = async (type: string, data: NodeItemConfigType) => {
+  const categoryEnumName = getCagegoryEnumName(type);
+
+  const nodeConfigName = getNodeConfigName(data.name);
+
+  const content = `
+  import { ${categoryEnumName} } from '../../../enum/category';
+  import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
+  import type { NodeItemConfigType } from '../../../types/node';
+  import { RuleNodeTypeEnum } from '../../index.type';
+
+  const keys = useCreateNodeKey(${categoryEnumName}.${getEnumKeyName(data.name)});
+
+  export interface ${upperFirst(camelCase(data.name))}DataType {
+
+  }
+
+  export const ${nodeConfigName}: NodeItemConfigType = {
+    ...keys,
+    clazz: '${data.clazz}',
+    categoryType: RuleNodeTypeEnum.${type.toUpperCase()},
+    name: '${data.name}',
+    backgroundColor: '#ede550',
+    configurationDescriptor: ${JSON.stringify(data.configurationDescriptor, null, 2)}
+  };
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/index.ts`,
+    content
+  );
+
+  return content;
+};
+
+const generateNodeVueTemplateFile = async (type: string, data: NodeItemConfigType) => {
+  const content = `
+  <script lang="ts" setup>
+    import type { CreateModalDefineExposeType } from '../../../types';
+    import { BasicForm, useForm } from '/@/components/Form';
+    import { formSchemas } from './create.config';
+    import { NodeData } from '../../../types/node';
+
+    defineProps<{
+      config: NodeData;
+    }>();
+
+    const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
+      schemas: formSchemas,
+      showActionButtonGroup: false,
+    });
+
+    const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
+      await validate();
+      const value = getFieldsValue() || {};
+      return value;
+    };
+
+    const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
+      resetFields();
+      setFieldsValue(value);
+    };
+
+    defineExpose({
+      setFieldsValue: setValue,
+      getFieldsValue: getValue,
+    } as CreateModalDefineExposeType);
+  </script>
+
+  <template>
+    <BasicForm @register="register" />
+  </template>
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/create.vue`,
+    content
+  );
+  return content;
+};
+
+const generateNodeVueConfigFile = async (type: string, data: NodeItemConfigType) => {
+  const content = `
+  import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+  import { FormSchema } from '/@/components/Form';
+
+  export const formSchemas: FormSchema[] = [
+  ];
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/create.config.ts`,
+    content
+  );
+  return content;
+};
+
+const generateNodeConfigFile = async (type: string, data: NodeItemConfigType) => {
+  const nodeConfigName = getNodeConfigName(data.name);
+  const categoryConfigName = getCategoryConfigName(type);
+  const content = `
+  import { cloneDeep } from 'lodash-es';
+  import { PublicNodeItemClass } from '../../../types/node';
+  import type {
+    CategoryConfigType,
+    CreateComponentType,
+    NodeItemConfigType,
+  } from '../../../types/node';
+  import { ${categoryConfigName} } from '..';
+  import { ${nodeConfigName} } from '.';
+
+  export class Config extends PublicNodeItemClass implements CreateComponentType {
+    public config: NodeItemConfigType = cloneDeep(${nodeConfigName});
+
+    public categoryConfig: CategoryConfigType = cloneDeep(${categoryConfigName});
+
+    constructor() {
+      super();
+    }
+  }
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/config.ts`,
+    content
+  );
+  return content;
+};
+
+const bootstrap = async () => {
+  const groupData = groupByType();
+  await generateRuleNodeEnumFile(groupData);
+  await generateCategoryEnumFile(groupData);
+
+  for (const type of Object.keys(groupData)) {
+    const item = groupData[type];
+    await generateCategoryIndexFile(type, item);
+    for (const temp of item) {
+      await generateNodeConfigFile(type, temp);
+      await generateNodeIndexFile(type, temp);
+      await generateNodeVueConfigFile(type, temp);
+      await generateNodeVueTemplateFile(type, temp);
+    }
+  }
+  execSync(`npx eslint --fix ${RULE_CHAIN_FILE_PATH}/*.{vue,ts}`);
+};
+
+bootstrap();

@@ -32,7 +32,8 @@
     "reinstall": "rimraf yarn.lock && rimraf package.lock.json && rimraf node_modules && npm run bootstrap",
     "reinstall": "rimraf yarn.lock && rimraf package.lock.json && rimraf node_modules && npm run bootstrap",
     "prepare": "husky install",
     "prepare": "husky install",
     "gen:icon": "esno ./build/generate/icon/index.ts",
     "gen:icon": "esno ./build/generate/icon/index.ts",
-    "gen:iconfont": "esno ./build/generate/iconfont/index.ts"
+    "gen:iconfont": "esno ./build/generate/iconfont/index.ts",
+    "gen:rule": "esno ./build/generate/ruleChain/index.ts"
   },
   },
   "dependencies": {
   "dependencies": {
     "@fingerprintjs/fingerprintjs": "^3.4.1",
     "@fingerprintjs/fingerprintjs": "^3.4.1",

@@ -2,6 +2,6 @@ export enum FilterCategoryComponentEnum {
   CHECK_ALARM_STATUS = 'CheckAlarmStatus',
   CHECK_ALARM_STATUS = 'CheckAlarmStatus',
 }
 }
 
 
-export enum EntryComponentEnum {
+export enum EntryCategoryComponentEnum {
   INPUT = 'Input',
   INPUT = 'Input',
 }
 }

 import type { VueFlowStore, Getters, Elements } from '@vue-flow/core';
 import type { VueFlowStore, Getters, Elements } from '@vue-flow/core';
 import { ComputedRef, ref, unref } from 'vue';
 import { ComputedRef, ref, unref } from 'vue';
 import { BasicNodeBindData, EdgeData, NodeData } from '../types/node';
 import { BasicNodeBindData, EdgeData, NodeData } from '../types/node';
-import { EntryComponentEnum } from '../enum/category';
+import { EntryCategoryComponentEnum } from '../enum/category';
 import { useBasicDataTransform } from './useBasicDataTransform';
 import { useBasicDataTransform } from './useBasicDataTransform';
 import { getRuleChainData, saveRuleChainData } from '/@/api/ruleDesigner';
 import { getRuleChainData, saveRuleChainData } from '/@/api/ruleDesigner';
 import { ConnectionItemType, RuleChainType } from '../types/ruleNode';
 import { ConnectionItemType, RuleChainType } from '../types/ruleNode';
 import { useInputNode } from './useInputNode';
 import { useInputNode } from './useInputNode';
 import { buildUUID } from '/@/utils/uuid';
 import { buildUUID } from '/@/utils/uuid';
 
 
-const ignoreNodeKeys: string[] = [EntryComponentEnum.INPUT];
+const ignoreNodeKeys: string[] = [EntryCategoryComponentEnum.INPUT];
 
 
 export function useSaveAndRedo() {
 export function useSaveAndRedo() {
   const changeMarker = ref(false);
   const changeMarker = ref(false);
@@ -77,7 +77,7 @@ export function useSaveAndRedo() {
     edges: ComputedRef<Getters['getEdges']>
     edges: ComputedRef<Getters['getEdges']>
   ) {
   ) {
     const inputNode = unref(edges).find(
     const inputNode = unref(edges).find(
-      (item) => (item.sourceNode.data as NodeData).config?.key === EntryComponentEnum.INPUT
+      (item) => (item.sourceNode.data as NodeData).config?.key === EntryCategoryComponentEnum.INPUT
     );
     );
 
 
     if (inputNode) {
     if (inputNode) {

-import { EntryComponentEnum } from '../../../enum/category';
+import { EntryCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
 import { RuleNodeTypeEnum } from '../../index.type';
 
 
-const keys = useCreateNodeKey(EntryComponentEnum.INPUT);
+const keys = useCreateNodeKey(EntryCategoryComponentEnum.INPUT);
 
 
 export const InputConfig: NodeItemConfigType = {
 export const InputConfig: NodeItemConfigType = {
   ...keys,
   ...keys,
   categoryType: RuleNodeTypeEnum.ENTRY,
   categoryType: RuleNodeTypeEnum.ENTRY,
-  clazz: EntryComponentEnum.INPUT,
+  clazz: EntryCategoryComponentEnum.INPUT,
   maxConnectionPoint: 1,
   maxConnectionPoint: 1,
   backgroundColor: '#95E898',
   backgroundColor: '#95E898',
   configurationDescriptor: {
   configurationDescriptor: {