gatsby-source-notion-churnotion 1.1.28 → 1.1.29

package/dist/api/getPages.js

@@ -6,237 +6,115 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPages = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const constants_1 = require("../constants");
-const fetchData_1 = require("../util/fetchData");
 const processor_1 = require("../util/processor");
 const slugify_1 = require("../util/slugify");
-const bookCategoryMap_1 = __importDefault(require("../util/bookCategoryMap"));
 const formatDate_1 = require("../util/formatDate");
+const service_1 = require("./service");
+const timeLimit_1 = require("../util/timeLimit");
+// 최대 동시 요청 수 설정
+const MAX_CONCURRENT_REQUESTS = 5;
 const getPages = async ({ databaseId, reporter, getCache, actions, createNode, createNodeId, createParentChildLink, getNode, cache, }) => {
+    // Notion Service 초기화
+    const notionService = new service_1.NotionService({
+        reporter,
+        parallelLimit: MAX_CONCURRENT_REQUESTS,
+        enableCaching: true,
+    });
+    // 태그 매핑을 위한 객체
+    const tagMap = {};
     /**
      * 데이터베이스 내에 페이지들을 읽어서 재귀적으로 추가하는 서브 메서드드
      * @param databaseId 데이터베이스 아이디
      * @param parentCategoryId 부모 데이터베이스 아이디
      */
-    const processDatabase = async (databaseId, parentCategoryId = null, categoryPath = [], tagMap = {}, parentCategoryUrl = ``) => {
+    const processDatabase = async (databaseId, parentCategoryId = null, categoryPath = [], parentCategoryUrl = ``) => {
         let hasMore = true;
         try {
+            // 동시에 처리될 페이지 목록
+            const pagesToProcess = [];
             while (hasMore) {
-                const databaseUrl = `databases/${databaseId}/query`;
-                const body = {};
-                const result = await (0, fetchData_1.fetchPostWithRetry)(databaseUrl, body);
+                // 데이터베이스 쿼리
+                const result = await notionService.queryDatabase(databaseId);
+                hasMore = false; // Notion API가 페이지네이션을 완전히 지원하지 않으므로 일단 한 번만 처리
                 if (result?.results?.length) {
                     reporter.info(`[SUCCESS] total pages > ${result.results.length}`);
-                }
-                for (const page of result.results) {
-                    const pageUrl = `blocks/${page.id}/children?page_size=100`;
-                    // 페이지 데이터
-                    const pageData = await (0, fetchData_1.fetchGetWithRetry)(pageUrl);
-                    if (pageData.results[0].type === `child_database`) {
-                        const categoryJsonData = pageData.results[0];
-                        const title = categoryJsonData.child_database?.title || `Unnamed Category`;
-                        const slug = (0, slugify_1.slugify)(title) || `no-title-${categoryJsonData.id}`;
-                        if (!title) {
-                            reporter.warn(`[WARNING] Category without a title detected: ${categoryJsonData.id}`);
-                        }
-                        const nodeId = createNodeId(`${categoryJsonData.id}-category`);
-                        const categoryUrl = `${parentCategoryUrl}/${slug}`;
-                        const categoryNode = {
-                            id: nodeId,
-                            category_name: title,
-                            parent: parentCategoryId,
-                            slug: slug,
-                            children: [],
-                            internal: {
-                                type: constants_1.NODE_TYPE.Category,
-                                contentDigest: crypto_1.default
-                                    .createHash(`md5`)
-                                    .update(JSON.stringify(categoryJsonData))
-                                    .digest(`hex`),
-                            },
-                            url: `${constants_1.COMMON_URI}/${constants_1.CATEGORY_URI}${categoryUrl}`,
-                            books: [],
+                    // 페이지 ID 목록 수집
+                    const pageIds = result.results.map((page) => page.id);
+                    // 페이지 블록들을 병렬로 가져오기
+                    const pagesBlocks = await notionService.getMultiplePagesBlocks(pageIds);
+                    // 페이지 데이터와 블록 결합
+                    for (const page of result.results) {
+                        const pageData = {
+                            page,
+                            blocks: pagesBlocks[page.id] || [],
                         };
-                        await createNode(categoryNode);
-                        const bookRelations = page.properties?.book?.relation || null;
-                        if (bookRelations) {
-                            bookRelations.forEach((relation) => {
-                                const bookId = relation.id;
-                                const bookNodeId = createNodeId(`${bookId}-book`);
-                                const bookNode = getNode(bookNodeId);
-                                if (bookNode) {
-                                    createParentChildLink({
-                                        parent: categoryNode,
-                                        child: bookNode,
-                                    });
-                                    const updatedBookNode = {
-                                        ...bookNode,
-                                        book_category: categoryNode.id,
-                                        internal: {
-                                            type: bookNode.internal.type,
-                                            contentDigest: crypto_1.default
-                                                .createHash(`md5`)
-                                                .update(JSON.stringify(bookNode))
-                                                .digest(`hex`),
-                                        },
-                                    };
-                                    createNode(updatedBookNode);
-                                    reporter.info(`[SUCCESS] Linked Category-Book: ${categoryNode.category_name} -> child: ${bookNode.book_name}`);
-                                }
-                            });
-                        }
-                        if (parentCategoryId && categoryNode) {
-                            const parentNode = getNode(parentCategoryId); // Gatsby에서 노드를 검색
-                            if (parentNode) {
-                                createParentChildLink({
-                                    parent: parentNode,
-                                    child: categoryNode,
-                                });
-                                reporter.info(`[SUCCESS] Linked parent: ${parentNode.category_name} -> child: ${categoryNode.category_name}`);
-                            }
-                            else {
-                                reporter.warn(`[WARNING] Parent node not found for ID: ${parentCategoryId}`);
-                            }
-                        }
-                        const newCategoryPath = [...categoryPath, categoryNode];
-                        await processDatabase(categoryJsonData.id, nodeId, newCategoryPath, tagMap, categoryUrl);
-                    }
-                    else {
-                        // 페이지인 경우
-                        const title = page.properties?.[`이름`]?.title?.[0]?.plain_text || `Unnamed`;
-                        const slug = (0, slugify_1.slugify)(page.properties?.[`slug`]?.rich_text?.[0]?.plain_text ||
-                            crypto_1.default
-                                .createHash(`md5`)
-                                .update(JSON.stringify(title))
-                                .digest(`hex`));
-                        if (!page.properties?.[`이름`]?.title?.[0]?.plain_text) {
-                            reporter.warn(`[WARNING] Category without a title detected: ${page.id}`);
-                        }
-                        const nodeId = createNodeId(`${page.id}-page`);
-                        // Tag 노드 만들기
-                        const tagIds = [];
-                        if (page.properties.tags && page.properties.tags.multi_select) {
-                            page.properties.tags.multi_select.forEach((tagData) => {
-                                if (tagMap[tagData.name]) {
-                                    // 이미 존재하는 태그라면 tagMap에서 가져오기
-                                    const existingTagId = tagMap[tagData.name];
-                                    tagIds.push(existingTagId); // 기존 태그 ID 추가
-                                    reporter.info(`[INFO] Reusing existing tag: ${tagData.name}`);
-                                }
-                                else {
-                                    // 새로운 태그 생성
-                                    const tagNodeId = createNodeId(`${tagData.id}-tag`);
-                                    tagMap[tagData.name] = tagNodeId; // tagMap에 저장
-                                    tagIds.push(tagNodeId); // 새로운 태그 ID 추가
-                                    const slug = (0, slugify_1.slugify)(tagData.name) || `no-tag-${tagNodeId}`;
-                                    // 태그 노드 생성
-                                    const tagNode = {
-                                        id: tagNodeId,
-                                        tag_name: tagData.name,
-                                        slug: slug,
-                                        color: tagData.color,
-                                        children: [],
-                                        internal: {
-                                            type: constants_1.NODE_TYPE.Tag,
-                                            contentDigest: crypto_1.default
-                                                .createHash(`md5`)
-                                                .update(JSON.stringify(tagData))
-                                                .digest(`hex`),
-                                        },
-                                        url: `${constants_1.COMMON_URI}/${constants_1.TAG_URI}/${slug}`,
-                                        churnotions: [],
-                                        parent: null,
-                                    };
-                                    createNode(tagNode);
-                                    reporter.info(`[SUCCESS] Created new tag: ${tagData.name}`);
-                                }
-                            });
-                        }
-                        const bookId = page.properties?.book?.relation?.[0]?.id || null;
-                        const bookNodeId = createNodeId(`${bookId}-book`);
-                        const bookNode = getNode(bookNodeId);
-                        const [imageNode, tableOfContents, updatedBlocks, rawText] = await (0, processor_1.processor)(pageData.results, actions, getCache, createNodeId, reporter, cache);
-                        const postNode = {
-                            id: nodeId,
-                            category: parentCategoryId,
-                            book: bookNode?.id,
-                            book_index: page.properties?.bookIndex?.number || 0,
-                            title: title,
-                            content: updatedBlocks,
-                            create_date: (0, formatDate_1.useFormatDate)(page.created_time),
-                            update_date: (0, formatDate_1.useFormatDate)(page.last_edited_time),
-                            version: page.properties?.version?.number || null,
-                            description: page.properties?.description?.rich_text?.[0]?.plain_text ||
-                                rawText.substring(0, 400),
-                            slug: slug,
-                            category_list: categoryPath,
-                            children: [],
-                            tableOfContents,
-                            internal: {
-                                type: constants_1.NODE_TYPE.Post,
-                                contentDigest: crypto_1.default
-                                    .createHash(`md5`)
-                                    .update(JSON.stringify(nodeId))
-                                    .digest(`hex`),
-                            },
-                            tags: tagIds,
-                            parent: null,
-                            url: `${constants_1.COMMON_URI}/${constants_1.POST_URI}${parentCategoryUrl}/${slug}`,
-                            thumbnail: imageNode,
-                            rawText,
-                        };
-                        await createNode(postNode);
-                        if (bookNode) {
-                            createParentChildLink({
-                                parent: bookNode,
-                                child: postNode,
-                            });
-                            reporter.info(`[SUCCESS] Linked book: ${bookNode.book_name} -> page: ${postNode.title}`);
-                        }
-                        // tag와 post 부모-자식 관계 설정
-                        tagIds.forEach((tagId) => {
-                            const tagNode = getNode(tagId);
-                            if (tagNode) {
-                                createParentChildLink({
-                                    parent: tagNode,
-                                    child: postNode,
-                                });
-                                reporter.info(`[SUCCESS] Linked tag: ${tagNode.tag_name} -> page: ${postNode.title}`);
-                            }
-                            else {
-                                reporter.warn(`[WARNING] Tag node not found for ID: ${tagId}`);
-                            }
-                        });
-                        // category와 post 부모-자식 관계 설정
-                        if (parentCategoryId && postNode) {
-                            const parentNode = getNode(parentCategoryId); // Gatsby에서 노드를 검색
-                            if (parentNode) {
-                                createParentChildLink({
-                                    parent: parentNode,
-                                    child: postNode,
-                                });
-                                reporter.info(`[SUCCESS] Linked parent: ${parentNode.category_name} -> child: ${postNode.title}`);
-                            }
-                            else {
-                                reporter.warn(`[WARNING] Parent node not found for ID: ${parentCategoryId}`);
-                            }
-                        }
+                        pagesToProcess.push(pageData);
                     }
                 }
-                hasMore = result.has_more;
             }
+            // 모든 페이지 병렬 처리
+            await Promise.all(pagesToProcess.map(async ({ page, blocks }) => {
+                try {
+                    // Timeout 설정으로 너무 오래 걸리는 페이지는 건너뛰기
+                    await (0, timeLimit_1.timeLimit)(processPageData(page, blocks, parentCategoryId, categoryPath, tagMap, parentCategoryUrl), 30000, // 30초 제한
+                    `Processing page ${page.id} timed out after 30 seconds`);
+                }
+                catch (error) {
+                    reporter.warn(`[WARNING] Error processing page ${page.id}: ${error}`);
+                }
+            }));
         }
         catch (error) {
-            reporter.error(`[ERROR] fetching page`);
-            hasMore = false;
+            reporter.error(`[ERROR] Processing database ${databaseId} failed: ${error}`);
         }
     };
-    await processDatabase(databaseId);
-    // Category - Book Relation Update
-    for (const [categoryId, bookIds] of bookCategoryMap_1.default.entries()) {
-        const categoryNode = getNode(categoryId);
-        if (categoryNode) {
-            for (const bookId of bookIds) {
-                const bookNode = getNode(bookId);
+    /**
+     * 페이지 데이터 처리 메서드
+     */
+    const processPageData = async (page, pageBlocks, parentCategoryId, categoryPath, tagMap, parentCategoryUrl) => {
+        // 첫 번째 블록이 child_database인지 확인
+        if (pageBlocks?.[0]?.type === `child_database`) {
+            await processCategory(page, pageBlocks, parentCategoryId, categoryPath, tagMap, parentCategoryUrl);
+        }
+        else {
+            await processPost(page, pageBlocks, parentCategoryId, categoryPath, tagMap, parentCategoryUrl);
+        }
+    };
+    /**
+     * 카테고리 처리 메서드
+     */
+    const processCategory = async (page, pageBlocks, parentCategoryId, categoryPath, tagMap, parentCategoryUrl) => {
+        const categoryJsonData = pageBlocks[0];
+        const title = categoryJsonData.child_database?.title || `Unnamed Category`;
+        const slug = (0, slugify_1.slugify)(title) || `no-title-${categoryJsonData.id}`;
+        if (!title) {
+            reporter.warn(`[WARNING] Category without a title detected: ${categoryJsonData.id}`);
+        }
+        const nodeId = createNodeId(`${categoryJsonData.id}-category`);
+        const categoryUrl = `${parentCategoryUrl}/${slug}`;
+        const categoryNode = {
+            id: nodeId,
+            category_name: title,
+            parent: parentCategoryId,
+            slug: slug,
+            children: [],
+            internal: {
+                type: constants_1.NODE_TYPE.Category,
+                contentDigest: crypto_1.default
+                    .createHash(`md5`)
+                    .update(JSON.stringify(categoryJsonData))
+                    .digest(`hex`),
+            },
+            url: `${constants_1.COMMON_URI}/${constants_1.CATEGORY_URI}${categoryUrl}`,
+            books: [],
+        };
+        await createNode(categoryNode);
+        const bookRelations = page.properties?.book?.relation || null;
+        if (bookRelations) {
+            bookRelations.forEach((relation) => {
+                const bookId = relation.id;
+                const bookNodeId = createNodeId(`${bookId}-book`);
+                const bookNode = getNode(bookNodeId);
                 if (bookNode) {
                     createParentChildLink({
                         parent: categoryNode,
@@ -254,16 +132,153 @@ const getPages = async ({ databaseId, reporter, getCache, actions, createNode, c
                         },
                     };
                     createNode(updatedBookNode);
-                    reporter.info(`[SUCCESS] Linked Book to Category: ${bookNode.book_name} -> ${categoryNode.category_name}`);
+                    reporter.info(`[SUCCESS] Linked Category-Book: ${categoryNode.category_name} -> child: ${bookNode.book_name}`);
+                }
+            });
+        }
+        if (parentCategoryId && categoryNode) {
+            const parentNode = getNode(parentCategoryId);
+            if (parentNode) {
+                createParentChildLink({
+                    parent: parentNode,
+                    child: categoryNode,
+                });
+                reporter.info(`[SUCCESS] Linked parent: ${parentNode.category_name} -> child: ${categoryNode.category_name}`);
+            }
+            else {
+                reporter.warn(`[WARNING] Parent node not found for ID: ${parentCategoryId}`);
+            }
+        }
+        const newCategoryPath = [...categoryPath, categoryNode];
+        await processDatabase(categoryJsonData.id, nodeId, newCategoryPath, categoryUrl);
+    };
+    /**
+     * 포스트 처리 메서드
+     */
+    const processPost = async (page, pageBlocks, parentCategoryId, categoryPath, tagMap, parentCategoryUrl) => {
+        const title = page.properties?.[`이름`]?.title?.[0]?.plain_text || `Unnamed`;
+        const slug = (0, slugify_1.slugify)(page.properties?.[`slug`]?.rich_text?.[0]?.plain_text ||
+            crypto_1.default.createHash(`md5`).update(JSON.stringify(title)).digest(`hex`));
+        if (!page.properties?.[`이름`]?.title?.[0]?.plain_text) {
+            reporter.warn(`[WARNING] Post without a title detected: ${page.id}`);
+        }
+        const nodeId = createNodeId(`${page.id}-page`);
+        // Tag 노드 만들기
+        const tagIds = [];
+        if (page.properties.tags && page.properties.tags.multi_select) {
+            page.properties.tags.multi_select.forEach((tagData) => {
+                if (tagMap[tagData.name]) {
+                    // 이미 존재하는 태그라면 tagMap에서 가져오기
+                    const existingTagId = tagMap[tagData.name];
+                    tagIds.push(existingTagId); // 기존 태그 ID 추가
+                    reporter.info(`[INFO] Reusing existing tag: ${tagData.name}`);
                 }
                 else {
-                    reporter.warn(`[WARNING] Book node not found: ${bookId}`);
+                    // 새로운 태그 생성
+                    const tagNodeId = createNodeId(`${tagData.id}-tag`);
+                    tagMap[tagData.name] = tagNodeId; // tagMap에 저장
+                    tagIds.push(tagNodeId); // 새로운 태그 ID 추가
+                    const slug = (0, slugify_1.slugify)(tagData.name) || `no-tag-${tagNodeId}`;
+                    // 태그 노드 생성
+                    const tagNode = {
+                        id: tagNodeId,
+                        tag_name: tagData.name,
+                        slug: slug,
+                        color: tagData.color,
+                        children: [],
+                        internal: {
+                            type: constants_1.NODE_TYPE.Tag,
+                            contentDigest: crypto_1.default
+                                .createHash(`md5`)
+                                .update(JSON.stringify(tagData))
+                                .digest(`hex`),
+                        },
+                        url: `${constants_1.COMMON_URI}/${constants_1.TAG_URI}/${slug}`,
+                        churnotions: [],
+                        parent: null,
+                    };
+                    createNode(tagNode);
+                    reporter.info(`[SUCCESS] Created new tag: ${tagData.name}`);
                 }
+            });
+        }
+        const bookId = page.properties?.book?.relation?.[0]?.id || null;
+        const bookNodeId = createNodeId(`${bookId}-book`);
+        const bookNode = getNode(bookNodeId);
+        const [imageNode, tableOfContents, updatedBlocks, rawText] = await (0, processor_1.processor)(pageBlocks, actions, getCache, createNodeId, reporter, cache);
+        const postNode = {
+            id: nodeId,
+            category: parentCategoryId,
+            book: bookNode?.id,
+            book_index: page.properties?.bookIndex?.number || 0,
+            title: title,
+            content: updatedBlocks,
+            create_date: (0, formatDate_1.useFormatDate)(page.created_time),
+            update_date: (0, formatDate_1.useFormatDate)(page.last_edited_time),
+            version: page.properties?.version?.number || null,
+            description: page.properties?.description?.rich_text?.[0]?.plain_text ||
+                rawText.substring(0, 400),
+            slug: slug,
+            category_list: categoryPath,
+            children: [],
+            tags: tagIds,
+            tableOfContents,
+            internal: {
+                type: constants_1.NODE_TYPE.Post,
+                contentDigest: crypto_1.default
+                    .createHash(`md5`)
+                    .update(JSON.stringify(nodeId))
+                    .digest(`hex`),
+            },
+            url: `${constants_1.COMMON_URI}/${constants_1.POST_URI}/${slug}`,
+            thumbnail: imageNode,
+            parent: parentCategoryId,
+        };
+        await createNode(postNode);
+        if (parentCategoryId) {
+            const parentNode = getNode(parentCategoryId);
+            if (parentNode) {
+                createParentChildLink({
+                    parent: parentNode,
+                    child: postNode,
+                });
+                reporter.info(`[SUCCESS] Linked parent: ${parentNode.category_name} -> child: ${postNode.title}`);
             }
         }
-        else {
-            reporter.warn(`[WARNING] Category node not found: ${categoryId}`);
+        // 태그와 포스트 연결
+        tagIds.forEach((tagId) => {
+            const tagNode = getNode(tagId);
+            if (tagNode) {
+                const updatedTagNode = {
+                    ...tagNode,
+                    churnotions: [...(tagNode.churnotions || []), nodeId],
+                    internal: {
+                        type: tagNode.internal.type,
+                        contentDigest: crypto_1.default
+                            .createHash(`md5`)
+                            .update(JSON.stringify({
+                            ...tagNode,
+                            churnotions: [...(tagNode.churnotions || []), nodeId],
+                        }))
+                            .digest(`hex`),
+                    },
+                };
+                createNode(updatedTagNode);
+                reporter.info(`[SUCCESS] Added post to tag: ${tagNode.tag_name} -> ${postNode.title}`);
+            }
+        });
+        // 책과 포스트 연결
+        if (bookNode && postNode) {
+            createParentChildLink({
+                parent: bookNode,
+                child: postNode,
+            });
+            reporter.info(`[SUCCESS] Linked Book-Post: ${bookNode.book_name} -> child: ${postNode.title}`);
         }
-    }
+    };
+    // 초기 데이터베이스 처리 시작
+    await processDatabase(databaseId);
+    // 캐시 정리
+    notionService.clearCache();
 };
 exports.getPages = getPages;

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

@@ -0,0 +1 @@
+export * from "./notionService";

package/dist/api/service/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./notionService"), exports);

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

@@ -0,0 +1,37 @@
+import { Reporter } from "gatsby";
+import { BaseContentBlock } from "notion-types";
+export interface NotionServiceOptions {
+    reporter: Reporter;
+    parallelLimit?: number;
+    enableCaching?: boolean;
+}
+export declare class NotionService {
+    private reporter;
+    private parallelLimit;
+    private enableCaching;
+    private cache;
+    private limiter;
+    constructor(options: NotionServiceOptions);
+    /**
+     * 데이터베이스 쿼리
+     */
+    queryDatabase(databaseId: string, body?: any): Promise<any>;
+    /**
+     * 페이지의 자식 블록 가져오기
+     */
+    getPageBlocks(pageId: string): Promise<BaseContentBlock[]>;
+    /**
+     * 여러 페이지의 블록 병렬 처리
+     */
+    getMultiplePagesBlocks(pageIds: string[]): Promise<{
+        [id: string]: BaseContentBlock[];
+    }>;
+    /**
+     * 캐시 초기화
+     */
+    clearCache(): void;
+    /**
+     * 병렬 처리 제한 설정
+     */
+    setParallelLimit(limit: number): void;
+}

package/dist/api/service/notionService.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotionService = void 0;
+const fetchData_1 = require("../../util/fetchData");
+const p_limit_1 = __importDefault(require("p-limit"));
+class NotionService {
+    reporter;
+    parallelLimit;
+    enableCaching;
+    cache;
+    limiter;
+    constructor(options) {
+        this.reporter = options.reporter;
+        this.parallelLimit = options.parallelLimit || 5; // 기본 동시 요청 수
+        this.enableCaching = options.enableCaching !== false; // 기본값은 캐싱 활성화
+        this.cache = new Map();
+        this.limiter = (0, p_limit_1.default)(this.parallelLimit);
+    }
+    /**
+     * 데이터베이스 쿼리
+     */
+    async queryDatabase(databaseId, body = {}) {
+        const cacheKey = `database-${databaseId}-${JSON.stringify(body)}`;
+        if (this.enableCaching && this.cache.has(cacheKey)) {
+            this.reporter.info(`[CACHE] Using cached database query for ${databaseId}`);
+            return this.cache.get(cacheKey);
+        }
+        const databaseUrl = `databases/${databaseId}/query`;
+        try {
+            const result = await (0, fetchData_1.fetchPostWithRetry)(databaseUrl, body);
+            if (this.enableCaching) {
+                this.cache.set(cacheKey, result);
+            }
+            this.reporter.info(`[SUCCESS] Database query ${databaseId} - results: ${result?.results?.length || 0}`);
+            return result;
+        }
+        catch (error) {
+            this.reporter.error(`[ERROR] Failed to query database ${databaseId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 페이지의 자식 블록 가져오기
+     */
+    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);
+        }
+        const pageUrl = `blocks/${pageId}/children?page_size=100`;
+        try {
+            const data = await (0, fetchData_1.fetchGetWithRetry)(pageUrl);
+            const blocks = data.results;
+            if (this.enableCaching) {
+                this.cache.set(cacheKey, blocks);
+            }
+            return blocks;
+        }
+        catch (error) {
+            this.reporter.error(`[ERROR] Failed to get page blocks ${pageId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 여러 페이지의 블록 병렬 처리
+     */
+    async getMultiplePagesBlocks(pageIds) {
+        this.reporter.info(`[NOTION] Fetching blocks for ${pageIds.length} pages in parallel (limit: ${this.parallelLimit})`);
+        const tasks = pageIds.map((pageId) => this.limiter(async () => {
+            try {
+                const blocks = await this.getPageBlocks(pageId);
+                return { pageId, blocks };
+            }
+            catch (error) {
+                this.reporter.warn(`[WARNING] Failed to fetch blocks for page ${pageId}: ${error}`);
+                return { pageId, blocks: [] };
+            }
+        }));
+        const results = await Promise.all(tasks);
+        return results.reduce((acc, { pageId, blocks }) => {
+            acc[pageId] = blocks;
+            return acc;
+        }, {});
+    }
+    /**
+     * 캐시 초기화
+     */
+    clearCache() {
+        this.reporter.info(`[NOTION] Clearing service cache - entries: ${this.cache.size}`);
+        this.cache.clear();
+    }
+    /**
+     * 병렬 처리 제한 설정
+     */
+    setParallelLimit(limit) {
+        this.parallelLimit = limit;
+        this.limiter = (0, p_limit_1.default)(limit);
+        this.reporter.info(`[NOTION] Updated parallel request limit to ${limit}`);
+    }
+}
+exports.NotionService = NotionService;