RubyGems - bridgetown_directus - Versions diffs - 0.1.2 → 0.2.0 - Mend

bridgetown_directus 0.1.2 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +10 -0
data/README.md +74 -94
data/Rakefile +1 -1
data/bridgetown.automation.rb +52 -24
data/bridgetown_directus.gemspec +9 -2
data/example/bridgetown.config.yml +24 -0
data/example/config/initializers.rb +34 -0
data/lib/bridgetown_directus/builder.rb +115 -42
data/lib/bridgetown_directus/client.rb +71 -0
data/lib/bridgetown_directus/configuration.rb +82 -0
data/lib/bridgetown_directus/data_mapper.rb +152 -0
data/lib/bridgetown_directus/utils.rb +6 -1
data/lib/bridgetown_directus/version.rb +1 -1
data/lib/bridgetown_directus.rb +24 -12
metadata +19 -15
data/lib/bridgetown_directus/api_client.rb +0 -56

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2311ee5e15d9cab7cd7cd04746afd03d17a85982e2cc43cdadcc25ffba3646cb
-  data.tar.gz: 2cce7fa9fe95891b1559968d5e3d1c139752182966160a1fa6ac44933a6b36d3
+  metadata.gz: dd3625cab0b39f5374ad7a3647e5b6e369bed783f05412cb38e15e8f10208908
+  data.tar.gz: a99f097216b2c9239188563a288b0df5752709782c29bfe15673edd73fd6c80d
 SHA512:
-  metadata.gz: 8aa565c2c68cb96330213ace4efcd99a31948aa7349594004de99018dc9195518ce6620e97f4e6f578d8def0354f4b2519e92f5128b1a57cb6179948f1f3900f
-  data.tar.gz: 91b5f0df720865f92c388a27b2613dfeeed7c4b95190d2dd56699eaec6719f0c495be02f5ccd7504c748615ba7ca41851dd8d437aff089d84f4268712c48d8fd
+  metadata.gz: d70b609eab2f9c4015c4e8898324fe046f8a62673c51d11057ec166372cceb7dfc3cba9793b1a37e3dd175f150d1d2dbc2c7c371427e740b61303630228793f0
+  data.tar.gz: 1dafe4be86342c4196ca93700035ad75f99b0a6a7d0ab78f0592f8ec0a76e51a223b7b63a7f46bf1b0568593b8322b0428f95e5329f38788c55d0a9b07907a9a

data/CHANGELOG.md CHANGED Viewed

@@ -9,6 +9,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ...
+## [0.2.0] - 2025-04-16
+- BREAKING: Simplified configuration—`resource_type` is no longer required. Use the Bridgetown collection name and layout instead.
+- Automation now prompts for both Directus and Bridgetown collection names and sets up the initializer accordingly.
+- Generated files are now flagged with `directus_generated: true` in front matter for safe cleanup.
+- Only plugin-generated files (with this flag) are deleted during cleanup; user-authored files are preserved.
+- Layouts for custom collections are now singular (e.g., `staff_member.erb`).
+- README and example configuration updated for new conventions.
+- Test suite updated for custom collections and file safety logic.
 ## [0.1.0] - 2024-09-27
 - First version

data/README.md CHANGED Viewed

@@ -1,138 +1,118 @@
 # Bridgetown Directus Plugin
-This Bridgetown plugin integrates with the [Directus](https://directus.io/) which is among other things a [headless CMS](https://en.wikipedia.org/wiki/Headless_content_management_system). The plugin allows Bridgetown to pull content from a Directus API during the build process and generate static content in your site. It currently supports fetching published posts, with future plans for more flexibility and features.
+[![Gem Version](https://badge.fury.io/rb/bridgetown_directus.svg)](https://badge.fury.io/rb/bridgetown_directus)
+This Bridgetown plugin integrates with [Directus](https://directus.io/), a flexible headless CMS. The plugin allows Bridgetown to pull content from a Directus API during the build process and generate static content in your site. It supports both single-language and multilingual content through Directus translations.
 ## Features
-- Fetch **published posts** from Directus during the build process
-- Simple setup and configuration
+- Fetch content from **multiple Directus collections** during the build process
+- Support for **flexible field mapping** and custom converters
+- Support for **multilingual content** via Directus translations
+- **Experimental**: Advanced **filtering, sorting, and pagination** options
+- Simple configuration for any Bridgetown collection (posts, pages, or custom types)
 ## Installation
-Before installing the plugin make sure you have an [Auth Token](https://docs.directus.io/reference/authentication.html#access-tokens) in your Directus instance.
+Before installing the plugin, make sure you have an [Auth Token](https://docs.directus.io/reference/authentication.html#access-tokens) in your Directus instance.
 ### Recommended Installation (Bridgetown Automation)
 1. Run the plugin's automation setup:
    ```bash
    bin/bridgetown apply https://github.com/munkun-estudio/bridgetown_directus
    ```
-2.	The setup will guide you to provide the Directus API URL and Auth Token, and configure the plugin automatically.
+   This will:
+   - Prompt for your Directus API URL, token, Directus collection name, and Bridgetown collection name
+   - Generate a minimal `config/initializers/bridgetown_directus.rb`
+   - All further customization is done in Ruby, not YAML
 ### Manual Installation
-1.	Add the gem to your Gemfile:
-```ruby
-bundle add "bridgetown_directus"
-```
-2.	Run bundle install to install the gem.
-3.	Add the plugin configuration to your config/initializers.rb file:
-```ruby
-init :bridgetown_directus do
-  api_url "https://your-directus-instance.com"
-  token ENV['DIRECTUS_AUTH_TOKEN'] || "your_token"
-  # Required field mappings
-  mappings do
-    title "title"
-    content "content"
-    slug "slug"
-    date "date"
-    category "category"
-    excerpt "excerpt"
-    image "image"
-  end
-end
-```
+1. Add the gem to your Gemfile:
-## Configuration
+   ```ruby
+   bundle add "bridgetown_directus"
+   ```
-To configure the plugin:
+2. Run `bundle install` to install the gem.
+3. Create `config/initializers/bridgetown_directus.rb` (see below for configuration).
-1.	You can either use environment variables for the API URL and token:
-```bash
-export DIRECTUS_API_URL="https://your-directus-instance.com"
-export DIRECTUS_AUTH_TOKEN="your-token"
-```
+## Configuration
+### Minimal Example
-2.	Or hard-code the values directly in your initializer:
 ```ruby
-init :bridgetown_directus do
-  api_url "https://your-directus-instance.com"
-  token "your_token"
-  # Required field mappings
-  mappings do
-    title "title"
-    content "content"
-    slug "slug"
-    date "date"
-    category "category"
-    excerpt "excerpt"
-    image "image"
+# config/initializers/bridgetown_directus.rb
+init :bridgetown_directus do |directus|
+  directus.api_url = ENV["DIRECTUS_API_URL"] || "https://your-directus-instance.com"
+  directus.token = ENV["DIRECTUS_API_TOKEN"] || "your-token"
+  directus.register_collection(:posts) do |c|
+    c.endpoint = "posts"
+    c.layout = "post" # Use the singular layout for individual pages
+    # Minimal mapping (optional):
+    c.field :id, "id"
+    c.field :title, "title"
+    # To enable translations, uncomment and edit:
+    # c.enable_translations([:title, :content])
   end
 end
 ```
-## Usage
-Once the plugin is installed and configured, it will fetch posts from your Directus instance during each build. These posts will be generated as in-memory resources, meaning they are not written to disk but are treated as normal posts by Bridgetown.
-### Directus Setup
-To use the plugin, ensure that you’ve set up a collection in your Directus instance with the following fields (you can name the collection anything you like):
--	**title**: The title of the post (Text field)
--	**content**: The content of the post (Rich Text or Text field)
--	**slug**: Optional. A unique slug for the post (Text field)
--	**date**: Optional.The publish date (Datetime field)
--	**status**: Optional. The status of the post (Option field with values like “published”, “draft”, etc.)
--	**category**: Optional. The category for the post (Text field)
--	**excerpt**: Optional. A short excerpt (Text field)
--	**image**: Optional. An image associated with the post (File/Media field)
+For custom collections, create a layout file at `src/_layouts/[singular].erb` (e.g., `staff_member.erb`) to control the page rendering.
-Make sure the **status** field uses `"published"` for posts that you want to be visible on your site.
+**By default, all Directus fields will be written to the front matter of generated Markdown files.**
+You only need to declare fields with `c.field` if you want to:
+- Rename a field in the output
+- Transform/convert a field value (e.g., format a date, generate a slug, etc.)
+- Set a default value if a field is missing
-#### Image Permissions
+#### Example: Customizing a Field
-If your posts contain images, and you want to display them in your Bridgetown site, you'll need to ensure that the **directus_files** collection has the appropriate permissions for public access.
+```ruby
+c.field :slug, "slug" do |value|
+  value || "staff_member-#{SecureRandom.hex(4)}"
+end
+```
-1. **Public Role Configuration:**
-   - In Directus, navigate to **Settings** > **Roles & Permissions**.
-   - Select the **Public** role (or create a custom role if needed).
-   - Under the **Collections** tab, locate the **directus_files** collection.
-   - Set the **read** permission to **enabled** so that the images can be accessed publicly.
+### Translations
-2. **Image Uploads and Management:**
-   - When users upload images to posts, ensure that the images are associated with the **directus_files** collection.
-   - By default, Directus will store image URLs, which the plugin can reference directly. Ensure that the **image** field or URL is added to the **body** field (or wherever applicable).
+To enable translations for specific fields, add this inside your collection block:
+```ruby
+c.enable_translations([:title, :content])
+```
-### Fetching Posts
+- You can list any field that exists in your Directus collection, even if it's not declared above with `c.field`.
+- Only declare a field with `c.field` if you want to rename, transform, or set a default for it.
-Posts are fetched from Directus during each build and treated as Bridgetown resources. These resources are available in your site just like regular posts, and you can access them through your templates or layouts.
+### File Generation & Cleanup
-By default, only posts with a status of "published" are fetched from Directus.
+- **Generated files**: The plugin writes Markdown files to `src/_[bridgetown_collection]/` (e.g., `src/_staff_members/`).
+- **Safety**: Only files with the `directus_generated: true` flag in their front matter are deleted during cleanup. User-authored files are never removed.
-## TODO List
+### Advanced Configuration
-Here are features that are planned for future versions of the plugin:
+See the plugin source and inline documentation for advanced features such as:
+- Multiple collections
+- Custom layouts per collection
+- Filtering, sorting, and pagination via `c.default_query` (**experimental**; not fully tested in production—see notes below)
+- Selective field output
-- [ ]	Support for Additional Content Types: Extend the plugin to handle other Directus collections and custom content types.
-- [ ]	Custom Field Mapping via DSL: Implement a DSL for more advanced field mapping.
-- [ ]	Asset Handling: Add functionality to download and manage images and other assets.
-- [ ]	Caching & Incremental Builds: Implement caching to improve build performance when fetching content.
-- [ ] Draft Previews: Add support for previewing unpublished (draft) posts.
+**Note:** Filtering, sorting, and pagination via `c.default_query` is experimental and not yet fully tested in real Bridgetown projects. Please report issues or contribute test cases if you use this feature!
-## Testing
+### Migrating from 0.1.x
-Testing isn’t fully set up yet, but contributions and improvements are welcome.
+- **YAML config is no longer used.** All configuration is now in Ruby in `config/initializers/bridgetown_directus.rb`.
+- Field mapping, transformation, and translations are handled in the initializer.
+- All Directus fields are output by default; use `c.field` for customization.
+- **Upgrading?** The `resource_type` option is no longer required. Use the Bridgetown collection name and layout instead. See the [CHANGELOG](CHANGELOG.md) for details.
-## Contributing
+---
-We welcome contributions to this project! To contribute:
+For more details and advanced usage, see the [plugin README](https://github.com/Munkun-Estudio/bridgetown_directus).
-1. Fork the repository
-2. Create a new branch (git checkout -b feature-branch)
-3. Make your changes
-4. Push to the branch (git push origin feature-branch)
-5. Open a Pull Request
+See [CHANGELOG.md](CHANGELOG.md) for upgrade notes and detailed changes.

data/Rakefile CHANGED Viewed

@@ -4,7 +4,7 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
+  t.test_files = FileList["test/**/*_test.rb"]
   t.warning = false
 end

data/bridgetown.automation.rb CHANGED Viewed

@@ -2,35 +2,63 @@ say_status :directus, "Installing the bridgetown_directus plugin..."
 # Prompt the user for Directus API URL and Auth Token
 api_url = ask("What's your Directus instance URL? (Example: https://your-instance.example.com)")
-auth_token = ask("What's your Directus API auth token? (Leave blank to use ENV['DIRECTUS_AUTH_TOKEN'])")
-collection = ask("What's the name of the collection? (Example: posts")
+auth_token = ask("What's your Directus API auth token? (Leave blank to use ENV['DIRECTUS_API_TOKEN'])")
+directus_collection = ask("What's the Directus collection name (API endpoint/model)? (Example: posts)")
+bridgetown_collection = ask("What's the Bridgetown collection name (used for folder and resource)? (Example: posts)")
 # Add the bridgetown_directus gem
 add_gem "bridgetown_directus"
-# Add Directus configuration to config/initializers.rb using add_initializer method
-add_initializer :"bridgetown_directus" do
+# Add minimal Directus configuration to config/initializers.rb in the idiomatic Bridgetown plugin style
+add_initializer :bridgetown_directus do |directus|
   <<~RUBY
-    do
-      api_url "#{api_url}"
-      token "#{auth_token.present? ? auth_token : "<%= ENV['DIRECTUS_AUTH_TOKEN'] %>"}"
-      collection "#{collection}"
-      # Field Mappings (Ensure your Directus collection has these fields)
-      mappings do
-        title "title"           # Required field
-        content "content"       # Required field
-        slug "slug"             # Optional, will be auto-generated if not provided
-        date "date"             # Optional, defaults to the current date/time if not provided
-        category "category"     # Optional
-        excerpt "excerpt"       # Optional, defaults to content excerpt if not provided
-        image "image"           # Optional, URL for the image associated with the post
-      end
+    # This block was generated by bridgetown_directus automation.
+    # All Directus configuration is now handled here (not in YAML).
+    # Set DIRECTUS_API_URL and DIRECTUS_API_TOKEN in your .env or shell environment.
+    #
+    # By default, ALL fields from Directus will be written to the front matter of generated Markdown files.
+    # You only need to declare fields here if you want to:
+    #   - Rename a field in the output
+    #   - Transform/convert a field value (e.g., format a date, generate a slug, etc.)
+    #   - Set a default value if a field is missing
+    #
+    # Example: To customize or transform fields, use the c.field declaration:
+    #   # require "securerandom" # Uncomment if you use SecureRandom in your mapping
+    #   c.field :slug, "slug" do |value|
+    #     value || "post-#{SecureRandom.hex(4)}"
+    #   end
+    #
+    # ---
+    # TRANSLATIONS:
+    # To enable translations for specific fields, add this line inside your collection block:
+    #   c.enable_translations([:title, :content])
+    # You can list any field that exists in your Directus collection, even if it's not declared above with c.field.
+    # Declaring a field with c.field is only required if you want to rename, transform, or set a default for it.
+    # ---
+    directus.api_url = ENV["DIRECTUS_API_URL"] || "#{api_url}"
+    directus.token = ENV["DIRECTUS_API_TOKEN"] || "#{auth_token}"
+    directus.register_collection(:#{bridgetown_collection}) do |c|
+      c.endpoint = "#{directus_collection}"
+      c.layout = "#{bridgetown_collection.to_s.singularize}"
+      # Minimal mapping (optional):
+      c.field :id, "id"
+      c.field :title, "title"
+      # Add more c.field declarations above as needed for custom logic.
+      # To enable translations, uncomment and edit the following line:
+      # c.enable_translations([:title, :content])
     end
   RUBY
 end
-# Success message
-say_status :directus, "Directus integration is complete! Please make sure your Directus collection contains the required fields as specified in the initializer."
-say_status :directus, "Check config/initializers.rb for your Directus setup and adjust mappings if necessary."
-say_status :directus, "For usage help visit:"
-say_status :directus, "https://github.com/Munkun-Estudio/bridgetown_directus/blob/main/README.md"
+say_status :success, "Bridgetown Directus plugin has been installed!", :green
+say_status :directus, "Check config/initializers.rb for your Directus setup."
+say_status :directus, "Check bridgetown.config.yml for your collection setup."
+# Only remind the user to create a layout if it's a custom collection (not 'posts' or 'pages')
+if !%w[posts pages].include?(bridgetown_collection.to_s)
+  say_status :directus, "Don't forget to create a layout file at src/_layouts/#{bridgetown_collection.to_s.singularize}.erb for your custom collection pages!"
+end
+say_status :directus, "For advanced usage and field customization, see the README: https://github.com/Munkun-Estudio/bridgetown_directus"

data/bridgetown_directus.gemspec CHANGED Viewed

@@ -15,9 +15,16 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r!^test/!)
   spec.require_paths = ["lib"]
+  spec.metadata         = {
+      "source_code_uri" => spec.homepage,
+      "bug_tracker_uri" => "#{spec.homepage}/issues",
+      "changelog_uri"   => "#{spec.homepage}/releases",
+      "homepage_uri"    => spec.homepage
+  }
   spec.required_ruby_version = ">= 2.7.0"
-  spec.add_dependency "bridgetown", ">= 1.2.0", "< 2.0"
+  spec.add_dependency "bridgetown", ">= 2.0.0.beta4", "< 3.0"
   spec.add_dependency "faraday", "~> 2.12"
   spec.add_development_dependency "bundler", "~> 2.0"
@@ -25,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop-bridgetown", "~> 0.3"
   spec.add_development_dependency "shoulda", "~> 3.0"
   spec.add_development_dependency "minitest", "~> 5.0"
-  spec.add_development_dependency "minitest-profile", "~> 0.5"
+  spec.add_development_dependency "minitest-profile", "~> 0.0.2"
   spec.add_development_dependency "minitest-reporters", "~> 1.0"
   spec.add_development_dependency "webmock", "~> 3.0"
 end

data/example/bridgetown.config.yml ADDED Viewed

@@ -0,0 +1,24 @@
+# Example Bridgetown configuration file for the enhanced Directus plugin
+# Site settings
+title: My Bridgetown Site with Directus
+email: your-email@example.com
+description: >-
+  A Bridgetown site powered by Directus headless CMS
+baseurl: ""
+url: ""
+# Collections
+collections:
+  posts:
+    output: true
+    permalink: /blog/:slug/
+    source: _posts
+    future: true
+  staff_members:
+    output: true
+    permalink: /staff_members/:slug/
+    source: _staff_members
+    sort_field: 'created_at'
+    sort_reverse: false

data/example/config/initializers.rb ADDED Viewed

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# Example Bridgetown Directus plugin initializer for v2+
+#
+# All Directus configuration is now handled here, NOT in bridgetown.config.yml.
+# Use ENV variables for secrets and API credentials.
+require "securerandom"
+require "time"
+init :bridgetown_directus do |directus|
+  # Set API credentials from environment variables
+  directus.api_url = ENV["DIRECTUS_API_URL"] || "https://your-directus-instance.com"
+  directus.token = ENV["DIRECTUS_API_TOKEN"] || "your-token-here"
+  # Example custom collection: staff_members
+  directus.register_collection(:staff_members) do |c|
+    c.endpoint = "staff_members"
+    c.layout = "staff_member"
+    c.field :id, "id"
+    c.field :title, "title"
+    # To enable translations, uncomment and edit:
+    # c.enable_translations([:title, :content])
+    # Add more fields as needed
+  end
+  # Example for posts (if needed)
+  directus.register_collection(:posts) do |c|
+    c.endpoint = "articles"
+    c.layout = "post"
+    c.field :title, "title"
+    c.field :content, "body"
+  end
+end

data/lib/bridgetown_directus/builder.rb CHANGED Viewed

@@ -1,62 +1,135 @@
 # frozen_string_literal: true
+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
-      Utils.log_directus "Fetched #{posts_data.size} posts from Directus."
+      config.collections.each_value do |collection_config|
+        next unless [:posts, :pages, :custom_collection].include?(collection_config.resource_type)
-      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
+    # Write a Directus item as a Markdown file in the correct Bridgetown collection directory
+    def write_directus_file(item, collection_dir, layout = nil, api_url = nil)
+      require "fileutils"
+      FileUtils.mkdir_p(collection_dir)
+      slug = item["slug"] || item["id"].to_s
+      filename = build_filename(collection_dir, slug)
+      item = transform_item_fields(item, api_url, layout)
+      item["directus_generated"] = true # Add flag to front matter
+      content = item.delete("body") || ""
+      front_matter = generate_front_matter(item)
+      write_markdown_file(filename, front_matter, content)
     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
-      else
-        raise "Unexpected structure of posts_data: #{posts_data.inspect}"
-      end
-      posts_array.each_with_index do |post, index|
-        # Fallback to slugify if no slug is provided
-        slug = post["slug"] || Bridgetown::Utils.slugify(post["title"])
-        date = post["date"] || Time.now.iso8601
-        # Construct the image URL if the image ID is present
-        image = post["image"]
-        image = image ? "#{site.config.bridgetown_directus.api_url}/assets/#{image}" : nil
-        begin
-          add_resource :posts, "#{slug}.md" do
-            layout "post"
-            title post["title"]
-            content post["body"] # Make sure content is directly from post["body"]
-            date date
-            category post["category"]
-            excerpt post["excerpt"]
-            image image
-          end
-        rescue => e
-          Utils.log_directus "Error processing post at index #{index}: #{e.message}"
-          raise e
+    def build_filename(collection_dir, slug)
+      File.join(collection_dir, "#{slug}.md")
+    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
+    def write_markdown_file(filename, front_matter, content)
+      File.write(filename, "---\n#{front_matter}---\n\n#{content}")
+    end
+    # Remove only plugin-generated Markdown files in the target directory before writing new ones
+    def clean_collection_directory(collection_dir)
+      require "yaml"
+      Dir.glob(File.join(collection_dir, "*.md")).each do |file|
+        fm = File.read(file)[%r{\A---.*?---}m]
+        File.delete(file) if fm && YAML.safe_load(fm)["directus_generated"]
+      rescue StandardError => e
+        warn "[BridgetownDirectus] Could not check/delete #{file}: #{e.message}"
+      end
+    end
+    def process_collection(client:, collection_config:)
+      endpoint = collection_config.endpoint || collection_config.name.to_s
+      begin
+        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)
+      clean_collection_directory(collection_dir)
+      api_url = site.config.bridgetown_directus.api_url
+      sanitized_response = sanitize_keys(response)
+      sanitized_response.each do |item|
+        write_directus_file(item, collection_dir, collection_config.layout, api_url)
+      end
+    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
-      Utils.log_directus "Finished generating #{posts_array.size} posts."
+    # 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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,152 @@
+# 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 = field_config.is_a?(Hash) ? field_config[:directus_field] : field_config.to_s
+          # 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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

data/lib/bridgetown_directus.rb CHANGED Viewed

@@ -1,27 +1,39 @@
 # frozen_string_literal: true
 require "bridgetown"
-require_relative "bridgetown_directus/version"
 require_relative "bridgetown_directus/utils"
-require_relative "bridgetown_directus/api_client"
+require_relative "bridgetown_directus/client"
+require_relative "bridgetown_directus/data_mapper"
+require_relative "bridgetown_directus/configuration"
 require_relative "bridgetown_directus/builder"
 module BridgetownDirectus
   # Bridgetown initializer for the plugin
-  Bridgetown.initializer :bridgetown_directus do |config, api_url:, token:, collection:, mappings:|
-    config.bridgetown_directus ||= {}
-    config.bridgetown_directus.api_url ||= api_url || ENV.fetch("DIRECTUS_API_URL")
-    config.bridgetown_directus.token ||= token || ENV.fetch("DIRECTUS_API_TOKEN")
-    config.bridgetown_directus.collection ||= collection
-    config.bridgetown_directus.mappings ||= mappings
+  Bridgetown.initializer :bridgetown_directus do |config|
+    # Only assign config.bridgetown_directus if not already set
+    config.bridgetown_directus ||= Configuration.new
+    # Set up configuration directly (leave to user initializer if possible)
+    config.bridgetown_directus.api_url ||= ENV["DIRECTUS_API_URL"] || "[https://studio.munkun.com](https://studio.munkun.com)"
+    config.bridgetown_directus.token ||= ENV["DIRECTUS_TOKEN"] || "t1P6YstcUslmf-KJFbc6Kyg0bomMxkXY"
     # Register the builder
     config.builder BridgetownDirectus::Builder
+  end
+  class Configuration
+    attr_accessor :api_url, :token
+    attr_reader :collections
+    def initialize
+      @collections = {}
+    end
-    # Validate Directus config before proceeding
-    unless config.bridgetown_directus.api_url && config.bridgetown_directus.token
-      Bridgetown.logger.error "Invalid Directus configuration detected. Please check your API URL and token."
-      raise "Directus configuration invalid"
+    def register_collection(name, &block)
+      collection = CollectionConfig.new(name)
+      collection.instance_eval(&block) if block_given?
+      @collections[name] = collection
+      collection
     end
   end
 end

metadata CHANGED Viewed

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bridgetown_directus
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Munkun
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2025-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bridgetown
@@ -16,20 +15,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 2.0.0.beta4
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 2.0.0.beta4
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -120,14 +119,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.0.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -156,7 +155,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description:
 email: development@munkun.com
 executables: []
 extensions: []
@@ -171,17 +169,24 @@ files:
 - Rakefile
 - bridgetown.automation.rb
 - bridgetown_directus.gemspec
+- example/bridgetown.config.yml
+- example/config/initializers.rb
 - lib/bridgetown_directus.rb
-- lib/bridgetown_directus/api_client.rb
 - lib/bridgetown_directus/builder.rb
+- lib/bridgetown_directus/client.rb
+- lib/bridgetown_directus/configuration.rb
+- lib/bridgetown_directus/data_mapper.rb
 - lib/bridgetown_directus/utils.rb
 - lib/bridgetown_directus/version.rb
 - package.json
 homepage: https://github.com/munkun-estudio/bridgetown_directus
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/munkun-estudio/bridgetown_directus
+  bug_tracker_uri: https://github.com/munkun-estudio/bridgetown_directus/issues
+  changelog_uri: https://github.com/munkun-estudio/bridgetown_directus/releases
+  homepage_uri: https://github.com/munkun-estudio/bridgetown_directus
 rdoc_options: []
 require_paths:
 - lib
@@ -196,8 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Use Directus as headless CMS for Bridgetown
 test_files: []

data/lib/bridgetown_directus/api_client.rb DELETED Viewed

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-module BridgetownDirectus
-  class APIClient
-    def initialize(site)
-      @site = site
-      @api_url = site.config.bridgetown_directus.api_url
-      @api_token = site.config.bridgetown_directus.token
-      raise StandardError, "Invalid Directus configuration: missing API token or URL" if @api_token.nil? || @api_url.nil?
-    end
-    # Main method to fetch posts
-    def fetch_posts
-      Utils.log_directus "Request URL: #{@api_url}/items/#{@site.config.bridgetown_directus.collection}"
-      response = connection.get("/items/#{@site.config.bridgetown_directus.collection}") do |req|
-        req.params['filter'] = { status: { _eq: "published" } }.to_json
-      end
-      if response.success?
-        JSON.parse(response.body)  # Return the parsed posts
-      elsif response.status == 401
-        raise RuntimeError, "Unauthorized access to Directus API"
-      else
-        raise "Error fetching posts: #{response.status} - #{response.body}"
-      end
-    rescue Faraday::TimeoutError
-      raise Faraday::TimeoutError, "The request to fetch posts timed out"
-    rescue JSON::ParserError
-      raise JSON::ParserError, "The response from Directus was not valid JSON"
-    end
-    # Setup Faraday connection with authorization headers
-    def connection
-      Faraday.new(url: @api_url) do |faraday|
-        faraday.options.timeout = 5
-        faraday.options.open_timeout = 2
-        faraday.headers['Authorization'] = "Bearer #{@api_token}"
-        faraday.headers['Content-Type'] = 'application/json'
-        faraday.adapter Faraday.default_adapter
-      end
-    end
-    # New method for validating the data structure
-    private def validate_posts_data(posts_data)
-      if posts_data.is_a?(Hash) && posts_data.key?("data") && posts_data["data"].is_a?(Array)
-        posts_data["data"]
-      elsif posts_data.is_a?(Array)
-        posts_data
-      else
-        raise "Unexpected structure of posts_data: #{posts_data.inspect}"
-      end
-    end
-  end
-end