How Functions Run

Ollie Hub acts as an intelligent proxy that intercepts requests to your target URLs and executes your custom functions. Learn how this interception works, how functions are routed and executed, and how to optimize performance.

Core Concept: Request Interception

How Ollie Hub Works

Request Interception

Ollie Hub receives requests intended for your target URL and captures all request details

Original: https://api.yourapp.com/users/123
Hub URL:  https://hub.ollie.app/https://api.yourapp.com/users/123

Function Routing

Based on URL patterns and HTTP methods, Hub determines which function should handle the request

// Exact match: /api/users/profile
// Pattern match: /api/users/*
// Catch-all: /*

Code Execution

Your custom function executes with full access to request data and can modify the response

export const handler = async (event) => {
  // Your custom logic here
  return { statusCode: 200, body: 'Custom response' };
};

Response Enhancement

Optional Response Functions can further modify the output before returning to the user

URL Patterns and Routing

Ollie Hub uses a simple proxy pattern to intercept requests:

# Your original endpoint
https://api.myapp.com/users

# Through Ollie Hub
https://hub.ollie.app/https://api.myapp.com/users

Ollie Hub uses a simple proxy pattern to intercept requests:

# Your original endpoint
https://api.myapp.com/users

# Through Ollie Hub
https://hub.ollie.app/https://api.myapp.com/users

When multiple functions could handle the same request:

1. Exact Match

/api/users/profile matches exactly

2. Parameter Match

/api/users/{id} with dynamic segments

3. Wildcard Match

/api/users/* catches all user routes

4. Catch-All

/* handles everything else

Functions can be configured to handle specific HTTP methods:

// Handle specific methods
export const handler = async (event) => {
  switch (event.httpMethod) {
    case 'GET':
      return await handleGet(event);
    case 'POST':
      return await handlePost(event);
    case 'PUT':
      return await handleUpdate(event);
    case 'DELETE':
      return await handleDelete(event);
    default:
      return { statusCode: 405, body: 'Method not allowed' };
  }
};

Error Handling & Policies

Understanding how Ollie Hub handles function failures is crucial for building reliable applications. Each function can be configured with an error policy that determines what happens when execution fails.

Skip Policy

Behavior: Continue execution even if function fails Use Case: Non-critical functions (analytics, logging, enhancements) Impact: Request processing continues normally Status: Function marked as skipped

Throw Policy

Behavior: Stop execution and return error if function fails Use Case: Critical functions (authentication, validation, security)
Impact: Request fails with error response Status: Function marked as failed

Error Policy Best Practices:

Use throw for authentication, validation, and security functions
Use skip for analytics, logging, and enhancement functions
Consider the impact on user experience when choosing policies

When functions have different error policies, the Hub handles them intelligently:

const functions = [
  { 
    name: "Authentication",
    on_error: "throw", 
    priority: 0 
  },      // Must succeed
  { 
    name: "Analytics", 
    on_error: "skip", 
    priority: 1 
  },      // Optional
  { 
    name: "Transform", 
    on_error: "throw", 
    priority: 2 
  }       // Must succeed
];

Key Points:

Request Functions: Execute sequentially, failures can stop the chain
Response Functions: Execute in parallel, failures are handled independently
Mixed Policies: Each function’s policy is evaluated individually

When functions have different error policies, the Hub handles them intelligently:

const functions = [
  { 
    name: "Authentication",
    on_error: "throw", 
    priority: 0 
  },      // Must succeed
  { 
    name: "Analytics", 
    on_error: "skip", 
    priority: 1 
  },      // Optional
  { 
    name: "Transform", 
    on_error: "throw", 
    priority: 2 
  }       // Must succeed
];

Key Points:

Request Functions: Execute sequentially, failures can stop the chain
Response Functions: Execute in parallel, failures are handled independently
Mixed Policies: Each function’s policy is evaluated individually

All errors are logged with rich context for debugging:

{
  "level": "warn",
  "msg": "Error executing function",
  "id": "func-123",
  "onError": "skip",
  "error": {
    "message": "API timeout after 30 seconds",
    "type": "TimeoutError"
  },
  "request": {
    "url": "https://api.example.com/users",
    "method": "GET"
  },
  "timestamp": "2024-01-15T10:30:00Z"
}

Error Information Includes:

Function ID and error policy
Detailed error message and type
Request context (URL, method, headers)
Execution timestamp for debugging

The Hub tracks execution status for each function in response headers:

x-ollie-functions: func-1:executed,func-2:skipped,func-3:executed

Use Cases:

Debugging: See which functions ran and their outcomes
Monitoring: Track function reliability and performance
Analytics: Understand function usage patterns
Troubleshooting: Quickly identify which functions are causing issues

Important: Functions with throw policy will prevent subsequent functions from executing. Always consider the order and error policies when designing your function chain.

Next Steps

Request Functions

Learn to handle HTTP requests and build APIs

Response Functions

Enhance responses with custom logic

Task Functions

Automate workflows with scheduled tasks

Local Development

Test and debug functions locally

Best Practices

Follow proven patterns and optimizations

Key Insight: Ollie Hub acts as an intelligent proxy that intercepts your requests and executes custom code seamlessly. Understanding this flow helps you build more efficient and reliable functions.

Overview

Getting Started

Core Concepts

Development

How Functions Run

Core Concept: Request Interception

How Ollie Hub Works

URL Patterns and Routing

1. Exact Match

2. Parameter Match

3. Wildcard Match

4. Catch-All

Error Handling & Policies

Skip Policy

Throw Policy

Next Steps

Request Functions

Response Functions

Task Functions

Local Development

Best Practices

Overview

Getting Started

Core Concepts

Development

​Core Concept: Request Interception

​How Ollie Hub Works

​URL Patterns and Routing

1. Exact Match

2. Parameter Match

3. Wildcard Match

4. Catch-All

​Error Handling & Policies

Skip Policy

Throw Policy

​Next Steps

Request Functions

Response Functions

Task Functions

Local Development

Best Practices

Core Concept: Request Interception

How Ollie Hub Works

URL Patterns and Routing

Error Handling & Policies

Next Steps