RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
fix(web): dataset auto-metadata toggle reverts to off after save (#18813)
euvreac0836429813
diff --git a/web/src/pages/dataset/setting/go/hooks.test.tsx b/web/src/pages/dataset/setting/go/hooks.test.tsxnew file mode 100644index 0000000000..08469f0cc9--- /dev/null+++ b/web/src/pages/dataset/setting/go/hooks.test.tsx@@ -0,0 +1,96 @@+import { useUpdateKnowledge } from '@/hooks/use-knowledge-request';+import { renderHook } from '@testing-library/react';+import { useSaveDatasetSetting } from './hooks';++let mockIsGoBackend = true;+jest.mock('@/utils/backend-runtime', () => ({+ isGoBackend: () => mockIsGoBackend,+ getBackendLanguage: () => (mockIsGoBackend ? 'go' : 'python'),+}));+jest.mock('@/hooks/use-knowledge-request', () => ({+ useFetchDatasetPipelineConfiguration: jest.fn(),+ useUpdateKnowledge: jest.fn(),+}));+jest.mock('@/pages/user-setting/data-source/constant', () => ({+ useDataSourceInfo: jest.fn(() => ({ dataSourceInfo: {} })),+}));+jest.mock('@/services/knowledge-service', () => ({+ checkEmbedding: jest.fn(),+}));++const mockUseUpdateKnowledge = jest.mocked(useUpdateKnowledge);++describe('useSaveDatasetSetting parser_config metadata lift', () => {+ beforeEach(() => {+ mockIsGoBackend = true;+ mockUseUpdateKnowledge.mockReset();+ });++ function setup() {+ const saveKnowledgeConfiguration = jest.fn();+ mockUseUpdateKnowledge.mockReturnValue({+ saveKnowledgeConfiguration,+ loading: false,+ } as never);+ const {+ result: { current },+ } = renderHook(() => useSaveDatasetSetting());+ return { handleSave: current.handleSave, saveKnowledgeConfiguration };+ }++ it('makes the extractor metadata group authoritative over the stale top-level copy', async () => {+ const { handleSave, saveKnowledgeConfiguration } = setup();++ await handleSave({+ parse_type: 'built-in',+ parser_config: {+ 'Extractor:AutoExtractDefault': {+ llm_id: 'llm-a',+ metadata: {+ enabled: true,+ metadata: [],+ built_in_metadata: [{ key: 'update_time', type: 'time' }],+ },+ },+ metadata: {+ enabled: false,+ metadata: [],+ built_in_metadata: [],+ },+ },+ } as never);++ const payload = saveKnowledgeConfiguration.mock.calls[0][0];+ expect(payload.parser_config.metadata).toEqual({+ enabled: true,+ metadata: [],+ built_in_metadata: [{ key: 'update_time', type: 'time' }],+ });+ expect(+ payload.parser_config['Extractor:AutoExtractDefault'].metadata.enabled,+ ).toBe(true);+ });++ it('leaves the top-level object untouched when the pipeline has no extractor', async () => {+ const { handleSave, saveKnowledgeConfiguration } = setup();++ await handleSave({+ parse_type: 'built-in',+ parser_config: {+ 'Tokenizer:SomeNode': { fields: 'text' },+ metadata: {+ enabled: true,+ metadata: [],+ built_in_metadata: [],+ },+ },+ } as never);++ const payload = saveKnowledgeConfiguration.mock.calls[0][0];+ expect(payload.parser_config.metadata).toEqual({+ enabled: true,+ metadata: [],+ built_in_metadata: [],+ });+ });+});diff --git a/web/src/pages/dataset/setting/go/hooks.ts b/web/src/pages/dataset/setting/go/hooks.tsindex 4fd8d59c6b..8d8a181ea3 100644--- a/web/src/pages/dataset/setting/go/hooks.ts+++ b/web/src/pages/dataset/setting/go/hooks.ts@@ -1,3 +1,4 @@+import { Operator } from '@/constants/agent';import { ParseType } from '@/constants/knowledge';import {useFetchDatasetPipelineConfiguration,@@ -130,14 +131,30 @@ export const useSaveDatasetSetting = () => {// Apply forward transforms to parser_config if in pipeline modeif (payload.parser_config) {const transformedConfig: Record<string, any> = {};+ let extractorMetadataGroup: Record<string, any> | undefined;for (const [operatorId, config] of Object.entries(payload.parser_config,)) {const operatorType = getOperatorType(operatorId);- transformedConfig[operatorId] = transformFormConfigToApi(+ const transformed = transformFormConfigToApi(operatorType,config as Record<string, any>,);+ transformedConfig[operatorId] = transformed;+ if (+ operatorType === Operator.Extractor &&+ extractorMetadataGroup === undefined+ ) {+ extractorMetadataGroup = transformed?.metadata;+ }+ }+ // parser_config.metadata is the dataset-level object the backend+ // preserves and re-scopes into every Extractor node. The extractor+ // tab is the only place the user edits it, so lift its metadata+ // group to the top level — otherwise the stale copy loaded with the+ // form would silently revert the toggle the user just set.+ if (extractorMetadataGroup) {+ transformedConfig.metadata = extractorMetadataGroup;}payload.parser_config = transformedConfig;}diff --git a/web/src/utils/__tests__/pipeline-operator.test.ts b/web/src/utils/__tests__/pipeline-operator.test.tsnew file mode 100644index 0000000000..061d279ca1--- /dev/null+++ b/web/src/utils/__tests__/pipeline-operator.test.ts@@ -0,0 +1,104 @@+import { buildOperatorNode } from '@/utils/pipeline-operator';++let mockIsGoBackend = true;+jest.mock('@/utils/backend-runtime', () => ({+ isGoBackend: () => mockIsGoBackend,+ getBackendLanguage: () => (mockIsGoBackend ? 'go' : 'python'),+}));++const extractorNode = {+ id: 'Extractor:AutoExtractDefault',+ data: { form: {} },+} as any;++describe('buildOperatorNode dataset-level metadata precedence', () => {+ beforeEach(() => {+ mockIsGoBackend = true;+ });++ it('seeds the extractor metadata toggle from the dataset-level object', () => {+ const node = buildOperatorNode(extractorNode, {+ 'Extractor:AutoExtractDefault': {+ llm_id: 'llm-a',+ metadata: { enabled: false, metadata: [], built_in_metadata: [] },+ },+ metadata: {+ enabled: true,+ metadata: [],+ built_in_metadata: [{ key: 'update_time', type: 'time' }],+ },+ });++ const form = (node.data as Record<string, any>).form;+ expect(form.metadata.enabled).toBe(true);+ expect(form.metadata.built_in_metadata).toEqual([+ { key: 'update_time', type: 'time' },+ ]);+ });++ it('falls back to the per-node metadata group without a dataset-level object', () => {+ const node = buildOperatorNode(extractorNode, {+ 'Extractor:AutoExtractDefault': {+ llm_id: 'llm-a',+ metadata: {+ enabled: true,+ metadata: [],+ built_in_metadata: [{ key: 'file_name', type: 'string' }],+ },+ },+ });++ const form = (node.data as Record<string, any>).form;+ expect(form.metadata.enabled).toBe(true);+ expect(form.metadata.built_in_metadata).toEqual([+ { key: 'file_name', type: 'string' },+ ]);+ });++ it('ignores a flat metadata array at the top level', () => {+ const node = buildOperatorNode(extractorNode, {+ 'Extractor:AutoExtractDefault': {+ llm_id: 'llm-a',+ metadata: { enabled: false, metadata: [], built_in_metadata: [] },+ },+ metadata: [{ key: 'category', type: 'string' }],+ });++ const form = (node.data as Record<string, any>).form;+ expect(form.metadata.enabled).toBe(false);+ });++ it('ignores an object without the metadata group shape', () => {+ const node = buildOperatorNode(extractorNode, {+ 'Extractor:AutoExtractDefault': {+ llm_id: 'llm-a',+ metadata: { enabled: false, metadata: [], built_in_metadata: [] },+ },+ metadata: { enabled: 'yes', metadata: [], built_in_metadata: [] },+ });++ const form = (node.data as Record<string, any>).form;+ expect(form.metadata.enabled).toBe(false);+ });++ it('does not touch non-extractor operators', () => {+ const node = buildOperatorNode(+ {+ id: 'Tokenizer:SomeNode',+ data: { form: {} },+ } as any,+ {+ 'Tokenizer:SomeNode': { fields: 'text' },+ metadata: {+ enabled: true,+ metadata: [],+ built_in_metadata: [],+ },+ },+ );++ const form = (node.data as Record<string, any>).form;+ expect(form.fields).toBe('text');+ expect(form).not.toHaveProperty('metadata');+ });+});diff --git a/web/src/utils/pipeline-operator.ts b/web/src/utils/pipeline-operator.tsindex d1715cc4d0..7e65b28489 100644--- a/web/src/utils/pipeline-operator.ts+++ b/web/src/utils/pipeline-operator.ts@@ -39,6 +39,19 @@ export function getOperatorType(operatorId: string): Operator {return (operatorId.split(':')[0] || operatorId) as Operator;}+// The dataset-level metadata group stored at parser_config.metadata. The group+// is shaped {enabled, metadata, built_in_metadata}; the boolean enabled flag+// and the built_in_metadata array identify it among other values.+function isDatasetMetadataGroup(value: any): boolean {+ return (+ typeof value === 'object' &&+ value !== null &&+ !Array.isArray(value) &&+ typeof value.enabled === 'boolean' &&+ Array.isArray(value.built_in_metadata)+ );+}+export function transformParserConfigSetups(setups: Record<string, any> | undefined,): any[] {@@ -397,10 +410,24 @@ export function buildOperatorNode(};if (!isEmpty(pipelineParserConfig)) {+ let apiConfig = pipelineParserConfig[operatorId];+ // Dataset-level auto-metadata lives at parser_config.metadata; the+ // backend preserves that object and re-scopes it into every Extractor+ // node on write, so it is the authoritative source for the metadata+ // toggle's initial state — prefer it over a possibly stale per-node copy.+ if (+ operatorType === Operator.Extractor &&+ isDatasetMetadataGroup(pipelineParserConfig.metadata)+ ) {+ apiConfig = {+ ...apiConfig,+ metadata: pipelineParserConfig.metadata,+ };+ }// user overrides from API (now also form format)Object.assign(rawForm,- transformApiConfigToForm(operatorType, pipelineParserConfig[operatorId]), // Convert API config to form format, then merge (DSL template is baseline, API overrides)+ transformApiConfigToForm(operatorType, apiConfig), // Convert API config to form format, then merge (DSL template is baseline, API overrides));}