Development Integration

# Local invocation commands
sls invoke local --function <name>                    # Invoke function locally with webpack
sls invoke local --function <name> --watch           # Invoke with watch mode
sls invoke local --function <name> --skip-build     # Skip webpack compilation
sls invoke local --function <name> --webpack-use-polling <ms>  # Enable polling mode
sls invoke local --function <name> --data <json>    # Pass data to function
sls invoke local --function <name> --path <file>    # Load data from file

# Global invoke options
--stage <stage>                                       # Set deployment stage
--region <region>                                    # Set AWS region  
--log                                               # Show logs
--docker                                           # Use Docker for invocation

# Basic local invocation
sls invoke local --function hello

# Invoke with data and watch mode
sls invoke local --function api --data '{"key": "value"}' --watch

# Invoke with file input and polling
sls invoke local --function processor --path test-data.json --webpack-use-polling 1000

# Skip build for faster iterations
sls invoke local --function quick-test --skip-build

/**
 * Watch mode configuration and behavior
 */
interface WatchModeOptions {
  enabled: boolean;                   // Enable/disable watch mode
  usePolling: boolean;               // Use polling instead of filesystem events
  pollingInterval: number;           // Polling interval in milliseconds (default: 3000)
  ignored: string[];                 // Patterns to ignore during watch
  watchOptions: {                    // Webpack watch options
    aggregateTimeout: number;        // Delay before rebuilding (default: 300ms)
    poll: boolean | number;          // Polling configuration
    ignored: RegExp | string[];      // Files/directories to ignore
  };
}

# Standard watch mode
sls invoke local --function api --watch

# Watch with custom polling for Docker/VM environments
sls invoke local --function api --watch --webpack-use-polling 2000

# Watch specific function during development
sls invoke local --function userHandler --watch --data '{"userId": "123"}'

# Serverless offline commands with webpack
sls offline start                                    # Start offline server with webpack
sls offline start --webpack-no-watch               # Disable webpack watch mode
sls offline start --skip-build                     # Skip initial webpack build  
sls offline start --port <port>                    # Custom port for offline server
sls offline start --host <host>                    # Custom host binding

# Offline-specific webpack options
--webpack-no-watch                                  # Disable automatic webpack watch
--skip-build                                       # Skip webpack compilation entirely

# Start offline development server
sls offline start

# Start without webpack watch (manual rebuilds)
sls offline start --webpack-no-watch

# Quick start without initial build
sls offline start --skip-build

# Custom port with webpack watch
sls offline start --port 4000

# Run command with webpack integration
sls run                                             # Run function locally with webpack
sls run --watch                                     # Run with watch mode enabled
sls run --function <name>                          # Run specific function
sls run --data <json>                              # Pass data to function
sls run --path <file>                              # Load data from file

# Run-specific options
--watch                                            # Enable watch mode for run command
--stage <stage>                                    # Set deployment stage  
--region <region>                                  # Set AWS region

# Run function with webpack
sls run --function processData

# Run with watch mode for development
sls run --function api --watch

# Run with input data
sls run --function calculator --data '{"operation": "add", "numbers": [1, 2, 3]}'

# Step Functions offline integration
sls step-functions-offline start                    # Start step functions offline with webpack

# Integration hooks
before:step-functions-offline:start                 # Webpack preparation hook

# Start step functions offline development
sls step-functions-offline start

/**
 * Development environment detection
 */
const slsw = require('serverless-webpack');

// Available in webpack configuration
slsw.lib.webpack.isLocal: boolean;  // True when running locally

/**
 * Local environment triggers:
 * - sls invoke local
 * - sls offline start  
 * - sls run
 * - sls step-functions-offline start
 */

// webpack.config.js - Environment-specific configuration
const slsw = require('serverless-webpack');

module.exports = {
  entry: slsw.lib.entries,
  target: 'node',
  mode: slsw.lib.webpack.isLocal ? 'development' : 'production',
  
  // Development optimizations
  devtool: slsw.lib.webpack.isLocal ? 'eval-source-map' : 'source-map',
  
  optimization: {
    minimize: !slsw.lib.webpack.isLocal
  },
  
  // Environment-specific externals
  externals: slsw.lib.webpack.isLocal ? [] : ['aws-sdk']
};

# Debug webpack compilation
export SLS_DEBUG=*                                 # Enable debug output
sls invoke local --function <name>

# Inspect webpack output
sls webpack --out debug-build                      # Custom output directory
ls -la debug-build/                               # Inspect compiled files

# Preserve webpack output for inspection
custom:
  webpack:
    keepOutputDirectory: true                      # Keep .webpack directory

# Debug webpack compilation issues
export SLS_DEBUG=*
sls invoke local --function problematic-function

# Inspect webpack bundle contents
sls webpack compile --out inspection
find inspection -name "*.js" -exec head -20 {} \;

# Debug with preserved output
sls invoke local --function test --log
ls -la .webpack/service/

/**
 * Hot reloading configuration
 */
interface HotReloadOptions {
  watchMode: boolean;                 // Enable webpack watch mode
  liveReload: boolean;               // Enable live reloading
  hotModuleReplacement: boolean;     // Enable HMR (limited support)
  restartOnChange: boolean;          // Restart process on changes
}

# Hot reloading with invoke local
sls invoke local --function api --watch
# Changes to source files trigger automatic recompilation and re-invocation

# Hot reloading with offline
sls offline start
# Changes trigger recompilation and server restart

/**
 * Development workflow optimization techniques
 */
interface DevWorkflowOptions {
  skipBuild: boolean;                // Skip webpack build for faster iteration
  cacheEnabled: boolean;             // Enable webpack caching
  parallelBuilds: boolean;           // Enable parallel compilation
  sourceMapType: string;             // Source map type for debugging
}

// webpack.config.js - Development optimizations
const slsw = require('serverless-webpack');

module.exports = {
  entry: slsw.lib.entries,
  target: 'node',
  
  // Faster development builds
  mode: slsw.lib.webpack.isLocal ? 'development' : 'production',
  devtool: slsw.lib.webpack.isLocal ? 'eval-cheap-module-source-map' : 'source-map',
  
  // Webpack 5 caching for faster rebuilds
  cache: slsw.lib.webpack.isLocal ? {
    type: 'filesystem',
    buildDependencies: {
      config: [__filename]
    }
  } : false,
  
  optimization: {
    minimize: false,  // Disable minification in development
    removeAvailableModules: false,
    removeEmptyChunks: false,
    splitChunks: false
  }
};

# serverless.yml - Development configuration
custom:
  webpack:
    concurrency: 1                    # Reduce memory usage during development
    keepOutputDirectory: true         # Preserve build output for inspection

# Testing with webpack compilation
sls invoke local --function testHandler --path test/fixtures/input.json

# Test-specific build configurations
NODE_ENV=test sls webpack compile

# Run tests against compiled functions
sls webpack compile
npm test

# Test individual functions
sls invoke local --function userService --path test/user-test-data.json

# Integration testing with offline
sls offline start --stage test &
npm run integration-tests

/**
 * Development error handling
 */
interface DevErrorHandling {
  continueOnError: boolean;          // Continue watch mode on compilation errors
  errorOverlay: boolean;            // Display error overlay
  logLevel: 'error' | 'warn' | 'info' | 'verbose'; // Logging verbosity
  stackTraceLimit: number;          // Stack trace depth
}

# Verbose error reporting
export SLS_DEBUG=*
sls invoke local --function problematic --log

# Continue development despite errors  
sls invoke local --function api --watch
# Watch continues even if compilation fails

/**
 * Development performance monitoring
 */
interface DevPerformanceMetrics {
  compilationTime: number;           // Webpack compilation duration
  bundleSize: number;               // Output bundle size
  moduleCount: number;              // Number of processed modules
  rebuildTime: number;              // Incremental rebuild time
}

# Monitor compilation performance
time sls webpack compile

# Analyze bundle size
sls webpack compile --out analysis
ls -lah analysis/

# Monitor watch rebuild performance
sls invoke local --function api --watch
# Displays rebuild times in watch mode