Edmonds Commerce - Symfony API Platform

Overview

Hypermedia API development with API Platform and JSON-LD support for modern API-first architectures.

What We Build

Production-ready APIs using Symfony API Platform. We build APIs that power mobile apps, single-page applications, and third-party integrations with automatic documentation, powerful querying capabilities, and enterprise-grade security.

API Platform Capabilities

Hypermedia APIs

JSON-LD support for semantic data and linked data relationships.

Hypermedia Features:

JSON-LD metadata for rich semantics
Linked data with @context
Resource relationships as links
Discoverability through hypermedia
Content negotiation
Automatic CRUD operations

GraphQL & REST

Both GraphQL and REST endpoints from a single data model.

Dual API Support:

REST endpoints for traditional clients
GraphQL for flexible querying
Shared Doctrine models
Consistent authorization
Single source of truth

Auto-Generated Documentation

Interactive API documentation generated automatically from your code.

Documentation Features:

OpenAPI/Swagger documentation
Interactive API explorer
Request/response examples
Authentication documentation
Rate limit information
Schema visualization

Advanced Filtering

Powerful filtering and search capabilities for flexible queries.

Filtering Options:

Field-based filtering
Range filtering
Text search
Geo-spatial filtering
Custom filters
Filter composition

Pagination

Handle large result sets efficiently.

Pagination Strategies:

Offset-based pagination
Cursor-based pagination
Keyset pagination
Configurable page sizes
Sorting options

Versioning & Deprecation

Evolve your API without breaking existing clients.

Versioning Features:

URI versioning
Content negotiation versioning
Deprecation warnings
Migration paths
Backwards compatibility

Why API Platform?

Rapid Development: Automatic CRUD operations eliminate boilerplate. Define your data model and get a full API.

Standards Compliance: JSON-LD, OpenAPI, and JSON Schema compliance ensures interoperability.

Powerful Querying: GraphQL and REST both supported. Clients choose the approach that fits their needs.

Developer Experience: Auto-generated documentation keeps developers productive. Interactive testing eliminates guesswork.

Enterprise Security: Built-in authentication, authorization, and comprehensive logging.

API Platform Architecture

Data Models (Entities)

Doctrine entities define your API structure.

#[ApiResource]
      class Product {
          #[ApiProperty(description: 'Product name')]
          public string $name;
      
          #[ApiProperty(description: 'Product price')]
          public float $price;
      
          #[ApiProperty(readable: false, writable: true)]
          public string $internalNotes;
      }

Operations

Define what actions are available on resources.

#[ApiResource(
          operations: [
              new Get(),           // GET /products/{id}
              new GetCollection(), // GET /products
              new Post(),          // POST /products
              new Put(),           // PUT /products/{id}
              new Delete(),        // DELETE /products/{id}
          ]
      )]
      class Product { ... }

Filters & Search

Enable powerful querying on your API.

#[ApiResource]
      #[ApiFilter(SearchFilter::class, properties: ['name' => 'partial', 'category' => 'exact'])]
      #[ApiFilter(RangeFilter::class, properties: ['price'])]
      class Product { ... }

Security & Authorization

Control access to resources and operations.

#[ApiResource(
          security: "is_granted('ROLE_ADMIN')"
      )]
      class AdminPanel { ... }

Serialization Groups

Control what fields are exposed in different contexts.

#[ApiResource(
          normalizationContext: ['groups' => ['read:product']],
          denormalizationContext: ['groups' => ['write:product']],
      )]
      class Product { ... }

API Platform Use Cases

CRUD APIs: Simple resource management with minimal configuration.

Hypermedia APIs: Rich semantic data with JSON-LD for powerful clients.

GraphQL Servers: Modern query language for frontend developers.

Mobile Backend: Flexible APIs that serve mobile and web clients.

Microservices: Expose microservice capabilities through APIs.

Data Portals: Public data APIs with advanced filtering and search.

Technology Stack

Symfony 7 framework
API Platform 4+
Doctrine ORM
PostgreSQL/MySQL
Redis for caching
Docker containerisation
PHPUnit for testing

Our API Platform Development

1. API Design

Design your API structure and relationships.

Identify resources and relationships
Plan operations (GET, POST, PUT, DELETE)
Design filtering strategies
Plan pagination approach

2. Entity Modelling

Create Doctrine entities with API annotations.

Define entities with properties
Configure API filters
Set serialization groups
Implement validation rules

3. Security & Authorization

Implement access control.

Define security policies
Configure authentication
Implement authorization rules
Add audit logging

4. Testing & Documentation

Comprehensive testing and automatic documentation.

Test all API operations
Validate filtering and search
Test authentication flows
Generate API documentation

5. Deployment

Deploy your API to production.

Containerisation with Docker
Deployment to Kubernetes
Monitoring and alerting
Performance optimisation

Advanced Features

Event Listeners: Hook into resource operations with event listeners.

Data Transformers: Transform data between representations (e.g., JSON to Entity).

Custom Operations: Define operations beyond standard CRUD.

Webhooks: Send notifications when resources change.

Rate Limiting: Protect your API from abuse.

Caching: Intelligent caching for read operations.

Performance Optimization

Query Optimization: Eager load relationships to avoid N+1 queries.

Caching Strategies: HTTP caching, ETags, cache invalidation.

Pagination: Reduce payload size with efficient pagination.

Filtering: Offload filtering to database rather than application.

Compression: GZIP compression for network efficiency.

Target Audiences

Frontend Teams: Powerful APIs that support modern SPA and mobile development.

API-First Organizations: Build backend services for multiple frontends.

Data Portal Operators: Public APIs with advanced search and filtering.

Microservices Teams: Expose microservice capabilities through APIs.

Common API Patterns

Resource APIs: Traditional CRUD with collections and resources.

Hypermedia APIs: Rich semantic data with JSON-LD relationships.

GraphQL APIs: Flexible querying for complex client requirements.

Search APIs: Full-text search and filtering.

Webhook APIs: Event-driven integrations.

Related Services

Symfony Development: Full Symfony expertise for your application.

Hexagonal Architecture: Clean architecture patterns for complex domains.

GraphQL Development: Advanced GraphQL patterns and optimisation.

Infrastructure & DevOps: Kubernetes deployment and scaling.

Contact

Based in the UK, serving global development teams. Discuss your API requirements, architecture, or GraphQL implementation.