gatsby-source-notion-churnotion 1.2.3 → 1.2.5

package/dist/createSchemaCustomization.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSchemaCustomization = void 0;
 const constants_1 = require("./constants");
+const resolvers_1 = require("./util/resolvers");
 const createSchemaCustomization = ({ actions, schema }) => {
     const { createTypes } = actions;
     createTypes([
@@ -119,48 +120,118 @@ const createSchemaCustomization = ({ actions, schema }) => {
                 },
             },
         }),
-        `
-        type ${constants_1.NODE_TYPE.Post} implements Node {
-            id: ID!
-            category: ${constants_1.NODE_TYPE.Category}! @link(by: "id", from: "category")
-            tags: [${constants_1.NODE_TYPE.Tag}] @link(by: "id")
-            book: ${constants_1.NODE_TYPE.Book} @link(by: "id")
-            book_index: Int
-            title: String
-            content: [JSON]
-            create_date: Date! @dateformat
-            update_date: Date! @dateformat
-            version: Int
-            description: String
-            slug: String
-            tableOfContents: [JSON]
-            category_list: [${constants_1.NODE_TYPE.Category}]
-            url: String!
-            thumbnail: File @link(by: "id", from: "thumbnail")
-            rawText: String
-        }
-        
-        type ${constants_1.NODE_TYPE.Tag} implements Node {
-            id: ID!
-            tag_name: String!
-            slug: String!
-            color: String!
-            children: [${constants_1.NODE_TYPE.Post}] @link(by: "id", from: "tags")
-            url: String!
-        }
-
-        type ${constants_1.NODE_TYPE.Metadata} implements Node {
-            id: ID!,
-            title: String,
-            description: String,
-            image: String,
-            url: String,
-        }
-
-        type ${constants_1.NODE_TYPE.RelatedPost} implements Node {
-            posts: [${constants_1.NODE_TYPE.Post}] @link(by: "id")
-        }
-    `,
+        schema.buildObjectType({
+            name: constants_1.NODE_TYPE.Post,
+            interfaces: ["Node"],
+            fields: {
+                id: "ID!",
+                category: {
+                    type: `${constants_1.NODE_TYPE.Category}!`,
+                    extensions: {
+                        link: { by: "id", from: "category" },
+                    },
+                },
+                tags: {
+                    type: `[${constants_1.NODE_TYPE.Tag}]`,
+                    extensions: {
+                        link: { by: "id" },
+                    },
+                },
+                book: {
+                    type: constants_1.NODE_TYPE.Book,
+                    extensions: {
+                        link: { by: "id" },
+                    },
+                },
+                book_index: "Int",
+                title: "String",
+                content: "[JSON]",
+                create_date: {
+                    type: "Date!",
+                    extensions: {
+                        dateformat: {},
+                    },
+                },
+                update_date: {
+                    type: "Date!",
+                    extensions: {
+                        dateformat: {},
+                    },
+                },
+                version: "Int",
+                description: "String",
+                slug: "String",
+                tableOfContents: "[TocEntry]",
+                formattedTableOfContents: {
+                    type: "[TocEntry]",
+                    resolve: (source, args, context) => {
+                        if (!source.tableOfContents)
+                            return [];
+                        return (0, resolvers_1.formatTableOfContents)(source.tableOfContents, context.reporter);
+                    },
+                },
+                category_list: `[${constants_1.NODE_TYPE.Category}]`,
+                url: "String!",
+                thumbnail: {
+                    type: "File",
+                    extensions: {
+                        link: { by: "id", from: "thumbnail" },
+                    },
+                },
+                rawText: "String",
+            },
+        }),
+        schema.buildObjectType({
+            name: constants_1.NODE_TYPE.Tag,
+            interfaces: ["Node"],
+            fields: {
+                id: "ID!",
+                tag_name: "String!",
+                slug: "String!",
+                color: "String!",
+                children: {
+                    type: `[${constants_1.NODE_TYPE.Post}]`,
+                    extensions: {
+                        link: { by: "id", from: "tags" },
+                    },
+                },
+                url: "String!",
+            },
+        }),
+        schema.buildObjectType({
+            name: constants_1.NODE_TYPE.Metadata,
+            interfaces: ["Node"],
+            fields: {
+                id: "ID!",
+                title: "String",
+                description: "String",
+                image: "String",
+                url: "String",
+            },
+        }),
+        schema.buildObjectType({
+            name: constants_1.NODE_TYPE.RelatedPost,
+            interfaces: ["Node"],
+            fields: {
+                posts: {
+                    type: `[${constants_1.NODE_TYPE.Post}]`,
+                    extensions: {
+                        link: { by: "id" },
+                    },
+                },
+            },
+        }),
+        schema.buildObjectType({
+            name: "TocEntry",
+            fields: {
+                type: "String!",
+                hash: "String!",
+                title: "String!",
+                contextTitle: "String",
+                parentHash: "String",
+                level: "Int",
+            },
+        }),
     ]);
 };
 exports.createSchemaCustomization = createSchemaCustomization;

package/dist/util/processor.js

@@ -4,6 +4,7 @@ exports.processor = void 0;
 const metadataProcessor_1 = require("./metadataProcessor");
 const blocks_1 = require("./blocks");
 const tocHelper_1 = require("./tocHelper");
+const tableOfContent_1 = require("./tableOfContent");
 const processor = async (blocks, actions, getCache, createNodeId, reporter, cache) => {
     const { thumbnail, tableOfContents, updatedBlocks, rawText } = await processBlocksForContent(blocks, actions, getCache, createNodeId, reporter, cache);
     await (0, metadataProcessor_1.processMetadata)(blocks, actions, createNodeId, reporter, cache);
@@ -18,6 +19,8 @@ const processBlocksForContent = async (blocks, actions, getCache, createNodeId,
         reporter,
         cache,
     };
+    // 목차 컨텍스트 초기화
+    (0, tableOfContent_1.resetTocContext)();
     // 블록 프로세서 레지스트리 생성
     const processorRegistry = new blocks_1.BlockProcessorRegistry(context);
     const tableOfContents = [];
@@ -26,6 +29,11 @@ const processBlocksForContent = async (blocks, actions, getCache, createNodeId,
     const updatedBlocks = [];
     // 첫 번째 이미지 블록을 찾아 썸네일로 사용
     let firstImageIndex = blocks.findIndex((block) => block.type === "image");
+    // 헤딩 타입 블록을 먼저 처리하여 구조를 생성
+    const headingBlocks = blocks.filter((block) => ["heading_1", "heading_2", "heading_3"].includes(block.type));
+    if (headingBlocks.length > 0) {
+        reporter.info(`Found ${headingBlocks.length} heading blocks for TOC generation`);
+    }
     // 블록 처리
     const processResults = await Promise.all(blocks.map(async (block, index) => {
         const result = await processorRegistry.processBlock(block);
@@ -43,8 +51,19 @@ const processBlocksForContent = async (blocks, actions, getCache, createNodeId,
         }
         return result;
     }));
+    // 목차 로깅 및 디버깅
+    const h1Count = tableOfContents.filter((item) => item.type === "heading_1").length;
+    const h2Count = tableOfContents.filter((item) => item.type === "heading_2").length;
+    const h3Count = tableOfContents.filter((item) => item.type === "heading_3").length;
+    reporter.info(`TOC entries before optimization: ${tableOfContents.length} total, ${h1Count} h1, ${h2Count} h2, ${h3Count} h3`);
     // 목차 최적화
-    const processedToc = (0, tocHelper_1.optimizeTocArray)(tableOfContents, reporter);
+    const processedToc = (0, tocHelper_1.optimizeTocArray)(tableOfContents, reporter, {
+        maxSize: 2000,
+        warnThreshold: 500,
+        removeDuplicates: true,
+        enhanceDuplicates: true,
+        buildHierarchy: true,
+    });
     // 업데이트된 블록 적용
     processResults.forEach((result, index) => {
         if (result.updatedBlock) {

package/dist/util/resolvers.d.ts

@@ -0,0 +1,6 @@
+import { Reporter } from "gatsby";
+import { TocEntry } from "./tocHelper";
+/**
+ * 목차 구조를 계층적으로 변환하는 함수
+ */
+export declare const formatTableOfContents: (tableOfContents: TocEntry[], reporter: Reporter) => TocEntry[];

package/dist/util/resolvers.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTableOfContents = void 0;
+/**
+ * 목차 구조를 계층적으로 변환하는 함수
+ */
+const formatTableOfContents = (tableOfContents, reporter) => {
+    if (!tableOfContents || tableOfContents.length === 0) {
+        return [];
+    }
+    try {
+        // Deep clone to avoid modifying original
+        const tocClone = JSON.parse(JSON.stringify(tableOfContents));
+        // Ensure TOC entries are sorted by level first, then by appearance order
+        const sortedToc = tocClone.sort((a, b) => {
+            // Level 기준 정렬
+            if ((a.level || 0) !== (b.level || 0)) {
+                return (a.level || 0) - (b.level || 0);
+            }
+            // Original order is preserved
+            return 0;
+        });
+        // Add contextTitle where missing
+        for (const entry of sortedToc) {
+            if (!entry.contextTitle) {
+                entry.contextTitle = entry.title;
+            }
+        }
+        // 1. Find all main headings (h1)
+        const mainHeadings = sortedToc.filter((entry) => entry.level === 1);
+        // 2. Find all command headings (h2) with their parent h1
+        const commandHeadings = sortedToc.filter((entry) => entry.level === 2);
+        // Group h2 by parent h1 for easier traversal
+        const h1ToH2Map = new Map();
+        for (const h1 of mainHeadings) {
+            h1ToH2Map.set(h1.hash, []);
+        }
+        for (const h2 of commandHeadings) {
+            if (h2.parentHash) {
+                const h2List = h1ToH2Map.get(h2.parentHash) || [];
+                h2List.push(h2);
+                h1ToH2Map.set(h2.parentHash, h2List);
+            }
+        }
+        // 3. Find all subheadings (h3) with their parent h2
+        const subheadings = sortedToc.filter((entry) => entry.level === 3);
+        // Group h3 by parent h2 for easier traversal
+        const h2ToH3Map = new Map();
+        for (const h2 of commandHeadings) {
+            h2ToH3Map.set(h2.hash, []);
+        }
+        for (const h3 of subheadings) {
+            if (h3.parentHash) {
+                const h3List = h2ToH3Map.get(h3.parentHash) || [];
+                h3List.push(h3);
+                h2ToH3Map.set(h3.parentHash, h3List);
+            }
+        }
+        // Find all unique h3 titles that appear anywhere
+        const allH3Titles = new Set();
+        for (const h3 of subheadings) {
+            allH3Titles.add(h3.title);
+        }
+        // Common expected subheadings for commands
+        const commonSubheadings = [
+            "요약",
+            "개요",
+            "설명",
+            "옵션",
+            "문법",
+            "주요 명령어",
+            "주요 속성 설명",
+            "설치",
+            "기본 명령",
+        ];
+        // Add common subheadings to the set
+        for (const title of commonSubheadings) {
+            allH3Titles.add(title);
+        }
+        reporter.info(`Found ${allH3Titles.size} unique h3 titles across sections`);
+        // For each command, ensure all common subheadings exist
+        const finalToc = [...sortedToc];
+        let addedEntries = 0;
+        // Create a map of known title combinations to avoid duplicates
+        const knownCombinations = new Set();
+        // Add all existing combinations to the known set
+        for (const entry of subheadings) {
+            if (entry.parentHash) {
+                const parentCommand = commandHeadings.find((h2) => h2.hash === entry.parentHash);
+                if (parentCommand) {
+                    const combo = `${parentCommand.title}:${entry.title}`;
+                    knownCombinations.add(combo);
+                }
+            }
+        }
+        // Check which commands are missing which subheadings
+        for (const h2 of commandHeadings) {
+            const h3Entries = h2ToH3Map.get(h2.hash) || [];
+            const existingTitles = new Set(h3Entries.map((entry) => entry.title));
+            // For each expected subheading, check if it exists
+            for (const title of commonSubheadings) {
+                const combo = `${h2.title}:${title}`;
+                // Skip if we already have this combination
+                if (knownCombinations.has(combo) || existingTitles.has(title)) {
+                    continue;
+                }
+                // We don't have this subheading for this command - but don't add synthetic entries
+                // in this implementation as we want to show only what's actually in the document
+            }
+        }
+        // If we added entries, re-sort the TOC
+        if (addedEntries > 0) {
+            reporter.info(`Added ${addedEntries} missing subheadings to TOC`);
+            finalToc.sort((a, b) => {
+                if ((a.level || 0) !== (b.level || 0)) {
+                    return (a.level || 0) - (b.level || 0);
+                }
+                return 0;
+            });
+        }
+        // Always make sure all h3 entries have context titles that include their parent command
+        for (const entry of finalToc) {
+            if (entry.level === 3 && entry.parentHash) {
+                const parentCommand = commandHeadings.find((h2) => h2.hash === entry.parentHash);
+                if (parentCommand) {
+                    entry.contextTitle = `${entry.title} (${parentCommand.title})`;
+                }
+            }
+        }
+        return finalToc;
+    }
+    catch (error) {
+        reporter.error(`Error formatting table of contents: ${error}`);
+        return tableOfContents; // Return original on error
+    }
+};
+exports.formatTableOfContents = formatTableOfContents;

package/dist/util/tableOfContent.d.ts

@@ -1,3 +1,4 @@
 import { BaseContentBlock } from "notion-types";
 import { TocEntry } from "./tocHelper";
+export declare const resetTocContext: () => void;
 export declare const processTableOfContents: (block: BaseContentBlock, tableOfContents: TocEntry[]) => Promise<void>;

package/dist/util/tableOfContent.js

@@ -1,17 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processTableOfContents = void 0;
+exports.processTableOfContents = exports.resetTocContext = void 0;
 const crypto_1 = require("crypto");
 // Hash 생성 시 사용할 캐시
 const hashCache = new Map();
+// 헤딩 레벨 트래킹을 위한 변수들
+let lastH1Hash = "";
+let lastH2Hash = "";
+let lastH1Title = "";
+let lastH2Title = "";
+let currentCommandSection = ""; // 현재 명령어 섹션 추적
+const resetTocContext = () => {
+    lastH1Hash = "";
+    lastH2Hash = "";
+    lastH1Title = "";
+    lastH2Title = "";
+    currentCommandSection = "";
+};
+exports.resetTocContext = resetTocContext;
 const processTableOfContents = async (block, tableOfContents) => {
     if (["heading_1", "heading_2", "heading_3"].includes(block.type) &&
         block[block.type]?.rich_text?.length > 0) {
         const plainText = block[block.type]?.rich_text?.[0]?.plain_text || "";
+        // 부모 컨텍스트 추가
+        let contextualId = plainText;
+        let parentHash = "";
+        let level = 0;
+        // 상위 헤딩에 따라 컨텍스트 저장
+        if (block.type === "heading_1") {
+            lastH1Title = plainText;
+            lastH2Title = "";
+            currentCommandSection = ""; // 새 섹션 시작
+            contextualId = `h1-${plainText}`;
+            level = 1;
+            // heading_1은 최상위 레벨이므로 부모가 없음
+        }
+        else if (block.type === "heading_2") {
+            lastH2Title = plainText;
+            currentCommandSection = plainText; // 현재 명령어 설정 (예: useradd, usermod 등)
+            contextualId = `h2-${lastH1Title}-${plainText}`;
+            parentHash = lastH1Hash; // heading_2의 부모는 가장 최근의 heading_1
+            level = 2;
+        }
+        else if (block.type === "heading_3") {
+            // 서브섹션 제목에 명령어 컨텍스트 추가 (예: 요약 -> useradd 요약)
+            const fullContextId = `h3-${lastH1Title}-${currentCommandSection}-${plainText}`;
+            contextualId = fullContextId;
+            parentHash = lastH2Hash || lastH1Hash; // heading_3의 부모는 가장 최근의 heading_2, 없으면 heading_1
+            level = 3;
+        }
         // 이미 처리된 플레인텍스트인지 확인
         let hash;
-        if (hashCache.has(plainText)) {
-            hash = hashCache.get(plainText);
+        if (hashCache.has(contextualId)) {
+            hash = hashCache.get(contextualId);
         }
         else {
             hash = `link-${plainText
@@ -19,16 +60,33 @@ const processTableOfContents = async (block, tableOfContents) => {
                 .trim()
                 .replace(/\s+/g, "-")
                 .toLowerCase()}-${(0, crypto_1.randomUUID)().substring(0, 4)}`;
-            hashCache.set(plainText, hash);
+            hashCache.set(contextualId, hash);
+        }
+        // 현재 해시 저장
+        if (block.type === "heading_1") {
+            lastH1Hash = hash;
+        }
+        else if (block.type === "heading_2") {
+            lastH2Hash = hash;
         }
         block.hash = hash;
+        // 항상 복사본을 사용하여 중복을 방지
+        const displayTitle = plainText;
+        let contextTitle = displayTitle;
+        // 서브헤딩에 컨텍스트 추가
+        if (level === 3 && currentCommandSection) {
+            contextTitle = `${plainText} (${currentCommandSection})`;
+        }
         // 중복 체크 - 동일한 hash가 이미 존재하는지 확인
         const existingTocIndex = tableOfContents.findIndex((toc) => toc.hash === hash);
         if (existingTocIndex === -1) {
             tableOfContents.push({
                 type: block.type,
                 hash,
-                title: plainText,
+                title: displayTitle,
+                contextTitle,
+                parentHash,
+                level,
             });
         }
     }

package/dist/util/tocHelper.d.ts

@@ -6,13 +6,23 @@ export interface TocEntry {
     type: string;
     hash: string;
     title: string;
+    contextTitle?: string;
+    parentHash?: string;
+    level?: number;
+    children?: TocEntry[];
 }
 /**
  * Utility function to efficiently handle large table of contents arrays
- * by removing duplicates and optionally limiting size
+ * by removing duplicates and optionally limiting size while preserving hierarchy
  */
 export declare const optimizeTocArray: (tocEntries: TocEntry[], reporter: Reporter, options?: {
     maxSize?: number;
     warnThreshold?: number;
     removeDuplicates?: boolean;
+    enhanceDuplicates?: boolean;
+    buildHierarchy?: boolean;
 }) => TocEntry[];
+/**
+ * Enhances TOC entries with contextual titles to disambiguate duplicate titles
+ */
+export declare const enrichDuplicateTitles: (tocEntries: TocEntry[], reporter: Reporter) => void;

package/dist/util/tocHelper.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.optimizeTocArray = void 0;
+exports.enrichDuplicateTitles = exports.optimizeTocArray = void 0;
 /**
  * Utility function to efficiently handle large table of contents arrays
- * by removing duplicates and optionally limiting size
+ * by removing duplicates and optionally limiting size while preserving hierarchy
  */
 const optimizeTocArray = (tocEntries, reporter, options = {}) => {
-    const { maxSize = 1000, // Maximum entries to include
+    const { maxSize = 2000, // Maximum entries to include
     warnThreshold = 300, // Threshold to issue warning
     removeDuplicates = true, // Whether to remove duplicates
+    enhanceDuplicates = true, // Whether to enhance duplicate titles with context
+    buildHierarchy = true, // Whether to build the hierarchy tree
      } = options;
     if (!tocEntries || tocEntries.length === 0) {
         return [];
@@ -17,27 +19,106 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
     if (tocEntries.length > warnThreshold) {
         reporter.warn(`Large table of contents detected (${tocEntries.length} items). This might affect performance.`);
     }
+    // Pre-process all entries to ensure proper levels
+    const enrichedTocEntries = tocEntries.map((entry) => {
+        if (!entry.level) {
+            const level = entry.type === "heading_1"
+                ? 1
+                : entry.type === "heading_2"
+                    ? 2
+                    : entry.type === "heading_3"
+                        ? 3
+                        : 0;
+            return { ...entry, level };
+        }
+        return entry;
+    });
     // Remove duplicates if requested
-    let processedToc = tocEntries;
+    let processedToc = enrichedTocEntries;
     if (removeDuplicates) {
         const startTime = Date.now();
         const uniqueMap = new Map();
-        // Use a map for faster duplicate removal - O(n) instead of O(n²)
-        for (const entry of tocEntries) {
+        // Use the hash to ensure uniqueness, but preserve context
+        for (const entry of enrichedTocEntries) {
             uniqueMap.set(entry.hash, entry);
         }
         processedToc = Array.from(uniqueMap.values());
-        const removedCount = tocEntries.length - processedToc.length;
+        const removedCount = enrichedTocEntries.length - processedToc.length;
         const processTime = Date.now() - startTime;
         if (removedCount > 0) {
             reporter.info(`Removed ${removedCount} duplicate TOC entries in ${processTime}ms.`);
         }
     }
+    // Add context to duplicate title entries for better display
+    if (enhanceDuplicates) {
+        (0, exports.enrichDuplicateTitles)(processedToc, reporter);
+    }
     // Limit size if necessary
     if (processedToc.length > maxSize) {
         reporter.warn(`Table of contents exceeds maximum size (${processedToc.length} > ${maxSize}). Truncating.`);
         processedToc = processedToc.slice(0, maxSize);
     }
+    // Build the hierarchical structure if requested
+    if (buildHierarchy) {
+        // First level sort - by level, then by approximate order
+        processedToc.sort((a, b) => {
+            if ((a.level || 0) !== (b.level || 0)) {
+                return (a.level || 0) - (b.level || 0);
+            }
+            return 0; // Keep original order for same level
+        });
+        // 확인을 위한 로깅
+        const h1Count = processedToc.filter((item) => item.level === 1).length;
+        const h2Count = processedToc.filter((item) => item.level === 2).length;
+        const h3Count = processedToc.filter((item) => item.level === 3).length;
+        reporter.info(`TOC structure: ${h1Count} h1, ${h2Count} h2, ${h3Count} h3 headings`);
+    }
     return processedToc;
 };
 exports.optimizeTocArray = optimizeTocArray;
+/**
+ * Enhances TOC entries with contextual titles to disambiguate duplicate titles
+ */
+const enrichDuplicateTitles = (tocEntries, reporter) => {
+    if (!tocEntries || tocEntries.length === 0)
+        return;
+    // Find duplicate titles
+    const titleCounts = new Map();
+    const duplicateTitles = new Set();
+    // Count occurrences of each title
+    for (const entry of tocEntries) {
+        const count = (titleCounts.get(entry.title) || 0) + 1;
+        titleCounts.set(entry.title, count);
+        if (count > 1) {
+            duplicateTitles.add(entry.title);
+        }
+    }
+    if (duplicateTitles.size === 0)
+        return;
+    reporter.info(`Found ${duplicateTitles.size} duplicate title(s) in TOC. Adding context...`);
+    // Build parent map for fast lookups
+    const entryMap = new Map();
+    for (const entry of tocEntries) {
+        entryMap.set(entry.hash, entry);
+    }
+    // Process each entry to ensure all duplicate titles have context
+    for (const entry of tocEntries) {
+        if (duplicateTitles.has(entry.title) && !entry.contextTitle) {
+            let context = "";
+            let parentEntry;
+            // Find parent context
+            if (entry.parentHash && entryMap.has(entry.parentHash)) {
+                parentEntry = entryMap.get(entry.parentHash);
+                context = parentEntry?.title || "";
+            }
+            // Add context to title
+            if (context) {
+                entry.contextTitle = `${entry.title} (${context})`;
+            }
+            else {
+                entry.contextTitle = entry.title;
+            }
+        }
+    }
+};
+exports.enrichDuplicateTitles = enrichDuplicateTitles;

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.2.3",
+  "version": "1.2.5",
   "skipLibCheck": true,
   "license": "0BSD",
   "main": "./dist/gatsby-node.js",