roda-kabk 0.1.5

data/lib/roda/plugins/kabk/route_tree.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require "json"
+require "kabk/rest_engine"
+require "kabk/schema_renderer"
+
+module RodaPlugins
+  module Kabk
+    # The HTTP glue layer isolating Roda logic from Kabk core logic
+    class RouteTree
+      PUBLIC_DIR = File.expand_path("../../../../public", __dir__)
+
+      def self.call(r, opts)
+        # Helper to respond with JSON safely
+        respond_json = lambda do |response_hash, status_code = 200|
+          r.response.status = status_code
+          r.response["Content-Type"] = "application/json"
+          response_hash.to_json
+        end
+
+        respond_error = lambda do |error|
+          respond_json.call(error.to_h, error.http_status)
+        end
+
+        auth_strategy = opts[:auth_strategy]
+        serve_ui = opts[:serve_ui] != false
+        mount_at = opts[:mount_at] || "/api/admin"
+
+        is_auth_route = r.path.include?("/auth/")
+        is_login_or_refresh = is_auth_route && (r.path.end_with?("/login") || r.path.end_with?("/refresh"))
+
+        is_ui_request = serve_ui && (
+          r.path == mount_at ||
+          r.path == "#{mount_at}/" ||
+          r.path == "#{mount_at}/index.html" ||
+          r.path == "#{mount_at}/ui" ||
+          r.path.include?("/assets/") ||
+          r.path.end_with?("/simurgh-logo.svg")
+        )
+
+        user_context = nil
+        # Middleware for Authentication check if auth strategy is present and route is not login/refresh or UI
+        if auth_strategy && !is_login_or_refresh && !is_ui_request
+          auth_header = r.env["HTTP_AUTHORIZATION"]
+          begin
+            raise ::Kabk::UnauthorizedError, "Missing Authorization Header" unless auth_header&.start_with?("Bearer ")
+            token = auth_header.split(" ").last
+            user_context = auth_strategy.verify_access_token!(token)
+          rescue ::Kabk::ApiError => e
+            return respond_error.call(e)
+          end
+        end
+
+        if serve_ui
+          serve_index_html = lambda do
+            index_path = File.join(PUBLIC_DIR, "index.html")
+            if File.file?(index_path)
+              content = File.read(index_path)
+              base_url = mount_at
+
+              # Dynamically render registered Kabk schema
+              sys_config = opts[:system_config] || {}
+              
+              # Strip trailing slash if present for clean concatenation, unless it's just '/'
+              base = mount_at == "/" ? "" : mount_at
+              
+              sys_config[:endpoints] ||= {
+                login: "#{base}/auth/login",
+                me: "#{base}/auth/me",
+                logout: "#{base}/auth/logout",
+                refresh: "#{base}/auth/refresh",
+                upload: "#{base}/uploads"
+              }
+              schema_renderer = ::Kabk::SchemaRenderer.new(system_config: sys_config)
+              dynamic_schema = schema_renderer.render
+              dynamic_schema_json = JSON.pretty_generate(dynamic_schema)
+
+              # Replace embedded simurgh-schema script tag content
+              content = content.sub(%r{<script id="simurgh-schema" type="application/json">.*?</script>}m, "<script id=\"simurgh-schema\" type=\"application/json\">\n#{dynamic_schema_json}\n    </script>")
+
+              # Set baseURL in APP_CONFIG
+              config_snippet = "window.APP_CONFIG = { baseURL: '#{base_url}' };"
+              content = content.sub(/window\.APP_CONFIG\s*=\s*\{[^}]*\};/m, config_snippet)
+
+              if mount_at != "" && mount_at != "/"
+                content = content.gsub('href="/assets/', "href=\"#{mount_at}/assets/")
+                                 .gsub('src="/assets/', "src=\"#{mount_at}/assets/")
+                                 .gsub('href="/simurgh-logo.svg"', "href=\"#{mount_at}/simurgh-logo.svg\"")
+                                 .gsub('src="/simurgh-logo.svg"', "src=\"#{mount_at}/simurgh-logo.svg\"")
+              end
+
+              r.response["Content-Type"] = "text/html; charset=utf-8"
+              content
+            else
+              respond_error.call(::Kabk::NotFoundError.new("Simurgh UI index.html not found"))
+            end
+          end
+
+          r.get "assets", String do |asset_name|
+            asset_path = File.join(PUBLIC_DIR, "assets", asset_name)
+            if File.file?(asset_path)
+              ext = File.extname(asset_name).downcase
+              content_type = case ext
+                             when ".js" then "application/javascript; charset=utf-8"
+                             when ".css" then "text/css; charset=utf-8"
+                             when ".svg" then "image/svg+xml"
+                             when ".woff2" then "font/woff2"
+                             when ".png" then "image/png"
+                             else "application/octet-stream"
+                             end
+              r.response["Content-Type"] = content_type
+              
+              if ext == ".js"
+                # Remove hardcoded "/api/admin/" from API calls in the JS bundle
+                # because the Axios frontend will prepend the dynamic APP_CONFIG.baseURL anyway.
+                content = File.read(asset_path)
+                return content.gsub('"/api/admin/', '"/')
+              end
+
+              return File.read(asset_path)
+            end
+          end
+
+          r.get "simurgh-logo.svg" do
+            logo_path = File.join(PUBLIC_DIR, "simurgh-logo.svg")
+            if File.file?(logo_path)
+              r.response["Content-Type"] = "image/svg+xml"
+              return File.read(logo_path)
+            end
+          end
+
+          r.is do
+            r.get do
+              return serve_index_html.call
+            end
+          end
+
+          r.is "index.html" do
+            r.get do
+              return serve_index_html.call
+            end
+          end
+
+          r.is "ui" do
+            r.get do
+              return serve_index_html.call
+            end
+          end
+        end
+
+        r.on "auth" do
+          r.post "login" do
+            body = JSON.parse(r.body.read) rescue {}
+            begin
+              login_handler = opts[:login_handler]
+              raise ::Kabk::ApiError.new("Login handler not configured", code: "NOT_SUPPORTED", http_status: 501) unless login_handler
+
+              response = auth_strategy.login(body["username"], body["password"]) do |username, password|
+                login_handler.call(username, password)
+              end
+              respond_json.call(response)
+            rescue ::Kabk::ApiError => e
+              respond_error.call(e)
+            end
+          end
+
+          r.post "refresh" do
+            body = JSON.parse(r.body.read) rescue {}
+            begin
+              response = auth_strategy.refresh(body["refresh_token"])
+              respond_json.call(response)
+            rescue ::Kabk::ApiError => e
+              respond_error.call(e)
+            end
+          end
+
+          r.get "me" do
+            respond_json.call({
+              success: true,
+              data: user_context
+            })
+          end
+
+          r.post "logout" do
+            # Basic logout
+            respond_json.call({ success: true, message: "Successfully logged out" })
+          end
+
+          r.post "change-password" do
+            body = JSON.parse(r.body.read) rescue {}
+            begin
+              cp_handler = opts[:change_password_handler]
+              raise ::Kabk::ApiError.new("Change password handler not configured", code: "NOT_SUPPORTED", http_status: 501) unless cp_handler
+              
+              cp_handler.call(user_context, body["old_password"], body["new_password"])
+              respond_json.call({ success: true, message: "Password updated successfully" })
+            rescue ::Kabk::ApiError => e
+              respond_error.call(e)
+            end
+          end
+        end
+
+        r.post "uploads" do
+          file_param = r.params["file"] || r.params
+          upload_handler = opts[:upload_handler]
+
+          if upload_handler.respond_to?(:call)
+            result = upload_handler.call(file_param, r)
+            respond_json.call(::Kabk::UploadHandler.format_response(
+              url: result[:url] || result["url"],
+              file_name: result[:file_name] || result["file_name"] || result[:filename] || result["filename"],
+              size: result[:size] || result["size"],
+              mime_type: result[:mime_type] || result["mime_type"]
+            ))
+          elsif file_param.is_a?(Hash) && file_param[:tempfile]
+            respond_json.call(::Kabk::UploadHandler.format_response(
+              url: "/uploads/#{file_param[:filename]}",
+              file_name: file_param[:filename],
+              size: file_param[:tempfile].size,
+              mime_type: file_param[:type]
+            ))
+          else
+            respond_error.call(::Kabk::ApiError.new("No file uploaded or file parameter missing", code: "BAD_REQUEST", http_status: 400))
+          end
+        end
+
+        # Generic Resource Routes
+        r.on String do |plural_name|
+          # Match plural_name to a registered resource
+          resource = ::Kabk::Registry.instance.all.find { |res| res.plural_name == plural_name }
+          if resource.nil?
+            return respond_error.call(::Kabk::NotFoundError.new("Endpoint not found"))
+          end
+
+          engine = ::Kabk::RestEngine.new(resource.name)
+
+          r.is do
+            # GET /:plural_name
+            r.get do
+              # We use request.params directly, it parses the query string nicely
+              begin
+                respond_json.call(engine.list(r.params))
+              rescue ::Kabk::ApiError => e
+                respond_error.call(e)
+              end
+            end
+
+            # POST /:plural_name
+            r.post do
+              body = JSON.parse(r.body.read) rescue {}
+              begin
+                respond_json.call(engine.create(body))
+              rescue ::Kabk::ApiError => e
+                respond_error.call(e)
+              end
+            end
+          end
+
+          r.on "export" do
+            r.get do
+              begin
+                format = r.params["format"] || "csv"
+                # For streaming/buffering
+                # Just call ExportHandler
+                dataset = ::Kabk::QueryBuilder.build(resource, r.params)
+                file_data = ::Kabk::ExportHandler.export(resource, dataset, format: format)
+                
+                r.response["Content-Disposition"] = "attachment; filename=\"#{plural_name}_export.#{format}\""
+                r.response["Content-Type"] = format == "csv" ? "text/csv" : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                file_data
+              rescue ::Kabk::ApiError => e
+                respond_error.call(e)
+              end
+            end
+          end
+
+          r.on String do |id|
+            record_id = id.to_i
+
+            r.is do
+              # GET /:plural_name/:id
+              r.get do
+                begin
+                  respond_json.call(engine.get(record_id))
+                rescue ::Kabk::ApiError => e
+                  respond_error.call(e)
+                end
+              end
+
+              # PUT /:plural_name/:id
+              r.put do
+                body = JSON.parse(r.body.read) rescue {}
+                begin
+                  respond_json.call(engine.update(record_id, body))
+                rescue ::Kabk::ApiError => e
+                  respond_error.call(e)
+                end
+              end
+
+              # DELETE /:plural_name/:id
+              r.delete do
+                begin
+                  respond_json.call(engine.delete(record_id))
+                rescue ::Kabk::ApiError => e
+                  respond_error.call(e)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/plugins/kabk.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "kabk"
+require_relative "kabk/route_tree"
+
+class Roda
+  module RodaPlugins
+    # Kabk plugin for Roda
+    module Kabk
+      def self.load_dependencies(app, opts = {})
+        app.plugin :all_verbs
+      end
+
+      def self.configure(app, opts = {})
+        app.opts[:kabk] ||= {}
+        app.opts[:kabk][:mount_at] = opts[:mount_at] || "/api/admin"
+        app.opts[:kabk][:system_config] = opts[:system_config] || nil
+        app.opts[:kabk][:auth_strategy] = opts[:auth_strategy] # E.g., Kabk::Auth::JwtStrategy.new(secret: '...', default_exp: 86400)
+        app.opts[:kabk][:login_handler] = opts[:login_handler]
+        app.opts[:kabk][:change_password_handler] = opts[:change_password_handler]
+        app.opts[:kabk][:upload_handler] = opts[:upload_handler]
+        app.opts[:kabk][:serve_ui] = opts.key?(:serve_ui) ? opts[:serve_ui] : true
+      end
+
+      module RequestMethods
+        # The route block that mounts all Kabk endpoints
+        def kabk
+          options = scope.opts[:kabk]
+          mount_at = options[:mount_at]
+
+          # Use Roda routing methods to scope everything under mount_at
+          on mount_at.sub(%r{^/}, "") do
+            ::RodaPlugins::Kabk::RouteTree.call(self, options)
+          end
+        end
+      end
+    end
+
+    register_plugin(:kabk, Kabk)
+  end
+end