bridgetown_directus 0.1.3 → 0.3.0

data/lib/bridgetown_directus/builder.rb

@@ -1,103 +1,249 @@
+# frozen_string_literal: true
+
+require "date"
+require "fileutils"
+require "yaml"
+
 module BridgetownDirectus
   class Builder < Bridgetown::Builder
     def build
+      config = site.config.bridgetown_directus
       return if site.ssr?
 
-      Utils.log_directus "Connecting to Directus API..."
-      posts_data = fetch_posts
+      config.collections.each_value do |collection_config|
+        next unless [:posts, :pages, :custom_collection].include?(collection_config.resource_type)
 
-      Utils.log_directus "Fetched #{posts_data.size} posts from Directus."
-
-      create_documents(posts_data)
+        process_collection(
+          client: Client.new(
+            api_url: config.api_url,
+            token: config.token
+          ),
+          collection_config: collection_config
+        )
+      end
     end
 
     private
 
-    def fetch_posts
-      api_client = BridgetownDirectus::APIClient.new(site)
-      api_client.fetch_posts
+    # Determine the output directory for the given collection name
+    def collection_directory(collection_name)
+      case collection_name.to_s
+      when "posts"
+        File.join(site.source, "_posts")
+      when "pages"
+        File.join(site.source, "_pages")
+      else
+        File.join(site.source, "_#{collection_name}")
+      end
+    end
+
+    def build_directus_payload(item, collection_dir, collection_config, api_url = nil)
+      mapped_item = apply_data_mapping(item, collection_config)
+      slug = normalize_slug(mapped_item)
+      mapped_item["slug"] = slug
+      filename = build_filename(collection_dir, collection_config, mapped_item, slug)
+      mapped_item = transform_item_fields(mapped_item, api_url, collection_config.layout)
+      mapped_item["directus_generated"] = true # Add flag to front matter
+      content = mapped_item.delete("body") || ""
+      front_matter = generate_front_matter(mapped_item)
+      payload = render_markdown(front_matter, content)
+      [filename, payload]
     end
 
-    def create_documents(posts_data)
-      # Ensure posts_data contains a "data" key and it is an array
-      if posts_data.is_a?(Hash) && posts_data.key?("data") && posts_data["data"].is_a?(Array)
-        posts_array = posts_data["data"]
-      elsif posts_data.is_a?(Array)
-        posts_array = posts_data
+    def build_filename(collection_dir, collection_config, item, slug)
+      if collection_config.resource_type == :posts || collection_config.name.to_s == "posts"
+        post_date = extract_post_date(item)
+        if post_date
+          return File.join(collection_dir, "#{post_date.strftime("%Y-%m-%d")}-#{slug}.md")
+        end
+      end
+
+      File.join(collection_dir, "#{slug}.md")
+    end
+
+    def normalize_slug(item)
+      slug = item["slug"] || item[:slug]
+      slug = slug.to_s.strip
+      return slug unless slug.empty?
+
+      title = item["title"] || item[:title]
+      if title && defined?(Bridgetown::Utils) && Bridgetown::Utils.respond_to?(:slugify)
+        slug = Bridgetown::Utils.slugify(title.to_s)
       else
-        raise "Unexpected structure of posts_data: #{posts_data.inspect}"
+        slug = title.to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")
       end
 
-      created_posts = 0
-      posts_array.each do |post|
-        if translations_enabled?
-          created_posts += create_translated_posts(post)
-        else
-          created_posts += create_single_post(post)
-        end
+      slug = slug.strip
+      return slug unless slug.empty?
+
+      id = item["id"] || item[:id]
+      id.to_s
+    end
+
+    def apply_data_mapping(item, collection_config)
+      mapped_item = item.dup
+      return mapped_item unless collection_config.fields.any? || collection_config.translations_enabled
+
+      mapped_fields = if collection_config.translations_enabled
+                        DataMapper.map_translations(collection_config, item, resolve_locale)
+                      else
+                        DataMapper.map(collection_config, item)
+                      end
+
+      mapped_item.merge!(mapped_fields)
+      mapped_item
+    end
+
+    def resolve_locale
+      return site.locale if site.respond_to?(:locale) && site.locale
+
+      config_locale = site.config["locale"] || site.config[:locale]
+      return config_locale.to_sym if config_locale
+
+      :en
+    end
+
+    def extract_post_date(item)
+      raw = item["date"] || item[:date] || item["published_at"] || item[:published_at] || item["date_created"]
+      item["date"] ||= item["published_at"] if item["published_at"] && !item["date"]
+      return nil unless raw
+
+      return raw.to_date if raw.respond_to?(:to_date)
+
+      Date.parse(raw.to_s)
+    rescue ArgumentError
+      nil
+    end
+
+    def transform_item_fields(item, api_url, layout)
+      item = item.dup
+      if item["image"] && api_url && !item["image"].to_s.start_with?("http://", "https://")
+        item["image"] = File.join(api_url, "assets", item["image"])
       end
+      item["layout"] = layout if layout
+      item
+    end
+
+    def generate_front_matter(item)
+      yaml = item.to_yaml
+      yaml.sub(%r{^---\s*\n}, "") # Remove leading --- if present
+    end
 
-      Utils.log_directus "Finished generating #{created_posts} posts."
+    def render_markdown(front_matter, content)
+      "---\n#{front_matter}---\n\n#{content}"
     end
 
-    def translations_enabled?
-      site.config.dig("directus", "translations", "enabled") == true
+    def write_markdown_file(filename, payload)
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.write(filename, payload)
+    end
+
+    def file_unchanged?(filename, payload)
+      return false unless File.exist?(filename)
+
+      File.read(filename) == payload
+    rescue StandardError
+      false
     end
 
-    def create_single_post(post)
-      slug = post["slug"] || Bridgetown::Utils.slugify(post["title"])
-      api_url = site.config.dig("directus", "api_url")
+    # Remove only plugin-generated Markdown files in the target directory before writing new ones
+    def clean_collection_directory(collection_dir, keep_files: [])
+      keep_set = keep_files.map { |file| File.expand_path(file) }.to_h { |file| [file, true] }
 
+      deleted = 0
+      Dir.glob(File.join(collection_dir, "*.md")).each do |file|
+        next if keep_set[File.expand_path(file)]
+
+        fm = File.read(file)[%r{\A---.*?---}m]
+        if fm && YAML.safe_load(fm, permitted_classes: [Date, Time, DateTime])["directus_generated"]
+          File.delete(file)
+          deleted += 1
+        end
+      rescue StandardError => e
+        warn "[BridgetownDirectus] Could not check/delete #{file}: #{e.message}"
+      end
+
+      deleted
+    end
+
+    def process_collection(client:, collection_config:)
+      endpoint = collection_config.endpoint || collection_config.name.to_s
       begin
-        add_resource :posts, "#{slug}.md" do
-          layout "post"
-          title post["title"]
-          content post["body"]
-          date post["date"] || Time.now.iso8601
-          category post["category"]
-          excerpt post["excerpt"]
-          image post["image"] ? "#{api_url}/assets/#{post['image']}" : nil
+        response = client.fetch_collection(endpoint, collection_config.default_query)
+      rescue StandardError => e
+        warn "Error fetching collection '#{endpoint}': #{e.message}"
+        return
+      end
+      collection_dir = collection_directory(collection_config.name)
+      FileUtils.mkdir_p(collection_dir)
+      api_url = site.config.bridgetown_directus.api_url
+      sanitized_response = sanitize_keys(response)
+      payloads = sanitized_response.to_h do |item|
+        build_directus_payload(item, collection_dir, collection_config, api_url)
+      end
+      log_directus("Generating #{collection_label(collection_config)} (#{payloads.size} items)")
+      deleted = clean_collection_directory(collection_dir, keep_files: payloads.keys)
+      written = 0
+      skipped = 0
+      payloads.each do |filename, payload|
+        if file_unchanged?(filename, payload)
+          skipped += 1
+          next
         end
-        1
-      rescue => e
-        Utils.log_directus "Error creating post #{slug}: #{e.message}"
-        0
+
+        write_markdown_file(filename, payload)
+        written += 1
       end
+      log_directus("Updated #{collection_label(collection_config)}: wrote #{written}, skipped #{skipped}, deleted #{deleted}")
+    end
+
+    def log_directus(message)
+      return unless directus_logging_enabled?
+
+      Utils.log_directus(message)
+    end
+
+    def directus_logging_enabled?
+      flag = ENV["BRIDGETOWN_DIRECTUS_LOG"]
+      flag && !flag.to_s.strip.empty? && flag.to_s != "0"
     end
 
-    def create_translated_posts(post)
-      posts_created = 0
-      translations = post["translations"] || []
-
-      translations.each do |translation|
-        lang_code = translation["languages_code"].split("-").first.downcase
-        bridgetown_locale = lang_code.to_sym
-        
-        next unless site.config["available_locales"].include?(bridgetown_locale)
-
-        slug = translation["slug"] || Bridgetown::Utils.slugify(translation["title"])
-        api_url = site.config.dig("directus", "api_url")
-
-        begin
-          add_resource :posts, "#{slug}.md" do
-            layout "post"
-            title translation["title"]
-            content translation["body"]
-            date post["date"] || Time.now.iso8601
-            category post["category"]
-            excerpt translation["excerpt"]
-            image post["image"] ? "#{api_url}/assets/#{post['image']}" : nil
-            locale bridgetown_locale
-            translations translations
-          end
-
-          posts_created += 1
-        rescue => e
-          Utils.log_directus "Error creating post #{slug} for locale #{bridgetown_locale}: #{e.message}"
+    def collection_label(collection_config)
+      collection_config.name.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+    end
+
+    # Recursively sanitize keys to avoid illegal instance variable names (Ruby 3.4+)
+    def sanitize_keys(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(k, v), h|
+          safe_key = if %r{^\d}.match?(k.to_s)
+                       "n_#{k}"
+                     else
+                       k
+                     end
+          h[safe_key] = sanitize_keys(v)
         end
+      when Array
+        obj.map { |v| sanitize_keys(v) }
+      else
+        obj
       end
+    end
 
-      posts_created
+    # Recursively log all keys to find problematic ones
+    def log_all_keys(obj, path = "")
+      case obj
+      when Hash
+        obj.each do |k, v|
+          # puts "[BridgetownDirectus DEBUG] Key at #{path}: #{k.inspect}" if %r{^\d}.match?(k.to_s)
+          log_all_keys(v, "#{path}/#{k}")
+        end
+      when Array
+        obj.each_with_index do |v, idx|
+          log_all_keys(v, "#{path}[#{idx}]")
+        end
+      end
     end
   end
 end

data/lib/bridgetown_directus/client.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+require "faraday"
+
+module BridgetownDirectus
+  # Client for interacting with the Directus API
+  class Client
+    attr_reader :api_url, :token
+
+    def initialize(api_url:, token:)
+      @api_url = api_url
+      @token = token
+      return unless @token.nil? || @api_url.nil?
+
+      raise StandardError, "Invalid Directus configuration: missing API token or URL"
+    end
+
+    def fetch_collection(collection, params = {})
+      response = connection.get("/items/#{collection}") do |req|
+        req.params.merge!(prepare_params(params))
+      end
+      handle_response(response)
+    end
+
+    def fetch_item(collection, id, params = {})
+      response = connection.get("/items/#{collection}/#{id}") do |req|
+        req.params.merge!(prepare_params(params))
+      end
+      handle_response(response)
+    end
+
+    def fetch_items_with_filter(collection, filter, params = {})
+      merged_params = params.merge(filter: filter)
+      fetch_collection(collection, merged_params)
+    end
+
+    def fetch_related_items(collection, id, relation, params = {})
+      response = connection.get("/items/#{collection}/#{id}/#{relation}") do |req|
+        req.params.merge!(prepare_params(params))
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: @api_url) do |faraday|
+        faraday.headers["Authorization"] = "Bearer #{@token}"
+        faraday.headers["Content-Type"] = "application/json"
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def prepare_params(params)
+      params.transform_keys(&:to_s)
+    end
+
+    def handle_response(response)
+      unless response.success?
+        Utils.log_directus "Directus API error: #{response.status} - #{response.body}"
+        raise "Directus API error: #{response.status}"
+      end
+      json = JSON.parse(response.body)
+      json["data"] || []
+    rescue JSON::ParserError => e
+      Utils.log_directus "Failed to parse Directus response: #{e.message}"
+      raise
+    end
+  end
+end

data/lib/bridgetown_directus/configuration.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module BridgetownDirectus
+  # Configuration module for Bridgetown Directus plugin
+  class Configuration
+    attr_reader :collections
+    attr_accessor :api_url, :token
+
+    def initialize
+      @collections = {}
+    end
+
+    # Register a new collection with the given name
+    # @param name [Symbol] The name of the collection
+    # @param block [Proc] Configuration block for the collection
+    # @return [CollectionConfig] The collection configuration
+    def register_collection(name, &block)
+      collection = CollectionConfig.new(name)
+      collection.instance_eval(&block) if block_given?
+      @collections[name] = collection
+      collection
+    end
+
+    # Find a collection by name
+    # @param name [Symbol] The name of the collection
+    # @return [CollectionConfig, nil] The collection configuration or nil if not found
+    def find_collection(name)
+      @collections[name]
+    end
+
+    # Collection configuration class
+    class CollectionConfig
+      attr_reader :name
+
+      # Initialize a new collection configuration
+      # @param name [Symbol] The name of the collection
+      def initialize(name)
+        @name = name
+        @fields = {}
+        @default_query = {}
+        @resource_type = :posts
+        @layout = "post"
+        @translations_enabled = false
+        @translatable_fields = []
+        @endpoint = nil
+      end
+
+      # Set up accessors for collection configuration properties
+      attr_accessor :endpoint, :fields, :default_query, :resource_type, :layout,
+                    :translations_enabled, :translatable_fields
+
+      # Define a field mapping with optional converter
+      # @param bridgetown_field [Symbol] The field name in Bridgetown
+      # @param directus_field [String, Symbol] The field name in Directus
+      # @param converter [Proc, nil] Optional converter to transform the field value
+      # @return [void]
+      def field(bridgetown_field, directus_field, &converter)
+        @fields[bridgetown_field] = {
+          directus_field: directus_field.to_s,
+          converter: converter,
+        }
+      end
+
+      # Enable translations for this collection
+      # @param fields [Array<Symbol>] The fields that should be translated
+      # @return [void]
+      def enable_translations(fields = [])
+        @translations_enabled = true
+        @translatable_fields = fields
+      end
+
+      # Generate the resource path for a given item
+      # @param item [Hash] The data item from Directus
+      # @return [String] The resource path
+      def path(item)
+        # Default: /:resource_type/:slug/index.html
+        slug = item["slug"] || item[:slug] || item["id"] || item[:id]
+        "/#{resource_type}/#{slug}/index.html"
+      end
+    end
+  end
+end

data/lib/bridgetown_directus/data_mapper.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module BridgetownDirectus
+  # Data mapper for transforming Directus data into Bridgetown resources
+  class DataMapper
+    class << self
+      # Map Directus data to Bridgetown format based on collection configuration
+      # @param collection_config [CollectionConfig] The collection configuration
+      # @param data [Hash] The Directus data
+      # @return [Hash] The mapped data
+      def map(collection_config, data)
+        mapped_data = {}
+
+        collection_config.fields.each do |bridgetown_field, field_config|
+          if field_config.is_a?(Hash)
+            directus_field = field_config[:directus_field]
+            converter = field_config[:converter]
+
+            value = extract_value(data, directus_field)
+
+            # Apply converter if provided
+            value = converter.call(value) if converter.respond_to?(:call)
+
+            mapped_data[bridgetown_field] = value
+          else
+            # Support for simple string mapping for backward compatibility
+            directus_field = field_config.to_s
+            mapped_data[bridgetown_field] = extract_value(data, directus_field)
+          end
+        end
+
+        mapped_data
+      end
+
+      # Map translated fields from Directus data
+      # @param collection_config [CollectionConfig] The collection configuration
+      # @param data [Hash] The Directus data
+      # @param locale [Symbol] The locale to map
+      # @return [Hash] The mapped data with translations
+      def map_translations(collection_config, data, locale)
+        # First map the base data
+        mapped_data = map(collection_config, data)
+
+        # If translations are enabled and the data has translations
+        return mapped_data unless collection_config.translations_enabled && data["translations"]
+
+        # Find the translation for the requested locale
+        translation = find_translation_for_locale(data["translations"], locale)
+
+        # Apply translations if found
+        if translation
+          apply_translations(collection_config, translation, mapped_data)
+          mapped_data[:locale] = locale
+        end
+
+        mapped_data
+      end
+
+      # Resolve relationships in the data
+      # @param client [Client] The Directus client
+      # @param collection_config [CollectionConfig] The collection configuration
+      # @param data [Hash] The mapped data
+      # @param relationships [Hash] Relationship configuration
+      # @return [Hash] The data with resolved relationships
+      def resolve_relationships(client, collection_config, data, relationships)
+        return data unless relationships
+
+        resolved_data = data.dup
+
+        relationships.each do |field, relationship_config|
+          relation_id = data[field]
+          next unless relation_id
+
+          related_collection = relationship_config[:collection]
+          related_fields = relationship_config[:fields] || "*"
+
+          # Fetch the related item
+          related_item = client.fetch_item(
+            related_collection,
+            relation_id,
+            { fields: related_fields }
+          )
+
+          # Add the related data to the resolved data
+          if related_item && related_item["data"]
+            resolved_data["#{field}_data"] = related_item["data"]
+          end
+        end
+
+        resolved_data
+      end
+
+      private
+
+      # Find translation for a specific locale
+      # @param translations [Array] Array of translation objects
+      # @param locale [Symbol] The locale to find
+      # @return [Hash, nil] The translation for the locale or nil if not found
+      def find_translation_for_locale(translations, locale)
+        translations.find do |t|
+          lang_code = t["languages_code"].to_s.split("-").first.downcase
+          lang_code == locale.to_s
+        end
+      end
+
+      # Apply translations to mapped data
+      # @param collection_config [CollectionConfig] The collection configuration
+      # @param translation [Hash] The translation data
+      # @param mapped_data [Hash] The mapped data to update
+      # @return [void]
+      def apply_translations(collection_config, translation, mapped_data)
+        collection_config.translatable_fields.each do |field|
+          # Get the Directus field name for this Bridgetown field
+          field_config = collection_config.fields[field]
+
+          directus_field = if field_config.nil?
+                             field.to_s
+                           elsif field_config.is_a?(Hash)
+                             field_config[:directus_field]
+                           else
+                             field_config.to_s
+                           end
+
+          directus_field = field.to_s if directus_field.to_s.empty?
+
+          # Check if the translation has this field
+          next unless translation[directus_field]
+
+          value = translation[directus_field]
+
+          # Apply converter if provided
+          if field_config.is_a?(Hash) && field_config[:converter].respond_to?(:call)
+            value = field_config[:converter].call(value)
+          end
+
+          mapped_data[field] = value
+        end
+      end
+
+      # Extract a value from nested data using dot notation
+      # @param data [Hash] The data to extract from
+      # @param field [String] The field path (e.g., "user.profile.name")
+      # @return [Object] The extracted value
+      def extract_value(data, field)
+        return nil unless data
+
+        keys = field.to_s.split(".")
+        value = data
+
+        keys.each do |key|
+          return nil unless value.is_a?(Hash) && value.key?(key)
+
+          value = value[key]
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/bridgetown_directus/utils.rb

@@ -3,7 +3,12 @@
 module BridgetownDirectus
   module Utils
     def self.log_directus(message)
-      Bridgetown.logger.info("Directus") { message }
+      if defined?(Bridgetown) && Bridgetown.respond_to?(:logger)
+        Bridgetown.logger.info("Directus") { message }
+      elsif ENV["BRIDGETOWN_DIRECTUS_DEBUG"]
+        # Fallback for testing or when Bridgetown is not available
+        puts "[Directus] #{message}"
+      end
     end
   end
 end

data/lib/bridgetown_directus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BridgetownDirectus
-  VERSION = "0.1.3"
+  VERSION = "0.3.0"
 end