gatsby-source-notion-churnotion 1.2.1 → 1.2.2

package/README.md

@@ -62,6 +62,15 @@ If you're considering Notion as your CMS for Gatsby, this plugin could be a grea
   - Better error handling
   - Improved type safety
 
+## Features
+
+- **Recursive Database Fetching**: Connect with a Notion database and fetch all entries, including nested entries.
+- **Type Safe**: All data types are converted to TypeScript types.
+- **Powerful TypeScript Implementation**: Uses efficient, battle-tested TypeScript code for processing Notion API requests in parallel.
+- **Customizable**: Allows for custom filtering and properties selection.
+
+> **Note**: The plugin currently uses a pure TypeScript implementation for parallel processing of Notion API requests. A Rust-based implementation was initially planned for high-performance use cases but has been put on hold due to cross-platform compilation issues.
+
 ## Install
 
 ```shell

package/dist/rust-bindings.d.ts

@@ -1,6 +1,6 @@
 /**
- * This file provides TypeScript bindings to the Rust implementation
- * of parallel Notion API processing.
+ * This file provides TypeScript bindings to the Notion API processing.
+ * Currently using the TypeScript implementation as the default.
  */
 import { Reporter } from "gatsby";
 /**
@@ -17,9 +17,8 @@ export interface RustNotionServiceOptions {
     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.
+ * A wrapper class that provides access to the TypeScript implementation
+ * for parallel processing of Notion API requests.
  */
 export declare class RustNotionService {
     private reporter;
@@ -27,14 +26,13 @@ export declare class RustNotionService {
     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
+     * Get blocks for multiple pages in parallel
      */
     getMultiplePagesBlocks(pageIds: string[]): Promise<{
         [id: string]: NotionBlock[];

package/dist/rust-bindings.js

@@ -34,19 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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.
+ * A wrapper class that provides access to the TypeScript implementation
+ * for parallel processing of Notion API requests.
  */
 class RustNotionService {
     reporter;
@@ -54,24 +44,13 @@ class RustNotionService {
     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;
-            }
-        }
+        this.reporter.info(`[NOTION] Initialized TypeScript-based parallel processing with limit: ${this.parallelLimit}`);
     }
     /**
      * Get blocks for a single page, with recursive fetching of child blocks
@@ -82,8 +61,6 @@ class RustNotionService {
             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) {
@@ -92,24 +69,11 @@ class RustNotionService {
         return blocks;
     }
     /**
-     * Get blocks for multiple pages in parallel, using Rust implementation if available
+     * Get blocks for multiple pages in parallel
      */
     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
+        // Import the TypeScript implementation
         const { NotionService } = await Promise.resolve().then(() => __importStar(require("./api/service/notionService")));
         // Create a NotionService instance with the same configuration
         const tsService = new NotionService({
@@ -125,10 +89,6 @@ class RustNotionService {
     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.2.1",
+  "version": "1.2.2",
   "skipLibCheck": true,
   "license": "0BSD",
   "main": "./dist/gatsby-node.js",
@@ -11,8 +11,7 @@
   ],
   "scripts": {
     "clean": "del-cli dist",
-    "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 ../..",
+    "build": "tsc",
     "develop": "tsc --watch",
     "test": "jest",
     "prepare": "npm run clean && npm run build"