Merge pull request #699 from code0-tech/698-add-cop-to-check-for-non-existing-error-codes

add cop to check for error codes

Author: Taucher2003

.rubocop.yml

@@ -105,3 +105,6 @@ Style/SymbolProc:
 
 Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: comma
+
+Sagittarius/ErrorCode:
+  Enabled: true

app/services/error_code.rb

@@ -56,6 +56,7 @@ def self.error_codes
       invalid_namespace_member: { description: 'The namespace member is invalid because of active model errors' },
       invalid_attachment: { description: 'The attachment is invalid because of active model errors' },
       invalid_namespace_license: { description: 'The namespace license is invalid because of active model errors' },
+      invalid_flow: { description: 'The flow is invalid because of active model errors' },
       project_not_found: { description: 'The namespace project with the given identifier was not found' },
       runtime_not_found: { description: 'The runtime with the given identifier was not found' },
       namespace_not_found: { description: 'The namespace with the given identifier was not found' },

docs/graphql/enum/errorcodeenum.md

@@ -25,6 +25,7 @@ Represents the available error responses
 | `INCONSISTENT_NAMESPACE` | Resources are from different namespaces |
 | `INVALID_ATTACHMENT` | The attachment is invalid because of active model errors |
 | `INVALID_EXTERNAL_IDENTITY` | This external identity is invalid |
+| `INVALID_FLOW` | The flow is invalid because of active model errors |
 | `INVALID_FLOW_SETTING` | The flow setting is invalid because of active model errors |
 | `INVALID_LOGIN_DATA` | Invalid login data provided |
 | `INVALID_NAMESPACE_LICENSE` | The namespace license is invalid because of active model errors |

tooling/rubocop/cop/sagittarius/error_code.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sagittarius
+      class ErrorCode < RuboCop::Cop::Base
+        MSG = 'Error code %s doesnt exist.'
+
+        def_node_matcher :is_service_error?, <<~PATTERN
+          (send (const _ :ServiceResponse) :error ...)
+        PATTERN
+
+        def on_send(node)
+          return unless in_service?(node)
+          return unless is_service_error?(node)
+
+          node.children.each do |child|
+            next unless child.is_a?(RuboCop::AST::HashNode)
+
+            child.children.each do |child_child|
+              next unless child_child.is_a?(RuboCop::AST::PairNode)
+              next unless child_child.children[0].sym_type?
+              next unless child_child.children[1].sym_type?
+              next unless child_child.children[0].value == :error_code
+
+              code = child_child.children[1].value
+              add_offense(child_child.children[1], message: MSG % ":#{code}") unless exists_error_code?(code)
+            end
+          end
+        end
+
+        def exists_error_code?(code)
+          @exists_error_code ||= extract_all_error_codes
+
+          @exists_error_code.include?(code)
+        end
+
+        def extract_error_code_hash_from_ast(ast)
+          return {} unless ast
+
+          method_defs = ast.each_node(:def, :defs).select do |node|
+            node.method_name == :error_codes
+          end
+
+          return {} if method_defs.empty?
+
+          # Collect all hash literals returned by these methods
+          hash_nodes = method_defs.filter_map do |m|
+            body = m.body
+            next unless body
+
+            # The body can be:
+            #   - a literal hash
+            #   - a call to `super.merge({ ... })`
+            if body.hash_type?
+              body
+            elsif body.send_type? && body.method_name == :merge
+              merge_arg = body.arguments.first
+              merge_arg if merge_arg&.hash_type?
+            end
+          end
+
+          hash_nodes.flat_map(&:pairs).each_with_object({}) do |pair, h|
+            key = pair.key
+            next unless key.sym_type?
+
+            h[key.value] = pair.value
+          end
+        end
+
+        def extract_all_error_codes
+          files = Dir.glob("#{__dir__}/../../../../**/app/services/**/error_code.rb")
+
+          merged = {}
+
+          files.each do |path|
+            next unless File.exist?(path)
+
+            ast = RuboCop::ProcessedSource.new(File.read(path), RUBY_VERSION.to_f).ast
+            partial = extract_error_code_hash_from_ast(ast)
+            merged.merge!(partial) # child overrides parent, matches super.merge behavior
+          end
+
+          merged.keys
+        end
+
+        def dirname(node)
+          File.dirname(filepath(node))
+        end
+
+        def filepath(node)
+          node.location.expression.source_buffer.name
+        end
+
+        def in_service?(node)
+          dirname(node).include?('app/services') # .include? because the path is ../app/services/...
+        end
+      end
+    end
+  end
+end