Feature Discussion: Multiselect + Copy Sections to Target CV

[rorar]

Context

This is coherent with #134 🙂 as it fulfills a layer over CRUD using the user interface (without the D in this case) :)

Currently, copying content between CVs requires one of these workflows:

Method	Limitation
Duplicate entire CV	Copies everything, not selective
Load Dataset A → manually copy items → Load Dataset B	Time-consuming, error-prone
Export/Import JSON	Works but not intuitive for quick tasks

Users with multiple CV versions (e.g., "Frontend Dev", "Full Stack Lead", "Contractor") often need to share specific sections across them — like a new certification or a project they want to showcase on multiple CVs.

Proposed Solution

Add multiselect capability for sections with the ability to copy selected sections to a target CV.

Use Cases

1. Share a new certification across all CV versions
2. Copy a custom section template to a new CV
3. Move experience from one CV to another (e.g., after a job change)
4. Bulk-copy skills categories between CVs with similar requirements

UX Flow

Option a): Either use a dedicated modal:

┌─────────────────────────────────────────────────────────────────┐
│  Copy Sections                                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Source CV: [Frontend Dev v2.0 ▼]                               │
│                                                                 │
│  Select sections to copy:                                       │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ [x] ✓ Experience                                        │    │
│  │ [ ]   Skills                                            │    │
│  │ [x] ✓ Certifications     ← selected                     │    │
│  │ [ ]   Education                                         │    │
│  │ [x] ✓ Projects           ← selected                     │    │
│  │ [ ]   Custom: Portfolio Links                           │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                 │
│  Target CV: [Contractor 2024 ▼]                                 │
│                                                                 │
│  Action: ○ Merge (add to existing)                              │
│          ○ Replace (clear & copy)                               │
│                                                                 │
│  ⚠️ Warning: Replace will clear existing data in target         │
│                                                                 │
│              [Cancel]              [Copy Selected]              │
└─────────────────────────────────────────────────────────────────┘

Option b): Or use the current userinterface alongside with checkboxes and actions.

Key Decisions

Decision	Rationale
Per-CV copy, not bulk	Simpler UX; user picks source and target explicitly
Merge vs Replace toggle	Gives control over data handling
Section-level granularity	Fine-grained enough for most use cases
No cross-dataset copy in one step	Complexity vs. benefit

Technical Approach

Data Structure (please verify)

Each section type has a distinct schema:

const sectionSchemas = {
    experiences: {
        table: 'experiences',
        fields: ['job_title', 'company_name', 'start_date', 'end_date', 
                 'location', 'country_code', 'highlights', 'summary', 
                 'sort_order', 'visible', 'logo_filename', 'logo_propagate']
    },
    certifications: {
        table: 'certifications',
        fields: ['name', 'provider', 'issue_date', 'expiry_date', 
                 'credential_id', 'sort_order', 'visible', 
                 'logo_filename', 'logo_propagate']
    },
    education: {
        table: 'education',
        fields: ['degree_title', 'institution_name', 'start_date', 
                 'end_date', 'description', 'sort_order', 'visible',
                 'logo_filename', 'logo_propagate']
    },
    skills: {
        tables: ['skill_categories', 'skills'],
        join: 'category_id'
    },
    projects: {
        table: 'projects',
        fields: ['title', 'description', 'technologies', 
                 'link', 'sort_order', 'visible']
    },
    customSections: {
        tables: ['custom_sections', 'custom_section_items']
    }
};

API Endpoints (please verify)

1. Export Sections (from source CV)

// GET /api/cv/sections/export?types=experiences,certifications,projects
app.get('/api/cv/sections/export', (req, res) => {
    const { types } = req.query;
    const allowed = ['experiences', 'certifications', 'education', 
                     'skills', 'projects', 'customSections'];
    const requested = types.split(',').filter(t => allowed.includes(t));
    
    if (requested.length === 0) {
        return res.status(400).json({ error: 'No valid section types' });
    }
    
    const data = {};
    for (const type of requested) {
        data[type] = gatherSectionData(type);
    }
    
    res.json({ sections: data });
});

2. Import Sections (to target CV) (please verify)

// POST /api/cv/sections/import
// Body: { sections: { experiences: [...], certifications: [...] }, mode: 'merge' | 'replace' }
app.post('/api/cv/sections/import', (req, res) => {
    const { sections, mode = 'merge', targetDatasetId } = req.body;
    
    if (!sections || typeof sections !== 'object') {
        return res.status(400).json({ error: 'Invalid sections data' });
    }
    
    if (mode !== 'merge' && mode !== 'replace') {
        return res.status(400).json({ error: 'Mode must be "merge" or "replace"' });
    }
    
    // Validate target dataset access
    // ... authorization check ...
    
    const importSections = db.transaction(() => {
        for (const [type, items] of Object.entries(sections)) {
            if (mode === 'replace') {
                clearSection(type);
            }
            importSection(type, items);
        }
    });
    
    try {
        importSections();
        // Update target dataset's saved data
        if (targetDatasetId) {
            updateDatasetSnapshot(targetDatasetId);
        }
        res.json({ success: true, imported: Object.keys(sections) });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

Logo Handling (please verify)

When copying sections with logos:

// Option A: Copy logo files (increases storage)
function copyLogoForSection(sectionType, sourceItem, targetDb) {
    if (sourceItem.logo_filename) {
        const sourcePath = path.join(uploadsPath, sourceItem.logo_filename);
        const targetFilename = `${Date.now()}_${sourceItem.logo_filename}`;
        const targetPath = path.join(uploadsPath, targetFilename);
        
        if (fs.existsSync(sourcePath)) {
            fs.copyFileSync(sourcePath, targetPath);
        }
        return targetFilename;
    }
    return null;
}

// Option B: Share logo references (simpler, shared storage)
// Just copy the filename, don't copy the file

Recommendation: Option B (share references) — simpler, less storage, but means editing logo in one CV affects all.

UI Implementation

Section Selector Component

function renderSectionSelector(sections, selected = new Set()) {
    const sectionIcons = {
        experiences: 'work_history',
        certifications: 'verified',
        education: 'school',
        skills: 'psychology',
        projects: 'folder',
        customSections: 'layers'
    };
    
    return `
        <div class="section-selector">
            ${sections.map(type => `
                <label class="section-option">
                    <input type="checkbox" 
                           name="sections" 
                           value="${type}"
                           ${selected.has(type) ? 'checked' : ''}>
                    <span class="material-symbols-outlined">
                        ${sectionIcons[type]}
                    </span>
                    <span>${t(`section.${type}`)}</span>
                </label>
            `).join('')}
        </div>
    `;
}

Copy Flow

async function copySectionsToTarget(sourceCvId, targetCvId, sections, mode) {
    // 1. Export sections from source
    const exportRes = await fetch(`/api/cv/sections/export?types=${sections.join(',')}`);
    const { sections: exportData } = await exportRes.json();
    
    // 2. Import to target
    const importRes = await fetch('/api/cv/sections/import', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ 
            sections: exportData,
            mode,
            targetDatasetId: targetCvId 
        })
    });
    
    if (importRes.ok) {
        toast(t('toast.sections_copied'));
    } else {
        toast(t('toast.copy_failed'), 'error');
    }
}

Edge Cases

Scenario	Handling
Copy to same CV	Show warning, allow anyway (no-op for most)
Replace mode with existing data	Require explicit confirmation
Empty source section	Skip silently
Logo file missing	Skip logo, copy rest of item
Duplicate entries (merge)	Always add as new items with new IDs
Target CV has 0 items, using merge	Works fine, adds all items
Copy custom section with items	Includes all child items

Out of Scope

• Copying individual items (not full sections)
• Copy between different users' CVs (multi-tenant)
• Real-time sync after copy
• Copy history/audit trail

Code Review Findings

When implementing this feature, be aware of these existing patterns:

🔴 Critical: Logo File Handling

Location: src/server.js:2677 (dataset load)

When sections are copied via POST /api/datasets/:id/load, logo filenames are copied but files are not. Both source and target CVs reference the same file.

Impact on this feature:

• Option A (copy files): Increases storage, but deleting a logo in one CV doesn't affect others
• Option B (share references): Simpler, but logo edits propagate to all CVs sharing it

Recommendation: Implement Option A with a copy-on-write strategy for V1.

🟡 Warning: Inconsistent Validation

Location: src/server.js:2240-2250

• experiences: No validation (accepts any input)
• certifications: Validates credential_id is a valid URL

For copy feature: Normalize/validate data from source CV before importing to target.

🟡 Warning: Empty Section Handling

Location: src/server.js:2178

PUT /api/sections/order accepts empty arrays silently. For copy feature, validate that at least one section is selected before processing.

🔵 Info: gatherCvData() Monolith (optional)

Location: src/server.js:1186

This function (~50 lines) gathers all CV data in one place. For the export endpoint, consider extracting section-specific helpers:

function gatherSectionData(type) {
    switch(type) {
        case 'experiences': return getExperiences();
        case 'certifications': return getCertifications();
        // ...
    }
}

References

• Section data gathering: src/server.js:1186 (gatherCvData())
• Dataset loading: src/server.js:2677 (POST /api/datasets/:id/load)
• Import endpoint: src/server.js:2988 (POST /api/import)
• Datasets UI: public/shared/admin.js:3111 (renderCvManagerList())