feat: parser pages range and parse type validation for dataset/document (#17293)

## Summary

Adds page-range parsing support to the Go-native pipeline path and
introduces strict `parse_type` validation for both dataset and document
update endpoints.

## What changed

### Pages range parsing
- **`internal/utility/pdf_pages.go`** — `NormalizePDFPages`: normalizes
raw page ranges (list of `[from,to]` 1-indexed inclusive ranges) into
sorted, merged, deduplicated `[][]int`. Invalid ranges are dropped.
- **`internal/ingestion/pipeline/pdf_pages.go`** —
`NormalizeParserConfigPages`: walks any parser_config map and normalizes
`"pages"` values under every component → filetype setup, so the
persisted config always carries clean, merged ranges.
- **`internal/deepdoc/parser/pdf/parser.go`** — integrates
`resolvePagesToProcess` to filter parsed PDF pages by the configured
ranges.
- Pipeline integration (parser pages):
`internal/parser/parser/pdf_parser_common.go`, `chunk_process.go`, plus
associated e2e and unit tests.

### Parse type validation (shared logic)
- **`internal/service/parser_mode.go`** (new) — `ValidateParseTypeMode`:
shared function that validates `parse_type` (1=BuiltIn/parser_id,
2=Pipeline/pipeline_id) and ensures the corresponding field is present.
Used by both dataset and document update endpoints.
- **`internal/service/dataset/crud.go`** / `update.go` — replaces inline
`isPipelineMode`/`isBuiltinMode` computation with the shared
`service.ValidateParseTypeMode`.
- **`internal/service/document/document_dataset_update.go`** — adds
strict `parse_type` validation in `validateDatasetDocumentUpdate`,
simplifies the reparse logic to a two-way switch (isBuiltin/isPipeline)
now that parse_type is always valid.
- **`internal/service/document/document.go`** — adds `ParseType` field
to `UpdateDatasetDocumentRequest`.
- **`internal/service/document/document_dataset_update.go`** —
`updateDocumentParserConfig` fallback path when DSL loading fails.
- **`internal/service/parser_mode_test.go`** (new) — test coverage for
nil, invalid, and missing-field scenarios.

### Frontend
- **`web/src/interfaces/request/document.ts`** — adds `parseType` to
`IChangeParserRequestBody`.
- **`web/src/hooks/use-document-request.ts`** —
`useSetDocumentPipelineParser` sends `parse_type` in the PATCH payload.
- **`web/src/pages/dataset/dataset/use-change-document-parser.ts`** —
Go/Python branching for the document parser config dialog.
-
**`web/src/components/document-pipeline-dialog/use-document-pipeline-form.ts`**
— `buildSubmitData` returns `parseType` (bugfix: was dropped from the
return value).

### Test changes
- **Removed**: 2 tests that verified the old "mutually exclusive" error
(replaced by `ValidateParseTypeMode` coverage).
- **Modified**: 6 tests across document and dataset packages to include
`ParseType` in request structs.
- **Added**: new e2e tests for pages parsing (`pages_e2e_test.go`,
`pdf_parser_pages_e2e_test.go`) and unit tests for `NormalizePDFPages`,
`NormalizeParserConfigPages`, `resolvePagesToProcess`.

## Backward compatibility
- The `parse_type` field is **required** when `parser_id` or
`pipeline_id` is sent. This changes the contract for both dataset and
document PATCH endpoints, but aligns the Go backend with the existing
frontend behavior (the frontend already sends `parse_type`). Callers
that omit `parse_type` when updating parser/pipeline selections will
receive a clear error message.
- Existing callers that only update fields like `name`, `enabled`, or
`meta_fields` are unaffected.
- Test updates ensure all known call sites are compliant.

internal/parser/parser/pdf_parser_cgo.go

@@ -35,6 +35,7 @@ func (p *PDFParser) ParseWithResult(ctx context.Context, filename string, data [
 	}
 	cfg := deepdoctype.DefaultParserConfig()
 	cfg.SkipOCR = false
+	cfg.Pages = p.Pages
 	parser := deepdocpdf.NewParser(cfg)
 	res := parsePDFWithDeepDocOptions(ctx, filename, data, pdfPostProcessOptions{
 		outputFormat:       p.OutputFormat,

internal/parser/parser/pdf_parser_common.go

@@ -33,6 +33,7 @@ import (
 	pdflayout "ragflow/internal/deepdoc/parser/pdf/layout"
 	"ragflow/internal/deepdoc/parser/pdf/util"
 	deepdoctype "ragflow/internal/deepdoc/parser/type"
+	"ragflow/internal/utility"
 )
 
 // ErrPDFEngineUnavailable is returned by PDFParser.ParseWithResult
@@ -58,12 +59,16 @@ type PDFParser struct {
 	Model      string // DeepDoc@buildin@ragflow
 	LibType    string // pdf_oxide, used by DeepDoc
 
-	FlattenMediaToText                bool
-	RemoveTOC                         bool
-	RemoveHeaderFooter                bool
-	EnableMultiColumn                 bool
-	OutputFormat                      string
-	ParseMethod                       string
+	FlattenMediaToText bool
+	RemoveTOC          bool
+	RemoveHeaderFooter bool
+	EnableMultiColumn  bool
+	OutputFormat       string
+	ParseMethod        string
+	// Pages restricts parsing to these 1-indexed inclusive page ranges.
+	// nil/empty means parse all pages. Populated by ConfigureFromSetup from
+	// the filetype setup map and forwarded to the deepdoc ParserConfig.
+	Pages                             [][]int
 	MinerUAPIServer                   string
 	MinerUAPIKey                      string
 	MinerUBackend                     string
@@ -250,6 +255,18 @@ func (p *PDFParser) ConfigureFromSetup(setup map[string]any) {
 	if v, ok := setup["markdown_image_response_type"].(string); ok && v != "" {
 		p.TCADPMarkdownImageResponseType = v
 	}
+	if raw, ok := setup["pages"]; ok {
+		// Request-layer validation (NormalizeParserConfigPages) already
+		// rejects invalid ranges at the API boundary. At parse time the input
+		// should already be normalized; degrade to "parse all pages" rather
+		// than failing the parse if an unexpected shape slips through.
+		if pages, err := utility.NormalizePDFPages(raw); err != nil {
+			slog.Warn("ConfigureFromSetup: invalid pages range, falling back to all pages",
+				"raw", raw, "err", err)
+		} else {
+			p.Pages = pages
+		}
+	}
 }
 
 func normalizePDFParseMethod(raw string) string {

internal/parser/parser/pdf_parser_pages_e2e_test.go

@@ -0,0 +1,85 @@
+package parser
+
+import (
+	"context"
+	"fmt"
+	"image"
+	"reflect"
+	"testing"
+
+	deepdocpdf "ragflow/internal/deepdoc/parser/pdf"
+	deepdoctype "ragflow/internal/deepdoc/parser/pdf/type"
+)
+
+// noopDocAnalyzer is a DocAnalyzer that reports unhealthy and returns empty
+// results, forcing the parser onto the charsToBoxes path. It lets the parser
+// package exercise the deepdoc parser without the real DeepDoc models.
+type noopDocAnalyzer struct{}
+
+func (noopDocAnalyzer) DLA(context.Context, image.Image) ([]deepdoctype.DLARegion, error) {
+	return nil, nil
+}
+func (noopDocAnalyzer) TSR(context.Context, image.Image) ([]deepdoctype.TSRCell, error) {
+	return nil, nil
+}
+func (noopDocAnalyzer) OCRDetect(context.Context, image.Image) ([]deepdoctype.OCRBox, error) {
+	return nil, nil
+}
+func (noopDocAnalyzer) OCRRecognize(context.Context, image.Image) ([]deepdoctype.OCRText, error) {
+	return nil, nil
+}
+func (noopDocAnalyzer) Health() bool { return false }
+
+// TestPDFParser_PagesEndToEnd_FromConfigureFromSetup verifies the full path
+// from a filetype setup map (as delivered by the pipeline override_params)
+// through ConfigureFromSetup -> PDFParser.Pages -> deepdoc ParserConfig.Pages
+// -> resolvePagesToProcess, asserting only the configured page ranges are
+// parsed.
+//
+// This ties together step 2 (ConfigureFromSetup + cfg.Pages plumbing) and
+// step 1 (deepdoc page filtering) at the PDFParser level.
+func TestPDFParser_PagesEndToEnd_FromConfigureFromSetup(t *testing.T) {
+	// Build a 10-page mock engine where page N carries the text "pN".
+	chars := make(map[int][]deepdoctype.TextChar, 10)
+	for i := 0; i < 10; i++ {
+		chars[i] = []deepdoctype.TextChar{
+			{Text: fmt.Sprintf("p%d", i), X0: 10, X1: 50, Top: 10, Bottom: 30, PageNumber: i},
+		}
+	}
+	eng := &deepdocpdf.MockEngine{NumPages: 10, Chars: chars, RenderW: 100, RenderH: 100}
+
+	// 1. ConfigureFromSetup reads "pages" exactly as the pipeline would pass
+	//    it (JSON-decoded []any of []any of float64).
+	p := &PDFParser{}
+	p.ConfigureFromSetup(map[string]any{
+		"pages": []any{
+			[]any{float64(1), float64(3)},
+			[]any{float64(8), float64(10)},
+		},
+	})
+	wantPages := [][]int{{1, 3}, {8, 10}}
+	if !reflect.DeepEqual(p.Pages, wantPages) {
+		t.Fatalf("PDFParser.Pages = %v, want %v", p.Pages, wantPages)
+	}
+
+	// 2. Build the deepdoc config the same way ParseWithResult does
+	//    (cfg.Pages = p.Pages) and run the parser.
+	cfg := deepdoctype.DefaultParserConfig()
+	cfg.Pages = p.Pages
+	docParser := deepdocpdf.NewParser(cfg)
+
+	result, err := docParser.ParseRaw(context.Background(), eng, noopDocAnalyzer{})
+	if err != nil {
+		t.Fatalf("ParseRaw: %v", err)
+	}
+
+	// 3. [1,3] -> 0-based 0..2 ; [8,10] -> 7..9
+	gotPages := make(map[int]struct{}, len(result.PageHeight))
+	for k := range result.PageHeight {
+		gotPages[k] = struct{}{}
+	}
+	want := map[int]struct{}{0: {}, 1: {}, 2: {}, 7: {}, 8: {}, 9: {}}
+	if !reflect.DeepEqual(gotPages, want) {
+		t.Errorf("PageHeight keys = %v, want %v", gotPages, want)
+	}
+}

internal/parser/parser/pdf_parser_pages_test.go

@@ -0,0 +1,87 @@
+package parser
+
+import (
+	"reflect"
+	"testing"
+)
+
+// TestConfigureFromSetup_Pages verifies ConfigureFromSetup reads the "pages"
+// field from the filetype setup map, normalizes it, and assigns it to
+// PDFParser.Pages.
+func TestConfigureFromSetup_Pages(t *testing.T) {
+	t.Run("reads and normalizes pages", func(t *testing.T) {
+		p := &PDFParser{}
+		setup := map[string]any{
+			"pages": []any{
+				[]any{float64(1), float64(3)},
+				[]any{float64(8), float64(10)},
+			},
+		}
+		p.ConfigureFromSetup(setup)
+		want := [][]int{{1, 3}, {8, 10}}
+		if !reflect.DeepEqual(p.Pages, want) {
+			t.Errorf("Pages = %v, want %v", p.Pages, want)
+		}
+	})
+
+	t.Run("overlapping ranges merged", func(t *testing.T) {
+		p := &PDFParser{}
+		setup := map[string]any{
+			"pages": []any{
+				[]any{float64(1), float64(200)},
+				[]any{float64(111), float64(333)},
+			},
+		}
+		p.ConfigureFromSetup(setup)
+		want := [][]int{{1, 333}}
+		if !reflect.DeepEqual(p.Pages, want) {
+			t.Errorf("Pages = %v, want %v", p.Pages, want)
+		}
+	})
+
+	t.Run("all invalid -> nil", func(t *testing.T) {
+		p := &PDFParser{}
+		setup := map[string]any{
+			"pages": []any{[]any{float64(3), float64(1)}},
+		}
+		p.ConfigureFromSetup(setup)
+		if p.Pages != nil {
+			t.Errorf("Pages = %v, want nil", p.Pages)
+		}
+	})
+
+	t.Run("missing pages key -> nil", func(t *testing.T) {
+		p := &PDFParser{}
+		setup := map[string]any{"flatten_media_to_text": true}
+		p.ConfigureFromSetup(setup)
+		if p.Pages != nil {
+			t.Errorf("Pages = %v, want nil", p.Pages)
+		}
+	})
+
+	// Regression guard: reading pages must not break other fields.
+	t.Run("other fields still read (no regression)", func(t *testing.T) {
+		p := &PDFParser{}
+		setup := map[string]any{
+			"flatten_media_to_text": true,
+			"parse_method":          "DeepDOC",
+			"output_format":         "json",
+			"pages": []any{
+				[]any{float64(1), float64(100)},
+			},
+		}
+		p.ConfigureFromSetup(setup)
+		if !p.FlattenMediaToText {
+			t.Error("FlattenMediaToText not read")
+		}
+		if p.ParseMethod != "DeepDOC" {
+			t.Errorf("ParseMethod = %q, want DeepDOC", p.ParseMethod)
+		}
+		if p.OutputFormat != "json" {
+			t.Errorf("OutputFormat = %q, want json", p.OutputFormat)
+		}
+		if want := [][]int{{1, 100}}; !reflect.DeepEqual(p.Pages, want) {
+			t.Errorf("Pages = %v, want %v", p.Pages, want)
+		}
+	})
+}