feat: fetch all orders (#10)

* feat: fetch all orders
chore: Makefile added

* chore: made document more clear

* chore: review fixes

Author: alok87

.gitignore

@@ -2,4 +2,5 @@
 /bin
 /.go
 /logs
-/vendor
+/vendor
+razorpay-mcp-server

CONTRIBUTING.md

@@ -6,6 +6,18 @@ Thank you for your interest in contributing to the Razorpay MCP Server! This doc
 
 Please be respectful and considerate of others when contributing to this project. We strive to maintain a welcoming and inclusive environment for all contributors.
 
+## TLDR;
+
+```
+make test
+make fmt
+make lint
+make build
+make run
+```
+
+We use Cursor to contribute - our AI developer. Look at `~/.cusor/rules`. It understands the standards we have defined and codes with that.
+
 ## Development Process
 
 We use a fork-based workflow for all contributions:
@@ -95,6 +107,8 @@ We use a fork-based workflow for all contributions:
 
 ### Running the Server Locally
 
+There are `make` commands also available now for the below, refer TLDR; above.
+
 To run the server in development mode:
 
 ```bash

Makefile

@@ -0,0 +1,93 @@
+# Build variables
+VERSION ?= $(shell git describe --tags --always --dirty --match="v*" 2> /dev/null || echo "dev")
+BUILD_DATE = $(shell date -u '+%Y-%m-%d')
+COMMIT = $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
+LDFLAGS = -ldflags "-X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.buildDate=$(BUILD_DATE)"
+
+# Go variables
+GO = go
+GOBIN = $(shell $(GO) env GOPATH)/bin
+
+# Docker variables
+IMAGE = razorpay-mcp-server
+TAG ?= latest
+
+# Default target
+all: verify fmt test lint build
+
+# Build docker image
+build:
+	docker build -t $(IMAGE):$(TAG) .
+
+# Run docker container
+run:
+	docker run -it --rm \
+		-e RAZORPAY_KEY_ID=your_key_id \
+		-e RAZORPAY_KEY_SECRET=your_key_secret \
+		$(IMAGE):$(TAG)
+
+# Run the application
+local-run:
+	$(GO) run ./cmd/razorpay-mcp-server
+
+local-build:
+	$(GO) build -v ./cmd/razorpay-mcp-server
+
+# Verify dependencies
+verify:
+	$(GO) mod verify
+	$(GO) mod download
+
+# Format code
+fmt:
+	$(GO) fmt ./...
+	$(GO) mod tidy
+
+# Run tests
+test:
+	$(GO) test -race ./...
+
+# Run tests with coverage
+test-coverage:
+	$(GO) test -race -coverprofile=coverage.out -covermode=atomic ./pkg/...
+	$(GO) tool cover -html=coverage.out -o coverage.html
+
+# Install golangci-lint
+install-lint:
+	@LINT_VERSION=1.64.8; \
+	if ! command -v golangci-lint > /dev/null 2>&1; then \
+		echo "Installing golangci-lint v$$LINT_VERSION..."; \
+		curl -fsSL https://github.com/golangci/golangci-lint/releases/download/v$$LINT_VERSION/golangci-lint-$$LINT_VERSION-$$($(GO) env GOOS)-$$($(GO) env GOARCH).tar.gz | \
+			tar xz --strip-components 1 --wildcards \*/golangci-lint; \
+		mkdir -p bin && mv golangci-lint bin/; \
+		echo "golangci-lint installed to bin/golangci-lint"; \
+	fi
+
+# Run linter
+lint: install-lint
+	@if [ -f ./bin/golangci-lint ]; then \
+		./bin/golangci-lint run --out-format=colored-line-number --timeout=3m; \
+	else \
+		golangci-lint run --out-format=colored-line-number --timeout=3m; \
+	fi
+
+# Clean build artifacts
+clean:
+	rm -rf bin/
+	rm -f coverage.out coverage.html
+
+# Help
+help:
+	@echo "Available targets:"
+	@echo "  all            - Run verify, fmt, test, lint, and build (default)"
+	@echo "  build          - Build Docker image"
+	@echo "  run            - Run Docker container"
+	@echo "  local-build    - Build the application"
+	@echo "  local-run      - Run the application"
+	@echo "  verify         - Verify dependencies"
+	@echo "  fmt            - Format code"
+	@echo "  test           - Run tests"
+	@echo "  test-coverage  - Run tests with coverage"
+	@echo "  lint           - Run linter"
+	@echo "  clean          - Clean build artifacts"
+	@echo "  help           - Show this help message" 

README.md

@@ -6,14 +6,14 @@ The Razorpay MCP Server is a [Model Context Protocol (MCP)](https://modelcontext
 
 Currently, the Razorpay MCP Server provides the following tools:
 
-| Tool                  | Description                           |
-|-----------------------|---------------------------------------|
-| `fetch_payment`       | Fetch payment details                 |
-| `create_payment_link` | Creates a new payment link            |
-| `fetch_payment_link`  | Fetch details of a payment link       |
-| `create_order`        | Creates an order                      |
-| `fetch_order`         | Fetch order details                   |
-
+| Tool                  | Description                                     | API
+|:----------------------|:------------------------------------------------|:-----------------------------------
+| `fetch_payment`       | Fetch payment details with ID                   | [Payment](https://razorpay.com/docs/api/payments/fetch-with-id)
+| `create_payment_link` | Creates a new payment link (standard)           | [Payment Link](https://razorpay.com/docs/api/payments/payment-links/create-standard)
+| `fetch_payment_link`  | Fetch details of a payment link (standard)      | [Payment Link](https://razorpay.com/docs/api/payments/payment-links/fetch-id-standard/)
+| `create_order`        | Creates an order                                | [Order](https://razorpay.com/docs/api/orders/create/)
+| `fetch_order`         | Fetch order with ID                             | [Order](https://razorpay.com/docs/api/orders/fetch-with-id)
+| `fetch_all_orders`    | Fetch all orders                                | [Order](https://razorpay.com/docs/api/orders/fetch-all)
 
 ## Use Cases 
 - Workflow Automation: Automate your day to day workflow using Razorpay MCP Server.

pkg/razorpay/orders.go

@@ -192,3 +192,125 @@ func FetchOrder(
 		handler,
 	)
 }
+
+// FetchAllOrders returns a tool to fetch all orders with optional filtering
+func FetchAllOrders(
+	_ *slog.Logger,
+	client *rzpsdk.Client,
+) mcpgo.Tool {
+	parameters := []mcpgo.ToolParameter{
+		mcpgo.WithNumber(
+			"count",
+			mcpgo.Description("Number of orders to be fetched "+
+				"(default: 10, max: 100)"),
+			mcpgo.Min(1),
+			mcpgo.Max(100),
+		),
+		mcpgo.WithNumber(
+			"skip",
+			mcpgo.Description("Number of orders to be skipped (default: 0)"),
+			mcpgo.Min(0),
+		),
+		mcpgo.WithNumber(
+			"from",
+			mcpgo.Description("Timestamp (in Unix format) from when "+
+				"the orders should be fetched"),
+			mcpgo.Min(0),
+		),
+		mcpgo.WithNumber(
+			"to",
+			mcpgo.Description("Timestamp (in Unix format) up till "+
+				"when orders are to be fetched"),
+			mcpgo.Min(0),
+		),
+		mcpgo.WithNumber(
+			"authorized",
+			mcpgo.Description("Filter orders based on payment authorization status. "+
+				"Values: 0 (orders with unauthorized payments), "+
+				"1 (orders with authorized payments)"),
+			mcpgo.Min(0),
+			mcpgo.Max(1),
+		),
+		mcpgo.WithString(
+			"receipt",
+			mcpgo.Description("Filter orders that contain the "+
+				"provided value for receipt"),
+		),
+		mcpgo.WithArray(
+			"expand",
+			mcpgo.Description("Used to retrieve additional information. "+
+				"Supported values: payments, payments.card, transfers, virtual_account"),
+		),
+	}
+
+	handler := func(
+		ctx context.Context,
+		r mcpgo.CallToolRequest,
+	) (*mcpgo.ToolResult, error) {
+		// Prepare query parameters map
+		options := make(map[string]interface{})
+
+		// Process pagination options
+		if result := AddPaginationToQueryParams(r, options); result != nil {
+			return result, nil
+		}
+
+		// Process date range parameters directly
+		from, err := OptionalInt(r, "from")
+		if result, _ := HandleValidationError(err); result != nil {
+			return result, nil
+		}
+		if from > 0 {
+			options["from"] = from
+		}
+
+		to, err := OptionalInt(r, "to")
+		if result, _ := HandleValidationError(err); result != nil {
+			return result, nil
+		}
+		if to > 0 {
+			options["to"] = to
+		}
+
+		// Process authorized status parameter directly
+		authorized, err := OptionalInt(r, "authorized")
+		if result, _ := HandleValidationError(err); result != nil {
+			return result, nil
+		}
+
+		// Always add the authorized parameter if it was provided in the request
+		options["authorized"] = authorized
+
+		// Process receipt parameter directly
+		receipt, err := OptionalParam[string](r, "receipt")
+		if result, _ := HandleValidationError(err); result != nil {
+			return result, nil
+		}
+		if receipt != "" {
+			options["receipt"] = receipt
+		}
+
+		// Process expand parameters
+		if result := AddExpandToQueryParams(r, options); result != nil {
+			return result, nil
+		}
+
+		// Fetch all orders using Razorpay SDK
+		orders, err := client.Order.All(options, nil)
+		if err != nil {
+			return mcpgo.NewToolResultError(
+				fmt.Sprintf("fetching orders failed: %s", err.Error()),
+			), nil
+		}
+
+		// Convert to JSON
+		return mcpgo.NewToolResultJSON(orders)
+	}
+
+	return mcpgo.NewTool(
+		"fetch_all_orders",
+		"Fetch all orders with optional filtering and pagination",
+		parameters,
+		handler,
+	)
+}