Local Development

Develop complete, testable functions locally and deploy them to see real results. This guide walks you through building functions you can actually test with live URLs.

🌐 Live Testing

Deploy functions and test them with real URLs on your hub

🔄 Data Transformation

See your functions transform data in real-time

📁 Complete Examples

Full function structures with all necessary files

🚀 Deploy & Test

From local development to live URL in minutes

Quick Start: Your First Testable Function

Let’s build a complete function that you can test with a real URL after deployment.

Set up your project

# Create project directory
mkdir weather-api && cd weather-api

# Initialize npm and install dependencies
npm init -y
npm install -D typescript @types/node @types/aws-lambda ts-node

# Create project structure
mkdir src lib types

Create your function files

import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
import { validateCity, transformWeatherData } from './lib/weather';
import { createResponse, handleError } from './lib/utils';

export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  try {
    console.log('Weather API called:', {
      method: event.httpMethod,
      path: event.path,
      query: event.queryStringParameters
    });

    const city = event.queryStringParameters?.city;
    
    // Validate input
    const validation = validateCity(city);
    if (!validation.isValid) {
      return createResponse(400, { 
        error: 'Invalid city name',
        details: validation.errors 
      });
    }

    // Get weather data (simulated for demo)
    const rawWeatherData = await fetchWeatherData(city!);
    
    // Transform the data
    const transformedData = transformWeatherData(rawWeatherData);
    
    return createResponse(200, {
      city: city,
      weather: transformedData,
      timestamp: new Date().toISOString(),
      source: 'Ollie Hub Weather API'
    });
    
  } catch (error) {
    console.error('Weather API error:', error);
    return handleError(error);
  }
};

// Simulate weather API call
async function fetchWeatherData(city: string) {
  // Simulate API delay
  await new Promise(resolve => setTimeout(resolve, 100));
  
  // Return mock weather data
  return {
    temperature: Math.floor(Math.random() * 30) + 10,
    humidity: Math.floor(Math.random() * 40) + 40,
    conditions: ['sunny', 'cloudy', 'rainy', 'windy'][Math.floor(Math.random() * 4)],
    pressure: 1013 + Math.floor(Math.random() * 20) - 10,
    windSpeed: Math.floor(Math.random() * 20),
    rawTimestamp: Date.now()
  };
}

Test locally

Create a test file to verify your function works:

test.ts

import { handler } from './index';
import { APIGatewayProxyEvent } from 'aws-lambda';

async function testWeatherAPI() {
  console.log('🧪 Testing Weather API Function\n');
  
  // Test valid city
  const validEvent: Partial<APIGatewayProxyEvent> = {
    httpMethod: 'GET',
    path: '/weather',
    queryStringParameters: { city: 'London' },
    headers: {},
    body: null
  };
  
  console.log('Testing with city: London');
  const result1 = await handler(validEvent as APIGatewayProxyEvent);
  console.log('Status:', result1.statusCode);
  console.log('Response:', JSON.parse(result1.body));
  console.log('\n---\n');
  
  // Test invalid city
  const invalidEvent: Partial<APIGatewayProxyEvent> = {
    httpMethod: 'GET',
    path: '/weather',
    queryStringParameters: { city: 'X' },
    headers: {},
    body: null
  };
  
  console.log('Testing with invalid city: X');
  const result2 = await handler(invalidEvent as APIGatewayProxyEvent);
  console.log('Status:', result2.statusCode);
  console.log('Response:', JSON.parse(result2.body));
  console.log('\n---\n');
  
  // Test missing city
  const missingEvent: Partial<APIGatewayProxyEvent> = {
    httpMethod: 'GET',
    path: '/weather',
    queryStringParameters: null,
    headers: {},
    body: null
  };
  
  console.log('Testing with missing city parameter');
  const result3 = await handler(missingEvent as APIGatewayProxyEvent);
  console.log('Status:', result3.statusCode);
  console.log('Response:', JSON.parse(result3.body));
  
  console.log('\n✅ Local testing completed!');
}

testWeatherAPI().catch(console.error);

Run the test:

npm test

Deploy and test live

Upload to Ollie Hub: Zip your function folder and upload it via the web interface
Get your function URL: Copy the URL from your function dashboard
Test with real URLs:

# Replace YOUR_FUNCTION_URL with your actual function URL

# Test valid city
curl "YOUR_FUNCTION_URL?city=Paris"

# Test another city to see different data
curl "YOUR_FUNCTION_URL?city=Tokyo"

# Test error handling
curl "YOUR_FUNCTION_URL?city=X"

# Test missing parameter
curl "YOUR_FUNCTION_URL"

Expected response for Paris:

{
  "city": "Paris",
  "weather": {
    "temp": {
      "celsius": 22,
      "fahrenheit": 72,
      "description": "Mild"
    },
    "humidity": {
      "percentage": 65,
      "level": "Moderate"
    },
    "conditions": {
      "current": "sunny",
      "emoji": "☀️"
    },
    "wind": {
      "speed": 8,
      "description": "Light breeze"
    },
    "comfort": {
      "score": 85,
      "rating": "Excellent"
    }
  },
  "timestamp": "2024-01-15T10:30:00.000Z",
  "source": "Ollie Hub Weather API"
}

Advanced Example: User Data Processor

Build a more complex function that processes and transforms user data:

import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
import { validateUserData, processUser, generateUserStats } from './lib/userProcessor';
import { createResponse, handleError } from './lib/utils';

export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  try {
    console.log('User processor called:', {
      method: event.httpMethod,
      path: event.path
    });

    if (event.httpMethod === 'GET') {
      return createResponse(200, {
        message: 'User Data Processor API',
        endpoints: {
          process: 'POST /process - Process user data',
          stats: 'GET /stats?users=number - Generate user statistics'
        },
        example: {
          url: 'POST YOUR_FUNCTION_URL',
          body: {
            name: 'John Doe',
            email: 'john@example.com',
            age: 28,
            interests: ['technology', 'sports'],
            location: 'New York'
          }
        }
      });
    }

    if (event.httpMethod === 'POST') {
      const userData = JSON.parse(event.body || '{}');
      
      // Validate user data
      const validation = validateUserData(userData);
      if (!validation.isValid) {
        return createResponse(400, {
          error: 'Invalid user data',
          details: validation.errors
        });
      }

      // Process and transform user data
      const processedUser = processUser(userData);
      
      return createResponse(200, {
        original: userData,
        processed: processedUser,
        transformation: {
          added: ['id', 'slug', 'category', 'score', 'recommendations'],
          computed: ['ageGroup', 'riskLevel', 'primaryInterest'],
          formatted: ['email', 'name', 'location']
        }
      });
    }

    // Handle stats endpoint
    if (event.path?.includes('stats')) {
      const userCount = parseInt(event.queryStringParameters?.users || '10');
      const stats = generateUserStats(userCount);
      
      return createResponse(200, {
        stats,
        generated: userCount,
        timestamp: new Date().toISOString()
      });
    }

    return createResponse(405, { error: 'Method not allowed' });
    
  } catch (error) {
    return handleError(error);
  }
};

Test the User Processor

Local Testing
Live URL Testing
Browser Testing

test-user-processor.ts

import { handler } from './index';
import { APIGatewayProxyEvent } from 'aws-lambda';

async function testUserProcessor() {
  console.log('🧪 Testing User Data Processor\n');
  
  // Test API info
  const infoEvent: Partial<APIGatewayProxyEvent> = {
    httpMethod: 'GET',
    path: '/',
    queryStringParameters: null,
    headers: {},
    body: null
  };
  
  console.log('1. Getting API information:');
  const infoResult = await handler(infoEvent as APIGatewayProxyEvent);
  console.log('Response:', JSON.parse(infoResult.body));
  console.log('\n---\n');
  
  // Test user processing
  const userData = {
    name: 'Alice Johnson',
    email: 'alice@example.com',
    age: 28,
    interests: ['technology', 'travel', 'photography'],
    location: 'San Francisco'
  };
  
  const processEvent: Partial<APIGatewayProxyEvent> = {
    httpMethod: 'POST',
    path: '/process',
    body: JSON.stringify(userData),
    headers: { 'Content-Type': 'application/json' },
    queryStringParameters: null
  };
  
  console.log('2. Processing user data:');
  console.log('Input:', userData);
  const processResult = await handler(processEvent as APIGatewayProxyEvent);
  console.log('Output:', JSON.parse(processResult.body));
  console.log('\n---\n');
  
  // Test stats generation
  const statsEvent: Partial<APIGatewayProxyEvent> = {
    httpMethod: 'GET',
    path: '/stats',
    queryStringParameters: { users: '100' },
    headers: {},
    body: null
  };
  
  console.log('3. Generating user statistics:');
  const statsResult = await handler(statsEvent as APIGatewayProxyEvent);
  console.log('Stats:', JSON.parse(statsResult.body));
  
  console.log('\n✅ All tests completed!');
}

testUserProcessor().catch(console.error);

After deploying, test with these commands:

# Get API information
curl YOUR_FUNCTION_URL

# Process user data
curl -X POST YOUR_FUNCTION_URL \
  -H "Content-Type: application/json" \
  -d '{
    "name": "John Smith",
    "email": "john@gmail.com",
    "age": 32,
    "interests": ["sports", "fitness", "technology"],
    "location": "Chicago"
  }'

# Generate statistics for 50 users
curl "YOUR_FUNCTION_URL?users=50"

# Test error handling
curl -X POST YOUR_FUNCTION_URL \
  -H "Content-Type: application/json" \
  -d '{
    "name": "X",
    "email": "invalid-email",
    "age": 5
  }'

You can also test in your browser by visiting:

YOUR_FUNCTION_URL
YOUR_FUNCTION_URL?users=25

For POST requests, use a tool like Postman or create a simple HTML form:

<!DOCTYPE html>
<html>
<head>
    <title>Test User Processor</title>
</head>
<body>
    <h2>Test User Data Processor</h2>
    <form id="userForm">
        <input type="text" name="name" placeholder="Name" required><br><br>
        <input type="email" name="email" placeholder="Email" required><br><br>
        <input type="number" name="age" placeholder="Age" required><br><br>
        <input type="text" name="interests" placeholder="Interests (comma-separated)" required><br><br>
        <input type="text" name="location" placeholder="Location" required><br><br>
        <button type="submit">Process User</button>
    </form>
    
    <div id="result"></div>
    
    <script>
    document.getElementById('userForm').addEventListener('submit', async (e) => {
        e.preventDefault();
        const formData = new FormData(e.target);
        const userData = {
            name: formData.get('name'),
            email: formData.get('email'),
            age: parseInt(formData.get('age')),
            interests: formData.get('interests').split(',').map(s => s.trim()),
            location: formData.get('location')
        };
        
        try {
            const response = await fetch('YOUR_FUNCTION_URL', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(userData)
            });
            const result = await response.json();
            document.getElementById('result').innerHTML = 
                '<pre>' + JSON.stringify(result, null, 2) + '</pre>';
        } catch (error) {
            document.getElementById('result').innerHTML = 'Error: ' + error.message;
        }
    });
    </script>
</body>
</html>

Real-World Data Transformation Examples

Deployment Checklist

Local testing passes

✅ All functions run without errors locally
✅ Data transformation works as expected
✅ Error handling catches edge cases
✅ TypeScript compiles without warnings

Function structure is correct

✅ index.ts exists with exported handler
✅ package.json includes all dependencies
✅ Helper files are properly structured
✅ No sensitive data in source code

Upload and configure

✅ Function uploaded to Ollie Hub
✅ Environment variables configured
✅ Function type set correctly (Request/Task/Response)
✅ Memory and timeout settings appropriate

Live testing

✅ Function URL accessible
✅ Data transformation works on live data
✅ Error responses are user-friendly
✅ Performance is acceptable

Next Steps

Deploy Your Function

Learn how to deploy your functions to Ollie Hub

Environment Variables

Securely manage configuration and API keys

Function Types

Understand Request, Response, and Task functions

Examples Gallery

Explore more real-world function examples

Ready to Build? Start with the Weather API example above - it’s designed to work immediately and show you real data transformation. You’ll have a working function with a testable URL in under 10 minutes!

Overview

Getting Started

Core Concepts

Development

🌐 Live Testing

🔄 Data Transformation

📁 Complete Examples

🚀 Deploy & Test

Quick Start: Your First Testable Function

Advanced Example: User Data Processor

Test the User Processor

Real-World Data Transformation Examples

Deployment Checklist

Next Steps

Deploy Your Function

Environment Variables

Function Types

Examples Gallery

Overview

Getting Started

Core Concepts

Development

🌐 Live Testing

🔄 Data Transformation

📁 Complete Examples

🚀 Deploy & Test

​Quick Start: Your First Testable Function

​Advanced Example: User Data Processor

​Test the User Processor

​Real-World Data Transformation Examples

​Deployment Checklist

​Next Steps

Deploy Your Function

Environment Variables

Function Types

Examples Gallery

Quick Start: Your First Testable Function

Advanced Example: User Data Processor

Test the User Processor

Real-World Data Transformation Examples

Deployment Checklist

Next Steps