activeproject 0.2.0 → 0.5.0

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

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module GithubProject
+      #
+      # Project-item CRUD operations for GitHub Projects v2.
+      #
+      # This module exists because GitHub decided that "issues," "drafts," and "project items"
+      # are three different species, and we have to *unify the galaxy.*
+      #
+      module Issues
+        include Helpers
+        # Like everything on GitHub: decent default, weird edge cases. Why not 25 like a normal person?
+        DEFAULT_ITEM_PAGE_SIZE = 50
+
+        #
+        # Lists *every* issue or draft in a GitHub Project.
+        # Handles pagination the GitHub way: manually, painfully, endlessly.
+        #
+        # options[:page_size] → control how much data you want per jump into hyperspace.
+        #
+        def list_issues(project_id, options = {})
+          page_size = options.fetch(:page_size, DEFAULT_ITEM_PAGE_SIZE)
+          query = <<~GQL
+            query($id:ID!, $first:Int!, $after:String){
+              node(id:$id){
+                ... on ProjectV2{
+                  items(first:$first, after:$after){
+                    nodes{
+                      id type content{__typename ... on Issue{ id number title body state
+                        assignees(first:10){nodes{login id}}
+                        reporter:author{login} } }
+                      createdAt updatedAt
+                    }
+                    pageInfo{hasNextPage endCursor}
+                  }
+                }
+              }
+            }
+          GQL
+
+          nodes = fetch_all_pages(
+            query,
+            variables: { id: project_id, first: page_size },
+            connection_path: %w[node items]
+          ) { |vars| request_gql(query: query, variables: vars) }
+
+          nodes.map { |n| map_item_to_issue(n, project_id) }
+        end
+
+        #
+        # Fetch a single issue or draft item by its mysterious GraphQL node ID.
+        # If it's missing, you get a 404 so you can take a day off.
+        #
+        def find_issue(item_id, _ctx = {})
+          query = <<~GQL
+            query($id:ID!){
+              node(id:$id){
+                ... on ProjectV2Item{
+                  id
+                  type
+                  fieldValues(first:20){
+                    nodes{
+                      ... on ProjectV2ItemFieldTextValue{
+                        text
+                        field { ... on ProjectV2FieldCommon { name } }
+                      }
+                    }
+                  }
+                  content{
+                    __typename
+                    ... on Issue{
+                      id number title body state
+                      assignees(first:10){nodes{login id}}
+                      reporter:author{login}
+                    }
+                  }
+                  createdAt
+                  updatedAt
+                  project { id }
+                }
+              }
+            }
+          GQL
+          node = request_gql(query: query, variables: { id: item_id })["node"]
+          raise NotFoundError, "Project item #{item_id} not found" unless node
+
+          map_item_to_issue(node, node.dig("project", "id"))
+        end
+
+        #
+        # Create a new issue in the project.
+        #
+        # Choose your destiny:
+        #   - Pass :content_id → links an existing GitHub Issue or PR into the project.
+
+        def create_issue(project_id, attrs)
+          content_id = attrs[:content_id] or
+            raise ArgumentError, "DraftIssues not supported—pass :content_id of a real Issue or PR"
+
+          mutation = <<~GQL
+            mutation($project:ID!, $content:ID!) {
+              addProjectV2ItemById(input:{projectId:$project, contentId:$content}) {
+                item { id }
+              }
+            }
+          GQL
+
+          data = request_gql(
+            query: mutation,
+            variables: { project: project_id, content: content_id }
+          ).dig("addProjectV2ItemById", "item")
+
+          find_issue(data["id"])
+        end
+
+        #
+        # Update fields on an existing ProjectV2Item.
+        #
+        # You can adjust:
+        #   - Title (text field)
+        #   - Status (single-select nightmare field)
+        #
+        # NOTE: Requires you to preload field mappings, because GitHub’s GraphQL API
+        # refuses to help unless you memorize all their withcrafts.
+        #
+        def update_issue_original(project_id, item_id, attrs = {})
+          field_ids = project_field_ids(project_id)
+
+          # -- Update Title (basic) --
+          if attrs[:title]
+            mutation = <<~GQL
+              mutation($proj:ID!, $item:ID!, $field:ID!, $title:String!) {
+                updateProjectV2ItemFieldValue(input:{
+                  projectId:$proj, itemId:$item,
+                  fieldId:$field, value:{text:$title}
+                }) { projectV2Item { id } }
+              }
+            GQL
+            request_gql(query: mutation,
+                        variables: {
+                          proj: project_id,
+                          item: item_id,
+                          field: field_ids.fetch("Title"),
+                          title: attrs[:title]
+                        })
+          end
+
+          # -- Update Status (dark side difficulty) --
+          if attrs[:status]
+            status_field_id = field_ids.fetch("Status")
+            option_id = status_option_id(project_id, attrs[:status])
+            mutation = <<~GQL
+              mutation($proj:ID!, $item:ID!, $field:ID!, $opt:String!) {
+                updateProjectV2ItemFieldValue(input:{
+                  projectId:$proj, itemId:$item,
+                  fieldId:$field, value:{singleSelectOptionId:$opt}
+                }) { projectV2Item { id } }
+              }
+            GQL
+            request_gql(query: mutation,
+                        variables: { proj: project_id, item: item_id,
+                                     field: status_field_id, opt: option_id })
+          end
+
+          find_issue(item_id)
+        end
+
+        #
+        # Delete a ProjectV2Item from a project.
+        # No soft delete, no grace period — just *execute Order 66*.
+        #
+        def delete_issue_original(project_id, item_id)
+          mutation = <<~GQL
+            mutation($proj:ID!, $item:ID!){
+              deleteProjectV2Item(input:{projectId:$proj, itemId:$item}){deletedItemId}
+            }
+          GQL
+          request_gql(query: mutation,
+                      variables: { proj: project_id, item: item_id })
+          true
+        end
+
+        #
+        # Check if a status symbol like :in_progress is known for a project.
+        # Avoids exploding like fukushima reactor if you try to set a status that doesn't exist.
+        #
+        def status_known?(project_id, sym)
+          (@status_cache && @status_cache[project_id] || {}).key?(sym)
+        end
+
+        private
+
+        #
+        # Turn a GraphQL project item node into a clean, beautiful Resources::Issue object.
+        #
+        # Because the only thing worse than undocumented fields is undocumented *types.*
+        #
+        def map_item_to_issue(node, project_id)
+          content = node["content"] || {}
+          typename = content["__typename"]
+          title =
+            if typename == "Issue"
+              content["title"]
+            else
+              # Draft card – try to pull “Title” field value
+              fv = node.dig("fieldValues", "nodes")
+                       &.find { |n| n.dig("field", "name") == "Title" }
+              "(draft) #{fv&.dig('text')}"
+            end
+          description = typename == "Issue" ? content["body"] : nil
+          status = :open
+          status = :closed if typename == "Issue" && content["state"] == "CLOSED"
+
+          assignees = if content["assignees"] && content["assignees"]["nodes"]
+                        content["assignees"]["nodes"].map { |u| map_user(u) }
+          else
+                        []
+          end
+
+          reporter = map_user(content["reporter"]) if content["reporter"]
+
+          Resources::Issue.new(
+            self,
+            id: node["id"],
+            key: typename == "Issue" ? content["number"] : nil,
+            title: title,
+            description: description,
+            status: status,
+            assignees: assignees,
+            reporter: reporter,
+            project_id: project_id,
+            created_at: Time.parse(node["createdAt"]),
+            updated_at: Time.parse(node["updatedAt"]),
+            due_on: nil,
+            priority: nil,
+            adapter_source: :github,
+            raw_data: node
+          )
+        end
+
+        #
+        # Look up the option ID for a given status symbol, or raise a tantrum.
+        #
+        def status_option_id(project_id, symbol)
+          @status_cache ||= Concurrent::Map.new
+          cache = (@status_cache[project_id] ||= load_status_options(project_id))
+
+          return cache[symbol] if cache.key?(symbol)
+
+          available = cache.keys.map(&:inspect).join(", ")
+          raise ArgumentError,
+                "No status #{symbol.inspect} in project; valid symbols are: #{available}"
+        end
+
+        #
+        # Load all valid status options for a project’s "Status" field.
+        # Only way to win is not to play.
+        #
+        def load_status_options(project_id)
+          q = <<~GQL
+            query($id:ID!){
+              node(id:$id){
+                ... on ProjectV2{
+                  field(name:"Status"){
+                    ... on ProjectV2SingleSelectField{
+                      options{ id name }
+                    }
+                  }
+                }
+              }
+            }
+          GQL
+
+          opts = request_gql(query: q, variables: { id: project_id })
+                 .dig("node", "field", "options")
+
+          opts.to_h do |o|
+            key = o["name"].downcase.tr(" ", "_").to_sym
+            [ key, o["id"] ]
+          end
+        end
+      end
+    end
+  end
+end

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