jekyll-notion-cms 1.0.0

data/lib/jekyll_notion_cms/generator.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module JekyllNotionCMS
+  # Jekyll Generator that fetches data from Notion databases
+  class Generator < Jekyll::Generator
+    safe true
+    priority :highest
+
+    def generate(site)
+      @site = site
+      @config = site.config['notion'] || {}
+      @collections_config = @config['collections'] || {}
+
+      unless @config['enabled'] != false
+        Jekyll.logger.info 'NotionCMS:', 'Plugin disabled in configuration'
+        return
+      end
+
+      unless ENV['NOTION_TOKEN']
+        Jekyll.logger.info 'NotionCMS:', 'No NOTION_TOKEN found, using collections fallback'
+        use_all_collections_fallback
+        return
+      end
+
+      Jekyll.logger.info 'NotionCMS:', 'Fetching data from Notion API...'
+
+      begin
+        @client = NotionClient.new(ENV.fetch('NOTION_TOKEN', nil))
+
+        @collections_config.each do |collection_name, collection_config|
+          fetch_collection_data(collection_name, collection_config)
+        end
+
+        Jekyll.logger.info 'NotionCMS:', 'All data fetched successfully'
+      rescue StandardError => e
+        Jekyll.logger.error 'NotionCMS:', "Error fetching data: #{e.message}"
+        Jekyll.logger.warn 'NotionCMS:', 'Falling back to collections'
+        use_all_collections_fallback
+      end
+    end
+
+    private
+
+    # Fetch data for a single collection
+    def fetch_collection_data(collection_name, config)
+      env_var = config['database_env']
+      data_file = config['data_file']
+
+      database_id = ENV.fetch(env_var, nil)
+      if database_id.nil? || database_id.empty? || database_id.start_with?('example_')
+        Jekyll.logger.info 'NotionCMS:', "No #{env_var} found, using fallback for #{collection_name}"
+        use_collection_fallback(collection_name, config)
+        return
+      end
+
+      begin
+        notion_data = @client.query_database(database_id)
+        organized_data = DataOrganizers.organize(notion_data, config)
+
+        if DataOrganizers.data_present?(organized_data)
+          data_key = data_file.sub('.yml', '').sub('.yaml', '')
+          @site.data[data_key] = organized_data
+          create_data_file(organized_data, data_file, collection_name)
+
+          count = organized_data.is_a?(Hash) ? organized_data.size : organized_data.length
+          Jekyll.logger.info 'NotionCMS:', "#{collection_name} fetched (#{count} items)"
+        else
+          Jekyll.logger.warn 'NotionCMS:', "No data found for #{collection_name}, using fallback"
+          use_collection_fallback(collection_name, config)
+        end
+      rescue StandardError => e
+        Jekyll.logger.error 'NotionCMS:', "Error fetching #{collection_name}: #{e.message}"
+        use_collection_fallback(collection_name, config)
+      end
+    end
+
+    # Create a YAML data file
+    def create_data_file(data, file_name, collection_name)
+      data_dir = File.join(@site.source, '_data')
+      FileUtils.mkdir_p(data_dir)
+
+      data_file = File.join(data_dir, file_name)
+      new_content = data.to_yaml
+
+      # Skip if content unchanged
+      if File.exist?(data_file)
+        existing_content = File.read(data_file)
+        yaml_start = existing_content.index("---\n")
+        if yaml_start
+          existing_yaml = existing_content[yaml_start..]
+          if existing_yaml.strip == new_content.strip
+            Jekyll.logger.info 'NotionCMS:', "#{collection_name} data unchanged, skipping"
+            return
+          end
+        end
+      end
+
+      File.open(data_file, 'w') do |file|
+        file.write("# #{collection_name.capitalize} data imported from Notion\n")
+        file.write("# Auto-generated by jekyll-notion-cms - Do not edit manually\n")
+        file.write("# Last updated: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+        file.write(new_content)
+      end
+
+      Jekyll.logger.info 'NotionCMS:', "#{collection_name} written to _data/#{file_name}"
+    end
+
+    # Use fallback for all collections
+    def use_all_collections_fallback
+      @collections_config.each do |collection_name, config|
+        use_collection_fallback(collection_name, config)
+      end
+    end
+
+    # Use Jekyll collections as fallback
+    def use_collection_fallback(collection_name, config)
+      Jekyll.logger.info 'NotionCMS:', "Using fallback for #{collection_name}"
+
+      data_file = config['data_file']
+      data_key = data_file.sub('.yml', '').sub('.yaml', '')
+      properties_config = config['properties'] || []
+
+      # Convert Jekyll collection to Notion-like format
+      mock_data = { 'results' => [] }
+
+      @site.collections[collection_name]&.docs&.each_with_index do |doc, index|
+        mock_data['results'] << {
+          'id' => "collection_#{index}",
+          'properties' => convert_doc_to_properties(doc.data, properties_config),
+          'created_time' => doc.data['date']&.to_s,
+          'last_edited_time' => doc.data['last_modified']&.to_s
+        }
+      end
+
+      organized_data = DataOrganizers.organize(mock_data, config)
+      @site.data[data_key] = organized_data
+      create_data_file(organized_data, data_file, collection_name)
+
+      count = organized_data.is_a?(Hash) ? organized_data.size : organized_data.length
+      Jekyll.logger.info 'NotionCMS:', "#{collection_name} fallback applied (#{count} items)"
+    end
+
+    # Convert Jekyll document data to Notion-like properties
+    def convert_doc_to_properties(data, properties_config)
+      properties = {}
+
+      properties_config.each do |prop_config|
+        prop_name = prop_config['name']
+        prop_type = prop_config['type']
+        prop_key = prop_config['key'] || PropertyExtractors.normalize_key(prop_name)
+
+        value = data[prop_key] || data[prop_name.downcase] || data[prop_name]
+        next if value.nil?
+
+        properties[prop_name] = convert_value_to_notion_property(value, prop_type)
+      end
+
+      properties
+    end
+
+    # Convert a value to Notion property format
+    def convert_value_to_notion_property(value, prop_type)
+      case prop_type
+      when 'title'
+        { 'type' => 'title', 'title' => [{ 'plain_text' => value.to_s }] }
+      when 'rich_text'
+        { 'type' => 'rich_text', 'rich_text' => [{ 'plain_text' => value.to_s }] }
+      when 'number'
+        { 'type' => 'number', 'number' => value.to_i }
+      when 'checkbox'
+        { 'type' => 'checkbox', 'checkbox' => !!value }
+      when 'date'
+        { 'type' => 'date', 'date' => { 'start' => value.to_s } }
+      when 'select'
+        { 'type' => 'select', 'select' => { 'name' => value.to_s } }
+      when 'multi_select'
+        items = value.is_a?(Array) ? value : [value]
+        { 'type' => 'multi_select', 'multi_select' => items.map { |v| { 'name' => v.to_s } } }
+      when 'url'
+        { 'type' => 'url', 'url' => value.to_s }
+      else
+        { 'type' => 'rich_text', 'rich_text' => [{ 'plain_text' => value.to_s }] }
+      end
+    end
+  end
+end

data/lib/jekyll_notion_cms/notion_client.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module JekyllNotionCMS
+  # Client for interacting with the Notion API
+  class NotionClient
+    NOTION_API_VERSION = '2022-06-28'
+    NOTION_API_BASE_URL = 'https://api.notion.com/v1'
+
+    def initialize(token)
+      @token = token
+      raise ConfigurationError, 'Notion token is required' if @token.nil? || @token.empty?
+    end
+
+    # Query a Notion database and return all results
+    # @param database_id [String] The ID of the database to query
+    # @param filter [Hash] Optional filter for the query
+    # @param sorts [Array] Optional sorts for the query
+    # @return [Hash] The API response with results
+    def query_database(database_id, filter: nil, sorts: nil)
+      all_results = []
+      start_cursor = nil
+
+      loop do
+        response = query_database_page(database_id, filter: filter, sorts: sorts, start_cursor: start_cursor)
+        all_results.concat(response['results'])
+
+        break unless response['has_more']
+
+        start_cursor = response['next_cursor']
+      end
+
+      { 'results' => all_results }
+    end
+
+    # Retrieve a single page
+    # @param page_id [String] The ID of the page to retrieve
+    # @return [Hash] The page data
+    def get_page(page_id)
+      uri = URI("#{NOTION_API_BASE_URL}/pages/#{page_id}")
+      request = build_request(:get, uri)
+      execute_request(uri, request)
+    end
+
+    # Retrieve page content (blocks)
+    # @param page_id [String] The ID of the page
+    # @return [Hash] The blocks data
+    def get_page_content(page_id)
+      all_results = []
+      start_cursor = nil
+
+      loop do
+        uri = URI("#{NOTION_API_BASE_URL}/blocks/#{page_id}/children")
+        uri.query = URI.encode_www_form({ start_cursor: start_cursor, page_size: 100 }.compact)
+
+        request = build_request(:get, uri)
+        response = execute_request(uri, request)
+
+        all_results.concat(response['results'])
+
+        break unless response['has_more']
+
+        start_cursor = response['next_cursor']
+      end
+
+      { 'results' => all_results }
+    end
+
+    private
+
+    def query_database_page(database_id, filter: nil, sorts: nil, start_cursor: nil)
+      uri = URI("#{NOTION_API_BASE_URL}/databases/#{database_id}/query")
+
+      body = { page_size: 100 }
+      body[:filter] = filter if filter
+      body[:sorts] = sorts if sorts
+      body[:start_cursor] = start_cursor if start_cursor
+
+      request = build_request(:post, uri)
+      request.body = body.to_json
+
+      execute_request(uri, request)
+    end
+
+    def build_request(method, uri)
+      request_class = case method
+                      when :get then Net::HTTP::Get
+                      when :post then Net::HTTP::Post
+                      else raise ArgumentError, "Unknown method: #{method}"
+                      end
+
+      request = request_class.new(uri)
+      request['Authorization'] = "Bearer #{@token}"
+      request['Notion-Version'] = NOTION_API_VERSION
+      request['Content-Type'] = 'application/json'
+      request
+    end
+
+    def execute_request(uri, request)
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+        http.request(request)
+      end
+
+      handle_response(response)
+    end
+
+    def handle_response(response)
+      case response
+      when Net::HTTPSuccess
+        JSON.parse(response.body)
+      when Net::HTTPUnauthorized
+        raise APIError, 'Invalid Notion token (401 Unauthorized)'
+      when Net::HTTPNotFound
+        raise APIError, 'Database or page not found (404 Not Found)'
+      when Net::HTTPTooManyRequests
+        raise APIError, 'Rate limit exceeded (429 Too Many Requests)'
+      else
+        error_message = parse_error_message(response)
+        raise APIError, "Notion API error: #{response.code} #{error_message}"
+      end
+    end
+
+    def parse_error_message(response)
+      error_json = JSON.parse(response.body)
+      error_json['message'] || response.message
+    rescue JSON::ParserError
+      response.message
+    end
+  end
+end

data/lib/jekyll_notion_cms/property_extractors.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module JekyllNotionCMS
+  # Module for extracting values from Notion property types
+  module PropertyExtractors
+    module_function
+
+    # Extract a property value based on its type
+    # @param properties [Hash] The properties hash from a Notion page
+    # @param property_name [String] The name of the property
+    # @param property_type [String] The expected type of the property
+    # @return [Object] The extracted value
+    def extract(properties, property_name, property_type)
+      property = properties[property_name]
+      return nil unless property
+
+      case property_type
+      when 'title'
+        extract_title(property)
+      when 'rich_text'
+        extract_rich_text(property)
+      when 'number'
+        extract_number(property)
+      when 'checkbox'
+        extract_checkbox(property)
+      when 'date'
+        extract_date(property)
+      when 'select'
+        extract_select(property)
+      when 'multi_select'
+        extract_multi_select(property)
+      when 'url'
+        extract_url(property)
+      when 'email'
+        extract_email(property)
+      when 'phone_number'
+        extract_phone_number(property)
+      when 'rollup'
+        extract_rollup(property)
+      when 'formula'
+        extract_formula(property)
+      when 'formula_array'
+        extract_formula_array(property)
+      when 'relation'
+        extract_relation(property)
+      when 'people'
+        extract_people(property)
+      when 'files'
+        extract_files(property)
+      when 'created_time'
+        extract_created_time(property)
+      when 'last_edited_time'
+        extract_last_edited_time(property)
+      when 'status'
+        extract_status(property)
+      end
+    end
+
+    # Extract all properties from a Notion page based on configuration
+    # @param properties [Hash] The properties hash from a Notion page
+    # @param properties_config [Array<Hash>] Configuration for each property
+    # @return [Hash] Extracted properties with normalized keys
+    def extract_all(properties, properties_config)
+      item = {}
+
+      properties_config.each do |prop_config|
+        prop_name = prop_config['name']
+        prop_type = prop_config['type']
+        prop_key = prop_config['key'] || normalize_key(prop_name)
+
+        value = extract(properties, prop_name, prop_type)
+        item[prop_key] = value
+      end
+
+      # Use 'title' as the main identifier, fall back to 'name'
+      item['title'] ||= item['name']
+
+      item
+    end
+
+    # Normalize a property name to a valid key
+    # @param name [String] The property name
+    # @return [String] The normalized key
+    def normalize_key(name)
+      name.downcase.gsub(/\s+/, '_')
+    end
+
+    # Title property
+    def extract_title(property)
+      return nil unless property['type'] == 'title'
+
+      property['title'].map { |text| text['plain_text'] }.join
+    end
+
+    # Rich text property
+    def extract_rich_text(property)
+      return nil unless property['type'] == 'rich_text'
+      return nil if property['rich_text'].nil? || property['rich_text'].empty?
+
+      property['rich_text'].map { |text| text['plain_text'] }.join
+    end
+
+    # Number property (also handles select-to-number conversion)
+    def extract_number(property)
+      case property['type']
+      when 'number'
+        property['number']
+      when 'select'
+        convert_select_to_number(property['select']&.dig('name'))
+      end
+    end
+
+    # Convert common select values to numbers
+    def convert_select_to_number(value)
+      case value
+      when 'Expert', 'Avancé', 'Advanced' then 90
+      when 'Intermédiaire', 'Intermediate' then 70
+      when 'Débutant', 'Beginner' then 50
+      end
+    end
+
+    # Checkbox property
+    def extract_checkbox(property)
+      property['type'] == 'checkbox' ? property['checkbox'] : false
+    end
+
+    # Date property
+    def extract_date(property)
+      return nil unless property['type'] == 'date'
+      return nil if property['date'].nil?
+
+      {
+        'start' => property['date']['start'],
+        'end' => property['date']['end'],
+        'time_zone' => property['date']['time_zone']
+      }.compact
+    end
+
+    # Select property
+    def extract_select(property)
+      return nil unless property['type'] == 'select'
+
+      property['select']&.dig('name')
+    end
+
+    # Multi-select property
+    def extract_multi_select(property)
+      return [] unless property['type'] == 'multi_select'
+
+      property['multi_select'].map { |item| item['name'] }
+    end
+
+    # URL property (also handles rich_text containing URLs)
+    def extract_url(property)
+      case property['type']
+      when 'url'
+        property['url']
+      when 'rich_text'
+        extract_rich_text(property)
+      end
+    end
+
+    # Email property
+    def extract_email(property)
+      return nil unless property['type'] == 'email'
+
+      property['email']
+    end
+
+    # Phone number property
+    def extract_phone_number(property)
+      return nil unless property['type'] == 'phone_number'
+
+      property['phone_number']
+    end
+
+    # Rollup property
+    def extract_rollup(property)
+      return nil unless property['type'] == 'rollup'
+      return nil unless property['rollup']
+
+      rollup = property['rollup']
+
+      case rollup['type']
+      when 'array'
+        extract_rollup_array(rollup['array'])
+      when 'number'
+        rollup['number']
+      when 'date'
+        rollup['date']&.dig('start')
+      end
+    end
+
+    # Extract first value from rollup array
+    def extract_rollup_array(array)
+      return nil if array.nil? || array.empty?
+
+      array.map do |item|
+        case item['type']
+        when 'title'
+          item['title'].map { |text| text['plain_text'] }.join
+        when 'rich_text'
+          item['rich_text'].map { |text| text['plain_text'] }.join
+        when 'select'
+          item['select']&.dig('name')
+        when 'number'
+          item['number']
+        end
+      end.compact.first
+    end
+
+    # Formula property
+    def extract_formula(property)
+      return nil unless property['type'] == 'formula'
+      return nil if property['formula'].nil?
+
+      formula = property['formula']
+
+      case formula['type']
+      when 'string'
+        formula['string']
+      when 'number'
+        formula['number']
+      when 'boolean'
+        formula['boolean']
+      when 'date'
+        formula['date']&.dig('start')
+      end
+    end
+
+    # Formula returning array
+    def extract_formula_array(property)
+      return [] unless property['type'] == 'formula'
+      return [] if property['formula'].nil?
+
+      formula = property['formula']
+
+      case formula['type']
+      when 'array'
+        extract_formula_array_items(formula['array'])
+      when 'string'
+        parse_formula_string(formula['string'])
+      else
+        []
+      end
+    end
+
+    # Extract items from formula array
+    def extract_formula_array_items(array)
+      return [] unless array
+
+      array.map do |item|
+        case item['type']
+        when 'string'
+          item['string']
+        when 'rich_text'
+          item['rich_text']&.map { |text| text['plain_text'] }&.join
+        end
+      end.compact
+    end
+
+    # Parse formula string to array (split by delimiter)
+    def parse_formula_string(string_value)
+      return [] if string_value.nil? || string_value.empty?
+
+      string_value.split('- ').map do |item|
+        cleaned = item.strip.gsub(/^\.+|\.+$/, '')
+        cleaned.empty? ? nil : cleaned
+      end.compact
+    end
+
+    # Relation property
+    def extract_relation(property)
+      return [] unless property['type'] == 'relation'
+      return [] if property['relation'].nil? || property['relation'].empty?
+
+      property['relation'].map { |relation| relation['id'] }
+    end
+
+    # People property
+    def extract_people(property)
+      return [] unless property['type'] == 'people'
+      return [] if property['people'].nil? || property['people'].empty?
+
+      property['people'].map do |person|
+        {
+          'id' => person['id'],
+          'name' => person['name'],
+          'email' => person.dig('person', 'email'),
+          'avatar_url' => person['avatar_url']
+        }.compact
+      end
+    end
+
+    # Files property
+    def extract_files(property)
+      return [] unless property['type'] == 'files'
+      return [] if property['files'].nil? || property['files'].empty?
+
+      property['files'].map do |file|
+        url = file.dig('file', 'url') || file.dig('external', 'url')
+        {
+          'name' => file['name'],
+          'url' => url,
+          'type' => file['type']
+        }.compact
+      end
+    end
+
+    # Created time property
+    def extract_created_time(property)
+      return nil unless property['type'] == 'created_time'
+
+      property['created_time']
+    end
+
+    # Last edited time property
+    def extract_last_edited_time(property)
+      return nil unless property['type'] == 'last_edited_time'
+
+      property['last_edited_time']
+    end
+
+    # Status property
+    def extract_status(property)
+      return nil unless property['type'] == 'status'
+
+      property['status']&.dig('name')
+    end
+  end
+end

data/lib/jekyll_notion_cms/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JekyllNotionCMS
+  VERSION = '1.0.0'
+end