Large file process

{
  "uploadType": "resumable",
  "source": "myFile.json", (1)
  "access": "public" (2)
}

#!/usr/bin/env node
import fs from "fs";
import path from "path";

/**
 * This is a demo script to upload a large file to the LF Endpoint of filestore.
 * It should be run with Node.js.
 */

const API_KEY =
  "YOUR_API_KEY"; // You can generate an API key from the DXP Console
const TENANT_ID = "YOUR_TENANT_ID"; // You can find your tenant ID in the DXP Console
const DXP_URL = "YOUR_DXP_URL"; // This is the base URL of your DXP instance
const LFS_ENDPOINT = "__dxp/service/file-storage/api/v2/file"; // This is the LF endpoint
const FILE_NAME = "YOUR_FILE_NAME"; // The name of the file you want to upload

/**
 * This is the main function that will be run when the script is executed.
 * It will upload the file to the large files endpoint.
 * It will first make an initial request to the LF endpoint to get the file ID.
 * Then, it will stream the file data to the LF endpoint in chunks.
 * The chunk size is set to 5MB.
 * The script will log the progress as it goes.
 * If there are any errors, they will be logged to the console.
 * A success message will be logged to the console if the file is uploaded successfully.
 */
(async () => {
  console.log("Uploading file...");
  try {
    // Make our initial request to the LF endpoint
    const { fileId } = await doInitialRequest();

    // Now we can start streaming the file data to the LF endpoint
    await doStreamRequests(fileId);

    // Done
    console.log("File uploaded successfully!");
  } catch (error) {
    console.error("Error uploading file:", error);
  }
})();

/**
 * This function will stream the file data to the LF endpoint in chunks.
 * @param fileId The file ID returned from the initial request
 */
async function doStreamRequests(fileId: string) {
  // Get the file size so we can calculate the number of chunks we need to send
  const { size } = fs.statSync(path.resolve("./", FILE_NAME));

  // Set the chunk size to 5MB
  const chunkSize = 5 * 1024 * 1024;

  // Calculate the number of chunks we need to send
  const numberOfChunks = Math.ceil(size / chunkSize);

  // Create a buffer to store the chunk data
  const buffer = Buffer.alloc(chunkSize);

  // Open the file for reading
  const file = fs.openSync(path.resolve("./", FILE_NAME), "r");

  // Loop through the file and send the chunks
  for (let i = 0; i < numberOfChunks; i++) {
    // Read the chunk from the file
    const bytesRead = fs.readSync(file, buffer, 0, chunkSize, i * chunkSize);

    // Log the progress
    console.log(
      `Uploading chunk ${i + 1} of ${numberOfChunks} (${bytesRead} bytes)`
    );

    // Send the chunk to the LF endpoint
    await fetch(`${DXP_URL}/${LFS_ENDPOINT}/${fileId}`, {
      method: "PATCH",
      headers: {
        "x-api-key": API_KEY,
        "x-dxp-tenant": TENANT_ID,
        "content-type": "application/octet-stream",
        "content-range": `bytes ${i * chunkSize}-${
          i * chunkSize + bytesRead - 1
        }/${size}`,
      },
      body: buffer.subarray(0, bytesRead),
    });
  }

  // Close the file
  fs.closeSync(file);
}

/**
 * This function will make the initial request to the LF endpoint to get the file ID.
 * @returns The response from the LF endpoint
 */
async function doInitialRequest() {
  // Make our initial request to the LF endpoint
  const response = await fetch(`${DXP_URL}/${LFS_ENDPOINT}`, {
    method: "POST",
    headers: {
      "x-api-key": API_KEY,
      "x-dxp-tenant": TENANT_ID,
      "content-type": "application/json",
    },
    body: JSON.stringify({
      uploadType: "resumable",
      source: FILE_NAME, // optional on the PATCH endpoint
      access: "public", // optional on the PATCH endpoint
    }),
  });

  return await response.json();
}