Configuring API Endpoints

Learn how to set up and optimize API endpoints for intelligent caching in SuperAPI

The Role of Endpoints in SuperAPI's Caching System

Endpoints form the foundation of SuperAPI's intelligent caching capabilities. They establish the crucial connections between your API routes, database tables, and cache management rules. By properly configuring endpoints, you create a system that automatically maintains fresh cache based on actual data changes rather than arbitrary time limits.

When you define endpoints in SuperAPI, you're essentially creating a knowledge map that helps the system understand:

Which API routes should be cached for faster response times
How long cached responses should remain valid (TTL)
Which database tables contain the data used to create this API response
How parameters in your API requests relate to specific database tables & columns
When changes to your data should trigger cache updates

This comprehensive understanding allows SuperAPI to serve cached responses whenever possible while ensuring those responses remain consistent with your database state.

Endpoint Types: Cacheable and Mutation Endpoints

SuperAPI supports two complementary endpoint types that work together to create an intelligent caching system:

Cacheable API Endpoints

These endpoints deliver data that SuperAPI will store in its cache. For a cacheable endpoint, you'll define:

TTL (Time-to-Live) - The maximum duration a cached response remains valid
Tables of Interest - Tables that affect this endpoint's responses
Parameter Relationships - How URL path and query parameters correspond to database fields

Cacheable endpoints dramatically improve API performance by serving responses from cache rather than querying your database for every request.

Mutation API Endpoints

These endpoints signal that data has changed, potentially affecting cached responses. Typically, these are POST, PUT, PATCH, or DELETE requests that modify your database.

Mutation endpoints ensure that when data changes through your API, the affected cached responses are automatically refreshed or invalidated, maintaining data consistency.

Understanding Tables of Interest and TTL Settings

When configuring a cacheable endpoint, you need to specify which database tables contain the data returned by this endpoint:

Tables of Interest

These are additional tables that influence the endpoint's response. For instance, an endpoint returning a user profile with their recent orders might list both the users table and the orders table as tables of interest.

By identifying these tables, you're informing SuperAPI which database changes should trigger cache updates for this endpoint. Changes to specified tables will refresh the cache; changes to unrelated tables won't affect it.

TTL (Time-to-Live)

TTL defines the maximum time (in seconds) that a cached response remains valid before requiring a refresh. Even with a high TTL, SuperAPI will still update the cache when relevant data changes in your database.

Creating Parameter Relationships Between APIs and Data

SuperAPI's ability to map API endpoint parameters to database fields enables precise cache management focused only on affected data.

Parameter Types and Format Requirements

SuperAPI recognizes two types of parameters:

Path Parameters - Parameters embedded in the URL path
- Must be prefixed with a colon (:) to be recognized
- Example: /users/:id/orders where :id is the parameter
Query Parameters - Parameters in the URL query string
- Must include empty angle brackets (<>) for the value in the configuration
- Example: ?order_id=<> (not ?order_id=123)
- The form will show an error if angle brackets are missing

Creating Parameter-to-Database Relationships

For each parameter, you define:

Parameter Name - The name as it appears in your API route
Operation - The relationship between the parameter and database field
Value - The database table and column this parameter corresponds to

Understanding Relationship Operators

SuperAPI offers three operators to define parameter relationships:

Equal (==) - Ensures cache updates only apply when the parameter exactly matches the database field. This is the most common operator, used to target specific data records.
Not Equal (!=) - Updates cache when the parameter differs from the database field, useful for excluding specific data from cache updates while refreshing everything else.
Ignore - Indicates the parameter doesn't influence cache management for this endpoint. Ideal for parameters that don't affect the returned data, such as pagination, sorting, or display preferences.

Optimization Strategies for Endpoint Configuration

To maximize SuperAPI's caching benefits, consider these strategies:

Be selective with Tables of Interest - Include only tables directly related to the endpoint's response to prevent unnecessary cache updates
Create precise parameter relationships - The more specific your parameter mappings, the more targeted your cache management will be
Don't overlook query parameters - Remember to map all query parameters that affect the returned data

By implementing these strategies, you'll create a cache configuration that maximizes performance while ensuring data consistency across your application.

Building a Resilient Caching Strategy

Properly configured endpoints enable SuperAPI to understand your application's unique data patterns. By mapping API parameters to database structures, you teach SuperAPI when to serve cached responses and when to refresh them. This creates a system that delivers both high performance and data consistency.

As you gain experience with SuperAPI, you'll develop an intuition for optimizing endpoint configurations through fine-tuned parameter relationships, appropriate TTL values, and precise Tables of Interest. These refinements will create a more efficient API experience while reducing infrastructure load.

Effective caching ultimately delivers what matters most: predictable, reliable experiences that users can trust.

Configuring API Endpoints

On this page