gatsby-source-notion-churnotion 1.1.27 → 1.1.29

package/dist/util/blocks/blockProcessor.d.ts

@@ -0,0 +1,35 @@
+import { BaseContentBlock } from "notion-types";
+import { Actions, GatsbyCache, Reporter } from "gatsby";
+import { CustomImageBlock } from "../../types";
+export interface BlockProcessorContext {
+    actions: Actions;
+    getCache: (this: void, id: string) => GatsbyCache;
+    createNodeId: (this: void, input: string) => string;
+    reporter: Reporter;
+    cache: GatsbyCache;
+}
+export interface ProcessBlockResult {
+    thumbnail?: string | null;
+    plainText?: string;
+    updatedBlock?: BaseContentBlock;
+    tableOfContents?: {
+        type: string;
+        hash: string;
+        title: string;
+    }[];
+}
+export declare abstract class BlockProcessor {
+    protected context: BlockProcessorContext;
+    constructor(context: BlockProcessorContext);
+    abstract canProcess(block: BaseContentBlock): boolean;
+    abstract process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+    protected extractPlainText(block: BaseContentBlock): string | null;
+    protected isTextContentBlock(block: BaseContentBlock): block is BaseContentBlock & {
+        [key in "paragraph" | "heading_1" | "heading_2" | "heading_3" | "quote" | "bulleted_list_item" | "numbered_list_item" | "callout" | "code" | "toggle" | "to_do" | "bookmark" | "table_of_contents" | "breadcrumb" | "divider" | "embed"]?: {
+            rich_text: {
+                plain_text: string;
+            }[];
+        };
+    };
+    protected isImageBlock(block: BaseContentBlock): block is CustomImageBlock;
+}

package/dist/util/blocks/blockProcessor.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProcessor = void 0;
+class BlockProcessor {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    extractPlainText(block) {
+        if (this.isTextContentBlock(block)) {
+            const richTextArray = block[block.type]?.rich_text || [];
+            return richTextArray
+                .map((text) => block.type === "code" // code의 \n 제거
+                ? text.plain_text.replace(/\\n/g, "")
+                : text.plain_text)
+                .join(" ");
+        }
+        return null;
+    }
+    isTextContentBlock(block) {
+        return [
+            "paragraph",
+            "heading_1",
+            "heading_2",
+            "heading_3",
+            "quote",
+            "bulleted_list_item",
+            "numbered_list_item",
+            "callout",
+            "code",
+            "toggle",
+            "to_do",
+            "bookmark",
+            "table_of_contents",
+            "breadcrumb",
+            "divider",
+            "embed",
+        ].includes(block.type);
+    }
+    isImageBlock(block) {
+        return block.type === "image" && "image" in block;
+    }
+}
+exports.BlockProcessor = BlockProcessor;

package/dist/util/blocks/blockProcessorRegistry.d.ts

@@ -0,0 +1,10 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, BlockProcessorContext, ProcessBlockResult } from "./blockProcessor";
+export declare class BlockProcessorRegistry {
+    private processors;
+    private context;
+    constructor(context: BlockProcessorContext);
+    private registerDefaultProcessors;
+    registerProcessor(processor: BlockProcessor): void;
+    processBlock(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/blockProcessorRegistry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProcessorRegistry = void 0;
+const textBlockProcessor_1 = require("./textBlockProcessor");
+const imageBlockProcessor_1 = require("./imageBlockProcessor");
+const mediaBlockProcessor_1 = require("./mediaBlockProcessor");
+const structureBlockProcessor_1 = require("./structureBlockProcessor");
+class BlockProcessorRegistry {
+    processors = [];
+    context;
+    constructor(context) {
+        this.context = context;
+        this.registerDefaultProcessors();
+    }
+    registerDefaultProcessors() {
+        // 기본 프로세서 등록
+        this.registerProcessor(new textBlockProcessor_1.TextBlockProcessor(this.context));
+        this.registerProcessor(new imageBlockProcessor_1.ImageBlockProcessor(this.context));
+        this.registerProcessor(new mediaBlockProcessor_1.MediaBlockProcessor(this.context));
+        this.registerProcessor(new structureBlockProcessor_1.StructureBlockProcessor(this.context));
+    }
+    registerProcessor(processor) {
+        this.processors.push(processor);
+    }
+    async processBlock(block) {
+        for (const processor of this.processors) {
+            if (processor.canProcess(block)) {
+                return await processor.process(block);
+            }
+        }
+        // 어떤 프로세서도 처리할 수 없는 경우 (디버깅을 위해 타입 로그)
+        this.context.reporter.warn(`Unsupported block type: ${block.type}`);
+        // 기본 결과 반환
+        return {
+            updatedBlock: block,
+            plainText: "",
+        };
+    }
+}
+exports.BlockProcessorRegistry = BlockProcessorRegistry;

package/dist/util/blocks/imageBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class ImageBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/imageBlockProcessor.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const gatsby_source_filesystem_1 = require("gatsby-source-filesystem");
+class ImageBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return this.isImageBlock(block);
+    }
+    async process(block) {
+        const { actions, getCache, createNodeId, reporter, cache } = this.context;
+        const { createNode } = actions;
+        const imageBlock = block;
+        if (block.type === "image" && "image" in block) {
+            const imageSourceType = imageBlock.image.type;
+            const imageUrl = imageSourceType === `external`
+                ? imageBlock.image.external?.url
+                : imageBlock.image?.file?.url;
+            if (!imageUrl)
+                return { updatedBlock: block };
+            // GIF 파일 처리
+            if (imageUrl.endsWith(".gif")) {
+                const staticDir = path_1.default.join(process.cwd(), "static"); // Gatsby의 static 디렉토리
+                const gifFileName = path_1.default.basename(imageUrl); // 파일 이름 추출
+                const gifFilePath = path_1.default.join(staticDir, gifFileName);
+                // 이미 static 디렉토리에 파일이 있는지 확인
+                if (!fs_extra_1.default.existsSync(gifFilePath)) {
+                    try {
+                        reporter.info(`[GIF PROCESSING] Downloading GIF: ${imageUrl}`);
+                        const response = await fetch(imageUrl);
+                        if (!response.ok) {
+                            throw new Error(`Failed to download GIF: ${response.statusText}`);
+                        }
+                        const arrayBuffer = await response.arrayBuffer();
+                        const buffer = Buffer.from(arrayBuffer);
+                        await fs_extra_1.default.ensureDir(staticDir); // static 디렉토리 생성
+                        await fs_extra_1.default.writeFile(gifFilePath, buffer); // GIF 파일 저장
+                        reporter.info(`[GIF SUCCESS] Saved GIF to static: ${gifFilePath}`);
+                    }
+                    catch (error) {
+                        reporter.warn(`[GIF WARNING] Failed to process GIF: ${imageUrl}`);
+                        return { updatedBlock: block };
+                    }
+                }
+                else {
+                    reporter.info(`[GIF CACHE HIT] GIF already exists: ${gifFilePath}`);
+                }
+                // GIF 파일을 정적 파일로 추가
+                const updatedBlock = {
+                    ...imageBlock,
+                    image: {
+                        fileId: gifFileName, // static 경로를 기준으로 참조
+                        caption: imageBlock.image.caption,
+                    },
+                };
+                return {
+                    updatedBlock: updatedBlock,
+                    thumbnail: gifFileName,
+                };
+            }
+            // GIF가 아닌 경우 기존 로직 유지
+            const cacheKey = `${imageUrl}-post-image`;
+            const cachedFileNodeId = await cache.get(cacheKey);
+            if (cachedFileNodeId) {
+                reporter.info(`[CACHE HIT] Image already processed: ${imageUrl}`);
+                const updatedBlock = {
+                    ...imageBlock,
+                    image: {
+                        fileId: cachedFileNodeId,
+                        caption: imageBlock.image.caption,
+                    },
+                };
+                return {
+                    updatedBlock: updatedBlock,
+                    thumbnail: cachedFileNodeId,
+                };
+            }
+            try {
+                const fileNode = await (0, gatsby_source_filesystem_1.createRemoteFileNode)({
+                    url: imageUrl,
+                    parentNodeId: block.id,
+                    getCache,
+                    createNode,
+                    createNodeId,
+                });
+                if (fileNode) {
+                    await cache.set(cacheKey, fileNode.id);
+                    const updatedBlock = {
+                        ...imageBlock,
+                        image: {
+                            fileId: fileNode.id,
+                            caption: imageBlock.image.caption,
+                        },
+                    };
+                    return {
+                        updatedBlock: updatedBlock,
+                        thumbnail: fileNode.id,
+                    };
+                }
+            }
+            catch (error) {
+                reporter.warn(`[WARNING] Failed to download or process image: ${imageUrl}`);
+            }
+        }
+        return { updatedBlock: block };
+    }
+}
+exports.ImageBlockProcessor = ImageBlockProcessor;

package/dist/util/blocks/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./blockProcessor";
+export * from "./blockProcessorRegistry";
+export * from "./imageBlockProcessor";
+export * from "./mediaBlockProcessor";
+export * from "./structureBlockProcessor";
+export * from "./textBlockProcessor";

package/dist/util/blocks/index.js

@@ -0,0 +1,22 @@
+"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("./blockProcessor"), exports);
+__exportStar(require("./blockProcessorRegistry"), exports);
+__exportStar(require("./imageBlockProcessor"), exports);
+__exportStar(require("./mediaBlockProcessor"), exports);
+__exportStar(require("./structureBlockProcessor"), exports);
+__exportStar(require("./textBlockProcessor"), exports);

package/dist/util/blocks/mediaBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class MediaBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/mediaBlockProcessor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class MediaBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return ["bookmark", "embed", "video", "audio", "pdf", "file"].includes(block.type);
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        // 미디어 블록 타입 처리 로직
+        const blockType = block.type;
+        // 각 블록 타입에 맞는 특별한 처리가 필요한 경우 여기에 추가
+        switch (blockType) {
+            case "bookmark":
+                reporter.info(`Processing bookmark block: ${JSON.stringify(block.bookmark?.url)}`);
+                break;
+            case "embed":
+                reporter.info(`Processing embed block: ${JSON.stringify(block.embed?.url)}`);
+                break;
+            case "video":
+                reporter.info(`Processing video block with type: ${JSON.stringify(block.video?.type)}`);
+                break;
+            case "audio":
+                reporter.info(`Processing audio block with type: ${JSON.stringify(block.audio?.type)}`);
+                break;
+            case "pdf":
+                reporter.info(`Processing pdf block with type: ${JSON.stringify(block.pdf?.type)}`);
+                break;
+            case "file":
+                reporter.info(`Processing file block with type: ${JSON.stringify(block.file?.type)}`);
+                break;
+        }
+        // 블록의 텍스트 컨텐츠를 추출하려고 시도합니다.
+        let plainText = "";
+        // bookmark와 같은 일부 블록은 캡션에 텍스트가 있을 수 있습니다.
+        if (blockType === "bookmark" && block.bookmark?.caption) {
+            plainText = block.bookmark.caption
+                .map((item) => item.plain_text)
+                .join(" ");
+        }
+        return {
+            plainText,
+            updatedBlock: block,
+        };
+    }
+}
+exports.MediaBlockProcessor = MediaBlockProcessor;

package/dist/util/blocks/structureBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class StructureBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/structureBlockProcessor.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class StructureBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return [
+            "column",
+            "column_list",
+            "table",
+            "table_row",
+            "divider",
+            "breadcrumb",
+            "table_of_contents",
+            "equation",
+            "synced_block",
+            "template",
+            "link_to_page",
+            "link_preview",
+        ].includes(block.type);
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        // 구조 블록 타입 처리 로직
+        const blockType = block.type;
+        // 각 블록 타입에 맞는 특별한 처리가 필요한 경우 여기에 추가
+        switch (blockType) {
+            case "column":
+                reporter.info(`Processing column block`);
+                break;
+            case "column_list":
+                reporter.info(`Processing column_list block`);
+                break;
+            case "table":
+                reporter.info(`Processing table block: table_width=${JSON.stringify(block.table?.table_width)}`);
+                break;
+            case "table_row":
+                const cellCount = block.table_row?.cells?.length || 0;
+                reporter.info(`Processing table_row block with ${cellCount} cells`);
+                break;
+            case "divider":
+                reporter.info(`Processing divider block`);
+                break;
+            case "breadcrumb":
+                reporter.info(`Processing breadcrumb block`);
+                break;
+            case "table_of_contents":
+                reporter.info(`Processing table_of_contents block`);
+                break;
+            case "equation":
+                reporter.info(`Processing equation block: ${JSON.stringify(block.equation?.expression)}`);
+                break;
+            case "synced_block":
+                reporter.info(`Processing synced_block`);
+                break;
+            case "template":
+                reporter.info(`Processing template block`);
+                break;
+            case "link_to_page":
+                reporter.info(`Processing link_to_page block`);
+                break;
+            case "link_preview":
+                reporter.info(`Processing link_preview block: ${JSON.stringify(block.link_preview?.url)}`);
+                break;
+        }
+        // 일부 구조 블록은 텍스트를 포함할 수 있음
+        let plainText = "";
+        // 테이블 셀에서 텍스트 추출 예시
+        if (blockType === "table_row" && block.table_row?.cells) {
+            plainText = block.table_row.cells
+                .flat()
+                .map((cell) => cell.plain_text || "")
+                .join(" ");
+        }
+        return {
+            plainText,
+            updatedBlock: block,
+        };
+    }
+}
+exports.StructureBlockProcessor = StructureBlockProcessor;

package/dist/util/blocks/textBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class TextBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/textBlockProcessor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+const tableOfContent_1 = require("../tableOfContent");
+class TextBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return this.isTextContentBlock(block);
+    }
+    async process(block) {
+        const tableOfContents = [];
+        // 목차 처리
+        await (0, tableOfContent_1.processTableOfContents)(block, tableOfContents);
+        // 텍스트 추출
+        const plainText = this.extractPlainText(block);
+        return {
+            plainText: plainText || "",
+            updatedBlock: block,
+            tableOfContents: tableOfContents.length > 0 ? tableOfContents : undefined,
+        };
+    }
+}
+exports.TextBlockProcessor = TextBlockProcessor;

package/dist/util/fetchData.js

@@ -16,13 +16,10 @@ const fetchAllBlocks = async (pageId, startCursor = null) => {
     let allResults = [];
     while (hasMore) {
         const pageUrl = `blocks/${pageId}/children?page_size=100${nextCursor ? `&start_cursor=${nextCursor}` : ""}`;
-        console.log(`[INFO] Fetching blocks from: ${pageUrl}`); // 디버깅용 로그
         const result = await (0, exports.fetchGetWithRetry)(pageUrl);
         if (result?.results?.length) {
             allResults = [...allResults, ...result.results]; // 기존 데이터와 병합
         }
-        console.log(`[INFO] Retrieved ${result.results.length} blocks`);
-        console.log(`[INFO] has_more: ${result.has_more}, next_cursor: ${result.next_cursor}`);
         hasMore = result.has_more || false; // 다음 데이터가 있는지 확인
         nextCursor = result.next_cursor || null; // 다음 페이지 커서 업데이트
         // 만약 nextCursor가 계속 null이라면 루프 탈출
@@ -37,16 +34,13 @@ exports.fetchAllBlocks = fetchAllBlocks;
  * Notion API에서 GET 요청을 수행하는 함수 (재시도 로직 포함)
  */
 const fetchGetWithRetry = async (url, options = {}, tryCount = 0, maxRetries = 5) => {
-    console.log(`[GET] Request URL: ${url}`); // 디버깅용 로그
     try {
         const response = await connector_1.instance.get(url);
         let results = response.data.results;
-        console.log(`[INFO] Initial results count: ${results.length}`);
         // Notion API 응답에 has_more가 있으면 추가 블록을 가져와 병합
         if (response.data.has_more) {
             const pageId = url.match(/blocks\/([^\/]*)\/children/)?.[1]; // 정확한 pageId 추출
             if (pageId) {
-                console.log(`[INFO] Fetching additional blocks for pageId: ${pageId} with next_cursor: ${response.data.next_cursor}`);
                 const additionalResults = await (0, exports.fetchAllBlocks)(pageId, response.data.next_cursor); // next_cursor도 함께 전달
                 results = [...results, ...additionalResults]; // 기존 results에 추가 데이터 병합
             }