panda-cms 0.10.0 → 0.10.2

data/lib/panda/cms/bulk_editor.rb

@@ -7,6 +7,14 @@ module Panda
     #
     # Bulk editor for site content in JSON format
     #
+    # IMPORTANT: When adding new fields to Page, Post, or Menu models via migrations:
+    # 1. Update the `extract_current_data` method to export the new fields
+    # 2. Update the `import` method to import the new fields
+    # 3. Run the spec at spec/lib/panda/cms/bulk_editor_spec.rb to verify completeness
+    # 4. The spec will fail if database columns are not being exported
+    #
+    # This ensures content can be properly exported and imported between environments.
+    #
     class BulkEditor
       #
       # Export all site content to a JSON string
@@ -45,8 +53,20 @@ module Panda
               page = Panda::CMS::Page.create!(
                 path: path,
                 title: page_data["title"],
+                status: page_data["status"] || "active",
+                page_type: page_data["page_type"] || "standard",
                 template: Panda::CMS::Template.find_by(name: page_data["template"]),
-                parent: Panda::CMS::Page.find_by(path: page_data["parent"])
+                parent: Panda::CMS::Page.find_by(path: page_data["parent"]),
+                # SEO fields
+                seo_title: page_data["seo_title"],
+                seo_description: page_data["seo_description"],
+                seo_keywords: page_data["seo_keywords"],
+                seo_index_mode: page_data["seo_index_mode"] || "visible",
+                canonical_url: page_data["canonical_url"],
+                # Open Graph fields
+                og_type: page_data["og_type"] || "website",
+                og_title: page_data["og_title"],
+                og_description: page_data["og_description"]
               )
             rescue => e
               debug[:error] << "Failed to create page '#{path}': #{e.message}"
@@ -62,18 +82,37 @@ module Panda
           else
             page = Panda::CMS::Page.find_by(path: path)
 
-            if page_data["title"] != current_data["pages"][path]["title"]
-              page.update(title: page_data["title"])
-              debug[:success] << "Updated: page '#{path}' title from '#{current_data["pages"][path]["title"]}' to '#{page_data["title"]}'"
-            end
-
+            # Check if template changed
             if page_data["template"] != current_data["pages"][path]["template"]
               # TODO: Handle page template changes
               debug[:error] << "Page '#{path}' template is '#{current_data["pages"][path]["template"]}' and cannot be changed to '#{page_data["template"]}' without manual intervention"
+            else
+              # Update page fields
+              begin
+                page.update!(
+                  title: page_data["title"],
+                  status: page_data["status"] || page.status,
+                  page_type: page_data["page_type"] || page.page_type,
+                  parent: Panda::CMS::Page.find_by(path: page_data["parent"]) || page.parent,
+                  # SEO fields
+                  seo_title: page_data["seo_title"],
+                  seo_description: page_data["seo_description"],
+                  seo_keywords: page_data["seo_keywords"],
+                  seo_index_mode: page_data["seo_index_mode"] || page.seo_index_mode,
+                  canonical_url: page_data["canonical_url"],
+                  # Open Graph fields
+                  og_type: page_data["og_type"] || page.og_type,
+                  og_title: page_data["og_title"],
+                  og_description: page_data["og_description"]
+                )
+                debug[:success] << "Updated page '#{path}'"
+              rescue => e
+                debug[:error] << "Failed to update page '#{path}': #{e.message}"
+              end
             end
           end
 
-          page_data["contents"].each do |key, block_data|
+          page_data["contents"]&.each do |key, block_data|
             content = block_data["content"]
 
             if current_data.dig("pages", path, "contents", key).nil?
@@ -117,12 +156,144 @@ module Panda
           end
         end
 
-        new_data["menus"].each do |menu_data|
+        # Posts
+        new_data["posts"]&.each do |post_data|
+          slug = post_data["slug"]
+          post = Panda::CMS::Post.find_by(slug: slug)
+
+          # Find or create user by email
+          user = if post_data["user_email"]
+            Panda::Core::User.find_by(email: post_data["user_email"]) || Panda::Core::User.first
+          else
+            Panda::Core::User.first # Fallback to first user
+          end
+
+          author = if post_data["author_email"]
+            Panda::Core::User.find_by(email: post_data["author_email"])
+          end
+
+          if post.nil?
+            begin
+              post = Panda::CMS::Post.create!(
+                slug: slug,
+                title: post_data["title"],
+                status: post_data["status"] || "draft",
+                published_at: post_data["published_at"],
+                user: user,
+                author: author,
+                content: post_data["content"] || "",
+                cached_content: post_data["cached_content"] || "",
+                # SEO fields
+                seo_title: post_data["seo_title"],
+                seo_description: post_data["seo_description"],
+                seo_keywords: post_data["seo_keywords"],
+                seo_index_mode: post_data["seo_index_mode"] || "visible",
+                canonical_url: post_data["canonical_url"],
+                # Open Graph fields
+                og_type: post_data["og_type"] || "article",
+                og_title: post_data["og_title"],
+                og_description: post_data["og_description"]
+              )
+
+              debug[:success] << "Created post '#{post.title}' (#{slug})"
+            rescue => e
+              debug[:error] << "Failed to create post '#{slug}': #{e.message}"
+            end
+          else
+            # Update existing post
+            begin
+              post.update!(
+                title: post_data["title"],
+                status: post_data["status"] || post.status,
+                published_at: post_data["published_at"] || post.published_at,
+                author: author || post.author,
+                content: post_data["content"] || post.content || "",
+                cached_content: post_data["cached_content"] || post.cached_content || "",
+                # SEO fields
+                seo_title: post_data["seo_title"],
+                seo_description: post_data["seo_description"],
+                seo_keywords: post_data["seo_keywords"],
+                seo_index_mode: post_data["seo_index_mode"] || post.seo_index_mode,
+                canonical_url: post_data["canonical_url"],
+                # Open Graph fields
+                og_type: post_data["og_type"] || post.og_type,
+                og_title: post_data["og_title"],
+                og_description: post_data["og_description"]
+              )
+
+              debug[:success] << "Updated post '#{post.title}' (#{slug})"
+            rescue => e
+              debug[:error] << "Failed to update post '#{slug}': #{e.message}"
+            end
+          end
         end
 
-        new_data["templates"].each do |template_data|
+        # Menus
+        new_data["menus"]&.each do |menu_data|
+          menu = Panda::CMS::Menu.find_by(name: menu_data["name"])
+
+          if menu.nil?
+            begin
+              if menu_data["kind"] == "auto"
+                start_page = Panda::CMS::Page.find_by(path: menu_data["start_page_path"])
+                menu = Panda::CMS::Menu.create!(
+                  name: menu_data["name"],
+                  kind: "auto",
+                  start_page: start_page
+                )
+                debug[:success] << "Created auto menu '#{menu.name}'"
+              else
+                menu = Panda::CMS::Menu.create!(
+                  name: menu_data["name"],
+                  kind: "static"
+                )
+
+                # Create menu items
+                menu_data["items"]&.each do |item_data|
+                  page = Panda::CMS::Page.find_by(path: item_data["page_path"]) if item_data["page_path"]
+                  menu.menu_items.create!(
+                    text: item_data["text"],
+                    page: page,
+                    external_url: item_data["external_url"]
+                  )
+                end
+
+                debug[:success] << "Created static menu '#{menu.name}' with #{menu_data["items"]&.length || 0} items"
+              end
+            rescue => e
+              debug[:error] << "Failed to create menu '#{menu_data["name"]}': #{e.message}"
+            end
+          else
+            # Update existing menu
+            if menu.kind != menu_data["kind"]
+              debug[:warning] << "Menu '#{menu.name}' kind mismatch (#{menu.kind} vs #{menu_data["kind"]}). Skipping update."
+              next
+            end
+
+            if menu_data["kind"] == "auto"
+              start_page = Panda::CMS::Page.find_by(path: menu_data["start_page_path"])
+              if menu.start_page != start_page
+                menu.update(start_page: start_page)
+                debug[:success] << "Updated auto menu '#{menu.name}' start page"
+              end
+            elsif menu_data["kind"] == "static"
+              # Update static menu items
+              menu.menu_items.destroy_all
+              menu_data["items"]&.each do |item_data|
+                page = Panda::CMS::Page.find_by(path: item_data["page_path"]) if item_data["page_path"]
+                menu.menu_items.create!(
+                  text: item_data["text"],
+                  page: page,
+                  external_url: item_data["external_url"]
+                )
+              end
+              debug[:success] << "Updated static menu '#{menu.name}' with #{menu_data["items"]&.length || 0} items"
+            end
+          end
         end
 
+        # Templates - skip as they are code-based
+
         debug
       end
 
@@ -135,7 +306,8 @@ module Panda
       def self.extract_current_data
         data = {
           "pages" => {},
-          "menus" => {},
+          "posts" => [],
+          "menus" => [],
           "templates" => {},
           "settings" => {}
         }
@@ -148,10 +320,32 @@ module Panda
         # TODO: Eventually set the position of the block in the template, and then order from there rather than the name?
         Panda::CMS::BlockContent.includes(:block,
           page: [:template]).order("panda_cms_pages.lft ASC, panda_cms_blocks.key ASC").each do |block_content|
+          # Skip block contents without a page (orphaned data)
+          next unless block_content.page
+
           item = data["pages"][block_content.page.path] ||= {}
+          item["id"] = block_content.page.id
+          item["path"] = block_content.page.path
           item["title"] = block_content.page.title
           item["template"] = block_content.page.template.name
           item["parent"] = block_content.page.parent&.path
+          item["status"] = block_content.page.status
+          item["page_type"] = block_content.page.page_type
+          # SEO fields
+          item["seo_title"] = block_content.page.seo_title if block_content.page.seo_title.present?
+          item["seo_description"] = block_content.page.seo_description if block_content.page.seo_description.present?
+          item["seo_keywords"] = block_content.page.seo_keywords if block_content.page.seo_keywords.present?
+          item["seo_index_mode"] = block_content.page.seo_index_mode
+          item["canonical_url"] = block_content.page.canonical_url if block_content.page.canonical_url.present?
+          # Open Graph fields
+          item["og_type"] = block_content.page.og_type
+          item["og_title"] = block_content.page.og_title if block_content.page.og_title.present?
+          item["og_description"] = block_content.page.og_description if block_content.page.og_description.present?
+          item["og_image_url"] = active_storage_url(block_content.page.og_image) if block_content.page.og_image.attached?
+          # Panda CMS Pro fields (if present)
+          item["contributor_count"] = block_content.page.contributor_count if block_content.page.respond_to?(:contributor_count)
+          item["workflow_status"] = block_content.page.workflow_status if block_content.page.respond_to?(:workflow_status)
+          item["inherit_seo"] = block_content.page.inherit_seo if block_content.page.respond_to?(:inherit_seo)
           item["contents"] ||= {}
           item["contents"][block_content.block.key] = {
             kind: block_content.block.kind, # We need the kind to recreate the block
@@ -160,16 +354,98 @@ module Panda
           data["pages"][block_content.page.path] = item
         end
 
+        # Posts
+        Panda::CMS::Post.order("published_at DESC").each do |post|
+          post_data = {
+            "id" => post.id,
+            "slug" => post.slug,
+            "title" => post.title,
+            "status" => post.status,
+            "published_at" => post.published_at&.iso8601,
+            "user_email" => post.user&.email,
+            "author_email" => post.author&.email,
+            "content" => post.content,
+            "cached_content" => post.cached_content
+          }
+
+          # SEO fields
+          post_data["seo_title"] = post.seo_title if post.seo_title.present?
+          post_data["seo_description"] = post.seo_description if post.seo_description.present?
+          post_data["seo_keywords"] = post.seo_keywords if post.seo_keywords.present?
+          post_data["seo_index_mode"] = post.seo_index_mode
+          post_data["canonical_url"] = post.canonical_url if post.canonical_url.present?
+
+          # Open Graph fields
+          post_data["og_type"] = post.og_type
+          post_data["og_title"] = post.og_title if post.og_title.present?
+          post_data["og_description"] = post.og_description if post.og_description.present?
+          post_data["og_image_url"] = active_storage_url(post.og_image) if post.og_image.attached?
+
+          # Panda CMS Pro fields (if present)
+          post_data["contributor_count"] = post.contributor_count if post.respond_to?(:contributor_count)
+          post_data["workflow_status"] = post.workflow_status if post.respond_to?(:workflow_status)
+
+          data["posts"] << post_data
+        end
+
         # Menus
-        # item = data["menus"][] ||= {}
+        Panda::CMS::Menu.includes(menu_items: :page).order(:name).each do |menu|
+          menu_data = {
+            "name" => menu.name,
+            "kind" => menu.kind
+          }
+
+          if menu.kind == "auto" && menu.start_page
+            menu_data["start_page_path"] = menu.start_page.path
+          elsif menu.kind == "static"
+            menu_data["items"] = serialize_menu_items(menu.menu_items)
+          end
+
+          data["menus"] << menu_data
+        end
 
         # Templates
-        # item = data["templates"][] ||= {}
+        # Skipping templates for now as they are code-based
 
         data["settings"] = {}
 
         data.with_indifferent_access
       end
+
+      #
+      # Serialize menu items recursively
+      #
+      # @param menu_items [ActiveRecord::Relation<Panda::CMS::MenuItem>]
+      # @return [Array<Hash>]
+      # @visibility private
+      def self.serialize_menu_items(menu_items)
+        menu_items.map do |item|
+          {
+            "text" => item.text,
+            "page_path" => item.page&.path,
+            "external_url" => item.external_url
+          }.compact
+        end
+      end
+
+      #
+      # Get URL for Active Storage attachment
+      #
+      # @param attachment [ActiveStorage::Attached::One]
+      # @return [String, nil]
+      # @visibility private
+      def self.active_storage_url(attachment)
+        return nil unless attachment.attached?
+
+        if Rails.application.routes.url_helpers.respond_to?(:rails_blob_url)
+          Rails.application.routes.url_helpers.rails_blob_url(attachment, only_path: false)
+        else
+          # Fallback: return the key which can be used to reconstruct the URL
+          attachment.key
+        end
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/panda/cms/engine/asset_config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # Asset pipeline and importmap configuration
+      module AssetConfig
+        extend ActiveSupport::Concern
+
+        included do
+          # Asset pipeline configuration
+          initializer "panda.cms.assets" do |app|
+            if Rails.configuration.respond_to?(:assets)
+              # Add JavaScript paths
+              app.config.assets.paths << root.join("app/javascript")
+              app.config.assets.paths << root.join("app/javascript/panda")
+              app.config.assets.paths << root.join("app/javascript/panda/cms")
+              app.config.assets.paths << root.join("app/javascript/panda/cms/controllers")
+
+              # Make sure these files are precompiled
+              app.config.assets.precompile += %w[
+                panda_cms_manifest.js
+                panda/cms/controllers/**/*.js
+                panda/cms/application.js
+              ]
+            end
+          end
+
+          # Add importmap paths from the engine
+          initializer "panda.cms.importmap", before: "importmap" do |app|
+            if app.config.respond_to?(:importmap)
+              # Create a new array if frozen
+              app.config.importmap.paths = app.config.importmap.paths.dup if app.config.importmap.paths.frozen?
+
+              # Add our paths
+              app.config.importmap.paths << root.join("config/importmap.rb")
+
+              # Handle cache sweepers similarly
+              if app.config.importmap.cache_sweepers.frozen?
+                app.config.importmap.cache_sweepers = app.config.importmap.cache_sweepers.dup
+              end
+              app.config.importmap.cache_sweepers << root.join("app/javascript")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/engine/autoload_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # Autoload paths configuration
+      module AutoloadConfig
+        extend ActiveSupport::Concern
+
+        included do
+          # Add services directory to autoload paths
+          config.autoload_paths += %W[
+            #{root}/app/services
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/engine/backtrace_config.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # Backtrace cleaner configuration for better error messages
+      module BacktraceConfig
+        extend ActiveSupport::Concern
+
+        included do
+          initializer "#{engine_name}.backtrace_cleaner" do |_app|
+            engine_root_regex = Regexp.escape(root.to_s + File::SEPARATOR)
+
+            # Clean those ERB lines, we don't need the internal autogenerated
+            # ERB method, what we do need (line number in ERB file) is already there
+            Rails.backtrace_cleaner.add_filter do |line|
+              line.sub(/(\.erb:\d+):in `__.*$/, '\\1')
+            end
+
+            # Remove our own engine's path prefix, even if it's
+            # being used from a local path rather than the gem directory.
+            Rails.backtrace_cleaner.add_filter do |line|
+              line.sub(/^#{engine_root_regex}/, "#{engine_name} ")
+            end
+
+            # Keep Umlaut's own stacktrace in the backtrace -- we have to remove Rails
+            # silencers and re-add them how we want.
+            Rails.backtrace_cleaner.remove_silencers!
+
+            # Silence what Rails silenced, UNLESS it looks like
+            # it's from Umlaut engine
+            Rails.backtrace_cleaner.add_silencer do |line|
+              (line !~ Rails::BacktraceCleaner::APP_DIRS_PATTERN) &&
+                (line !~ /^#{engine_root_regex}/) &&
+                (line !~ /^#{engine_name} /)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/engine/core_config.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # Configuration for Panda::Core integration (navigation, breadcrumbs, widgets)
+      module CoreConfig
+        extend ActiveSupport::Concern
+
+        included do
+          # Configure Core for CMS (runs before app initializers so apps can override)
+          initializer "panda.cms.configure_core", before: :load_config_initializers do |app|
+            Panda::Core.configure do |config|
+              # Core now provides the admin interface foundation
+              # Apps using CMS can customize login_logo_path, login_page_title, etc. in their own initializers
+
+              # Register CMS navigation items with nested structure
+              config.admin_navigation_items = ->(user) {
+                items = []
+
+                # Dashboard
+                items << {
+                  path: "#{config.admin_path}/cms",
+                  label: "Dashboard",
+                  icon: "fa-solid fa-house"
+                }
+
+                # Content group - Pages, Posts, Collections
+                content_children = [
+                  {label: "Pages", path: "#{config.admin_path}/cms/pages"},
+                  {label: "Posts", path: "#{config.admin_path}/cms/posts"}
+                ]
+
+                # Add Collections if enabled
+                if Panda::CMS::Features.enabled?(:collections)
+                  content_children << {label: "Collections", path: "#{config.admin_path}/cms/collections"}
+                end
+
+                items << {
+                  label: "Content",
+                  icon: "fa-solid fa-file-lines",
+                  children: content_children
+                }
+
+                # Forms & Files group
+                items << {
+                  label: "Forms & Files",
+                  icon: "fa-solid fa-folder",
+                  children: [
+                    {label: "Forms", path: "#{config.admin_path}/cms/forms"},
+                    {label: "Files", path: "#{config.admin_path}/cms/files"}
+                  ]
+                }
+
+                # Menus (standalone)
+                items << {
+                  path: "#{config.admin_path}/cms/menus",
+                  label: "Menus",
+                  icon: "fa-solid fa-bars"
+                }
+
+                # Tools group
+                items << {
+                  label: "Tools",
+                  icon: "fa-solid fa-wrench",
+                  children: [
+                    {label: "Import/Export", path: "#{config.admin_path}/cms/tools/import-export"}
+                  ]
+                }
+
+                # Settings (standalone)
+                items << {
+                  path: "#{config.admin_path}/cms/settings",
+                  label: "Settings",
+                  icon: "fa-solid fa-gear"
+                }
+
+                items
+              }
+
+              # Redirect to CMS dashboard after login
+              # Apps can override this if they want different behavior
+              config.dashboard_redirect_path = -> { "#{Panda::Core.config.admin_path}/cms" }
+
+              # Customize initial breadcrumb
+              config.initial_admin_breadcrumb = ->(controller) {
+                # Use CMS dashboard path - just use the string path
+                ["Admin", "#{config.admin_path}/cms"]
+              }
+
+              # Dashboard widgets
+              config.admin_dashboard_widgets = ->(user) {
+                widgets = []
+
+                # TODO: Add CMS statistics widgets when StatisticsComponent is implemented
+                # This was removed along with Pro code migration
+
+                widgets
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/engine/helper_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # Helper configuration
+      module HelperConfig
+        extend ActiveSupport::Concern
+
+        included do
+          # Make helpers available to ApplicationController
+          config.to_prepare do
+            ApplicationController.helper(::ApplicationHelper)
+            ApplicationController.helper(Panda::CMS::AssetHelper)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/engine/route_config.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # Route mounting and configuration
+      module RouteConfig
+        extend ActiveSupport::Concern
+
+        included do
+          # Auto-mount CMS routes
+          config.after_initialize do |app|
+            # Append routes to the routes file
+            app.routes.append do
+              mount Panda::CMS::Engine => "/", :as => "panda_cms"
+              post "/_forms/:id", to: "panda/cms/form_submissions#create", as: :panda_cms_form_submit
+              get "/_maintenance", to: "panda/cms/errors#error_503", as: :panda_cms_maintenance
+
+              # Catch-all route for CMS pages, but exclude admin paths and assets
+              admin_path = Panda::Core.config.admin_path.delete_prefix("/")
+              constraints = ->(request) {
+                !request.path.start_with?("/#{admin_path}") &&
+                  !request.path.start_with?("/panda-cms-assets/")
+              }
+              get "/*path", to: "panda/cms/pages#show", as: :panda_cms_page, constraints: constraints
+
+              root to: "panda/cms/pages#root"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/engine/view_component_config.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    class Engine < ::Rails::Engine
+      # ViewComponent configuration
+      module ViewComponentConfig
+        extend ActiveSupport::Concern
+
+        included do
+          # Set up ViewComponent
+          initializer "panda.cms.view_component" do |app|
+            app.config.view_component.preview_paths ||= []
+            app.config.view_component.preview_paths << root.join("spec/components/previews")
+            app.config.view_component.generate.sidecar = true
+            app.config.view_component.generate.preview = true
+
+            # Add preview directories to autoload paths in development
+            if Rails.env.development?
+              # Handle frozen autoload_paths array
+              if app.config.autoload_paths.frozen?
+                app.config.autoload_paths = app.config.autoload_paths.dup
+              end
+              app.config.autoload_paths << root.join("spec/components/previews")
+            end
+          end
+        end
+      end
+    end
+  end
+end