activeproject 0.3.0 → 0.5.0

data/lib/active_project/adapters/github_project/projects.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubProject
+      module Projects
+        include Helpers
+
+        #
+        # List all ProjectsV2 for a GitHub user.
+        #
+        # Because nothing says "weekend hustle" like spinning up yet another project,
+        # posting "🚀 Day 1 of #BuildInPublic" on X, and immediately abandoning it by Tuesday.
+        #
+        def list_projects(options = {})
+          owner     = options[:owner] || @config.owner
+          page_size = options.fetch(:page_size, 50)
+
+          # ---- build query template ------------------------------------------------
+          query_tmpl = lambda { |kind|
+            # rubocop:disable Layout/LineLength
+            <<~GQL
+              query($login:String!, $first:Int!, $after:String){
+                #{kind}(login:$login){
+                  projectsV2(first:$first, after:$after){
+                    nodes{ id number title }
+                    pageInfo{ hasNextPage endCursor }
+                  }
+                }
+              }
+            GQL
+            # rubocop:enable Layout/LineLength
+          }
+
+          # ---- fetch pages, trying user first, then organisation -------------------
+          begin
+            nodes = fetch_all_pages(
+              query_tmpl.call("user"),
+              variables: { login: owner, first: page_size },
+              connection_path: %w[user projectsV2]
+            )
+          rescue ActiveProject::NotFoundError, ActiveProject::ValidationError
+            nodes = fetch_all_pages(
+              query_tmpl.call("organization"),
+              variables: { login: owner, first: page_size },
+              connection_path: %w[organization projectsV2]
+            )
+          end
+
+          nodes.map { |proj| build_project_resource(proj) }
+        end
+
+        #
+        # Find a project either by its public-facing number or internal node ID.
+        #
+        # Supports both:
+        #  - people who proudly know their project number (respect)
+        #  - and people copy-pasting weird node IDs at 2am on a Saturday.
+        #
+        def find_project(id_or_number)
+          if id_or_number.to_s =~ /^\d+$/
+            # UI-visible number path: the civilized way.
+            owner = @config.owner
+            num = id_or_number.to_i
+            q = <<~GQL
+              query($login: String!, $num: Int!) {
+                user(login: $login) {
+                  projectV2(number: $num) { id number title }
+                }
+              }
+            GQL
+            data = request_gql(query: q, variables: { login: owner, num: num })
+            proj = data.dig("user", "projectV2") or raise NotFoundError
+          else
+            # Node ID path: the "I swear I know what I'm doing" path.
+            proj = request_gql(
+              query: "query($id:ID!){ node(id:$id){ ... on ProjectV2 { id number title }}}",
+              variables: { id: id_or_number }
+            )["node"]
+          end
+          build_project_resource(proj)
+        end
+
+        #
+        # Create a shiny new GitHub Project.
+        #
+        # Required:
+        #  - :name → preferably a trendy one like "TasklyAgent" or "ZenboardAI"
+        #
+        # Step 1: create project.
+        # Step 2: tweet "Just shipped something huge 🔥 #buildinpublic".
+        # Step 3: forget about it.
+        #
+        def create_project(attributes)
+          name = attributes[:name] or raise ArgumentError, "Missing :name"
+          owner_id = owner_node_id(@config.owner)
+          q = <<~GQL
+            mutation($name:String!, $owner:ID!){
+              createProjectV2(input:{title:$name,ownerId:$owner}) { projectV2 { id number title } }
+            }
+          GQL
+          proj = request_gql(query: q, variables: { name: name, owner: owner_id })
+                 .dig("createProjectV2", "projectV2")
+          build_project_resource(proj)
+        end
+
+        #
+        # Soft-delete a project by "closing" it.
+        #
+        # GitHub doesn't believe in real deletion yet, only ghosting.
+        # Just like that app idea you posted about but never launched.
+        #
+        def delete_project(project_id)
+          q = <<~GQL
+            mutation($id:ID!){ updateProjectV2(input:{projectId:$id, closed:true}) { clientMutationId } }
+          GQL
+          request_gql(query: q, variables: { id: project_id })
+          true
+        end
+
+        private
+
+        #
+        # Turn raw GraphQL sludge into a proper Project resource.
+        #
+        # For when you need your side project to at least *look* real in screenshots.
+        #
+        def build_project_resource(proj)
+          Resources::Project.new(self,
+                                 id: proj["id"],
+                                 key: proj["number"],
+                                 name: proj["title"],
+                                 adapter_source: :github,
+                                 raw_data: proj)
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/github_project/webhooks.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module ActiveProject
+  module Adapters
+    module GithubProject
+      # GitHub Project webhook processing for GitHub Projects V2.
+      # Handles project item and project events from GitHub webhooks.
+      module Webhooks
+        # Verifies GitHub webhook signature using SHA256 HMAC.
+        # @param request_body [String] Raw request body
+        # @param signature_header [String] Value of X-Hub-Signature-256 header
+        # @param webhook_secret [String] GitHub webhook secret
+        # @return [Boolean] true if signature is valid
+        def verify_webhook_signature(request_body, signature_header, webhook_secret: nil)
+          return false unless webhook_secret && signature_header
+
+          # GitHub sends signature as "sha256=<hash>"
+          return false unless signature_header.start_with?("sha256=")
+
+          expected_signature = signature_header[7..-1] # Remove "sha256=" prefix
+          computed_signature = OpenSSL::HMAC.hexdigest("SHA256", webhook_secret, request_body)
+
+          # Use secure comparison to prevent timing attacks
+          secure_compare(expected_signature, computed_signature)
+        end
+
+        # Parses GitHub webhook payload into standardized WebhookEvent.
+        # Supports projects_v2_item and projects_v2 events.
+        # @param request_body [String] Raw JSON payload
+        # @param headers [Hash] Request headers (for X-GitHub-Event)
+        # @return [ActiveProject::WebhookEvent, nil] Parsed event or nil if unsupported
+        def parse_webhook(request_body, headers = {})
+          payload = JSON.parse(request_body)
+          github_event = headers["X-GitHub-Event"] || headers["x-github-event"]
+
+          case github_event
+          when "projects_v2_item"
+            parse_project_item_event(payload)
+          when "projects_v2"
+            parse_project_event(payload)
+          else
+            # Return nil for unsupported events (not an error)
+            nil
+          end
+        rescue JSON::ParserError
+          # Invalid JSON - return nil
+          nil
+        end
+
+        private
+
+        # Secure string comparison to prevent timing attacks
+        def secure_compare(a, b)
+          return false unless a.bytesize == b.bytesize
+
+          l = a.unpack("C*")
+          r = b.unpack("C*")
+
+          result = 0
+          l.zip(r) { |x, y| result |= x ^ y }
+          result == 0
+        end
+
+        # Parses projects_v2_item events (item created, edited, deleted, etc.)
+        def parse_project_item_event(payload)
+          action = payload["action"]
+          item = payload["projects_v2_item"]
+          return nil unless item
+
+          # Map GitHub actions to ActiveProject event types
+          event_type = case action
+          when "created" then "issue_created"
+          when "edited" then "issue_updated"
+          when "deleted" then "issue_deleted"
+          when "archived" then "issue_updated"
+          when "restored" then "issue_updated"
+          else action # Pass through unknown actions
+          end
+
+          # Extract project info
+          project = payload["projects_v2"]
+          project_id = project&.dig("node_id")
+
+          # Extract actor (sender)
+          sender = payload["sender"]
+          actor = map_user_data(sender) if sender
+
+          # Build changes hash for updates
+          changes = {}
+          if action == "edited" && payload["changes"]
+            payload["changes"].each do |field, change_data|
+              changes[field] = {
+                from: change_data["from"],
+                to: change_data["to"]
+              }
+            end
+          end
+
+          # Extract content (linked issue/PR) if available
+          content = item["content"]
+          object_key = content&.dig("number")&.to_s
+          object_data = content || item
+
+          WebhookEvent.new(
+            event_type: event_type,
+            object_kind: "issue", # GitHub Project items are treated as issues
+            event_object_id: item["node_id"],
+            object_key: object_key,
+            project_id: project_id,
+            actor: actor,
+            timestamp: Time.parse(payload["created_at"] || Time.now.iso8601),
+            adapter_source: webhook_type,
+            changes: changes,
+            object_data: object_data,
+            raw_data: payload
+          )
+        end
+
+        # Parses projects_v2 events (project created, edited, deleted, etc.)
+        def parse_project_event(payload)
+          action = payload["action"]
+          project = payload["projects_v2"]
+          return nil unless project
+
+          # Map GitHub actions to ActiveProject event types
+          event_type = case action
+          when "created" then "project_created"
+          when "edited" then "project_updated"
+          when "deleted" then "project_deleted"
+          else action # Pass through unknown actions
+          end
+
+          # Extract actor (sender)
+          sender = payload["sender"]
+          actor = map_user_data(sender) if sender
+
+          # Build changes hash for updates
+          changes = {}
+          if action == "edited" && payload["changes"]
+            payload["changes"].each do |field, change_data|
+              changes[field] = {
+                from: change_data["from"],
+                to: change_data["to"]
+              }
+            end
+          end
+
+          WebhookEvent.new(
+            event_type: event_type,
+            object_kind: "project",
+            event_object_id: project["node_id"],
+            object_key: project["number"]&.to_s,
+            project_id: project["node_id"],
+            actor: actor,
+            timestamp: Time.parse(payload["created_at"] || Time.now.iso8601),
+            adapter_source: webhook_type,
+            changes: changes,
+            object_data: project,
+            raw_data: payload
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/github_project.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubProject
+    end
+  end
+end

data/lib/active_project/adapters/github_project_adapter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    class GithubProjectAdapter < Base
+      include GithubProject::Connection
+      include GithubProject::Projects
+      include GithubProject::Issues
+      include GithubProject::Comments
+      include GithubProject::Webhooks
+
+      def projects = ResourceFactory.new(adapter: self, resource_class: Resources::Project)
+      def issues   = ResourceFactory.new(adapter: self, resource_class: Resources::Issue)
+
+      def get_current_user
+        q = "query{viewer{ id login name email }}"
+        data = request_gql(query: q)
+        map_user_data(data["viewer"])
+      end
+
+      def connected? = begin
+        !get_current_user.nil?
+      rescue StandardError
+        false
+      end
+
+      def adapter_type
+        :github_project
+      end
+
+      def update_issue(id, attributes, context = {})
+        project_id = context[:project_id] || raise(ArgumentError,
+"GithubProjectAdapter requires :project_id in context")
+        update_issue_internal(project_id, id, attributes)
+      end
+
+      def delete_issue(id, context = {})
+        project_id = context[:project_id] || raise(ArgumentError,
+"GithubProjectAdapter requires :project_id in context")
+        delete_issue_internal(project_id, id)
+      end
+
+      private
+
+      def map_user_data(person_data)
+        return nil unless person_data && person_data["id"]
+
+        Resources::User.new(self, # Pass adapter instance
+                            id: person_data["id"],
+                            name: person_data["name"],
+                            email: person_data["email"],
+                            adapter_source: :github_project,
+                            raw_data: person_data)
+      end
+
+      def update_issue_internal(project_id, item_id, attrs = {})
+        update_issue_original(project_id, item_id, attrs)
+      end
+
+      def delete_issue_internal(project_id, item_id)
+        delete_issue_original(project_id, item_id)
+      end
+    end
+  end
+end

data/lib/active_project/adapters/github_repo/connection.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubRepo
+      module Connection
+        BASE_URL = "https://api.github.com"
+
+        # Initializes the GitHub Repo Adapter.
+        # @param config [Configurations::BaseAdapterConfiguration, Configurations::GithubConfiguration]
+        #        The configuration object for GitHub.
+        # @raise [ArgumentError] if required configuration options (:owner, :repo, :access_token) are missing.
+        def initialize(config:)
+          unless config.is_a?(ActiveProject::Configurations::BaseAdapterConfiguration)
+            raise ArgumentError, "GithubRepoAdapter requires a BaseAdapterConfiguration object"
+          end
+
+          @config = config
+
+          # Extract required configuration parameters
+          owner = @config.options[:owner]
+          repo = @config.options[:repo]
+          access_token = @config.options[:access_token]
+
+          # Validate required configuration parameters
+          unless owner && !owner.empty?
+            raise ArgumentError, "GithubRepoAdapter configuration requires :owner"
+          end
+
+          unless repo && !repo.empty?
+            raise ArgumentError, "GithubRepoAdapter configuration requires :repo"
+          end
+
+          unless access_token && !access_token.empty?
+            raise ArgumentError, "GithubRepoAdapter configuration requires :access_token"
+          end
+
+          # Set repository path for API requests
+          @repo_path = "repos/#{owner}/#{repo}"
+          @connection = initialize_connection
+        end
+
+        private
+
+        # Initializes the Faraday connection object.
+        # @return [Faraday::Connection] Configured Faraday connection for GitHub API
+        def initialize_connection
+          access_token = @config.options[:access_token]
+
+          Faraday.new(url: BASE_URL) do |conn|
+            conn.request :authorization, :bearer, access_token
+            conn.request :retry
+            conn.headers["Accept"] = "application/vnd.github.v3+json"
+            conn.headers["Content-Type"] = "application/json"
+            conn.headers["User-Agent"] = ActiveProject.user_agent
+            conn.response :raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/github_repo/issues.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubRepo
+      module Issues
+        # Lists GitHub issues within a specific repository (project).
+        # @param project_id [String] The repository name or full_name
+        # @param options [Hash] Optional filtering options.
+        #   Supported keys:
+        #   - status: 'open', 'closed', or 'all' (default: 'open')
+        #   - page: Page number for pagination (default: 1)
+        #   - per_page: Issues per page (default: 30, max: 100)
+        #   - sort: 'created', 'updated', or 'comments' (default: 'created')
+        #   - direction: 'asc' or 'desc' (default: 'desc')
+        # @return [Array<ActiveProject::Resources::Issue>]
+        def list_issues(project_id, options = {})
+          # Determine the repository path to use
+          repo_path = determine_repo_path(project_id)
+
+          # Build query parameters
+          query = {}
+          query[:state] = options[:status] || "open"
+          query[:page] = options[:page] if options[:page]
+          query[:per_page] = options[:per_page] if options[:per_page]
+          query[:sort] = options[:sort] if options[:sort]
+          query[:direction] = options[:direction] if options[:direction]
+
+          issues_data = make_request(:get, "#{repo_path}/issues", nil, query)
+          return [] unless issues_data.is_a?(Array)
+
+          issues_data.map { |issue_data| map_issue_data(issue_data) }
+        end
+
+        # Finds a specific issue by its number.
+        # @param id [String, Integer] The issue number within the repository.
+        # @param context [Hash] Optional context.
+        #   Supported keys:
+        #   - repo_owner: Repository owner if different from configured owner
+        #   - repo_name: Repository name if different from configured repo
+        # @return [ActiveProject::Resources::Issue]
+        def find_issue(id, context = {})
+          # Determine the repository path to use
+          repo_path = if context[:repo_owner] && context[:repo_name]
+                       "repos/#{context[:repo_owner]}/#{context[:repo_name]}"
+          else
+                       @repo_path
+          end
+
+          issue_data = make_request(:get, "#{repo_path}/issues/#{id}")
+          map_issue_data(issue_data)
+        end
+
+        # Creates a new issue in a GitHub repository.
+        # @param project_id [String] The repository name or full_name
+        # @param attributes [Hash] Issue attributes.
+        #   Required: :title
+        #   Optional: :description (body), :assignees (array of usernames)
+        # @return [ActiveProject::Resources::Issue]
+        def create_issue(project_id, attributes)
+          # Determine the repository path to use
+          repo_path = determine_repo_path(project_id)
+
+          unless attributes[:title] && !attributes[:title].empty?
+            raise ArgumentError, "Missing required attribute for GitHub issue creation: :title"
+          end
+
+          data = {
+            title: attributes[:title],
+            body: attributes[:description]
+          }
+
+          # Convert assignees if present
+          if attributes[:assignees] && attributes[:assignees].is_a?(Array)
+            if attributes[:assignees].all? { |a| a.is_a?(Hash) && a[:name] }
+              data[:assignees] = attributes[:assignees].map { |a| a[:name] }
+            else
+              data[:assignees] = attributes[:assignees]
+            end
+          end
+
+          # Add labels if present
+          data[:labels] = attributes[:labels] if attributes[:labels]
+
+          issue_data = make_request(:post, "#{repo_path}/issues", data)
+          map_issue_data(issue_data)
+        end
+
+        # Updates an existing issue in GitHub.
+        # @param id [String, Integer] The issue number.
+        # @param attributes [Hash] Issue attributes to update.
+        #   Supported keys: :title, :description (body), :status (state), :assignees
+        # @param context [Hash] Optional context.
+        #   Supported keys:
+        #   - repo_owner: Repository owner if different from configured owner
+        #   - repo_name: Repository name if different from configured repo
+        # @return [ActiveProject::Resources::Issue]
+        def update_issue(id, attributes, context = {})
+          # Determine the repository path to use
+          repo_path = if context[:repo_owner] && context[:repo_name]
+                       "repos/#{context[:repo_owner]}/#{context[:repo_name]}"
+          else
+                       @repo_path
+          end
+
+          data = {}
+          data[:title] = attributes[:title] if attributes.key?(:title)
+          data[:body] = attributes[:description] if attributes.key?(:description)
+
+          # Handle status mapping
+          if attributes.key?(:status)
+            state = case attributes[:status]
+            when :open, :in_progress then "open"
+            when :closed then "closed"
+            else attributes[:status].to_s
+            end
+            data[:state] = state
+          end
+
+          # Convert assignees if present
+          if attributes.key?(:assignees)
+            if attributes[:assignees].nil? || attributes[:assignees].empty?
+              data[:assignees] = []
+            elsif attributes[:assignees].all? { |a| a.is_a?(Hash) && a[:name] }
+              data[:assignees] = attributes[:assignees].map { |a| a[:name] }
+            else
+              data[:assignees] = attributes[:assignees]
+            end
+          end
+
+          issue_data = make_request(:patch, "#{repo_path}/issues/#{id}", data)
+          map_issue_data(issue_data)
+        end
+
+        # Attempts to delete an issue in GitHub, but since GitHub doesn't support
+        # true deletion, it closes the issue instead.
+        # @param id [String, Integer] The issue number.
+        # @param context [Hash] Optional context.
+        # @return [Boolean] Always returns false since GitHub doesn't support true deletion.
+        def delete_issue(id, context = {})
+          # GitHub doesn't support true deletion of issues
+          # The best we can do is close the issue
+          update_issue(id, { status: :closed }, context)
+          false # Return false indicating true deletion is not supported
+        end
+
+        private
+
+        # Determines the repository path to use based on project_id.
+        # @param project_id [String] Repository name or full_name
+        # @return [String] The repository API path
+        def determine_repo_path(project_id)
+          # If project_id matches configured repo or is the same as the full_name, use @repo_path
+          if project_id.to_s == @config.options[:repo] ||
+             project_id.to_s == "#{@config.options[:owner]}/#{@config.options[:repo]}"
+            return @repo_path
+          end
+
+          # If project_id contains a slash, assume it's a full_name
+          if project_id.to_s.include?("/")
+            return "repos/#{project_id}"
+          end
+
+          # Otherwise, assume it's just a repo name and use the configured owner
+          "repos/#{@config.options[:owner]}/#{project_id}"
+        end
+
+        # Maps raw GitHub issue data to an ActiveProject::Resources::Issue
+        # @param issue_data [Hash] Raw issue data from GitHub API
+        # @return [ActiveProject::Resources::Issue]
+        def map_issue_data(issue_data)
+          # Map state to status
+          status = @config.status_mappings[issue_data["state"]] || :unknown
+
+          # Map assignees
+          assignees = []
+          if issue_data["assignees"] && !issue_data["assignees"].empty?
+            assignees = issue_data["assignees"].map do |assignee|
+              Resources::User.new(
+                self,
+                id: assignee["id"].to_s,
+                name: assignee["login"],
+                adapter_source: :github,
+                raw_data: assignee
+              )
+            end
+          end
+
+          # Map reporter (user who created the issue)
+          reporter = nil
+          if issue_data["user"]
+            reporter = Resources::User.new(
+              self,
+              id: issue_data["user"]["id"].to_s,
+              name: issue_data["user"]["login"],
+              adapter_source: :github,
+              raw_data: issue_data["user"]
+            )
+          end
+
+          # Extract project ID (repo name) from the URL
+          project_id = nil
+          if issue_data["repository_url"]
+            # Extract owner/repo from repository_url
+            repo_parts = issue_data["repository_url"].split("/")
+            project_id = repo_parts.last(2).join("/")
+          elsif issue_data["url"]
+            # Try to extract from issue URL
+            url_parts = issue_data["url"].split("/")
+            if url_parts.include?("repos")
+              repos_index = url_parts.index("repos")
+              if repos_index && repos_index + 2 < url_parts.length
+                project_id = "#{url_parts[repos_index + 1]}/#{url_parts[repos_index + 2]}"
+              end
+            end
+          end
+
+          # If still not found, use configured repo
+          project_id ||= "#{@config.options[:owner]}/#{@config.options[:repo]}"
+
+          Resources::Issue.new(
+            self,
+            id: issue_data["id"].to_s,
+            key: issue_data["number"].to_s,
+            title: issue_data["title"],
+            description: issue_data["body"],
+            status: status,
+            assignees: assignees,
+            reporter: reporter,
+            project_id: project_id,
+            created_at: issue_data["created_at"] ? Time.parse(issue_data["created_at"]) : nil,
+            updated_at: issue_data["updated_at"] ? Time.parse(issue_data["updated_at"]) : nil,
+            due_on: nil, # GitHub issues don't have a built-in due date
+            priority: nil, # GitHub issues don't have a built-in priority
+            adapter_source: :github,
+            raw_data: issue_data
+          )
+        end
+      end
+    end
+  end
+end