@abtnode/core 1.17.7-beta-20251227-001958-ea2ba3f5 → 1.17.7-beta-20251229-223813-e1e6c5e3

package/lib/router/index.js

@@ -1,6 +1,6 @@
 const get = require('lodash/get');
 const uniq = require('lodash/uniq');
-const throttle = require('lodash/throttle');
+const debounce = require('lodash/debounce');
 const pick = require('lodash/pick');
 const isEqual = require('lodash/isEqual');
 const cloneDeep = require('@abtnode/util/lib/deep-clone');
@@ -27,30 +27,16 @@ const IP = require('../util/ip');
 
 const isServiceFeDevelopment = process.env.ABT_NODE_SERVICE_FE_PORT;
 
-const mergeAllowedOrigins = (domain, allowedOrigins) => {
-  const origins = Array.isArray(allowedOrigins) ? allowedOrigins : [domain];
-  if (origins.includes(domain) === false) {
-    origins.push(domain);
-  }
-
-  // skip site if domain is BLOCKLET_SITE_GROUP
-  const res = origins.filter((x) => !x.endsWith(BLOCKLET_SITE_GROUP_SUFFIX));
-
-  return res;
-};
-
 const expandSites = (sites = []) => {
   const result = [];
 
   sites.forEach((site) => {
-    site.corsAllowedOrigins = mergeAllowedOrigins(site.domain, site.corsAllowedOrigins);
     (site.domainAliases || []).forEach((domainAlias) => {
       const domain = typeof domainAlias === 'object' ? domainAlias.value : domainAlias;
       const tmpSite = cloneDeep(site);
       delete tmpSite.domainAliases;
       tmpSite.serviceType = isBlockletSite(site.domain) ? 'blocklet' : 'daemon';
       tmpSite.domain = domain;
-      tmpSite.corsAllowedOrigins = mergeAllowedOrigins(tmpSite.domain, site.corsAllowedOrigins);
       result.push(tmpSite);
     });
 
@@ -98,7 +84,7 @@ const getRoutingTable = ({ sites, nodeInfo }) => {
   const enableIpServer = nodeInfo.routing.enableIpServer ?? false;
 
   // eslint-disable-next-line no-use-before-define
-  let routingTable = Router.formatSites(sites);
+  let routingTable = Router.formatSites(sites, nodeInfo);
   routingTable = expandSites(routingTable);
   routingTable = filterSites({ sites: routingTable, enableDefaultServer, enableIpServer });
 
@@ -119,28 +105,122 @@ class Router {
   /**
    * Router
    * @constructor
-   * @param {object} routingProvider
+   * @param {object} options
+   * @param {object} options.provider - Router provider instance
+   * @param {function} options.getAllRoutingParams - Function to get all routing params (for full reload)
+   * @param {function} [options.getBlockletRoutingParams] - Function to get single blocklet's routing params (for lightweight updates)
+   * @param {function} [options.getSystemRoutingParams] - Function to get global/system routing params (for global-only updates)
    */
-  constructor({ provider, getRoutingParams }) {
+  constructor({ provider, getAllRoutingParams, getBlockletRoutingParams, getSystemRoutingParams }) {
     if (!provider) {
       throw new Error('Must provide valid router when create new router');
     }
 
-    if (typeof getRoutingParams !== 'function') {
-      throw new Error('Must provide a valid getRoutingParams function when create new router');
+    if (typeof getAllRoutingParams !== 'function') {
+      throw new Error('Must provide a valid getAllRoutingParams function when create new router');
     }
 
     this.provider = provider;
-    this.getRoutingParams = getRoutingParams;
+    this.getAllRoutingParams = getAllRoutingParams;
+    this.getBlockletRoutingParams = getBlockletRoutingParams; // Optional - for lightweight single blocklet updates
+    this.getSystemRoutingParams = getSystemRoutingParams; // Optional - for global-only updates (O(1))
     this.routingTable = [];
 
-    this.throttledReload = throttle(() => this.reload(), 5000, { leading: true, trailing: true });
-    this.throttledRestart = throttle(() => this.restart(), 5000, { leading: true, trailing: true });
+    // Batching for rapid changes
+    this.pendingChanges = {
+      global: false,
+      blocklets: new Set(),
+      blockletsRemoved: new Set(),
+    };
+    this._processingBatch = false;
+
+    // Debounced batch processor - waits 1000ms for more changes, max 5s
+    this.debouncedProcessBatch = debounce(() => this._processBatch(), 1000, { maxWait: 5000 });
   }
 
+  /**
+   * Update routing table by fetching params and calling provider.update()
+   * This is a convenience method that combines _getUpdateParams() and provider.update()
+   */
   async updateRoutingTable() {
-    logger.info('update routing table');
+    logger.info('router: update routing table');
+
+    const params = await this._getUpdateParams();
+    if (!params) {
+      logger.error('router: failed to get update params in updateRoutingTable');
+      return;
+    }
+    logger.info('router: update routing table params ready');
+
+    await this.provider.update(params);
+    logger.info('router: update routing table complete');
+  }
+
+  async update() {
+    logger.info('router: update');
+    await this.updateRoutingTable();
+    await this.provider.reload();
+    logger.info('router: reload provider success');
+  }
+
+  async start() {
+    logger.info('router: start');
+    await this.updateRoutingTable();
+    return this.provider.start();
+  }
+
+  async restart() {
+    logger.info('router: restart');
+    await this.updateRoutingTable();
+    return this.provider.restart();
+  }
+
+  async reload() {
+    logger.info('router: reload');
+    await this.updateRoutingTable();
+    return this.provider.reload();
+  }
+
+  stop() {
+    logger.info('router: stop');
+    return this.provider.stop();
+  }
+
+  async validateConfig() {
+    logger.info('router: validateConfig');
+    await this.provider.validateConfig();
+  }
+
+  async rotateLogs() {
+    logger.info('router: rotate logs');
+    await this.provider.rotateLogs();
+  }
+
+  getLogFilesForToday() {
+    return this.provider.getLogFilesForToday();
+  }
+
+  getLogDir() {
+    return this.provider.getLogDir();
+  }
 
+  searchCache(pattern, group) {
+    return this.provider.searchCache(pattern, group);
+  }
+
+  clearCache(group) {
+    return this.provider.clearCache(group);
+  }
+
+  supportsModSecurity() {
+    return !!this.provider.capabilities?.modsecurity;
+  }
+
+  /**
+   * Get update parameters for the provider
+   * @returns {Promise<object>} Parameters for provider.update()
+   */
+  async _getUpdateParams(fn = 'getAllRoutingParams') {
     const {
       sites,
       certificates,
@@ -148,10 +228,11 @@ class Router {
       services = [],
       nodeInfo = {},
       wafDisabledBlocklets = [],
-    } = (await this.getRoutingParams()) || {};
+    } = (await this[fn]()) || {};
+
     if (!Array.isArray(sites)) {
-      logger.error('sites is not an array', { sites });
-      return;
+      logger.error('router:_getUpdateParams: sites is not an array', { fn, sites });
+      return null;
     }
 
     this.routingTable = getRoutingTable({ sites, nodeInfo });
@@ -179,7 +260,6 @@ class Router {
     if (blockPolicy.enabled) {
       blockPolicy.blacklist = await expandBlacklist(blockPolicy.blacklist);
 
-      // remove current internal ip from blacklist to avoid blocking self
       const result = await IP.get({ timeout: 2000 });
       if (result?.internal) {
         blockPolicy.blacklist = blockPolicy.blacklist.filter((x) => x !== result.internal);
@@ -188,10 +268,7 @@ class Router {
         blockPolicy.blacklist = blockPolicy.blacklist.filter((x) => x !== result.external);
       }
 
-      // Append blocked ips from database
       const blockedIps = await getActiveBlacklist();
-      logger.info('router auto blocked ips', blockedIps);
-
       blockPolicy.blacklist = uniq([...blockPolicy.blacklist, ...blockedIps]);
     }
 
@@ -209,15 +286,12 @@ class Router {
       outboundAnomalyScoreThreshold: 10,
     };
 
-    logger.info('router: update routing table', {
-      snapshotHash: nodeInfo?.routing?.snapshotHash,
-    });
-    await this.provider.update({
+    return {
       routingTable: this.routingTable,
       certificates,
       commonHeaders: headers,
       services,
-      nodeInfo: pick(nodeInfo, ['name', 'version', 'port', 'mode', 'enableWelcomePage', 'routing']),
+      nodeInfo: pick(nodeInfo, ['did', 'name', 'version', 'port', 'mode', 'enableWelcomePage', 'routing']),
       requestLimit,
       blockPolicy,
       proxyPolicy,
@@ -226,87 +300,190 @@ class Router {
       wafDisabledBlocklets,
       enableDefaultServer: nodeInfo.routing.enableDefaultServer ?? false,
       enableIpServer: nodeInfo.routing.enableIpServer ?? false,
-    });
-    logger.info('router: update routing table success', {
-      snapshotHash: nodeInfo?.routing?.snapshotHash,
-    });
+    };
   }
 
-  async update() {
-    logger.info('router: update');
-    await this.updateRoutingTable();
-    await this.provider.reload();
-    logger.info('router: reload provider success');
-  }
+  /**
+   * Queue a change for batched processing
+   * @param {string} changeType - 'global', 'blocklet', or 'blocklet-remove'
+   * @param {string} [did] - The blocklet DID (for blocklet changes)
+   */
+  queueChange(changeType, did = undefined) {
+    if (changeType === 'global') {
+      this.pendingChanges.global = true;
+    } else if (changeType === 'blocklet' && did) {
+      this.pendingChanges.blocklets.add(did);
+      // If we're updating a blocklet, remove it from the remove list
+      this.pendingChanges.blockletsRemoved.delete(did);
+    } else if (changeType === 'blocklet-remove' && did) {
+      this.pendingChanges.blockletsRemoved.add(did);
+      // If we're removing a blocklet, remove it from the update list
+      this.pendingChanges.blocklets.delete(did);
+    }
 
-  async start() {
-    logger.info('router: start');
-    await this.updateRoutingTable();
-    return this.provider.start();
-  }
+    logger.info('router: queued change', {
+      changeType,
+      did,
+      global: this.pendingChanges.global,
+      blockletCount: this.pendingChanges.blocklets.size,
+      removeCount: this.pendingChanges.blockletsRemoved.size,
+    });
 
-  async restart() {
-    logger.info('router: restart');
-    await this.updateRoutingTable();
-    return this.provider.restart();
+    this.debouncedProcessBatch();
   }
 
-  async reload() {
-    logger.info('router: reload');
-    await this.updateRoutingTable();
-    return this.provider.reload();
-  }
+  /**
+   * Process batched changes with tiered approach:
+   * - Global-only changes: O(1) using getSystemRoutingParams
+   * - Blocklet changes: O(1) per blocklet using getBlockletRoutingParams
+   * - Global + blocklet changes: O(1) global + O(k) blocklets where k = number of changed blocklets
+   */
+  async _processBatch() {
+    if (this._processingBatch) {
+      logger.info('router: already processing batch, will retry');
+      this.debouncedProcessBatch();
+      return;
+    }
 
-  stop() {
-    logger.info('router: stop');
-    return this.provider.stop();
-  }
+    const { global: globalChanged, blocklets, blockletsRemoved } = this.pendingChanges;
+    const hasBlockletChanges = blocklets.size > 0 || blockletsRemoved.size > 0;
+    const hasChanges = globalChanged || hasBlockletChanges;
 
-  async validateConfig() {
-    logger.info('router: validateConfig');
-    await this.provider.validateConfig();
-  }
+    if (!hasChanges) {
+      logger.debug('router: no pending changes to process');
+      return;
+    }
 
-  async rotateLogs() {
-    logger.info('router: rotate logs');
-    await this.provider.rotateLogs();
-  }
+    this._processingBatch = true;
 
-  getLogFilesForToday() {
-    return this.provider.getLogFilesForToday();
-  }
+    // Clear pending changes before processing
+    const blockletsToUpdate = [...blocklets];
+    const blockletsToRemove = [...blockletsRemoved];
+    this.pendingChanges = {
+      global: false,
+      blocklets: new Set(),
+      blockletsRemoved: new Set(),
+    };
 
-  getLogDir() {
-    return this.provider.getLogDir();
-  }
+    logger.info('router: processing batched changes', {
+      globalChanged,
+      blockletsToUpdate: blockletsToUpdate.length,
+      blockletsToRemove: blockletsToRemove.length,
+    });
 
-  searchCache(pattern, group) {
-    return this.provider.searchCache(pattern, group);
-  }
+    try {
+      let needsReload = false;
 
-  clearCache(group) {
-    return this.provider.clearCache(group);
-  }
+      // Get global params once (O(1)) - needed for both global and blocklet updates
+      let globalParams = null;
+      if (typeof this.getSystemRoutingParams === 'function') {
+        globalParams = await this._getUpdateParams('getSystemRoutingParams');
+      }
 
-  supportsModSecurity() {
-    return !!this.provider.capabilities?.modsecurity;
-  }
-}
+      // Case 1: Global changed with no blocklet changes - use lightweight global update
+      if (globalChanged) {
+        if (globalParams) {
+          // Use global params for system sites + services + policies
+          await this.provider.update({ ...globalParams, skipBlockletSites: true });
+          needsReload = true;
+          logger.info('router: batch processed global-only changes');
+        } else {
+          logger.error('router: global-only changes found, but globalParams is not available');
+        }
+      }
 
-Router.formatSites = (sites = []) => {
-  const result = cloneDeep(sites);
+      // Case 2: Process blocklet updates (O(1) per blocklet)
+      if (blockletsToUpdate.length > 0 && typeof this.getBlockletRoutingParams === 'function') {
+        // eslint-disable-next-line no-restricted-syntax
+        for (const did of blockletsToUpdate) {
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            const rawParams = await this.getBlockletRoutingParams(did);
+            if (rawParams && rawParams.sites && rawParams.sites.length > 0) {
+              const { sites, certificates, headers = {}, nodeInfo = {}, wafDisabledBlocklets = [] } = rawParams;
+              const blockletParams = {
+                routingTable: getRoutingTable({ sites, nodeInfo }),
+                certificates,
+                commonHeaders: headers,
+                nodeInfo: pick(nodeInfo, ['did', 'name', 'version', 'port', 'mode', 'enableWelcomePage', 'routing']),
+                wafDisabledBlocklets,
+              };
+
+              if (typeof this.provider.updateSingleBlocklet === 'function') {
+                // eslint-disable-next-line no-await-in-loop
+                await this.provider.updateSingleBlocklet(did, blockletParams);
+                logger.info('router: batch processed blocklet changes', { did });
+                needsReload = true;
+              }
+            }
+          } catch (error) {
+            logger.warn('router: failed to update blocklet in batch, skipping', { did, error: error.message });
+          }
+        }
+      }
+
+      // Case 4: Process blocklet removals
+      // eslint-disable-next-line no-restricted-syntax
+      for (const did of blockletsToRemove) {
+        if (typeof this.provider._removeBlockletConfig === 'function') {
+          // eslint-disable-next-line no-await-in-loop
+          await this.provider._removeBlockletConfig(did);
+          logger.info('router: batch processed blocklet removal', { did });
+          needsReload = true;
+        }
+      }
+
+      // Single reload for all changes
+      if (needsReload) {
+        const status = await this.provider.getStatus();
+        logger.info('router: batch needs reload', { status });
+        if (!status.running) {
+          await this.provider.start();
+        } else {
+          await this.provider.reload();
+        }
+      }
 
-  // Add extra routing rules to make blocklets adaptive
-  let daemonRule = null;
-  for (let i = 0; i < result.length; i++) {
-    daemonRule = result[i].rules.find((x) => x.to.type === ROUTING_RULE_TYPES.DAEMON);
-    if (daemonRule) {
-      break;
+      logger.info('router: batch processing complete', {
+        globalChanged,
+        blockletsUpdated: blockletsToUpdate.length,
+        blockletsRemoved: blockletsToRemove.length,
+      });
+    } catch (error) {
+      logger.error('router: batch processing failed', { error: error.message });
+      // Try full reload as fallback
+      try {
+        await this.reload();
+      } catch (reloadError) {
+        logger.error('router: fallback reload also failed', { error: reloadError.message });
+      }
+    } finally {
+      this._processingBatch = false;
     }
   }
-  if (!daemonRule) {
-    return result;
+
+  /**
+   * Full regeneration - O(N) complexity
+   * Use for startup, manual rebuild, or when complete regeneration is needed
+   * @param {Object} options
+   * @param {string} [options.message] - Log message describing the reason for regeneration
+   */
+  async regenerateAll({ message = '' } = {}) {
+    logger.info('router: full regeneration', { message });
+    const params = await this._getUpdateParams('getAllRoutingParams');
+    if (!params) {
+      logger.error('router: failed to get update params for full regeneration');
+      return;
+    }
+
+    await this.provider.update(params);
+    await this.provider.reload();
+    logger.info('router: full regeneration complete', { message });
   }
+}
+
+Router.formatSites = (sites = [], info) => {
+  const result = cloneDeep(sites);
 
   result.forEach((site) => {
     const rules = Array.isArray(site.rules) ? cloneDeep(site.rules) : [];
@@ -324,7 +501,7 @@ Router.formatSites = (sites = []) => {
         },
         to: {
           type: ROUTING_RULE_TYPES.DAEMON,
-          port: daemonRule.to.port,
+          port: info.port,
           did: site.blockletDid,
         },
       });
@@ -334,7 +511,7 @@ Router.formatSites = (sites = []) => {
       site.rules.push({
         dynamic: true,
         from: { root: true, pathPrefix: '/', groupPathPrefix: '/', pathSuffix: '/favicon.ico' },
-        to: { type: ROUTING_RULE_TYPES.SERVICE, port: process.env.ABT_NODE_SERVICE_PORT, did: site.blockletDid },
+        to: { type: ROUTING_RULE_TYPES.SERVICE, port: info.port, did: site.blockletDid },
       });
     }
 
@@ -362,7 +539,7 @@ Router.formatSites = (sites = []) => {
         },
         to: {
           type: ROUTING_RULE_TYPES.DAEMON,
-          port: daemonRule.to.port,
+          port: info.port,
           did: rule.to.did,
           componentId: rule.to.componentId,
           pageGroup: rule.to.pageGroup,
@@ -374,7 +551,6 @@ Router.formatSites = (sites = []) => {
     if (isBlockletSite(site.domain) && Object.keys(grouped).length === 0) {
       grouped['/'] = {
         id: '',
-        groupId: '',
         to: {
           did: site.blockletDid,
           componentId: site.blockletDid,
@@ -397,7 +573,7 @@ Router.formatSites = (sites = []) => {
           from: rootFrom,
           to: {
             type: ROUTING_RULE_TYPES.DAEMON,
-            port: daemonRule.to.port,
+            port: info.port,
             pageGroup: rule.to.pageGroup,
             did: rule.to.did,
           },
@@ -411,7 +587,7 @@ Router.formatSites = (sites = []) => {
             pathPrefix: BLOCKLET_PROXY_PATH_PREFIX,
           },
           to: {
-            port: daemonRule.to.port,
+            port: info.port,
             type: ROUTING_RULE_TYPES.DAEMON,
             target: BLOCKLET_PROXY_PATH_PREFIX,
             cacheGroup: !isServiceFeDevelopment && site.mode === BLOCKLET_MODES.PRODUCTION ? 'blockletProxy' : '',

package/lib/router/manager.js

@@ -23,12 +23,7 @@ const checkDomainMatch = require('@abtnode/util/lib/check-domain-match');
 const { isDidDomain, isCustomDomain } = require('@abtnode/util/lib/url-evaluation');
 const { isTopLevelDomain } = require('@abtnode/util/lib/domain');
 const { EVENTS, WELLKNOWN_PING_PREFIX } = require('@abtnode/constant');
-const {
-  DOMAIN_FOR_IP_SITE,
-  DOMAIN_FOR_DEFAULT_SITE,
-  ROUTING_RULE_TYPES,
-  DEFAULT_SERVICE_PATH,
-} = require('@abtnode/constant');
+const { DOMAIN_FOR_IP_SITE, DOMAIN_FOR_DEFAULT_SITE, ROUTING_RULE_TYPES } = require('@abtnode/constant');
 const {
   BLOCKLET_BUNDLE_FOLDER,
   BLOCKLET_DYNAMIC_PATH_PREFIX,
@@ -59,15 +54,7 @@ const {
 const checkDNS = require('../util/check-dns');
 
 const checkPathPrefixInBlackList = (pathPrefix, extraBlackList = []) => {
-  const blacklist = [
-    'static',
-    'build',
-    'dist',
-    'assets',
-    '.service',
-    BLOCKLET_BUNDLE_FOLDER,
-    DEFAULT_SERVICE_PATH,
-  ].concat(extraBlackList);
+  const blacklist = ['static', 'build', 'dist', 'assets', '.service', BLOCKLET_BUNDLE_FOLDER].concat(extraBlackList);
   const prefixBlacklist = ['_abtnode_'].concat(extraBlackList);
   if (blacklist.find((b) => normalizePathPrefix(pathPrefix) === normalizePathPrefix(b))) {
     throw new Error(`path prefix can't be one of these values: ${blacklist.join(', ')}`);
@@ -420,7 +407,7 @@ class RouterManager extends EventEmitter {
   }
 
   async addRoutingRule(
-    { id, rule: tempRule, skipCheckDynamicBlacklist = false, formatPathPrefix = true },
+    { id, rule: tempRule, skipCheckDynamicBlacklist = false, formatPathPrefix = true, skipValidation = false },
     context = {}
   ) {
     const { rule } = await validateAddRule({ id, rule: tempRule }, context);
@@ -458,7 +445,9 @@ class RouterManager extends EventEmitter {
     }
 
     await this.validatePathPrefix(rule);
-    await this.validateRouterConfig('addRoutingRule', { id, rule });
+    if (!skipValidation) {
+      await this.validateRouterConfig('addRoutingRule', { id, rule });
+    }
 
     // add child blocklet rules
     for (const x of await this.getRulesForMutation(rule)) {
@@ -482,7 +471,7 @@ class RouterManager extends EventEmitter {
   }
 
   async updateRoutingRule(
-    { id, rule: tmpRule, skipProtectedRuleChecking = false, formatPathPrefix = true },
+    { id, rule: tmpRule, skipProtectedRuleChecking = false, formatPathPrefix = true, skipValidation = false },
     context = {}
   ) {
     const { rule } = await validateEditRule({ id, rule: tmpRule }, context);
@@ -518,13 +507,12 @@ class RouterManager extends EventEmitter {
     }
 
     await this.validatePathPrefix(rule);
-    await this.validateRouterConfig('updateRoutingRule', { id, rule });
+    if (!skipValidation) {
+      await this.validateRouterConfig('updateRoutingRule', { id, rule });
+    }
 
     // update rules
-    const newRules = [
-      ...dbSite.rules.filter((x) => (x.groupId && x.groupId !== rule.id) || x.id !== rule.id), // 有些路由没有 rule.groupId
-      ...(await this.getRulesForMutation(rule)),
-    ];
+    const newRules = [...dbSite.rules.filter((x) => x.id !== rule.id), ...(await this.getRulesForMutation(rule))];
 
     const updateResult = await states.site.update({ id }, { $set: { rules: newRules } });
     logger.info('update result', { updateResult });
@@ -551,8 +539,8 @@ class RouterManager extends EventEmitter {
 
     // 只要有匹配到的查询条件，不管是否删除成功都不会返回 0，所以这里没用 update 的返回值
     const doc = await states.site.findOne({ id });
-    if (doc.rules.some((x) => x.id === ruleId || x.groupId === ruleId)) {
-      const newRules = doc.rules.filter((x) => x.id !== ruleId && x.groupId !== ruleId);
+    if (doc.rules.some((x) => x.id === ruleId)) {
+      const newRules = doc.rules.filter((x) => x.id !== ruleId);
       await states.site.update({ id }, { $set: { rules: newRules } });
     }
 
@@ -840,7 +828,7 @@ class RouterManager extends EventEmitter {
     });
     const tempRouter = new Router({
       provider,
-      getRoutingParams: async () => ({
+      getAllRoutingParams: async () => ({
         sites: await ensureLatestInfo([site]),
         certificates,
         commonHeaders: get(info, 'routing.headers', {}),
@@ -865,7 +853,6 @@ class RouterManager extends EventEmitter {
     if (!rule.id) {
       rule.id = uuid.v4();
     }
-    rule.groupId = rule.id;
     rule.from.pathPrefix = normalizePathPrefix(rule.from.pathPrefix);
     if (rule.to.type === ROUTING_RULE_TYPES.BLOCKLET) {
       // pathPrefix of root blocklet maybe changed to another prefix than '/', so use old groupPathPrefix first
@@ -937,7 +924,6 @@ class RouterManager extends EventEmitter {
       // if is root path, child rule become root rule
       const childRule = {
         id: occupied ? rawRule.id : uuid.v4(),
-        groupId: rawRule.id,
         from: {
           pathPrefix: normalizePathPrefix(pathPrefix),
           groupPathPrefix: blockletPrefix,