notion-multipart-uploader 1.0.1 → 2.1.4

package/README.md

@@ -1,14 +1,16 @@
 # Notion Multipart Uploader
 
-A zero-dependency, native `fetch` helper to upload files (audio, images, PDFs, etc.) directly to Notion's servers via their `v1/file_uploads` multipart API.
-
-Because the official `@notionhq/client` SDK does not abstract the binary `multipart/form-data` upload step, this package handles the entire 2-step direct upload flow for you in one single, AI-optimized function call.
+A zero-dependency convenience wrapper around the Notion File Upload APIs. 
+Because the official `@notionhq/client` SDK requires manually orchestrating a multi-step fetch process (create, send, complete) with chunking for large files, this package handles the entire direct upload flow for you in one single, AI-optimized function call.
 
 ## Features
+- **Smart Multi-Part Chunking (V2):** Automatically slices files larger than 20MB into chunks and uploads them using Notion's `multi_part` API.
+- **Enterprise Resilience (V2):** Built-in exponential backoff. If a chunk fails due to a network blip, it automatically pauses and retries.
+- **Cancel & Timeout Support (V2):** Pass an `AbortSignal` or `timeoutMs` to instantly kill hung uploads.
+- **Workspace Limit Safety (V2):** Instantly catches and throws clear `400` errors if your Notion Workspace is out of storage.
 - **Zero Dependencies:** Uses native Node `fetch` and `FormData`.
 - **Any File Type & Media:** Works flawlessly with Videos (`.mp4`), Phone Gallery exports, Audio (`.m4a`, `.mp3`), Images (`.png`, `.jpg`), PDFs, and any raw binary buffers.
-- **Strict 20MB Limit Safety:** Automatically detects and safely rejects files over 20MB before initializing the API call to prevent Notion boundary errors.
-- **Tiny Size:** < 100 lines of code. Doesn't bloat your node_modules.
+- **Tiny Size:** Doesn't bloat your node_modules.
 - **TypeScript Support:** Full autocomplete out of the box with JSDoc types.
 
 ## Installation
@@ -17,42 +19,56 @@ Because the official `@notionhq/client` SDK does not abstract the binary `multip
 npm install notion-multipart-uploader
 ```
 
+> **Looking for the ultra-lightweight Version 1?**
+> If you are absolutely certain your app will only ever upload small files (under 20MB) and you want the absolute leanest possible script without the V2 multi-part chunking logic, you can install the legacy V1:
+> ```bash
+> npm install notion-multipart-uploader@1.0.1
+> ```
+
+## Getting an API Key
+To use this package, you need a Notion Integration Token:
+1. Go to [Notion's Integration Dashboard](https://www.notion.so/my-integrations).
+2. Click **New Integration**.
+3. Copy the **Internal Integration Secret** (`secret_...`).
+4. **CRITICAL:** Go to the Database page in your Notion app, click the three dots (`...`) in the top right, click **Connect to**, and select your new Integration name so it has permission to write files there!
+
 ## Usage
 
 ```javascript
-import { Client } from '@notionhq/client';
-import { uploadToNotion } from 'notion-multipart-uploader';
+const { uploadToNotion } = require("notion-multipart-uploader");
+const { Client } = require("@notionhq/client");
+const fs = require("fs");
+
+async function run() {
+    const fileBuffer = fs.readFileSync("./voice-note.m4a");
+    const apiKey = "secret_yourNotionApiKeyHere";
 
-const NOTION_KEY = process.env.NOTION_KEY;
-const notion = new Client({ auth: NOTION_KEY });
+    // V2: You can now pass Advanced Options
+    const options = {
+        retries: 5,           // Auto-retry network failures 5 times
+        timeoutMs: 60000      // Kill request if it takes longer than 60s
+    };
 
-async function saveFileToNotion(binaryBuffer) {
     // 1. Upload the binary file directly to Notion
-    const fileId = await uploadToNotion(
-        NOTION_KEY, 
-        binaryBuffer, 
-        "audio/mp4", // Or 'image/png', 'application/pdf', etc.
-        "voice-note.m4a"
-    );
+    const fileId = await uploadToNotion(apiKey, fileBuffer, "audio/mp4", "voice-note.m4a", options);
 
     // 2. Attach the uploaded file ID to a new Notion page block
+    const notion = new Client({ auth: apiKey });
     await notion.pages.create({
-        parent: { database_id: 'YOUR_DATABASE_ID' },
-        properties: {
-            "Name": { title: [{ text: { content: "Uploaded File" } }] }
-        },
-        children: [
-            {
-                object: 'block',
-                type: 'audio', // Or 'image', 'file', etc.
-                audio: {
-                    type: 'file_upload',
-                    file_upload: { id: fileId }
-                }
+        parent: { database_id: "your_database_id" },
+        properties: { "Title": { title: [{ text: { content: "My Voice Note" } }] } },
+        children: [{
+            object: "block",
+            type: "audio",
+            audio: {
+                type: "file_upload",
+                file_upload: { id: fileId }
             }
-        ]
+        }]
     });
+    console.log("Success!");
 }
+run();
 ```
 
 ---

package/index.d.ts

@@ -1,6 +1,18 @@
+export interface UploadOptions {
+    /** Override the default Notion API version (default: '2026-03-11') */
+    notionVersion?: string;
+    /** Number of times to retry failed network requests with exponential backoff (default: 3) */
+    retries?: number;
+    /** Timeout in milliseconds for each network request */
+    timeoutMs?: number;
+    /** Standard AbortSignal to cancel the upload at any time */
+    signal?: AbortSignal;
+}
+
 export declare function uploadToNotion(
     apiKey: string,
-    fileBuffer: Buffer | Blob,
+    fileBuffer: Uint8Array | Blob | any,
     mimeType: string,
-    filename?: string
+    filename?: string,
+    options?: UploadOptions
 ): Promise<string>;

package/index.js

@@ -1,59 +1,162 @@
 /**
- * Uploads a binary file directly to Notion's servers using a 2-step multipart flow.
+ * Uploads a binary file directly to Notion's servers using native fetch.
+ * Automatically handles single-part (<= 20MB) and multi-part (> 20MB) chunking.
  * 
  * @param {string} apiKey - Your Notion Integration Token
  * @param {Buffer|Blob} fileBuffer - The binary data of the file (audio, image, pdf, etc.)
  * @param {string} mimeType - e.g., 'audio/mp4', 'image/jpeg', 'application/pdf'
  * @param {string} filename - The name of the file (e.g., 'voice-note.m4a')
+ * @param {object} options - Additional options like retries or Notion API version
  * @returns {Promise<string>} The Notion File ID to use in your blocks
  */
-async function uploadToNotion(apiKey, fileBuffer, mimeType, filename) {
+async function uploadToNotion(apiKey, fileBuffer, mimeType, filename, options = {}) {
     if (!apiKey) throw new Error("Notion API Key is required");
     if (!fileBuffer) throw new Error("File buffer is required");
 
+    const notionVersion = options.notionVersion || "2026-03-11";
+    const maxRetries = options.retries || 3;
+    const timeoutMs = options.timeoutMs;
+    const userSignal = options.signal;
+
     const size = fileBuffer.length || fileBuffer.size || fileBuffer.byteLength;
-    if (size && size > 20971520) {
-        throw new Error("File exceeds Notion's 20MB direct upload limit. Multi-part chunking for larger files will be supported in v2.0.");
+    
+    // Notion strictly limits files to 5GB (paid workspaces)
+    if (size > 5 * 1024 * 1024 * 1024) {
+        throw new Error("File exceeds Notion's absolute maximum size limit of 5GB.");
+    }
+
+    const isMultiPart = size > 20971520; // Notion's 20MB limit
+    const mode = isMultiPart ? "multi_part" : "single_part";
+    
+    // Default to 10MB chunks, but dynamically scale up if we hit the 1000 part limit
+    let CHUNK_SIZE = 10 * 1024 * 1024;
+    let numParts = isMultiPart ? Math.ceil(size / CHUNK_SIZE) : 1;
+
+    if (numParts > 1000) {
+        CHUNK_SIZE = Math.ceil(size / 1000);
+        numParts = 1000;
+    }
+
+    // Exponential backoff retry wrapper with Abort/Timeout support
+    const fetchWithRetry = async (url, fetchOptions, retries = maxRetries) => {
+        for (let i = 0; i < retries; i++) {
+            const controller = new AbortController();
+            let timeoutId;
+            
+            if (timeoutMs) {
+                timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            }
+
+            let abortHandler;
+            if (userSignal) {
+                if (userSignal.aborted) throw new Error("Upload aborted by user");
+                abortHandler = () => controller.abort();
+                userSignal.addEventListener("abort", abortHandler);
+            }
+
+            try {
+                const res = await fetch(url, { ...fetchOptions, signal: controller.signal });
+                if (timeoutId) clearTimeout(timeoutId);
+                if (userSignal && abortHandler) userSignal.removeEventListener("abort", abortHandler);
+                
+                if (res.ok) return res;
+                
+                // Notion Workspace Limit Check or Bad Request: Don't retry 4xx errors except 429 (Rate Limit)
+                if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+                    const error = new Error(`Notion API Error (${res.status}): ${await res.text()}`);
+                    error.isFatal = true;
+                    throw error;
+                }
+                
+                if (i === retries - 1) throw new Error(`Notion API Failed (${res.status}): ${await res.text()}`);
+            } catch (err) {
+                if (timeoutId) clearTimeout(timeoutId);
+                if (userSignal && abortHandler) userSignal.removeEventListener("abort", abortHandler);
+                
+                if (err.name === 'AbortError') throw new Error(userSignal?.aborted ? "Upload aborted by user" : "Upload timed out");
+                if (err.isFatal) throw err;
+                if (i === retries - 1) throw err;
+            }
+            await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i))); 
+        }
+    };
+
+    const createBody = {
+        filename: filename || "uploaded-file",
+        content_type: mimeType,
+        mode: mode
+    };
+    if (isMultiPart) {
+        createBody.number_of_parts = numParts;
     }
 
     // Step 1: Initialize the upload with Notion
-    const createRes = await fetch("https://api.notion.com/v1/file_uploads", {
+    const createRes = await fetchWithRetry("https://api.notion.com/v1/file_uploads", {
         method: "POST",
         headers: {
             "Authorization": `Bearer ${apiKey}`,
             "Content-Type": "application/json",
-            "Notion-Version": "2022-06-28"
+            "Notion-Version": notionVersion
         },
-        body: JSON.stringify({
-            filename: filename || "uploaded-file",
-            content_type: mimeType
-        })
+        body: JSON.stringify(createBody)
     });
 
-    if (!createRes.ok) {
-        throw new Error(`Notion Init Upload Failed: ${await createRes.text()}`);
+    const createData = await createRes.json();
+    const { id, upload_url, complete_url } = createData;
+
+    // Step 2: Upload the binary data
+    if (!isMultiPart) {
+        // Single-part upload
+        const form = new FormData();
+        const blob = new Blob([fileBuffer], { type: mimeType });
+        form.append("file", blob, filename || "uploaded-file");
+
+        await fetchWithRetry(upload_url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Notion-Version": notionVersion
+            },
+            body: form
+        });
+        return id;
     }
-    
-    const { id, upload_url } = await createRes.json();
 
-    // Step 2: Upload the binary data via Multipart FormData
-    const form = new FormData();
-    const blob = new Blob([fileBuffer], { type: mimeType });
-    form.append("file", blob, filename || "uploaded-file");
+    // Multi-part chunked upload
+    for (let part = 0; part < numParts; part++) {
+        const start = part * CHUNK_SIZE;
+        const end = Math.min(start + CHUNK_SIZE, size);
+        
+        // Handle slice for both Buffer and Blob
+        const chunk = typeof fileBuffer.slice === 'function' ? fileBuffer.slice(start, end) : fileBuffer.subarray(start, end);
+
+        const form = new FormData();
+        const blob = new Blob([chunk], { type: mimeType });
+        form.append("file", blob, filename || "uploaded-file");
+        form.append("part_number", (part + 1).toString()); // 1-indexed
 
-    const uploadRes = await fetch(upload_url, {
+        await fetchWithRetry(upload_url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Notion-Version": notionVersion
+            },
+            body: form
+        });
+    }
+
+    // Step 3: Complete multi-part upload
+    const targetCompleteUrl = complete_url || `https://api.notion.com/v1/file_uploads/${id}/complete`;
+    await fetchWithRetry(targetCompleteUrl, {
         method: "POST",
         headers: {
             "Authorization": `Bearer ${apiKey}`,
-            "Notion-Version": "2022-06-28"
+            "Content-Type": "application/json",
+            "Notion-Version": notionVersion
         },
-        body: form
+        body: JSON.stringify({})
     });
 
-    if (!uploadRes.ok) {
-        throw new Error(`Notion Binary Upload Failed: ${await uploadRes.text()}`);
-    }
-
     return id;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notion-multipart-uploader",
-  "version": "1.0.1",
+  "version": "2.1.4",
   "description": "Native zero-dependency multipart file uploader for Notion API. Direct upload any media type (videos, phone gallery images, audio, PDFs, and binary blobs) to Notion without external hosting.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -14,7 +14,8 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node test.js"
+    "test": "node --test test.mock.js",
+    "test:integration": "node test.js"
   },
   "keywords": [
     "notion",