PPlus Bulk Data Migration with TypeScript

┌──────────────────────────────────────────────────────────┐
│  Phase 1: Auth & Discovery                               │
│  Read JWT + csr from browser localStorage               │
│  List levels, users, lookups, existing components       │
├──────────────────────────────────────────────────────────┤
│  Phase 2: Cleanup (optional)                             │
│  Delete logs first, then components bottom-up           │
│  L1 → L3 → L2  (children before parents)                │
├──────────────────────────────────────────────────────────┤
│  Phase 3: Migrate Hierarchy (top-down)                   │
│  Portfolios → Initiatives (link to Portfolio)           │
│  → Projects (link to Initiative)                        │
│  Save state.json after each — fully resumable           │
├──────────────────────────────────────────────────────────┤
│  Phase 4: Migrate Logs                                   │
│  Risks, Issues, Stakeholders, Progress Updates,         │
│  Contracts, Payment Plans — all attach to projects      │
├──────────────────────────────────────────────────────────┤
│  Phase 5: Schedule Import (.mpp / .xer)                  │
│  For each file:                                         │
│    a. POST /Service/api/Tasks/mmp/import   (parse)      │
│    b. PATCH /Service/api/Tasks/{lvl}/{id}  (save)       │
│    With overrideCurrent: true and flattened tree        │
├──────────────────────────────────────────────────────────┤
│  Phase 6: Verify                                         │
│  Re-read level summaries, count records, spot-check     │
└──────────────────────────────────────────────────────────┘

// api.ts
import * as fs from 'fs';

const auth = JSON.parse(fs.readFileSync('auth.json', 'utf8'));
export const BASE = auth.baseUrl;
export const TOKEN = auth.token;
export const CSR = auth.csr;

export async function api(path: string, options: any = {}): Promise<any> {
  const url = path.startsWith('http') ? path : `${BASE}${path}`;
  const res = await fetch(url, {
    ...options,
    headers: {
      Authorization: `Bearer ${TOKEN}`,
      csr: CSR,
      'Content-Type': 'application/json',
      ...(options.headers || {}),
    },
  });
  const text = await res.text();
  let data: any;
  try { data = JSON.parse(text); } catch { data = text; }
  if (!res.ok) {
    throw new Error(`HTTP ${res.status} on ${options.method || 'GET'} ${path}: ${text.slice(0, 500)}`);
  }
  return data;
}

const u = JSON.parse(localStorage.getItem('currentUser'));
console.log({
  token: u.data.token,                    // JWT
  csr: localStorage.getItem('csr'),       // = "=8yPFwmIQPX96bxPVFP_62WCH*+o]v*g" on every PPlus instance
  cacheSession: u.cacheSession
});

const body = {
  name: { ar: "اسم عربي", en: "English Name" },
  props: [
    {
      id: 0, propertyId: 8014,
      key: "K_Portfolio_Dvrc9wzwV6OJD1sB_manager",
      value: "<userId>", viewType: "User",
      label: "Portfolio Manager",
      AlldataForItem: { userId, displayName, userName, photo, email },
      order: 14, isBasic: false
    },
    // ...other props
  ],
  levelId: 2,
  sources: [],                  // [] for root, [parentId] for child levels
  attachments: [],
  isDraft: false,
  returnURL: null
};
const r = await api('/Service/api/Levels/2', { method: 'POST', body: JSON.stringify(body) });
const newPortfolioId = r.data;

const fd = new FormData();
fd.append('file', new Blob([fs.readFileSync(filePath)]), 'Project.mpp');
fd.append('levelId', String(projectId));

const parseRes = await fetch(`${BASE}/Service/api/Tasks/mmp/import`, {
  method: 'POST',
  headers: { Authorization: `Bearer ${TOKEN}`, csr: CSR },
  body: fd
});
const parsed = await parseRes.json();   // { data: [tree of tasks with .children] }

function flattenTasks(tree: any[]): any[] {
  const out: any[] = [];
  let id = 0;
  function walk(nodes: any[], parentGuid?: string) {
    for (const node of nodes) {
      const flat: any = {
        id: id++,
        startDate: node.startDate,
        finishDate: node.finishDate,
        baselineStart: node.baselineStart || node.startDate,
        baselineFinish: node.baselineFinish || node.finishDate,
        customProperties: node.customProperties || [],
        progress: node.progress || '0%',
        name: node.name,
        guid: node.guid,
        predecessors: node.predecessor                       // singular -> plural
          ? (Array.isArray(node.predecessor) ? node.predecessor : [node.predecessor])
          : [],
        isSelected: true,
        isMilestone: !!node.isMilestone,
      };
      if (parentGuid) flat.parentGuid = parentGuid;
      if (node.assignedTo) {
        flat.assignedTo = typeof node.assignedTo === 'string'
          ? node.assignedTo : node.assignedTo.userId;        // unwrap to id string
      }
      out.push(flat);
      if (node.children?.length) walk(node.children, node.guid);
    }
  }
  walk(tree);
  return out;
}

await fetch(`${BASE}/Service/api/Tasks/1/${projectId}`, {
  method: 'PATCH',
  headers: { Authorization: `Bearer ${TOKEN}`, csr: CSR, 'Content-Type': 'application/json' },
  body: JSON.stringify({ overrideCurrent: true, data: flattenTasks(parsed.data) })
});