gatsby-source-notion-churnotion 1.1.40 → 1.2.0

package/dist/api/getBooks.js

@@ -6,17 +6,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBooks = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const constants_1 = require("../constants");
-const fetchData_1 = require("../util/fetchData");
 const gatsby_source_filesystem_1 = require("gatsby-source-filesystem");
 const bookCategoryMap_1 = __importDefault(require("../util/bookCategoryMap"));
 const formatDate_1 = require("../util/formatDate");
+const service_1 = require("./service");
 const getBooks = async ({ bookDatabaseId, reporter, getCache, createNode, createNodeId, getNode, cache, }) => {
-    const databaseUrl = `databases/${bookDatabaseId}/query`;
+    // Initialize the TypeScript Notion Service for database queries
+    const notionService = new service_1.NotionService({
+        reporter,
+        parallelLimit: 5,
+        enableCaching: true,
+    });
     const cacheKey = `booksDatabase-${bookDatabaseId}`;
     let result = await cache.get(cacheKey);
     if (!result) {
         const body = {};
-        result = await (0, fetchData_1.fetchPostWithRetry)(databaseUrl, body);
+        result = await notionService.queryDatabase(bookDatabaseId, body);
         await cache.set(cacheKey, result);
     }
     if (result?.results?.length) {

package/dist/api/getPages.js

@@ -9,17 +9,32 @@ const constants_1 = require("../constants");
 const processor_1 = require("../util/processor");
 const slugify_1 = require("../util/slugify");
 const formatDate_1 = require("../util/formatDate");
+const rust_bindings_1 = require("../rust-bindings");
 const service_1 = require("./service");
 const timeLimit_1 = require("../util/timeLimit");
 // 최대 동시 요청 수 설정
-const MAX_CONCURRENT_REQUESTS = 5;
+const MAX_CONCURRENT_REQUESTS = 10;
 const getPages = async ({ databaseId, reporter, getCache, actions, createNode, createNodeId, createParentChildLink, getNode, cache, }) => {
-    // Notion Service 초기화
+    // Get the Notion API key from environment variables
+    const notionApiKey = process.env.NOTION_API_KEY;
+    if (!notionApiKey) {
+        reporter.error("[ERROR] NOTION_API_KEY environment variable is not set!");
+        throw new Error("NOTION_API_KEY environment variable is required");
+    }
+    // Initialize the TypeScript Notion Service for methods not implemented in Rust
     const notionService = new service_1.NotionService({
         reporter,
         parallelLimit: MAX_CONCURRENT_REQUESTS,
         enableCaching: true,
     });
+    // Initialize Rust-based Notion Service
+    const rustNotionService = new rust_bindings_1.RustNotionService({
+        reporter,
+        notionApiKey,
+        parallelLimit: MAX_CONCURRENT_REQUESTS,
+        enableCaching: true,
+    });
+    reporter.info(`[INIT] Initialized Rust-based Notion service with parallel limit: ${MAX_CONCURRENT_REQUESTS}`);
     // 태그 매핑을 위한 객체
     const tagMap = {};
     /**
@@ -33,7 +48,7 @@ const getPages = async ({ databaseId, reporter, getCache, actions, createNode, c
             // 동시에 처리될 페이지 목록
             const pagesToProcess = [];
             while (hasMore) {
-                // 데이터베이스 쿼리
+                // 데이터베이스 쿼리 (still use the TypeScript implementation for this)
                 const result = await notionService.queryDatabase(databaseId);
                 hasMore = false; // Notion API가 페이지네이션을 완전히 지원하지 않으므로 일단 한 번만 처리
                 if (result?.results?.length) {
@@ -44,7 +59,8 @@ const getPages = async ({ databaseId, reporter, getCache, actions, createNode, c
                     for (let i = 0; i < pageIds.length; i += 20) {
                         const batch = pageIds.slice(i, i + 20);
                         reporter.info(`[BATCH] Processing pages ${i + 1} to ${i + batch.length} of ${pageIds.length}`);
-                        const batchBlocks = await notionService.getMultiplePagesBlocks(batch);
+                        // Use the Rust implementation for parallel fetching
+                        const batchBlocks = await rustNotionService.getMultiplePagesBlocks(batch);
                         // 페이지 데이터와 블록 결합
                         for (const pageId of batch) {
                             const page = result.results.find((p) => p.id === pageId);

package/dist/api/service/notionService.d.ts

@@ -15,6 +15,18 @@ export declare class NotionService {
     private cache;
     private limiter;
     constructor(options: NotionServiceOptions);
+    /**
+     * GET 요청을 수행하는 함수 (재시도 로직 포함)
+     */
+    private fetchGetWithRetry;
+    /**
+     * POST 요청을 수행하는 함수 (재시도 로직 포함)
+     */
+    private fetchPostWithRetry;
+    /**
+     * 모든 블록 데이터를 가져오는 함수 (next_cursor 지원)
+     */
+    private fetchAllBlocks;
     /**
      * 데이터베이스 쿼리
      */

package/dist/api/service/notionService.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotionService = void 0;
-const fetchData_1 = require("../../util/fetchData");
+const connector_1 = require("../connector");
+const constants_1 = require("../../constants");
+const timeLimit_1 = require("../../util/timeLimit");
 /**
  * 간단한 병렬 제한 큐
  */
@@ -60,6 +62,99 @@ class NotionService {
         this.cache = new Map();
         this.limiter = new ParallelLimiter(this.parallelLimit);
     }
+    /**
+     * GET 요청을 수행하는 함수 (재시도 로직 포함)
+     */
+    async fetchGetWithRetry(url, tryCount = 0, maxRetries = 5) {
+        try {
+            const response = await connector_1.instance.get(url);
+            let results = response.data.results;
+            // Notion API 응답에 has_more가 있으면 추가 블록을 가져와 병합
+            if (response.data.has_more) {
+                const pageId = url.match(/blocks\/([^\/]*)\/children/)?.[1]; // 정확한 pageId 추출
+                if (pageId) {
+                    const additionalResults = await this.fetchAllBlocks(pageId, response.data.next_cursor);
+                    results = [...results, ...additionalResults]; // 기존 results에 추가 데이터 병합
+                }
+                else {
+                    this.reporter.warn(`[WARNING] Failed to extract pageId from URL: ${url}`);
+                }
+            }
+            return { ...response.data, results }; // 병합된 전체 데이터 반환
+        }
+        catch (error) {
+            const status = error.response?.status;
+            const message = error.response?.data?.message || `Unknown error`;
+            // Rate limit 오류 처리 (Exponential Backoff)
+            if (status === constants_1.NOTION_LIMIT_ERROR && tryCount < maxRetries) {
+                const delay = Math.pow(2, tryCount) * 1000;
+                this.reporter.info(`[${constants_1.PLUGIN_NAME}] Rate limit hit. Retrying in ${delay / 1000}s...`);
+                await (0, timeLimit_1.sleep)(delay);
+                return this.fetchGetWithRetry(url, tryCount + 1, maxRetries);
+            }
+            // 기타 예외 처리 (Exponential Backoff)
+            if (tryCount < maxRetries) {
+                const delay = Math.pow(2, tryCount) * 1000;
+                this.reporter.info(`[${constants_1.PLUGIN_NAME}] Unexpected error. Retrying in ${delay / 1000}s...`);
+                await (0, timeLimit_1.sleep)(delay);
+                return this.fetchGetWithRetry(url, tryCount + 1, maxRetries);
+            }
+            // 최대 재시도 초과 시 오류 출력 후 throw
+            this.reporter.error(`[${constants_1.PLUGIN_NAME}] Failed after ${tryCount} retries:`, message);
+            throw error;
+        }
+    }
+    /**
+     * POST 요청을 수행하는 함수 (재시도 로직 포함)
+     */
+    async fetchPostWithRetry(url, body, tryCount = 0, maxRetries = 5) {
+        try {
+            const response = await connector_1.instance.post(url, body);
+            return response.data;
+        }
+        catch (error) {
+            const status = error.response?.status;
+            const message = error.response?.data?.message || `Unknown error`;
+            // Rate limit 오류 처리 (Exponential Backoff)
+            if (status === constants_1.NOTION_LIMIT_ERROR && tryCount < maxRetries) {
+                const delay = Math.pow(2, tryCount) * 1000;
+                this.reporter.info(`[${constants_1.PLUGIN_NAME}] Rate limit hit. Retrying in ${delay / 1000}s...`);
+                await (0, timeLimit_1.sleep)(delay);
+                return this.fetchPostWithRetry(url, body, tryCount + 1, maxRetries);
+            }
+            // 기타 예외 처리 (Exponential Backoff)
+            if (tryCount < maxRetries) {
+                const delay = Math.pow(2, tryCount) * 1000;
+                this.reporter.info(`[${constants_1.PLUGIN_NAME}] Unexpected error. Retrying in ${delay / 1000}s...`);
+                await (0, timeLimit_1.sleep)(delay);
+                return this.fetchPostWithRetry(url, body, tryCount + 1, maxRetries);
+            }
+            // 최대 재시도 초과 시 오류 출력 후 throw
+            this.reporter.error(`[${constants_1.PLUGIN_NAME}] Failed after ${tryCount} retries:`, message);
+            throw error;
+        }
+    }
+    /**
+     * 모든 블록 데이터를 가져오는 함수 (next_cursor 지원)
+     */
+    async fetchAllBlocks(pageId, startCursor = null) {
+        let hasMore = true;
+        let nextCursor = startCursor;
+        let allResults = [];
+        while (hasMore) {
+            const pageUrl = `blocks/${pageId}/children?page_size=100${nextCursor ? `&start_cursor=${nextCursor}` : ""}`;
+            const result = await this.fetchGetWithRetry(pageUrl);
+            if (result?.results?.length) {
+                allResults = [...allResults, ...result.results];
+            }
+            hasMore = result.has_more || false;
+            nextCursor = result.next_cursor || null;
+            if (!nextCursor) {
+                hasMore = false;
+            }
+        }
+        return allResults;
+    }
     /**
      * 데이터베이스 쿼리
      */
@@ -71,7 +166,7 @@ class NotionService {
         }
         const databaseUrl = `databases/${databaseId}/query`;
         try {
-            const result = await (0, fetchData_1.fetchPostWithRetry)(databaseUrl, body);
+            const result = await this.fetchPostWithRetry(databaseUrl, body);
             if (this.enableCaching) {
                 this.cache.set(cacheKey, result);
             }
@@ -94,7 +189,7 @@ class NotionService {
         }
         const pageUrl = `blocks/${pageId}/children?page_size=100`;
         try {
-            const data = await (0, fetchData_1.fetchGetWithRetry)(pageUrl);
+            const data = await this.fetchGetWithRetry(pageUrl);
             const blocks = data.results;
             // 재귀적으로 has_children이 true인 블록의 자식들을 가져옴
             const blocksWithChildren = await this.fetchChildBlocks(blocks);

package/dist/rust-bindings.d.ts

@@ -0,0 +1,46 @@
+/**
+ * This file provides TypeScript bindings to the Rust implementation
+ * of parallel Notion API processing.
+ */
+import { Reporter } from "gatsby";
+/**
+ * Notion Block type from the Notion API
+ */
+export type NotionBlock = any;
+/**
+ * Options for the RustNotionService
+ */
+export interface RustNotionServiceOptions {
+    reporter: Reporter;
+    notionApiKey: string;
+    parallelLimit?: number;
+    enableCaching?: boolean;
+}
+/**
+ * A wrapper class that provides access to the Rust implementation
+ * of parallel processing for Notion API, with a fallback to the
+ * TypeScript implementation if the Rust module is not available.
+ */
+export declare class RustNotionService {
+    private reporter;
+    private notionApiKey;
+    private parallelLimit;
+    private enableCaching;
+    private cache;
+    private rustInstance;
+    constructor(options: RustNotionServiceOptions);
+    /**
+     * Get blocks for a single page, with recursive fetching of child blocks
+     */
+    getPageBlocks(pageId: string): Promise<NotionBlock[]>;
+    /**
+     * Get blocks for multiple pages in parallel, using Rust implementation if available
+     */
+    getMultiplePagesBlocks(pageIds: string[]): Promise<{
+        [id: string]: NotionBlock[];
+    }>;
+    /**
+     * Set the parallel processing limit
+     */
+    setParallelLimit(limit: number): void;
+}

package/dist/rust-bindings.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RustNotionService = void 0;
+// Use dynamic import with try-catch to handle module loading
+let notionParallel = null;
+try {
+    // When the compiled Rust library exists, load it
+    notionParallel = require("../rust/notion-parallel/index.node");
+}
+catch (error) {
+    console.warn("Rust bindings for notion-parallel not found. Using TypeScript fallback implementation.");
+}
+/**
+ * A wrapper class that provides access to the Rust implementation
+ * of parallel processing for Notion API, with a fallback to the
+ * TypeScript implementation if the Rust module is not available.
+ */
+class RustNotionService {
+    reporter;
+    notionApiKey;
+    parallelLimit;
+    enableCaching;
+    cache;
+    rustInstance = null;
+    constructor(options) {
+        this.reporter = options.reporter;
+        this.notionApiKey = options.notionApiKey;
+        this.parallelLimit = options.parallelLimit || 5;
+        this.enableCaching = options.enableCaching !== false;
+        this.cache = new Map();
+        // Initialize Rust instance if available
+        if (notionParallel) {
+            try {
+                this.rustInstance = new notionParallel.NotionParallel(this.notionApiKey, this.parallelLimit);
+                this.reporter.info(`[RUST] Initialized Rust-based parallel processing with limit: ${this.parallelLimit}`);
+            }
+            catch (error) {
+                this.reporter.warn(`[RUST] Failed to initialize Rust implementation: ${error}`);
+                this.rustInstance = null;
+            }
+        }
+    }
+    /**
+     * Get blocks for a single page, with recursive fetching of child blocks
+     */
+    async getPageBlocks(pageId) {
+        const cacheKey = `page-blocks-${pageId}`;
+        if (this.enableCaching && this.cache.has(cacheKey)) {
+            this.reporter.info(`[CACHE] Using cached page blocks for ${pageId}`);
+            return this.cache.get(cacheKey);
+        }
+        // Currently we don't have a direct Rust counterpart for a single page
+        // So we use the multiple pages method with a single ID
+        const results = await this.getMultiplePagesBlocks([pageId]);
+        const blocks = results[pageId] || [];
+        if (this.enableCaching) {
+            this.cache.set(cacheKey, blocks);
+        }
+        return blocks;
+    }
+    /**
+     * Get blocks for multiple pages in parallel, using Rust implementation if available
+     */
+    async getMultiplePagesBlocks(pageIds) {
+        this.reporter.info(`[NOTION] Fetching blocks for ${pageIds.length} pages in parallel (limit: ${this.parallelLimit})`);
+        // If Rust implementation is available and initialized, use it
+        if (this.rustInstance) {
+            try {
+                this.reporter.info(`[RUST] Using Rust implementation for parallel processing`);
+                const results = await this.rustInstance.getMultiplePagesBlocks(pageIds);
+                return results;
+            }
+            catch (error) {
+                this.reporter.warn(`[RUST] Error using Rust implementation, falling back to TypeScript: ${error}`);
+                // Fall back to TypeScript implementation
+            }
+        }
+        // Fallback to TypeScript implementation
+        // Import the TypeScript implementation dynamically
+        const { NotionService } = await Promise.resolve().then(() => __importStar(require("./api/service/notionService")));
+        // Create a NotionService instance with the same configuration
+        const tsService = new NotionService({
+            reporter: this.reporter,
+            parallelLimit: this.parallelLimit,
+            enableCaching: this.enableCaching,
+        });
+        return tsService.getMultiplePagesBlocks(pageIds);
+    }
+    /**
+     * Set the parallel processing limit
+     */
+    setParallelLimit(limit) {
+        this.reporter.info(`[NOTION] Updated parallel request limit to ${limit}`);
+        this.parallelLimit = limit;
+        // Update the Rust instance if available
+        if (this.rustInstance) {
+            this.rustInstance.setParallelLimit(limit);
+        }
+    }
+}
+exports.RustNotionService = RustNotionService;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gatsby-source-notion-churnotion",
   "description": "Gatsby plugin that can connect with One Notion Database RECURSIVELY using official API",
-  "version": "1.1.40",
+  "version": "1.2.0",
   "skipLibCheck": true,
   "license": "0BSD",
   "main": "./dist/gatsby-node.js",
@@ -11,7 +11,8 @@
   ],
   "scripts": {
     "clean": "del-cli dist",
-    "build": "tsc",
+    "build": "npm run build:rust && tsc",
+    "build:rust": "cd rust/notion-parallel && (cargo build --release || cargo build --release --target x86_64-pc-windows-gnu || echo 'Rust build failed, using TypeScript fallback') && cd ../..",
     "develop": "tsc --watch",
     "test": "jest",
     "prepare": "npm run clean && npm run build"
@@ -54,6 +55,7 @@
     "typescript": "^5.7.2"
   },
   "devDependencies": {
+    "@netlify/plugin-cachedir": "^1.0.0",
     "@types/node-fetch": "^2.6.12",
     "gatsby": "^5.14.0"
   },

package/dist/util/fetchData.d.ts

@@ -1,20 +0,0 @@
-/**
- * Notion API에서 모든 블록 데이터를 가져오는 함수 (next_cursor 지원)
- * @param {string} pageId - Notion 페이지 ID
- * @param {string | null} startCursor - 처음 호출 시 넘길 next_cursor (기본값 null)
- * @returns {Promise<any[]>} 모든 블록 데이터 리스트
- */
-export declare const fetchAllBlocks: (pageId: string, startCursor?: string | null) => Promise<any[]>;
-/**
- * Notion API에서 GET 요청을 수행하는 함수 (재시도 로직 포함)
- */
-export declare const fetchGetWithRetry: (url: string, options?: any, tryCount?: number, maxRetries?: number) => Promise<any>;
-/**
- * Notion API에서 POST 요청을 수행하는 함수 (재시도 로직 포함)
- * @param {string} url - API endpoint URL
- * @param {any} body - 요청 데이터
- * @param {number} tryCount - 현재 재시도 횟수
- * @param {number} maxRetries - 최대 재시도 횟수
- * @returns {Promise<any>} API 응답 데이터
- */
-export declare const fetchPostWithRetry: (url: string, body: any, tryCount?: number, maxRetries?: number) => Promise<any>;

package/dist/util/fetchData.js

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchPostWithRetry = exports.fetchGetWithRetry = exports.fetchAllBlocks = void 0;
-const connector_1 = require("../api/connector");
-const constants_1 = require("../constants");
-const timeLimit_1 = require("./timeLimit");
-/**
- * Notion API에서 모든 블록 데이터를 가져오는 함수 (next_cursor 지원)
- * @param {string} pageId - Notion 페이지 ID
- * @param {string | null} startCursor - 처음 호출 시 넘길 next_cursor (기본값 null)
- * @returns {Promise<any[]>} 모든 블록 데이터 리스트
- */
-const fetchAllBlocks = async (pageId, startCursor = null) => {
-    let hasMore = true;
-    let nextCursor = startCursor; // 초기 next_cursor를 설정
-    let allResults = [];
-    while (hasMore) {
-        const pageUrl = `blocks/${pageId}/children?page_size=100${nextCursor ? `&start_cursor=${nextCursor}` : ""}`;
-        const result = await (0, exports.fetchGetWithRetry)(pageUrl);
-        if (result?.results?.length) {
-            allResults = [...allResults, ...result.results]; // 기존 데이터와 병합
-        }
-        hasMore = result.has_more || false; // 다음 데이터가 있는지 확인
-        nextCursor = result.next_cursor || null; // 다음 페이지 커서 업데이트
-        // 만약 nextCursor가 계속 null이라면 루프 탈출
-        if (!nextCursor) {
-            hasMore = false;
-        }
-    }
-    return allResults;
-};
-exports.fetchAllBlocks = fetchAllBlocks;
-/**
- * Notion API에서 GET 요청을 수행하는 함수 (재시도 로직 포함)
- */
-const fetchGetWithRetry = async (url, options = {}, tryCount = 0, maxRetries = 5) => {
-    try {
-        const response = await connector_1.instance.get(url);
-        let results = response.data.results;
-        // Notion API 응답에 has_more가 있으면 추가 블록을 가져와 병합
-        if (response.data.has_more) {
-            const pageId = url.match(/blocks\/([^\/]*)\/children/)?.[1]; // 정확한 pageId 추출
-            if (pageId) {
-                const additionalResults = await (0, exports.fetchAllBlocks)(pageId, response.data.next_cursor); // next_cursor도 함께 전달
-                results = [...results, ...additionalResults]; // 기존 results에 추가 데이터 병합
-            }
-            else {
-                console.warn(`[WARNING] Failed to extract pageId from URL: ${url}`);
-            }
-        }
-        return { ...response.data, results }; // 병합된 전체 데이터 반환
-    }
-    catch (error) {
-        const status = error.response?.status;
-        const message = error.response?.data?.message || `Unknown error`;
-        // Rate limit 오류 처리 (Exponential Backoff)
-        if (status === constants_1.NOTION_LIMIT_ERROR && tryCount < maxRetries) {
-            const delay = Math.pow(2, tryCount) * 1000;
-            console.log(`[${constants_1.PLUGIN_NAME}] Rate limit hit. Retrying in ${delay / 1000}s...`);
-            await (0, timeLimit_1.sleep)(delay);
-            return (0, exports.fetchGetWithRetry)(url, options, tryCount + 1, maxRetries);
-        }
-        // 기타 예외 처리 (Exponential Backoff)
-        if (tryCount < maxRetries) {
-            const delay = Math.pow(2, tryCount) * 1000;
-            console.log(`[${constants_1.PLUGIN_NAME}] Unexpected error. Retrying in ${delay / 1000}s...`);
-            await (0, timeLimit_1.sleep)(delay);
-            return (0, exports.fetchGetWithRetry)(url, options, tryCount + 1, maxRetries);
-        }
-        // 최대 재시도 초과 시 오류 출력 후 throw
-        console.error(`[${constants_1.PLUGIN_NAME}] Failed after ${tryCount} retries:`, message);
-        throw error;
-    }
-};
-exports.fetchGetWithRetry = fetchGetWithRetry;
-/**
- * Notion API에서 POST 요청을 수행하는 함수 (재시도 로직 포함)
- * @param {string} url - API endpoint URL
- * @param {any} body - 요청 데이터
- * @param {number} tryCount - 현재 재시도 횟수
- * @param {number} maxRetries - 최대 재시도 횟수
- * @returns {Promise<any>} API 응답 데이터
- */
-const fetchPostWithRetry = async (url, body, tryCount = 0, maxRetries = 5) => {
-    try {
-        const response = await connector_1.instance.post(url, body);
-        // 요청 성공 시 데이터 반환
-        return response.data;
-    }
-    catch (error) {
-        const status = error.response?.status;
-        const message = error.response?.data?.message || `Unknown error`;
-        // Rate limit 오류 처리 (Exponential Backoff)
-        if (status === constants_1.NOTION_LIMIT_ERROR && tryCount < maxRetries) {
-            const delay = Math.pow(2, tryCount) * 1000;
-            console.log(`[${constants_1.PLUGIN_NAME}] Rate limit hit. Retrying in ${delay / 1000}s...`);
-            await (0, timeLimit_1.sleep)(delay);
-            return (0, exports.fetchPostWithRetry)(url, body, tryCount + 1, maxRetries);
-        }
-        // 기타 예외 처리 (Exponential Backoff)
-        if (tryCount < maxRetries) {
-            const delay = Math.pow(2, tryCount) * 1000;
-            console.log(`[${constants_1.PLUGIN_NAME}] Unexpected error. Retrying in ${delay / 1000}s...`);
-            await (0, timeLimit_1.sleep)(delay);
-            return (0, exports.fetchPostWithRetry)(url, body, tryCount + 1, maxRetries);
-        }
-        // 최대 재시도 초과 시 오류 출력 후 throw
-        console.error(`[${constants_1.PLUGIN_NAME}] Failed after ${tryCount} retries:`, message);
-        throw error;
-    }
-};
-exports.fetchPostWithRetry = fetchPostWithRetry;