feat: add docfill mvp cli

2026-06-18 20:03:47 +08:00
commit ca444bd5d0
22 changed files with 2539 additions and 0 deletions
--- a/internal/docfill/docfill.go
+++ b/internal/docfill/docfill.go
@@ -0,0 +1,740 @@
+package docfill
+
+import (
+	"archive/zip"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	_ "modernc.org/sqlite"
+
+	"github.com/xuri/excelize/v2"
+)
+
+type config struct {
+	Vars     map[string]string `json:"vars"`
+	Data     dataConfig        `json:"data"`
+	Template templateConfig    `json:"template"`
+	Output   outputConfig      `json:"output"`
+}
+
+type dataConfig struct {
+	Type      string   `json:"type"`
+	Path      string   `json:"path"`
+	Sheet     string   `json:"sheet"`
+	Query     string   `json:"query"`
+	Params    []string `json:"params"`
+	HeaderRow int      `json:"header_row"`
+}
+
+type templateConfig struct {
+	Path string `json:"path"`
+}
+
+type outputConfig struct {
+	Path      string `json:"path"`
+	Overwrite bool   `json:"overwrite"`
+}
+
+type RunOptions struct {
+	Vars map[string]string
+}
+
+type RunResult struct {
+	Files []string
+}
+
+var (
+	placeholderPattern    = regexp.MustCompile(`\{\{([^{}<>]+)\}\}`)
+	docxParagraphPattern  = regexp.MustCompile(`(?s)<w:p\b[^>]*>.*?</w:p>`)
+	docxTextNodePattern   = regexp.MustCompile(`(?s)<w:t\b[^>]*>(.*?)</w:t>`)
+	docxGeneratedXMLTypes = map[string]struct{}{
+		".xml": {},
+	}
+)
+
+// Run executes one configured fill task.
+func Run(configPath string) error {
+	_, err := RunWithOptions(configPath, RunOptions{})
+	return err
+}
+
+// RunWithOptions executes one configured fill task and returns generated files.
+func RunWithOptions(configPath string, opts RunOptions) (RunResult, error) {
+	cfg, err := loadConfig(configPath)
+	if err != nil {
+		return RunResult{}, err
+	}
+	if err := validateConfig(cfg); err != nil {
+		return RunResult{}, err
+	}
+
+	vars := mergeVars(cfg.Vars, opts.Vars)
+	rows, err := readRowsWithVars(cfg.Data, vars)
+	if err != nil {
+		return RunResult{}, err
+	}
+	if len(rows) == 0 {
+		return RunResult{}, errors.New("data returned no rows")
+	}
+
+	result := RunResult{Files: make([]string, 0, len(rows))}
+	for i, row := range rows {
+		context := renderContext(vars, row, i+1)
+		if err := ensurePlaceholdersAvailable("output path", cfg.Output.Path, context); err != nil {
+			return RunResult{}, fmt.Errorf("render row %d: %w", i+1, err)
+		}
+
+		outputPath := replacePathPlaceholders(cfg.Output.Path, context)
+		if hasPlaceholder(outputPath) {
+			return RunResult{}, fmt.Errorf("render row %d: unresolved placeholder in output path %q", i+1, outputPath)
+		}
+		if !cfg.Output.Overwrite && fileExists(outputPath) {
+			return RunResult{}, fmt.Errorf("render row %d: output already exists: %s", i+1, outputPath)
+		}
+		if err := renderTemplate(cfg.Template.Path, outputPath, context); err != nil {
+			return RunResult{}, fmt.Errorf("render row %d: %w", i+1, err)
+		}
+
+		result.Files = append(result.Files, outputPath)
+	}
+
+	return result, nil
+}
+
+func loadConfig(path string) (config, error) {
+	if path == "" {
+		return config{}, errors.New("config path is required")
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return config{}, fmt.Errorf("read config: %w", err)
+	}
+
+	var cfg config
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return config{}, fmt.Errorf("parse config json: %w", err)
+	}
+	resolveConfigPaths(&cfg, filepath.Dir(absPath(path)))
+	return cfg, nil
+}
+
+func validateConfig(cfg config) error {
+	if cfg.Data.Type == "" {
+		return errors.New("data.type is required")
+	}
+	if cfg.Data.Path == "" {
+		return errors.New("data.path is required")
+	}
+	if cfg.Template.Path == "" {
+		return errors.New("template.path is required")
+	}
+	if cfg.Output.Path == "" {
+		return errors.New("output.path is required")
+	}
+	if cfg.Data.HeaderRow < 0 {
+		return errors.New("data.header_row must not be negative")
+	}
+	return nil
+}
+
+func readRows(cfg dataConfig) ([]map[string]string, error) {
+	return readRowsWithVars(cfg, nil)
+}
+
+func readRowsWithVars(cfg dataConfig, vars map[string]string) ([]map[string]string, error) {
+	switch strings.ToLower(cfg.Type) {
+	case "excel", "xlsx":
+		return readExcelRows(cfg)
+	case "sqlite":
+		return readSQLiteRows(cfg, vars)
+	default:
+		return nil, fmt.Errorf("unsupported data.type %q", cfg.Type)
+	}
+}
+
+func readExcelRows(cfg dataConfig) ([]map[string]string, error) {
+	f, err := excelize.OpenFile(cfg.Path)
+	if err != nil {
+		return nil, fmt.Errorf("open excel data: %w", err)
+	}
+	defer f.Close()
+
+	sheet := cfg.Sheet
+	if sheet == "" {
+		sheet = f.GetSheetName(0)
+	}
+	if sheet == "" {
+		return nil, errors.New("excel data has no sheets")
+	}
+
+	rawRows, err := f.GetRows(sheet)
+	if err != nil {
+		return nil, fmt.Errorf("read excel sheet %q: %w", sheet, err)
+	}
+	if len(rawRows) == 0 {
+		return nil, errors.New("excel data has no header row")
+	}
+
+	headerRow := cfg.HeaderRow
+	if headerRow == 0 {
+		headerRow = 1
+	}
+	if headerRow > len(rawRows) {
+		return nil, fmt.Errorf("excel header_row %d is outside sheet %q", headerRow, sheet)
+	}
+
+	headers := make([]string, len(rawRows[headerRow-1]))
+	for i, header := range rawRows[headerRow-1] {
+		headers[i] = strings.TrimSpace(header)
+	}
+
+	var rows []map[string]string
+	for _, raw := range rawRows[headerRow:] {
+		if rowIsEmpty(raw) {
+			continue
+		}
+		row := make(map[string]string)
+		for i, header := range headers {
+			if header == "" {
+				continue
+			}
+			if i < len(raw) {
+				row[header] = raw[i]
+			} else {
+				row[header] = ""
+			}
+		}
+		rows = append(rows, row)
+	}
+
+	return rows, nil
+}
+
+func readSQLiteRows(cfg dataConfig, vars map[string]string) ([]map[string]string, error) {
+	if cfg.Query == "" {
+		return nil, errors.New("data.query is required for sqlite")
+	}
+
+	db, err := sql.Open("sqlite", cfg.Path)
+	if err != nil {
+		return nil, fmt.Errorf("open sqlite data: %w", err)
+	}
+	defer db.Close()
+
+	args, err := sqliteParams(cfg.Params, vars)
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := db.Query(cfg.Query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query sqlite data: %w", err)
+	}
+	defer result.Close()
+
+	columns, err := result.Columns()
+	if err != nil {
+		return nil, fmt.Errorf("read sqlite columns: %w", err)
+	}
+
+	var rows []map[string]string
+	for result.Next() {
+		values := make([]any, len(columns))
+		scanTargets := make([]any, len(columns))
+		for i := range values {
+			scanTargets[i] = &values[i]
+		}
+		if err := result.Scan(scanTargets...); err != nil {
+			return nil, fmt.Errorf("scan sqlite row: %w", err)
+		}
+
+		row := make(map[string]string)
+		for i, column := range columns {
+			row[column] = stringify(values[i])
+		}
+		rows = append(rows, row)
+	}
+	if err := result.Err(); err != nil {
+		return nil, fmt.Errorf("iterate sqlite rows: %w", err)
+	}
+
+	return rows, nil
+}
+
+func renderTemplate(templatePath, outputPath string, row map[string]string) error {
+	if err := validateTemplateFields(templatePath, row); err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(outputPath), 0o755); err != nil {
+		return fmt.Errorf("create output directory: %w", err)
+	}
+
+	switch strings.ToLower(filepath.Ext(templatePath)) {
+	case ".xlsx":
+		return renderXLSX(templatePath, outputPath, row)
+	case ".docx":
+		return renderDOCX(templatePath, outputPath, row)
+	default:
+		return fmt.Errorf("unsupported template extension %q", filepath.Ext(templatePath))
+	}
+}
+
+func renderXLSX(templatePath, outputPath string, row map[string]string) error {
+	f, err := excelize.OpenFile(templatePath)
+	if err != nil {
+		return fmt.Errorf("open xlsx template: %w", err)
+	}
+	defer f.Close()
+
+	for _, sheet := range f.GetSheetList() {
+		rows, err := f.GetRows(sheet)
+		if err != nil {
+			return fmt.Errorf("read template sheet %q: %w", sheet, err)
+		}
+		for r, values := range rows {
+			for c, value := range values {
+				if !strings.Contains(value, "{{") {
+					continue
+				}
+				cell, err := excelize.CoordinatesToCellName(c+1, r+1)
+				if err != nil {
+					return fmt.Errorf("cell name: %w", err)
+				}
+				rendered := replacePlaceholders(value, row)
+				if hasPlaceholder(rendered) {
+					return fmt.Errorf("unresolved placeholder in %s!%s", sheet, cell)
+				}
+				if err := f.SetCellValue(sheet, cell, rendered); err != nil {
+					return fmt.Errorf("set cell %s!%s: %w", sheet, cell, err)
+				}
+			}
+		}
+	}
+
+	if err := f.SaveAs(outputPath); err != nil {
+		return fmt.Errorf("save xlsx output: %w", err)
+	}
+	return nil
+}
+
+func renderDOCX(templatePath, outputPath string, row map[string]string) error {
+	reader, err := zip.OpenReader(templatePath)
+	if err != nil {
+		return fmt.Errorf("open docx template: %w", err)
+	}
+	defer reader.Close()
+
+	output, err := os.Create(outputPath)
+	if err != nil {
+		return fmt.Errorf("create docx output: %w", err)
+	}
+
+	writer := zip.NewWriter(output)
+	for _, source := range reader.File {
+		if err := copyDocxPart(writer, source, row); err != nil {
+			_ = writer.Close()
+			_ = output.Close()
+			return err
+		}
+	}
+	if err := writer.Close(); err != nil {
+		_ = output.Close()
+		return fmt.Errorf("close docx output: %w", err)
+	}
+	if err := output.Close(); err != nil {
+		return fmt.Errorf("close docx file: %w", err)
+	}
+
+	return nil
+}
+
+func copyDocxPart(writer *zip.Writer, source *zip.File, row map[string]string) error {
+	header := source.FileHeader
+	header.Name = source.Name
+	header.Method = source.Method
+
+	dest, err := writer.CreateHeader(&header)
+	if err != nil {
+		return fmt.Errorf("create docx part %s: %w", source.Name, err)
+	}
+
+	if source.FileInfo().IsDir() {
+		return nil
+	}
+
+	src, err := source.Open()
+	if err != nil {
+		return fmt.Errorf("open docx part %s: %w", source.Name, err)
+	}
+	defer src.Close()
+
+	data, err := io.ReadAll(src)
+	if err != nil {
+		return fmt.Errorf("read docx part %s: %w", source.Name, err)
+	}
+	if isDocxXMLPart(source.Name) {
+		rendered, err := renderDocxXML(string(data), row)
+		if err != nil {
+			return fmt.Errorf("render docx part %s: %w", source.Name, err)
+		}
+		if docxHasPlaceholder(rendered) {
+			return fmt.Errorf("unresolved placeholder in docx part %s", source.Name)
+		}
+		data = []byte(rendered)
+	}
+
+	if _, err := dest.Write(data); err != nil {
+		return fmt.Errorf("write docx part %s: %w", source.Name, err)
+	}
+	return nil
+}
+
+func replacePlaceholders(text string, row map[string]string) string {
+	return replacePlaceholdersWith(text, row, func(value string) string {
+		return value
+	})
+}
+
+func replaceDocxPlaceholders(text string, row map[string]string) string {
+	return replacePlaceholdersWith(text, row, escapeXMLText)
+}
+
+func replacePathPlaceholders(text string, row map[string]string) string {
+	return replacePlaceholdersWith(text, row, sanitizePathValue)
+}
+
+func replacePlaceholdersWith(text string, row map[string]string, transform func(string) string) string {
+	return placeholderPattern.ReplaceAllStringFunc(text, func(match string) string {
+		key := placeholderKey(match)
+		value, ok := row[key]
+		if !ok {
+			return match
+		}
+		return transform(value)
+	})
+}
+
+func rowIsEmpty(row []string) bool {
+	for _, cell := range row {
+		if strings.TrimSpace(cell) != "" {
+			return false
+		}
+	}
+	return true
+}
+
+func stringify(value any) string {
+	switch v := value.(type) {
+	case nil:
+		return ""
+	case []byte:
+		return string(v)
+	case string:
+		return v
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+func mergeVars(configVars, optionVars map[string]string) map[string]string {
+	merged := make(map[string]string)
+	for key, value := range configVars {
+		merged[key] = value
+	}
+	for key, value := range optionVars {
+		merged[key] = value
+	}
+	return merged
+}
+
+func renderContext(vars, row map[string]string, rowNumber int) map[string]string {
+	context := make(map[string]string)
+	for key, value := range vars {
+		context[key] = value
+	}
+	for key, value := range row {
+		context[key] = value
+	}
+	context["_row"] = strconv.Itoa(rowNumber)
+	return context
+}
+
+func sqliteParams(params []string, vars map[string]string) ([]any, error) {
+	args := make([]any, 0, len(params))
+	for i, param := range params {
+		if err := ensurePlaceholdersAvailable(fmt.Sprintf("sqlite params[%d]", i), param, vars); err != nil {
+			return nil, err
+		}
+		rendered := replacePlaceholders(param, vars)
+		if hasPlaceholder(rendered) {
+			return nil, fmt.Errorf("unresolved placeholder in sqlite params[%d]", i)
+		}
+		args = append(args, rendered)
+	}
+	return args, nil
+}
+
+func validateTemplateFields(templatePath string, row map[string]string) error {
+	fields, err := templatePlaceholders(templatePath)
+	if err != nil {
+		return err
+	}
+	for field := range fields {
+		if _, ok := row[field]; !ok {
+			return fmt.Errorf("missing template field %q", field)
+		}
+	}
+	return nil
+}
+
+func templatePlaceholders(templatePath string) (map[string]struct{}, error) {
+	switch strings.ToLower(filepath.Ext(templatePath)) {
+	case ".xlsx":
+		return xlsxPlaceholders(templatePath)
+	case ".docx":
+		return docxPlaceholders(templatePath)
+	default:
+		return nil, fmt.Errorf("unsupported template extension %q", filepath.Ext(templatePath))
+	}
+}
+
+func xlsxPlaceholders(templatePath string) (map[string]struct{}, error) {
+	f, err := excelize.OpenFile(templatePath)
+	if err != nil {
+		return nil, fmt.Errorf("open xlsx template: %w", err)
+	}
+	defer f.Close()
+
+	fields := make(map[string]struct{})
+	for _, sheet := range f.GetSheetList() {
+		rows, err := f.GetRows(sheet)
+		if err != nil {
+			return nil, fmt.Errorf("read template sheet %q: %w", sheet, err)
+		}
+		for _, row := range rows {
+			for _, value := range row {
+				addPlaceholders(fields, value)
+			}
+		}
+	}
+	return fields, nil
+}
+
+func docxPlaceholders(templatePath string) (map[string]struct{}, error) {
+	reader, err := zip.OpenReader(templatePath)
+	if err != nil {
+		return nil, fmt.Errorf("open docx template: %w", err)
+	}
+	defer reader.Close()
+
+	fields := make(map[string]struct{})
+	for _, file := range reader.File {
+		if !strings.HasSuffix(strings.ToLower(file.Name), ".xml") {
+			continue
+		}
+		rc, err := file.Open()
+		if err != nil {
+			return nil, fmt.Errorf("open docx part %s: %w", file.Name, err)
+		}
+		data, readErr := io.ReadAll(rc)
+		closeErr := rc.Close()
+		if readErr != nil {
+			return nil, fmt.Errorf("read docx part %s: %w", file.Name, readErr)
+		}
+		if closeErr != nil {
+			return nil, fmt.Errorf("close docx part %s: %w", file.Name, closeErr)
+		}
+		xml := string(data)
+		addPlaceholders(fields, xml)
+		addDocxTextPlaceholders(fields, xml)
+	}
+	return fields, nil
+}
+
+func ensurePlaceholdersAvailable(label, text string, row map[string]string) error {
+	fields := make(map[string]struct{})
+	addPlaceholders(fields, text)
+	for field := range fields {
+		if _, ok := row[field]; !ok {
+			return fmt.Errorf("missing %s field %q", label, field)
+		}
+	}
+	return nil
+}
+
+func addPlaceholders(fields map[string]struct{}, text string) {
+	matches := placeholderPattern.FindAllStringSubmatch(text, -1)
+	for _, match := range matches {
+		if len(match) < 2 {
+			continue
+		}
+		key := strings.TrimSpace(match[1])
+		if key != "" {
+			fields[key] = struct{}{}
+		}
+	}
+}
+
+func placeholderKey(match string) string {
+	matches := placeholderPattern.FindStringSubmatch(match)
+	if len(matches) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(matches[1])
+}
+
+func hasPlaceholder(text string) bool {
+	return placeholderPattern.MatchString(text)
+}
+
+func renderDocxXML(xml string, row map[string]string) (string, error) {
+	rendered := replaceDocxPlaceholders(xml, row)
+	return renderDocxSplitTextPlaceholders(rendered, row)
+}
+
+func renderDocxSplitTextPlaceholders(xml string, row map[string]string) (string, error) {
+	matches := docxParagraphPattern.FindAllStringIndex(xml, -1)
+	if len(matches) == 0 {
+		return renderDocxTextGroup(xml, row)
+	}
+
+	var out strings.Builder
+	cursor := 0
+	for _, match := range matches {
+		out.WriteString(xml[cursor:match[0]])
+		rendered, err := renderDocxTextGroup(xml[match[0]:match[1]], row)
+		if err != nil {
+			return "", err
+		}
+		out.WriteString(rendered)
+		cursor = match[1]
+	}
+	out.WriteString(xml[cursor:])
+	return out.String(), nil
+}
+
+func renderDocxTextGroup(xml string, row map[string]string) (string, error) {
+	textMatches := docxTextNodePattern.FindAllStringSubmatchIndex(xml, -1)
+	if len(textMatches) == 0 {
+		return xml, nil
+	}
+
+	joined := joinedDocxText(xml, textMatches)
+	if !hasPlaceholder(joined) {
+		return xml, nil
+	}
+	if err := ensurePlaceholdersAvailable("docx text", joined, row); err != nil {
+		return "", err
+	}
+	rendered := replaceDocxPlaceholders(joined, row)
+	if hasPlaceholder(rendered) {
+		return "", errors.New("unresolved placeholder in docx text")
+	}
+
+	var out strings.Builder
+	cursor := 0
+	for i, match := range textMatches {
+		out.WriteString(xml[cursor:match[2]])
+		if i == 0 {
+			out.WriteString(rendered)
+		}
+		out.WriteString(xml[match[3]:match[1]])
+		cursor = match[1]
+	}
+	out.WriteString(xml[cursor:])
+	return out.String(), nil
+}
+
+func joinedDocxText(xml string, matches [][]int) string {
+	var joined strings.Builder
+	for _, match := range matches {
+		joined.WriteString(xml[match[2]:match[3]])
+	}
+	return joined.String()
+}
+
+func addDocxTextPlaceholders(fields map[string]struct{}, xml string) {
+	matches := docxParagraphPattern.FindAllStringIndex(xml, -1)
+	if len(matches) == 0 {
+		addPlaceholders(fields, joinedDocxText(xml, docxTextNodePattern.FindAllStringSubmatchIndex(xml, -1)))
+		return
+	}
+	for _, match := range matches {
+		paragraph := xml[match[0]:match[1]]
+		textMatches := docxTextNodePattern.FindAllStringSubmatchIndex(paragraph, -1)
+		addPlaceholders(fields, joinedDocxText(paragraph, textMatches))
+	}
+}
+
+func docxHasPlaceholder(xml string) bool {
+	if hasPlaceholder(xml) {
+		return true
+	}
+	fields := make(map[string]struct{})
+	addDocxTextPlaceholders(fields, xml)
+	return len(fields) > 0
+}
+
+func escapeXMLText(value string) string {
+	replacer := strings.NewReplacer(
+		"&", "&amp;",
+		"<", "&lt;",
+		">", "&gt;",
+	)
+	return replacer.Replace(value)
+}
+
+func isDocxXMLPart(name string) bool {
+	_, ok := docxGeneratedXMLTypes[strings.ToLower(filepath.Ext(name))]
+	return ok
+}
+
+func sanitizePathValue(value string) string {
+	replacer := strings.NewReplacer(
+		"/", "_",
+		"\\", "_",
+		":", "_",
+		"*", "_",
+		"?", "_",
+		`"`, "_",
+		"<", "_",
+		">", "_",
+		"|", "_",
+	)
+	return strings.TrimSpace(replacer.Replace(value))
+}
+
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+func resolveConfigPaths(cfg *config, baseDir string) {
+	cfg.Data.Path = resolvePath(baseDir, cfg.Data.Path)
+	cfg.Template.Path = resolvePath(baseDir, cfg.Template.Path)
+	cfg.Output.Path = resolvePath(baseDir, cfg.Output.Path)
+}
+
+func resolvePath(baseDir, path string) string {
+	if path == "" || filepath.IsAbs(path) {
+		return path
+	}
+	return filepath.Clean(filepath.Join(baseDir, path))
+}
+
+func absPath(path string) string {
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return path
+	}
+	return abs
+}