@okf/ootils 1.22.0 → 1.24.0

package/dist/node.mjs

@@ -956,6 +956,14 @@ var init_AIChat = __esm({
           default: "aiChat",
           index: true
         },
+        immutableActiveFilters: {
+          type: mongoose4.Schema.Types.Mixed,
+          default: void 0
+        },
+        immutableContentTypes: {
+          type: [String],
+          default: void 0
+        },
         messages: [
           {
             id: String,
@@ -2252,6 +2260,897 @@ var getRoutePathToModerateContent = ({
   return sm_link ? parseSpecialConfigSyntax({ config: sm_link, content: { contentType, contentId } }) : standard_link;
 };
 
+// src/UI_CONTENT.ts
+var UI_CONTENT = {
+  autoGenFilterConfigs: {
+    annoTagsTitle: "Annotation Tags",
+    tagsTitle: "Document Tags",
+    tagsFilterTitle: "Filters for"
+  }
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/generateFilterKey.ts
+var generateFilterKey = ({
+  filterType,
+  scope = "doc",
+  tagType,
+  valuePath,
+  rollupPath,
+  tagTypeCollectionToRollup,
+  valuePathInRolledUpCollection,
+  relationshipValuePath,
+  rollupResourceTypes
+} = { filterType: "" }) => {
+  if (!filterType) return void 0;
+  const normalizeSimple = (s) => typeof s === "string" ? s.trim().replace(/\s+/g, " ") : s;
+  const normalizePath = (p) => {
+    if (typeof p !== "string") return p;
+    const trimmed = p.trim();
+    return trimmed.replace(/\.+/g, ".").replace(/^\./, "").replace(/\.$/, "");
+  };
+  switch (filterType) {
+    case "tagType":
+      if (!tagType) return void 0;
+      return `tagType::${scope}::${normalizeSimple(tagType)}`;
+    case "valuePathType":
+    case "dateRangeType":
+    case "numberRangeType":
+      if (!valuePath) return void 0;
+      {
+        const vp = normalizePath(valuePath);
+        return `${filterType}::${vp}`;
+      }
+    case "nestedRollupTagType":
+      if (!Array.isArray(rollupPath) || rollupPath.length === 0) return void 0;
+      return `nestedRollupTagType::${rollupPath.join("::")}`;
+    case "rollupValuePathType":
+      if (!tagTypeCollectionToRollup || !valuePathInRolledUpCollection) return void 0;
+      return `rollupValuePathType::${normalizeSimple(tagTypeCollectionToRollup)}::${normalizePath(
+        valuePathInRolledUpCollection
+      )}`;
+    case "rollupRelationshipType": {
+      const normalizedTypes = Array.isArray(rollupResourceTypes) ? [...rollupResourceTypes].sort().join("|") : "";
+      if (!relationshipValuePath) return void 0;
+      return `rollupRelationshipType::${normalizePath(relationshipValuePath)}::${normalizedTypes}${tagType ? `::${normalizeSimple(tagType)}` : ""}`;
+    }
+    default:
+      return void 0;
+  }
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/buildFilterConfigurations.ts
+var getTplTitle = (contentType, allTpls) => {
+  const tpl = allTpls.find((t) => t.kp_content_type === contentType);
+  return tpl?.general?.content?.title;
+};
+var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup = false, isAnno = false }) => {
+  const createFilterSection = ({ group, type: type2, totalTpls, isRollup: isRollup2, allTpls: allTpls2 }) => {
+    const isCommon = group.contentTypes.length === totalTpls;
+    const baseTitle = type2 === "tags" ? UI_CONTENT.autoGenFilterConfigs.tagsFilterTitle : type2 === "annoTags" ? UI_CONTENT.autoGenFilterConfigs.annoTagsTitle : "";
+    return {
+      id: `group_${group.contentTypes.join("_")}_${type2}`,
+      filterScope: type2,
+      title: isCommon ? `Common ${isRollup2 ? "Rollup " : ""}${baseTitle}` : `${isRollup2 ? "Rollup " : ""}${baseTitle}`,
+      subtitle: `${group.contentTypes.map((c) => {
+        let thisTpl = allTpls2.find((tpl) => tpl.kp_content_type === c);
+        return thisTpl?.general?.content?.title || thisTpl?.kp_content_type || "";
+      }).join(", ")}`,
+      contentTypesCount: group.contentTypes.length,
+      elements: group.elements
+    };
+  };
+  const buildFilterConfig = (element, section) => {
+    const allProfileTpls = allTpls.filter((d) => d.category === "userProfiles");
+    switch (element.filterType) {
+      case "split_valuePathType":
+        return element.block.props.subQuestionLabels.map((subQuestion) => {
+          const targetValuePath = element.block.valuePath + "." + subQuestion.value;
+          const display = element.display + " - " + subQuestion.display;
+          const filterKey = generateFilterKey({
+            filterType: "valuePathType",
+            valuePath: targetValuePath,
+            scope: section.filterScope
+          });
+          return {
+            filterId: `valuePathFilter_${element.contentType}_${targetValuePath.replaceAll(".", "_DOT_")}`,
+            display,
+            value: targetValuePath,
+            filterKey,
+            contentType: element.contentType,
+            path: element.valuePath,
+            source: {
+              filterType: "tplType",
+              contentType: element.contentType,
+              valuePath: element.valuePath,
+              scope: "tags"
+            },
+            target: {
+              filterType: "valuePathType",
+              valuePath: element.saveValueAsString ? targetValuePath : `${targetValuePath}.value`
+            }
+          };
+        });
+      case "valuePathType": {
+        const valuePathFilterKey = generateFilterKey({
+          filterType: "valuePathType",
+          valuePath: element.valuePath,
+          scope: section.filterScope
+        });
+        return {
+          filterId: `valuePathFilter_${element.contentType}_${element.valuePath.replaceAll(".", "_DOT_")}`,
+          display: element.display,
+          value: element.value || element.contentType || element.valuePath,
+          filterKey: valuePathFilterKey,
+          contentType: element.contentType,
+          path: element.valuePath,
+          source: {
+            filterType: "tplType",
+            contentType: element.contentType,
+            valuePath: element.valuePath,
+            scope: "tags"
+          },
+          target: {
+            filterType: "valuePathType",
+            valuePath: element.saveValueAsString ? element.valuePath : `${element.valuePath}.value`
+          }
+        };
+      }
+      case "dateRangeType": {
+        const dateFilterKey = generateFilterKey({
+          filterType: "dateRangeType",
+          valuePath: element.valuePath,
+          scope: section.filterScope
+        });
+        return {
+          filterId: `dateFilter_${element.contentType}_${element.valuePath.replaceAll(".", "_DOT_")}`,
+          display: element.display,
+          value: element.valuePath,
+          filterKey: dateFilterKey,
+          contentType: element.contentType,
+          path: element.valuePath,
+          source: { filterType: "dateRangeType" },
+          target: { filterType: "dateRangeType", valuePath: element.valuePath }
+        };
+      }
+      case "numberRangeType": {
+        const numberFilterKey = generateFilterKey({
+          filterType: "numberRangeType",
+          valuePath: element.valuePath,
+          scope: section.filterScope
+        });
+        return {
+          filterId: `numberFilter_${element.contentType}_${element.valuePath.replaceAll(".", "_DOT_")}`,
+          display: element.display,
+          value: element.valuePath,
+          filterKey: numberFilterKey,
+          contentType: element.contentType,
+          path: element.valuePath,
+          source: { filterType: "numberRangeType", valuePath: element.valuePath },
+          target: { filterType: "numberRangeType", valuePath: element.valuePath }
+        };
+      }
+      case "nestedRollupTagType": {
+        const lastItemInPath = element.rollupPath[element.rollupPath.length - 1];
+        const isTerminalValuePath = lastItemInPath.startsWith("main.");
+        const getDisplay = (rollupPath) => {
+          if (isTerminalValuePath) {
+            return element.filterDisplay || lastItemInPath;
+          }
+          const lastTag = rollupPath[rollupPath.length - 1];
+          const lastTagTpl = allTpls.find(
+            (tpl) => tpl.kp_content_type === lastTag
+          );
+          return lastTagTpl?.general?.content?.title || lastTagTpl?.kp_content_type;
+        };
+        const getTooltip = (rollupPath) => {
+          const displays = [...rollupPath].reverse().map((item, index) => {
+            if (index === 0 && isTerminalValuePath) {
+              return element.filterDisplay || item;
+            }
+            const tpl = allTpls.find((tpl2) => tpl2.kp_content_type === item);
+            return tpl?.general?.content?.title || tpl?.kp_content_type;
+          });
+          return `Indirect filter: ${displays.join(" > ")}`;
+        };
+        const lastTagInPath = element.rollupPath[element.rollupPath.length - 1];
+        const isLastTagProfile = !isTerminalValuePath && allProfileTpls.some(
+          (tpl) => tpl.kp_content_type === lastTagInPath
+        );
+        const getSourceConfig = () => {
+          if (isTerminalValuePath) {
+            const parentTagType = element.rollupPath[element.rollupPath.length - 2];
+            const sourceValuePath = lastItemInPath.endsWith(".value") ? lastItemInPath.slice(0, -6) : lastItemInPath;
+            return {
+              filterType: "tplType",
+              contentType: parentTagType,
+              valuePath: sourceValuePath,
+              scope: section.filterScope
+            };
+          }
+          if (isLastTagProfile) {
+            return {
+              filterType: "usersType",
+              profileTypes: [lastTagInPath],
+              scope: section.filterScope
+            };
+          }
+          return {
+            filterType: "tagType",
+            tagType: lastTagInPath,
+            scope: section.filterScope
+          };
+        };
+        return {
+          filterId: `ROLLUP_${section.filterScope}_${element.rollupPath.join(
+            "_"
+          )}`,
+          display: getDisplay(element.rollupPath),
+          value: element.rollupPath,
+          tooltip: getTooltip(element.rollupPath),
+          filterKey: generateFilterKey({
+            filterType: "nestedRollupTagType",
+            rollupPath: element.rollupPath,
+            scope: section.filterScope
+          }),
+          contentType: element.rollupPath[0],
+          path: `tags.${element.rollupPath[1]}`,
+          source: getSourceConfig(),
+          target: {
+            filterType: "nestedRollupTagType",
+            rollupPath: element.rollupPath,
+            ...isAnno && { isAnno: true }
+          }
+        };
+      }
+      case "rollupValuePathType": {
+        const rollupFilterKey = generateFilterKey({
+          filterType: "rollupValuePathType",
+          tagTypeCollectionToRollup: element.tagTypeCollectionToRollup,
+          valuePathInRolledUpCollection: element.valuePathInRolledUpCollection,
+          scope: section.filterScope
+        });
+        return {
+          filterId: `${section.filterScope}_${element.tagTypeCollectionToRollup}_${element.valuePathInRolledUpCollection.replaceAll(".", "_DOT_")}`,
+          display: element.filterDisplay,
+          value: element.filterDisplay,
+          filterKey: rollupFilterKey,
+          tooltip: `Indirect filter: ${element.filterDisplay} > ${getTplTitle(element.tagTypeCollectionToRollup, allTpls) || element.tagTypeCollectionToRollup}`,
+          contentType: element.tagTypeCollectionToRollup,
+          path: element.filterSourceValuePath,
+          source: {
+            filterType: "tplType",
+            contentType: element.tagTypeCollectionToRollup,
+            valuePath: element.filterSourceValuePath,
+            scope: section.filterScope
+          },
+          target: {
+            filterType: "rollupValuePathType",
+            tagTypeCollectionToRollup: element.tagTypeCollectionToRollup,
+            valuePathInRolledUpCollection: element.valuePathInRolledUpCollection,
+            ...isAnno && { isAnno: true }
+          }
+        };
+      }
+      case "tagType":
+      default: {
+        const tagFilterKey = generateFilterKey({
+          filterType: "tagType",
+          tagType: element.tagType,
+          scope: section.filterScope
+        });
+        return {
+          filterId: isAnno ? `annoTags_${element.tagType}` : `tags_${element.tagType}`,
+          display: allTpls.find((t) => t.kp_content_type === element.tagType)?.general?.content?.title || element.tagType,
+          value: element.tagType,
+          filterKey: tagFilterKey,
+          contentType: element.tagType,
+          path: `tags.${element.tagType}`,
+          source: allProfileTpls.some(
+            (tpl) => tpl.kp_content_type === element.tagType
+          ) ? {
+            filterType: "usersType",
+            profileTypes: [element.tagType],
+            scope: isAnno ? "annoTags" : "tags"
+          } : {
+            filterType: "tagType",
+            tagType: element.tagType,
+            scope: isAnno ? "annoTags" : "tags"
+          },
+          target: {
+            filterType: "tagType",
+            tagType: element.tagType,
+            ...isAnno && { isAnno: true }
+          }
+        };
+      }
+    }
+  };
+  return groups.sort((a, b) => b.contentTypes.length - a.contentTypes.length).map((group) => {
+    const section = createFilterSection({ group, type, totalTpls: selectedTpls.length, isRollup, allTpls });
+    return {
+      sectionId: section.id,
+      sectionTitle: section.title,
+      sectionSubtitle: section.subtitle,
+      configs: section.elements.map((element) => {
+        const config = buildFilterConfig(element, section);
+        return config;
+      }).reduce(
+        (acc, next) => [...acc, ...Array.isArray(next) ? next : [next]],
+        []
+      )
+    };
+  });
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/compareAndGroupBlocks.ts
+var compareAndGroupBlocks = (blocksPerTpl) => {
+  if (!blocksPerTpl || blocksPerTpl.length === 0) return [];
+  if (blocksPerTpl.length === 1) {
+    return [{
+      contentTypes: [blocksPerTpl[0].contentType],
+      elements: blocksPerTpl[0].blocks || []
+    }];
+  }
+  const getFilterElementKey = (element) => {
+    switch (element.filterType) {
+      case "tagType":
+        return `tagType:${element.tagType}`;
+      case "valuePathType":
+        return `valuePathType:${element.valuePath}`;
+      case "dateRangeType":
+        return `dateRangeType:${element.valuePath}`;
+      case "nestedRollupTagType":
+        return `nestedRollupTagType:${JSON.stringify(element.rollupPath)}`;
+      case "rollupValuePathType":
+        return `rollupValuePathType:${element.tagTypeCollectionToRollup}:${element.valuePathInRolledUpCollection}`;
+      default:
+        return JSON.stringify(element);
+    }
+  };
+  const filterToTemplates = /* @__PURE__ */ new Map();
+  blocksPerTpl.forEach((template) => {
+    const blocks = template.blocks || [];
+    blocks.forEach((block) => {
+      const filterKey = getFilterElementKey(block);
+      if (!filterToTemplates.has(filterKey)) {
+        filterToTemplates.set(filterKey, {
+          element: block,
+          contentTypes: /* @__PURE__ */ new Set()
+        });
+      }
+      filterToTemplates.get(filterKey).contentTypes.add(template.contentType);
+    });
+  });
+  const templateGroupToFilters = /* @__PURE__ */ new Map();
+  for (const [filterKey, data] of filterToTemplates) {
+    const templatesKey = Array.from(data.contentTypes).sort().join("|");
+    if (!templateGroupToFilters.has(templatesKey)) {
+      templateGroupToFilters.set(templatesKey, {
+        contentTypes: Array.from(data.contentTypes).sort(),
+        elements: []
+      });
+    }
+    templateGroupToFilters.get(templatesKey).elements.push(data.element);
+  }
+  return Array.from(templateGroupToFilters.values());
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/extractAndOrganizeBlocks.ts
+var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
+  const extractedBlocks = {};
+  const templateBlocksCache = /* @__PURE__ */ new Map();
+  const getCachedBlocks = (tpl) => {
+    if (!templateBlocksCache.has(tpl.kp_content_type)) {
+      templateBlocksCache.set(tpl.kp_content_type, extractAllBlocksFromTpl({ tpl }));
+    }
+    return templateBlocksCache.get(tpl.kp_content_type);
+  };
+  extractedBlocks.annoTagBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    const allTagTypes = allBlocks.filter((block) => block.props?.annotation?.enable).flatMap((block) => block.props.annotation.tagTypesConfig?.map((d) => d.tagType) || []);
+    const uniqueTagTypes = [...new Set(allTagTypes)];
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: uniqueTagTypes.map((tagType) => ({
+        tagType,
+        filterType: "tagType"
+      }))
+    };
+  });
+  extractedBlocks.annoEnabledBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => block.props?.annotation?.enable)
+    };
+  });
+  extractedBlocks.annoRollupBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    const uniqueTagTypes = Array.from(new Set(
+      allBlocks.filter((block) => block.props?.annotation?.enable).flatMap((block) => block.props.annotation.tagTypesConfig || []).map((conf) => conf.tagType)
+    ));
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: uniqueTagTypes.flatMap((tagType) => {
+        const possibilities = getRollupPossibilities({ tagType, allTpls });
+        return possibilities.map((p) => ({
+          ...p,
+          filterType: p.rollupPath ? "nestedRollupTagType" : "rollupValuePathType"
+        }));
+      })
+    };
+  });
+  extractedBlocks.docTagBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => block.valuePath.startsWith("tags.")).map((block) => ({
+        tagType: block.props.tagType,
+        filterType: "tagType"
+      }))
+    };
+  });
+  extractedBlocks.docRollupBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => block.valuePath.startsWith("tags.") && ["TagsInputSingle", "TagsInputMulti"].includes(block.comp)).flatMap((block) => {
+        const possibilities = getRollupPossibilities({ tagType: block.props.tagType, allTpls });
+        return possibilities.map((p) => ({
+          ...p,
+          filterType: p.rollupPath ? "nestedRollupTagType" : "rollupValuePathType"
+        }));
+      })
+    };
+  });
+  extractedBlocks.valuePathBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => ["DropdownSingle", "DropdownMulti", "RadioList", "CheckboxList"].includes(block.comp)).map((block) => ({
+        valuePath: block.valuePath,
+        display: block.props?.shortLabel || block.props?.label || block.valuePath,
+        value: block.valuePath,
+        saveValueAsString: block.props?.saveValueAsString,
+        contentType: tpl.kp_content_type,
+        filterType: "valuePathType"
+      }))
+    };
+  });
+  extractedBlocks.groupQuestionsBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => ["GroupQuestionsInputSingle"].includes(block.comp)).map((block) => ({
+        valuePath: block.valuePath,
+        display: block.props?.shortLabel || block.props?.label || block.valuePath,
+        value: block.valuePath,
+        saveValueAsString: block.props?.saveValueAsString,
+        contentType: tpl.kp_content_type,
+        block,
+        filterType: "split_valuePathType"
+      }))
+    };
+  });
+  extractedBlocks.dateBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => ["DatePicker", "DateRangePicker", "DateTimePicker", "DateTimeRangePicker"].includes(block.comp)).map((block) => ({
+        valuePath: block.valuePath,
+        display: block.props?.shortLabel || block.props?.label || block.valuePath,
+        value: block.valuePath,
+        contentType: tpl.kp_content_type,
+        filterType: "dateRangeType"
+      }))
+    };
+  });
+  extractedBlocks.numberBlocks = selectedTpls.map((tpl) => {
+    const allBlocks = getCachedBlocks(tpl);
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: allBlocks.filter((block) => block.comp === "NumberInput").map((block) => ({
+        valuePath: block.valuePath,
+        display: block.props?.shortLabel || block.props?.label || block.valuePath,
+        value: block.valuePath,
+        contentType: tpl.kp_content_type,
+        filterType: "numberRangeType"
+      }))
+    };
+  });
+  extractedBlocks.combinedDocumentBlocks = selectedTpls.map((tpl) => {
+    const docTagBlocks = extractedBlocks.docTagBlocks.find((t) => t.contentType === tpl.kp_content_type)?.blocks || [];
+    const valuePathBlocks = extractedBlocks.valuePathBlocks.find((t) => t.contentType === tpl.kp_content_type)?.blocks || [];
+    const groupQuestionsBlocks = extractedBlocks.groupQuestionsBlocks.find((t) => t.contentType === tpl.kp_content_type)?.blocks || [];
+    const dateBlocks = extractedBlocks.dateBlocks.find((t) => t.contentType === tpl.kp_content_type)?.blocks || [];
+    const numberBlocks = extractedBlocks.numberBlocks.find((t) => t.contentType === tpl.kp_content_type)?.blocks || [];
+    const rollupBlocks = extractedBlocks.docRollupBlocks.find((t) => t.contentType === tpl.kp_content_type)?.blocks || [];
+    return {
+      contentType: tpl.kp_content_type,
+      blocks: [...docTagBlocks, ...valuePathBlocks, ...groupQuestionsBlocks, ...dateBlocks, ...numberBlocks, ...rollupBlocks]
+    };
+  });
+  return extractedBlocks;
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/processAuthorAndCommonFilters.ts
+var processAuthorAndCommonFilters = (allTpls, filterScopes, annoEnabledBlocks = []) => {
+  const allProfileTpls = allTpls.filter((d) => d.category === "userProfiles");
+  const authorTagGroups = allProfileTpls.flatMap((tpl) => {
+    const blocks = tpl.kp_templates.myProfileConfig.reduce((acc, config) => [...acc, ...config.blocks], []).filter((block) => !!block.props?.tagType).map((block) => ({
+      ...block,
+      tplContentType: tpl.kp_content_type
+    }));
+    return blocks;
+  }).reduce((acc, block) => {
+    const existing = acc.find((b) => b.props.tagType === block.props.tagType);
+    if (existing) {
+      existing.tplContentTypes = [...existing.tplContentTypes, block.tplContentType];
+    } else {
+      acc.push({
+        ...block,
+        tplContentTypes: [block.tplContentType]
+      });
+    }
+    return acc;
+  }, []);
+  const authorTagConfigs = authorTagGroups.map((block) => ({
+    filterId: `authorTagFilter_${block.props.tagType}`,
+    blockId: `authorTagFilter_${block.props.tagType}`,
+    display: `Author Tag: ${block.props.tagType}`,
+    value: block.tplContentTypes,
+    filterKey: generateFilterKey({
+      filterType: "rollupRelationshipType",
+      relationshipValuePath: "meta.kp_contributed_by",
+      rollupResourceTypes: block.tplContentTypes,
+      tagType: block.props.tagType,
+      scope: "doc"
+    }),
+    source: {
+      filterType: "tagType",
+      tagType: block.props.tagType,
+      scope: "tags"
+    },
+    target: {
+      filterType: "rollupRelationshipType",
+      tagType: block.props.tagType,
+      rollupResourceTypes: block.tplContentTypes,
+      relationshipValuePath: "meta.kp_contributed_by"
+    }
+  }));
+  const commonAnnotationFilters = filterScopes.includes("anno") ? [{
+    sectionId: "commonAnnotationFilters",
+    sectionTitle: "Common Annotation Filters",
+    configs: [
+      {
+        filterId: "annoAuthorFilter",
+        blockId: "annoAuthorFilter",
+        display: "Annotation Author",
+        value: "annotation_author",
+        filterKey: generateFilterKey({
+          filterType: "valuePathType",
+          valuePath: "annotations.author.id",
+          scope: "anno"
+        }),
+        source: {
+          filterType: "usersType",
+          profileTypes: allProfileTpls.map((tpl) => tpl.kp_content_type)
+        },
+        target: {
+          filterType: "valuePathType",
+          valuePath: `annotations.author.id`
+        }
+      },
+      ...annoEnabledBlocks.length > 0 ? [{
+        filterId: "annoEnabledBlockValuePathFilter",
+        blockId: "annoEnabledBlockValuePathFilter",
+        display: "Document Field",
+        value: "annotation_value_path",
+        filterKey: generateFilterKey({
+          filterType: "valuePathType",
+          valuePath: "meta.valuePath",
+          scope: "anno"
+        }),
+        source: {
+          filterType: "staticType",
+          options: annoEnabledBlocks.map((block) => ({
+            display: block.props?.shortLabel || block.props?.label || block.valuePath,
+            value: block.valuePath
+          }))
+        },
+        target: {
+          filterType: "valuePathType",
+          valuePath: `meta.valuePath`
+        }
+      }] : []
+    ]
+  }] : [];
+  const commonDocumentFilters = filterScopes.includes("doc") ? [{
+    sectionId: "commonDocumentFilters",
+    sectionTitle: "Common Document Filters",
+    configs: [
+      {
+        filterId: "authorFilter",
+        blockId: "authorFilter",
+        display: "Author",
+        value: "author",
+        filterKey: generateFilterKey({
+          filterType: "valuePathType",
+          valuePath: "meta.kp_contributed_by",
+          scope: "doc"
+        }),
+        source: {
+          filterType: "authorsType",
+          profileTypes: allProfileTpls.map((tpl) => tpl.kp_content_type),
+          scope: "tags"
+        },
+        target: {
+          filterType: "valuePathType",
+          valuePath: `meta.kp_contributed_by`
+        }
+      },
+      ...authorTagConfigs,
+      {
+        filterId: "publishedDateFilter",
+        blockId: "publishedDateFilter",
+        display: "Published Date",
+        value: "published_date",
+        filterKey: generateFilterKey({
+          filterType: "dateRangeType",
+          valuePath: "kp_date_published",
+          scope: "doc"
+        }),
+        source: {
+          filterType: "dateRangeType"
+        },
+        target: {
+          filterType: "dateRangeType",
+          valuePath: "kp_date_published"
+        }
+      }
+    ]
+  }] : [];
+  return { authorTagConfigs, commonAnnotationFilters, commonDocumentFilters };
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/_self_managed_getFixedAnnoTagBlock.ts
+var _self_managed_getFixedAnnoTagBlock = (selectedTpls, annotationTagsCount) => {
+  if (!annotationTagsCount?.tags || annotationTagsCount.tags === 0) {
+    return [];
+  }
+  const selfManagedTagBlocks = selectedTpls.map((tpl) => ({
+    contentType: tpl.kp_content_type,
+    blocks: [
+      {
+        tagType: "tags",
+        filterType: "tagType"
+      }
+    ]
+  }));
+  return compareAndGroupBlocks(selfManagedTagBlocks);
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/_self_managed_getFixedAnnoRollupBlocks.ts
+var _self_managed_getFixedAnnoRollupBlocks = ({ selectedTpls, allTpls, annotationTagsCount }) => {
+  const rollupBlocks = [];
+  if (annotationTagsCount?.subThemes > 0 && annotationTagsCount?.themes > 0) {
+    rollupBlocks.push({
+      rollupType: "tagType",
+      rollupPath: ["tags", "subThemes", "themes"],
+      filterType: "nestedRollupTagType"
+    });
+  }
+  if (annotationTagsCount?.subThemes > 0) {
+    rollupBlocks.push({
+      rollupType: "tagType",
+      rollupPath: ["tags", "subThemes"],
+      filterType: "nestedRollupTagType"
+    });
+  }
+  if (rollupBlocks.length === 0) {
+    return [];
+  }
+  const selfManagedRollupBlocks = selectedTpls.map((tpl) => ({
+    contentType: tpl.kp_content_type,
+    blocks: rollupBlocks
+  }));
+  return compareAndGroupBlocks(selfManagedRollupBlocks);
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/_self_managed_buildAnnoHierarchyConfig.ts
+var FILTER_IDS = {
+  themes: "anno_themes",
+  subThemes: "anno_subThemes",
+  tags: "anno_tags"
+};
+var _self_managed_buildAnnoHierarchyConfig = ({
+  annotationTagsCount
+}) => {
+  const hasThemes = annotationTagsCount?.themes > 0;
+  const hasSubThemes = annotationTagsCount?.subThemes > 0;
+  const hasTags = annotationTagsCount?.tags > 0;
+  if (!hasThemes && !hasSubThemes && !hasTags) {
+    return null;
+  }
+  const hierarchyLevels = [
+    hasThemes && { level: "themes", filterId: FILTER_IDS.themes, tagType: "themes" },
+    hasSubThemes && { level: "subThemes", filterId: FILTER_IDS.subThemes, tagType: "subThemes" },
+    hasTags && { level: "tags", filterId: FILTER_IDS.tags, tagType: "tags" }
+  ].filter(Boolean);
+  return {
+    target: { filterType: "annoHierarchyType" },
+    filterId: "annoHierarchy_annotation_filters",
+    display: "Annotation Filters",
+    filterKey: "annoHierarchyType::anno",
+    source: {
+      filterType: "annoHierarchyType",
+      annotationTagsCount: {
+        themes: hasThemes,
+        subThemes: hasSubThemes,
+        tags: hasTags
+      },
+      levelLabels: {
+        themes: "Themes",
+        subThemes: "Independent Sub-Themes",
+        tags: "Independent Tags"
+      },
+      folderSelectionMode: "inclusive",
+      hierarchyLevels
+    }
+  };
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/TEMP_removeDuplicateFilters.ts
+var TEMP_removeDuplicateFilters = (filterGroups) => {
+  return filterGroups.map((group) => {
+    if (!group.elements || !Array.isArray(group.elements)) {
+      return group;
+    }
+    const seenFilters = /* @__PURE__ */ new Set();
+    const deduplicatedElements = [];
+    group.elements.forEach((element) => {
+      let uniqueKey;
+      if (element.filterType === "nestedRollupTagType" && element.rollupPath && Array.isArray(element.rollupPath)) {
+        const finalTarget = element.rollupPath[element.rollupPath.length - 1];
+        const firstContentType = group.contentTypes?.[0] || "unknown";
+        uniqueKey = `rollup_${firstContentType}_${finalTarget}`;
+      } else if (element.filterType === "tagType") {
+        const tagType = element.tagType || "unknown";
+        uniqueKey = `tag_${tagType}`;
+      } else {
+        deduplicatedElements.push(element);
+        return;
+      }
+      if (!seenFilters.has(uniqueKey)) {
+        seenFilters.add(uniqueKey);
+        deduplicatedElements.push(element);
+      }
+    });
+    return {
+      ...group,
+      elements: deduplicatedElements
+    };
+  });
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/getFilterKeyForBlock.ts
+var TAG_INPUT_COMPONENTS = ["TagsInputSingle", "TagsInputMulti"];
+var DATE_INPUT_COMPONENTS = ["DatePicker", "DateRangePicker", "DateTimePicker", "DateTimeRangePicker"];
+var NUMBER_INPUT_COMPONENTS = ["NumberInput"];
+var getFilterKeyForBlock = ({ block, scope = "tags" } = {}) => {
+  if (!block) return void 0;
+  const valuePath = block.valuePath;
+  const comp = block.comp;
+  const props = block.props || {};
+  const isTagBlock = typeof valuePath === "string" && valuePath.startsWith("tags.") || TAG_INPUT_COMPONENTS.includes(comp) || !!props.tagType;
+  if (isTagBlock) {
+    const tagType = props.tagType || (typeof valuePath === "string" ? valuePath.split(".")[1] : void 0);
+    if (!tagType) return void 0;
+    return generateFilterKey({
+      filterType: "tagType",
+      tagType,
+      scope
+    });
+  }
+  if (DATE_INPUT_COMPONENTS.includes(comp)) {
+    return generateFilterKey({ filterType: "dateRangeType", valuePath, scope });
+  }
+  if (NUMBER_INPUT_COMPONENTS.includes(comp)) {
+    return generateFilterKey({ filterType: "numberRangeType", valuePath, scope });
+  }
+  if (valuePath) {
+    return generateFilterKey({ filterType: "valuePathType", valuePath, scope });
+  }
+  return void 0;
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/index.ts
+var autoGenFilterConfigsFromTpl = ({
+  selectedTpls,
+  allTpls,
+  filterScopes,
+  isSelfManagedTenant = false,
+  annotationTagsCount
+}) => {
+  const extractedBlocks = extractAndOrganizeBlocks(selectedTpls, allTpls);
+  const allAnnoEnabledBlocks = filterScopes.includes("anno") ? extractedBlocks.annoEnabledBlocks.flatMap((item) => item.blocks).reduce((acc, block) => {
+    if (!acc.find((b) => b.valuePath === block.valuePath)) {
+      acc.push(block);
+    }
+    return acc;
+  }, []) : [];
+  const { authorTagConfigs, commonAnnotationFilters, commonDocumentFilters } = processAuthorAndCommonFilters(allTpls, filterScopes, allAnnoEnabledBlocks);
+  const annoTagGroups = filterScopes.includes("anno") ? isSelfManagedTenant ? _self_managed_getFixedAnnoTagBlock(selectedTpls, annotationTagsCount) : compareAndGroupBlocks(extractedBlocks.annoTagBlocks) : [];
+  let annoRollupGroups = filterScopes.includes("anno") ? isSelfManagedTenant ? _self_managed_getFixedAnnoRollupBlocks({ selectedTpls, allTpls, annotationTagsCount }) : compareAndGroupBlocks(extractedBlocks.annoRollupBlocks) : [];
+  const TEMP_deduplicatedAnnoTagGroups = TEMP_removeDuplicateFilters(annoTagGroups);
+  const TEMP_deduplicatedAnnoRollupGroups = TEMP_removeDuplicateFilters(annoRollupGroups);
+  const combinedDocumentGroups = filterScopes.includes("doc") ? compareAndGroupBlocks(extractedBlocks.combinedDocumentBlocks) : [];
+  const TEMP_deduplicatedCombinedDocumentGroups = TEMP_removeDuplicateFilters(combinedDocumentGroups);
+  const annotationTagSections = buildFilterConfigurations({
+    groups: TEMP_deduplicatedAnnoTagGroups,
+    type: "annoTags",
+    selectedTpls,
+    allTpls,
+    isRollup: false,
+    isAnno: true
+  });
+  const annotationRollupSections = buildFilterConfigurations({
+    groups: TEMP_deduplicatedAnnoRollupGroups,
+    type: "annoTags",
+    selectedTpls,
+    allTpls,
+    isRollup: true,
+    isAnno: true
+  });
+  const documentTagSections = buildFilterConfigurations({
+    groups: TEMP_deduplicatedCombinedDocumentGroups,
+    type: "tags",
+    selectedTpls,
+    allTpls,
+    isRollup: false,
+    isAnno: false
+  });
+  const final_annotationTagsFilterConfigs = {
+    sectionId: "annotationTagsSection",
+    sectionTitle: "Annotation Filters",
+    configs: isSelfManagedTenant ? [
+      {
+        sectionId: "self_managed_consolidated_anno_filters",
+        configs: (() => {
+          const annoHierarchyConfig = _self_managed_buildAnnoHierarchyConfig({
+            annotationTagsCount
+          });
+          const annoConfigs = annoHierarchyConfig ? [annoHierarchyConfig] : [
+            ...annotationRollupSections.flatMap((conf) => conf.configs),
+            ...annotationTagSections.flatMap((conf) => conf.configs)
+          ];
+          return [
+            ...annoConfigs,
+            ...commonAnnotationFilters.flatMap((conf) => conf.configs)
+          ];
+        })()
+      }
+    ] : [
+      ...commonAnnotationFilters,
+      ...annotationTagSections,
+      ...annotationRollupSections
+    ].filter((section) => Array.isArray(section.configs) ? section.configs.length > 0 : true)
+  };
+  const final_documentTagsFilterConfigs = {
+    sectionId: "documentTagsSection",
+    sectionTitle: "Document Filters",
+    configs: [
+      ...commonDocumentFilters,
+      ...documentTagSections
+    ].filter((section) => Array.isArray(section.configs) ? section.configs.length > 0 : true)
+  };
+  const result = [
+    final_annotationTagsFilterConfigs.configs.length > 0 ? final_annotationTagsFilterConfigs : null,
+    final_documentTagsFilterConfigs.configs.length > 0 ? final_documentTagsFilterConfigs : null
+  ].filter(Boolean);
+  return result;
+};
+
 // src/node.ts
 var import_MongoConnector3 = __toESM(require_MongoConnector());
 var import_ElasticSearchConnector = __toESM(require_ElasticSearchConnector());
@@ -2583,6 +3482,53 @@ var RedisCacheConnector = class _RedisCacheConnector {
 };
 RedisCacheConnector.instance = null;
 
+// src/SecretManagerConnector/index.js
+import { SecretManagerServiceClient } from "@google-cloud/secret-manager";
+import path from "path";
+var PROJECT_ID = "ok-framework";
+var SecretManagerConnector = class _SecretManagerConnector {
+  constructor({ secrets = [] } = {}) {
+    if (_SecretManagerConnector.instance) {
+      throw new Error(
+        "SecretManagerConnector instance already exists. Use SecretManagerConnector.getInstance() instead."
+      );
+    }
+    this.client = new SecretManagerServiceClient();
+    this.secrets = secrets;
+    this.cache = {};
+    _SecretManagerConnector.instance = this;
+  }
+  async connect() {
+    for (const { name, fallbackPath } of this.secrets) {
+      try {
+        const secretPath = `projects/${PROJECT_ID}/secrets/${name}/versions/latest`;
+        const [version] = await this.client.accessSecretVersion({ name: secretPath });
+        this.cache[name] = JSON.parse(version.payload.data.toString("utf8"));
+        console.log(`  Secret Manager: loaded "${name}"`);
+      } catch (err) {
+        if (fallbackPath) {
+          const fullPath = path.resolve(process.cwd(), fallbackPath);
+          const module = await import(fullPath);
+          this.cache[name] = module.default || module;
+          console.log(`  Secret Manager: "${name}" fallback to local file - ${err.message}`);
+        } else {
+          throw new Error(`Secret Manager: failed to load "${name}" - ${err.message}`);
+        }
+      }
+    }
+  }
+  static getSecret(secretName) {
+    return _SecretManagerConnector.instance.cache[secretName];
+  }
+  static getGlobalConfigs() {
+    return _SecretManagerConnector.getSecret("globalConfigs");
+  }
+  static getInstance() {
+    return _SecretManagerConnector.instance;
+  }
+};
+SecretManagerConnector.instance = null;
+
 // src/node.ts
 init_getDbByTenant();
 var import_getModelByTenant2 = __toESM(require_getModelByTenant());
@@ -2618,20 +3564,33 @@ export {
   export_BaseWorker as BaseWorker,
   export_ChunksElasticSyncProducer as ChunksElasticSyncProducer,
   export_ElasticSearchConnector as ElasticSearchConnector,
+  FILTER_IDS,
   export_GET_GLOBAL_BULLMQ_CONFIG as GET_GLOBAL_BULLMQ_CONFIG,
   GeneratedTopics_default as GeneratedTopicsSchema,
   export_MongoConnector as MongoConnector,
   PlatformConfigs_default as PlatformConfigsSchema,
   export_ProducerManager as ProducerManager,
   RedisCacheConnector,
+  SecretManagerConnector,
+  TEMP_removeDuplicateFilters,
   Tpl_default as TplSchema,
+  UI_CONTENT,
   export_WorkerManager as WorkerManager,
+  _self_managed_buildAnnoHierarchyConfig,
+  _self_managed_getFixedAnnoRollupBlocks,
+  _self_managed_getFixedAnnoTagBlock,
+  autoGenFilterConfigsFromTpl,
+  buildFilterConfigurations,
+  compareAndGroupBlocks,
   deleteVal,
   extractAllBlocksFromTpl,
+  extractAndOrganizeBlocks,
   genTagId,
+  generateFilterKey,
   export_getAIChatModelByTenant as getAIChatModelByTenant,
   export_getAnnotationsModelByTenant as getAnnotationsModelByTenant,
   getDbByTenant,
+  getFilterKeyForBlock,
   export_getGeneratedTopicsModelByTenant as getGeneratedTopicsModelByTenant,
   export_getModelByTenant as getModelByTenant,
   export_getPlatformConfigsModelByTenant as getPlatformConfigsModelByTenant,
@@ -2644,6 +3603,7 @@ export {
   getVal,
   mergeAnnoDataIntoAnnotationsTags,
   parseSpecialConfigSyntax,
+  processAuthorAndCommonFilters,
   _recursExtractBlocks as recursivelyExtractBlocks,
   segrigateDocs,
   setVal,