fourge-portal/scripts/backfill-request-files.mjs

// One-time script: copies existing submission files from Supabase Storage to FileBrowser
// Run: node scripts/backfill-request-files.mjs
import { readFileSync } from 'fs';
import { createClient } from '@supabase/supabase-js';
import { resolve, dirname } from 'path';
import { fileURLToPath } from 'url';

const __dir = dirname(fileURLToPath(import.meta.url));
const envFile = resolve(__dir, '../.env.backfill');

// Parse env file
const env = {};
readFileSync(envFile, 'utf8').split('\n').forEach(line => {
  const m = line.match(/^([^#=]+)=(.*)$/);
  if (m) env[m[1].trim()] = m[2].trim().replace(/^["']|["']$/g, '');
});

const SUPABASE_URL = env.VITE_SUPABASE_URL || env.SUPABASE_URL;
const SERVICE_ROLE_KEY = env.SUPABASE_SERVICE_ROLE_KEY;
const FB_URL = (env.FILEBROWSER_URL || '').replace(/\/+$/, '');
const FB_TOKEN = env.FILEBROWSER_TOKEN;
const CLIENT_ROOT = env.FILEBROWSER_CLIENT_ROOT || '/Clients';
const FB_SOURCE = 'srv';

if (!SUPABASE_URL || !SERVICE_ROLE_KEY) { console.error('Missing Supabase env'); process.exit(1); }
if (!FB_URL || !FB_TOKEN) { console.error('Missing FileBrowser env'); process.exit(1); }

const admin = createClient(SUPABASE_URL, SERVICE_ROLE_KEY, {
  auth: { persistSession: false, autoRefreshToken: false },
});

function normalizePath(path) {
  const parts = String(path || '/').trim().split('/').filter(Boolean);
  const clean = [];
  for (const p of parts) {
    if (p === '.') continue;
    if (p === '..') throw new Error('path traversal');
    clean.push(p);
  }
  return `/${clean.join('/')}`;
}

function joinPath(...parts) { return normalizePath(parts.join('/')); }

function safeName(v) {
  return String(v || '').trim()
    .replace(/[\\/:*?"<>|#%{}^~[\]`]+/g, '-')
    .replace(/\s+/g, ' ')
    .replace(/^-+|-+$/g, '');
}

async function fbFetch(method, endpoint, { params = {}, headers = {}, body } = {}) {
  const qs = new URLSearchParams({ source: FB_SOURCE, ...params }).toString();
  const res = await fetch(`${FB_URL}${endpoint}?${qs}`, {
    method,
    headers: { Authorization: `Bearer ${FB_TOKEN}`, ...headers },
    body,
  });
  if (!res.ok) {
    const text = await res.text();
    throw new Error(`FB ${res.status}: ${text.slice(0, 200)}`);
  }
  return res;
}

async function mkdir(path) {
  await fbFetch('POST', '/api/resources', { params: { path, isDir: 'true' } }).catch(() => {});
}

async function fbExists(path) {
  try {
    await fbFetch('GET', '/api/resources', { params: { path } });
    return true;
  } catch (e) {
    if (String(e.message || '').includes('404')) return false;
    throw e;
  }
}

async function ensureTaskStructure(companyName, projectName, taskTitle) {
  const companyDir = joinPath(CLIENT_ROOT, safeName(companyName));
  const projectsDir = joinPath(companyDir, 'Projects');
  const projectDir = joinPath(projectsDir, safeName(projectName));
  const taskDir = joinPath(projectDir, safeName(taskTitle));
  const requestInfoDir = joinPath(taskDir, 'Request Info');
  const workingFilesDir = joinPath(taskDir, 'Working Files');
  const oldBooksDir = joinPath(taskDir, 'Old Books');

  await mkdir(companyDir);
  await mkdir(projectsDir);
  await mkdir(projectDir);
  await mkdir(joinPath(projectDir, '00 Project Files'));
  await mkdir(taskDir);
  await mkdir(requestInfoDir);
  await mkdir(workingFilesDir);
  await mkdir(oldBooksDir);

  return { requestInfoDir };
}

async function main() {
  const { data: tasks, error: taskError } = await admin
    .from('tasks')
    .select(`
      id, title,
      project:projects!inner(
        id, name,
        company:companies!inner(name)
      )
    `);

  if (taskError) { console.error('Task query failed:', taskError.message); process.exit(1); }

  let ensuredTasks = 0;
  for (const task of tasks || []) {
    const project = task?.project;
    const company = project?.company;
    if (!task?.title || !project?.name || !company?.name) continue;
    await ensureTaskStructure(company.name, project.name, task.title);
    ensuredTasks++;
  }

  const { data: rows, error } = await admin
    .from('submission_files')
    .select(`
      id, name, storage_path,
      submission:submissions!inner(
        id, version_number,
        task:tasks!inner(
          id, title,
          project:projects!inner(
            id, name,
            company:companies!inner(name)
          )
        )
      )
    `);

  if (error) { console.error('Query failed:', error.message); process.exit(1); }

  // Group by task + version
  const groups = new Map();
  for (const row of rows || []) {
    const sub = row.submission;
    const task = sub?.task;
    const project = task?.project;
    const company = project?.company;
    if (!task || !project || !company) continue;

    const key = `${task.id}::${sub.version_number}`;
    if (!groups.has(key)) {
      groups.set(key, {
        companyName: company.name,
        projectName: project.name,
        taskTitle: task.title,
        versionNumber: sub.version_number,
        files: [],
      });
    }
    groups.get(key).files.push({ name: row.name, storage_path: row.storage_path });
  }

  console.log(`Ensured structure for ${ensuredTasks} tasks`);
  console.log(`Found ${groups.size} task/revision groups, ${rows.length} total files`);

  let processed = 0, skipped = 0, errors = 0;

  for (const [key, group] of groups) {
    if (group.files.length === 0) { skipped++; continue; }

    const revFolder = `R${String(group.versionNumber).padStart(2, '0')}`;
    const { requestInfoDir } = await ensureTaskStructure(group.companyName, group.projectName, group.taskTitle);
    const revDir = joinPath(requestInfoDir, revFolder);

    console.log(`\n[${group.companyName}] ${group.projectName} / ${group.taskTitle} / ${revFolder} (${group.files.length} files)`);

    await mkdir(revDir);

    for (const file of group.files) {
      try {
        const { data: blob, error: downloadErr } = await admin.storage
          .from('submissions')
          .download(file.storage_path);
        if (downloadErr || !blob) throw new Error(`download failed: ${downloadErr?.message}`);
        const fileBuffer = await blob.arrayBuffer();
        const form = new FormData();
        form.append('file', new Blob([fileBuffer]), file.name);

        const fbFilePath = joinPath(revDir, file.name);
        if (await fbExists(fbFilePath)) {
          console.log(`  - skip existing ${file.name}`);
          skipped++;
          continue;
        }
        await fbFetch('POST', '/api/resources', {
          params: { path: fbFilePath },
          body: form,
        });

        console.log(`  ✓ ${file.name}`);
        processed++;
      } catch (err) {
        console.error(`  ✗ ${file.name}: ${err.message}`);
        errors++;
      }
    }
  }

  console.log(`\nDone. Processed: ${processed}, Skipped: ${skipped}, Errors: ${errors}`);
}

main().catch(err => { console.error(err); process.exit(1); });