File upload

import { readFile } from 'node:fs/promises';
import { basename } from 'node:path';

const BASE_URL = 'https://files.adclear.ai';
const API_KEY = process.env.ADCLEAR_API_KEY!;

const authHeaders = {
  Authorization: `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

// Step 1 -- Initiate the upload
async function initiateUpload(
  filePath: string,
  contentType: string
): Promise<{ uploadId: string; maxChunkSize: number }> {
  const fileBuffer = await readFile(filePath);

  const res = await fetch(`${BASE_URL}/v1/uploads`, {
    method: 'POST',
    headers: authHeaders,
    body: JSON.stringify({
      fileName: basename(filePath),
      fileSize: fileBuffer.byteLength,
      contentType
    })
  });

  if (!res.ok) {
    const err = await res.json();
    throw new Error(`Initiate failed (${res.status}): ${err.error.message}`);
  }

  const { uploadId, maxChunkSize } = await res.json();
  return { uploadId, maxChunkSize };
}

// Step 2 -- Upload the file in chunks
async function uploadChunks(
  filePath: string,
  uploadId: string,
  contentType: string,
  maxChunkSize: number
): Promise<void> {
  const fileBuffer = await readFile(filePath);
  const totalSize = fileBuffer.byteLength;
  let offset = 0;

  while (offset < totalSize) {
    const end = Math.min(offset + maxChunkSize, totalSize) - 1;
    const chunk = fileBuffer.subarray(offset, end + 1);

    const res = await fetch(`${BASE_URL}/v1/uploads/${uploadId}`, {
      method: 'PUT',
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        'Content-Type': contentType,
        'Content-Range': `bytes ${offset}-${end}/${totalSize}`
      },
      body: chunk
    });

    if (!res.ok) {
      const err = await res.json();
      throw new Error(`Chunk upload failed (${res.status}): ${err.error.message}`);
    }

    const body = await res.json();
    console.log(`Uploaded bytes ${offset}-${end} of ${totalSize} -- status: ${body.status}`);
    offset = end + 1;
  }
}

// Step 3 -- Verify the upload completed
async function getUploadStatus(uploadId: string): Promise<{ status: string }> {
  const res = await fetch(`${BASE_URL}/v1/uploads/${uploadId}`, {
    headers: { Authorization: `Bearer ${API_KEY}` }
  });

  if (!res.ok) {
    const err = await res.json();
    throw new Error(`Status check failed (${res.status}): ${err.error.message}`);
  }

  return res.json();
}

// Full example
async function main(): Promise<void> {
  const filePath = process.argv[2];
  const contentType = process.argv[3] ?? 'application/pdf';

  if (!filePath) {
    console.error('Usage: npx tsx upload.ts <file-path> [content-type]');
    process.exit(1);
  }

  const { uploadId, maxChunkSize } = await initiateUpload(filePath, contentType);
  console.log(`Upload initiated: ${uploadId} (chunk size: ${maxChunkSize} bytes)`);

  await uploadChunks(filePath, uploadId, contentType, maxChunkSize);

  const status = await getUploadStatus(uploadId);
  console.log(`Final status: ${status.status}`);
}

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