panda-core 0.12.2 → 1.1.0

data/lib/panda/core/engine.rb

@@ -5,6 +5,7 @@ require "omniauth"
 
 require "panda/core/middleware"
 require "panda/core/module_registry"
+require "panda/core/search_registry"
 
 # Shared engine mixins
 require_relative "shared/inflections_config"
@@ -14,9 +15,11 @@ require_relative "shared/generator_config"
 require_relative "engine/autoload_config"
 require_relative "engine/importmap_config"
 require_relative "engine/omniauth_config"
-require_relative "engine/phlex_config"
+require_relative "engine/view_component_config"
 require_relative "engine/admin_controller_config"
 require_relative "engine/route_config"
+require_relative "engine/pending_migrations_check"
+require_relative "engine/sqlite_schema_compatibility"
 
 module Panda
   module Core
@@ -35,9 +38,11 @@ module Panda
       include AutoloadConfig
       include ImportmapConfig
       include OmniauthConfig
-      include PhlexConfig
+      include ViewComponentConfig
       include AdminControllerConfig
       include RouteConfig
+      include PendingMigrationsCheck
+      include SqliteSchemaCompatibility
 
       #
       # Misc configuration point
@@ -46,33 +51,93 @@ module Panda
         # Intentionally quiet — used as a stable anchor point
       end
 
+      #
+      # Clean up FileCategorization records before blob destruction.
+      # Without this, ActiveStorage::Blob#purge silently fails because
+      # panda_core_file_categorizations has a FK to active_storage_blobs,
+      # and Rails rescues the resulting InvalidForeignKey error.
+      #
+      initializer "panda_core.active_storage_blob_cleanup" do
+        ActiveSupport.on_load(:active_storage_blob) do
+          before_destroy :cleanup_file_categorizations
+
+          private
+
+          def cleanup_file_categorizations
+            Panda::Core::FileCategorization.where(blob_id: id).delete_all
+          end
+        end
+      end
+
+      #
+      # Auto-categorize files when ActiveStorage attachments are created.
+      # Maps known attachment types (user avatars, page images, etc.) to
+      # their corresponding file categories via FileCategorizer.
+      #
+      initializer "panda_core.active_storage_categorization" do
+        ActiveSupport.on_load(:active_storage_attachment) do
+          after_create_commit :auto_categorize_blob
+
+          private
+
+          def auto_categorize_blob
+            Panda::Core::FileCategorizer.new.categorize_attachment(self)
+          rescue => e
+            Rails.logger.warn("[Panda::Core] Auto-categorization failed for blob #{blob_id}: #{e.message}")
+          end
+        end
+      end
+
+      #
+      # Ensure system file categories exist on every boot.
+      # Skipped in test env to avoid interfering with fixtures.
+      # Uses find_or_create_by! so it's idempotent.
+      #
+      initializer "panda_core.ensure_file_categories", after: "panda_core.active_storage_categorization" do
+        config.after_initialize do
+          next if Rails.env.test?
+          if ActiveRecord::Base.connection.table_exists?("panda_core_file_categories")
+            require "panda/core/seeds/file_categories"
+            Panda::Core::Seeds::FileCategories.seed!
+          end
+        rescue ActiveRecord::NoDatabaseError, ActiveRecord::ConnectionNotEstablished
+          # Skip when DB isn't available (asset precompilation, etc.)
+        end
+      end
+
       #
       # Static asset handling for:
       #   /panda-core-assets
       #
-      initializer "panda_core.static_assets" do |app|
-        Panda::Core::Middleware.use(
-          app,
-          Rack::Static,
-          urls: ["/panda-core-assets"],
-          root: Panda::Core::Engine.root.join("public"),
-          header_rules: [
-            [
-              :all,
-              {
-                "Cache-Control" =>
-                  Rails.env.development? ?
-                    "no-cache, no-store, must-revalidate" :
-                    "public, max-age=31536000"
-              }
-            ]
+      # Configured during engine load phase to avoid Rails 8.1.2+ frozen middleware stack
+      # Use no-cache in development for easier debugging, long cache in production
+      config.app_middleware.use(
+        Rack::Static,
+        urls: ["/panda-core-assets"],
+        root: Panda::Core::Engine.root.join("public"),
+        header_rules: [
+          [
+            :all,
+            {
+              "Cache-Control" => if defined?(::Rails) && ::Rails.env.development?
+                                   "no-cache, no-store, must-revalidate"
+                                 else
+                                   "public, max-age=31536000"
+                                 end
+            }
           ]
-        )
+        ]
+      )
+
+      config.app_middleware.use(Panda::Core::ModuleRegistry::JavaScriptMiddleware)
 
-        Panda::Core::Middleware.use(
-          app,
-          Panda::Core::ModuleRegistry::JavaScriptMiddleware
-        )
+      #
+      # Serve Chartkick vendor assets when the chartkick gem is available
+      # Must be inserted BEFORE Rack::Static so it handles chartkick requests
+      # before Rack::Static catches all /panda-core-assets/* paths and returns 404
+      #
+      if Gem.loaded_specs["chartkick"]
+        config.app_middleware.insert_before(Rack::Static, Panda::Core::ChartkickAssetMiddleware)
       end
     end
   end
@@ -86,10 +151,10 @@ Panda::Core::ModuleRegistry.register(
   engine: "Panda::Core::Engine",
   paths: {
     builders: "app/builders/panda/core/**/*.rb",
-    components: "app/components/panda/core/**/*.rb",
+    components: "app/components/panda/core/**/*.{rb,erb,js}",
     helpers: "app/helpers/panda/core/**/*.rb",
     views: "app/views/panda/core/**/*.erb",
     layouts: "app/views/layouts/panda/core/**/*.erb",
-    javascripts: "app/assets/javascript/panda/core/**/*.js"
+    javascripts: "app/javascript/panda/core/**/*.js"
   }
 )

data/lib/panda/core/middleware.rb

@@ -142,5 +142,40 @@ module Panda
       end
       private_class_method :normalize_stack
     end
+
+    # Serves Chartkick vendor JS files (Chart.bundle.js, chartkick.js) from the
+    # chartkick gem's vendor directory at /panda-core-assets/chartkick/*.
+    class ChartkickAssetMiddleware
+      CHARTKICK_PATH_PREFIX = "/panda-core-assets/chartkick/"
+      ALLOWED_FILES = %w[Chart.bundle.js chartkick.js].freeze
+
+      def initialize(app)
+        @app = app
+        @vendor_root = Pathname.new(Gem.loaded_specs["chartkick"].gem_dir).join("vendor/assets/javascripts")
+      end
+
+      def call(env)
+        path = Rack::Utils.unescape_path(env[Rack::PATH_INFO])
+
+        if path.start_with?(CHARTKICK_PATH_PREFIX)
+          filename = path.delete_prefix(CHARTKICK_PATH_PREFIX)
+          return @app.call(env) unless ALLOWED_FILES.include?(filename)
+
+          file_path = @vendor_root.join(filename)
+          return @app.call(env) unless file_path.file?
+
+          content = File.binread(file_path)
+          cache = Rails.env.local? ? "no-cache, no-store, must-revalidate" : "public, max-age=31536000"
+
+          [200, {
+            "Content-Type" => "application/javascript; charset=utf-8",
+            "Content-Length" => content.bytesize.to_s,
+            "Cache-Control" => cache
+          }, [content]]
+        else
+          @app.call(env)
+        end
+      end
+    end
   end
 end

data/lib/panda/core/module_registry.rb

@@ -343,6 +343,10 @@ module Panda
         private
 
         def find_javascript_file(relative_path)
+          # Build list of paths to try - include .js extension fallback
+          paths_to_try = [relative_path]
+          paths_to_try << "#{relative_path}.js" unless relative_path.end_with?(".js")
+
           # Check each registered module's JavaScript directory
           ModuleRegistry.modules.each do |gem_name, info|
             next unless ModuleRegistry.send(:engine_available?, info[:engine])
@@ -350,24 +354,28 @@ module Panda
             root = ModuleRegistry.send(:engine_root, info[:engine])
             next unless root
 
-            # Check in app/javascript/panda/ (primary location)
-            candidate = root.join("app/javascript/panda", relative_path)
-            return candidate.to_s if candidate.exist? && candidate.file?
+            paths_to_try.each do |path|
+              # Check in app/javascript/panda/ (primary location)
+              candidate = root.join("app/javascript/panda", path)
+              return candidate.to_s if candidate.exist? && candidate.file?
 
-            # Fallback to public/panda/ (for CI environments where assets are copied)
-            public_candidate = root.join("public/panda", relative_path)
-            return public_candidate.to_s if public_candidate.exist? && public_candidate.file?
+              # Fallback to public/panda/ (for CI environments where assets are copied)
+              public_candidate = root.join("public/panda", path)
+              return public_candidate.to_s if public_candidate.exist? && public_candidate.file?
+            end
           end
 
           # Also check Rails.root if available (for dummy apps in CI)
           if defined?(Rails.root)
-            # Check app/javascript/panda/ in Rails.root
-            rails_candidate = Rails.root.join("app/javascript/panda", relative_path)
-            return rails_candidate.to_s if rails_candidate.exist? && rails_candidate.file?
-
-            # Fallback to public/panda/ in Rails.root
-            rails_public_candidate = Rails.root.join("public/panda", relative_path)
-            return rails_public_candidate.to_s if rails_public_candidate.exist? && rails_public_candidate.file?
+            paths_to_try.each do |path|
+              # Check app/javascript/panda/ in Rails.root
+              rails_candidate = Rails.root.join("app/javascript/panda", path)
+              return rails_candidate.to_s if rails_candidate.exist? && rails_candidate.file?
+
+              # Fallback to public/panda/ in Rails.root
+              rails_public_candidate = Rails.root.join("public/panda", path)
+              return rails_public_candidate.to_s if rails_public_candidate.exist? && rails_public_candidate.file?
+            end
           end
 
           nil