or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

angular-modules.mdbackend-implementation.mdconfiguration-options.mdheaders-parameters.mdhttp-services.mdindex.mdrequest-response.mdtesting.md
tile.json

configuration-options.mddocs/

Configuration and Options

Comprehensive configuration system for customizing HTTP requests and responses with default options and merging capabilities. Provides flexible option management for all HTTP operations.

Capabilities

RequestOptions Class

Configurable options for HTTP requests with merging support and comprehensive property management.

/**
 * HTTP request options configuration class
 * Provides comprehensive configuration for HTTP requests
 */
class RequestOptions {
  /**
   * Creates a new RequestOptions instance
   * @param opts - Configuration object with optional properties
   */
  constructor(opts?: RequestOptionsArgs);
  
  /** HTTP method for the request */
  method: RequestMethod | string | null;
  
  /** Headers collection for the request */
  headers: Headers | null;
  
  /** Request body data */
  body: any;
  
  /** Target URL for the request */
  url: string | null;
  
  /** URL search parameters */
  params: URLSearchParams;
  
  /** @deprecated Use params instead - URL search parameters */
  search: URLSearchParams;
  
  /** Whether to include credentials (cookies) with the request */
  withCredentials: boolean | null;
  
  /** Expected response content type */
  responseType: ResponseContentType | null;
  
  /**
   * Merges current options with new options
   * @param options - Additional options to merge
   * @returns New RequestOptions instance with merged configuration
   */
  merge(options?: RequestOptionsArgs): RequestOptions;
}

Usage Examples:

import { RequestOptions, RequestMethod, Headers, URLSearchParams, ResponseContentType } from '@angular/http';

class RequestConfigService {
  
  // Basic request options
  createBasicOptions(): RequestOptions {
    const options = new RequestOptions({
      method: RequestMethod.Get,
      headers: new Headers({ 'Accept': 'application/json' }),
      withCredentials: false
    });
    
    return options;
  }
  
  // Complete request configuration
  createCompleteOptions(): RequestOptions {
    const headers = new Headers({
      'Content-Type': 'application/json',
      'Authorization': 'Bearer token123',
      'Accept': 'application/json'
    });
    
    const params = new URLSearchParams();
    params.set('version', '2.0');
    params.set('format', 'json');
    
    const options = new RequestOptions({
      method: RequestMethod.Post,
      url: '/api/data',
      headers: headers,
      params: params,
      body: JSON.stringify({ key: 'value' }),
      withCredentials: true,
      responseType: ResponseContentType.Json
    });
    
    return options;
  }
  
  // Merge options
  createMergedOptions(): RequestOptions {
    const baseOptions = new RequestOptions({
      headers: new Headers({ 'Accept': 'application/json' }),
      withCredentials: false
    });
    
    // Merge with additional options
    const mergedOptions = baseOptions.merge({
      method: RequestMethod.Post,
      headers: new Headers({ 'Content-Type': 'application/json' }),
      body: JSON.stringify({ data: 'example' })
    });
    
    return mergedOptions;
  }
  
  // Dynamic options building
  buildDynamicOptions(config: any): RequestOptions {
    const optionsArgs: RequestOptionsArgs = {};
    
    if (config.method) {
      optionsArgs.method = config.method;
    }
    
    if (config.auth) {
      optionsArgs.headers = new Headers({
        'Authorization': `Bearer ${config.auth}`
      });
    }
    
    if (config.params) {
      const params = new URLSearchParams();
      Object.keys(config.params).forEach(key => {
        params.set(key, config.params[key]);
      });
      optionsArgs.params = params;
    }
    
    return new RequestOptions(optionsArgs);
  }
}

BaseRequestOptions Class

Default request options with predefined settings for common use cases.

/**
 * Default request options class
 * Injectable service providing default HTTP request configuration
 * Sets method to GET and creates empty headers
 */
class BaseRequestOptions extends RequestOptions {
  /**
   * Creates default request options
   * Sets method to GET and headers to empty Headers instance
   */
  constructor();
}

Usage Examples:

import { BaseRequestOptions, RequestOptions, Headers } from '@angular/http';
import { Injectable } from '@angular/core';

// Using BaseRequestOptions as default
@Injectable()
export class HttpConfigService {
  
  getDefaultOptions(): BaseRequestOptions {
    return new BaseRequestOptions();
  }
  
  // Extend base options
  createCustomDefaults(): RequestOptions {
    const baseOptions = new BaseRequestOptions();
    
    return baseOptions.merge({
      headers: new Headers({
        'Accept': 'application/json',
        'Content-Type': 'application/json'
      }),
      withCredentials: true
    });
  }
}

// Custom base options provider
@Injectable()
export class CustomBaseRequestOptions extends BaseRequestOptions {
  constructor() {
    super();
    // Override defaults
    this.headers = new Headers({
      'Accept': 'application/json',
      'X-API-Version': '2.0'
    });
    this.withCredentials = true;
  }
}

ResponseOptions Class

Configurable options for HTTP responses with comprehensive response configuration.

/**
 * HTTP response options configuration class
 * Provides comprehensive configuration for HTTP responses
 */
class ResponseOptions {
  /**
   * Creates a new ResponseOptions instance
   * @param opts - Configuration object with optional properties
   */
  constructor(opts?: ResponseOptionsArgs);
  
  /** Response body content */
  body: string | Object | ArrayBuffer | Blob | null;
  
  /** HTTP status code */
  status: number | null;
  
  /** Response headers collection */
  headers: Headers | null;
  
  /** HTTP status text */
  statusText: string | null;
  
  /** Response type */
  type: ResponseType | null;
  
  /** Response URL */
  url: string | null;
  
  /**
   * Merges current options with new options
   * @param options - Additional options to merge
   * @returns New ResponseOptions instance with merged configuration
   */
  merge(options?: ResponseOptionsArgs): ResponseOptions;
}

BaseResponseOptions Class

Default response options with predefined settings.

/**
 * Default response options class
 * Injectable service providing default HTTP response configuration
 * Sets status to 200, statusText to 'Ok', type to Default, and empty headers
 */
class BaseResponseOptions extends ResponseOptions {
  /**
   * Creates default response options
   * Sets status=200, statusText='Ok', type=Default, headers=new Headers()
   */
  constructor();
}

Usage Examples:

import { ResponseOptions, BaseResponseOptions, Headers, ResponseType } from '@angular/http';

class ResponseConfigService {
  
  // Create custom response options
  createResponseOptions(): ResponseOptions {
    const options = new ResponseOptions({
      status: 200,
      statusText: 'OK',
      headers: new Headers({ 'Content-Type': 'application/json' }),
      type: ResponseType.Default,
      url: '/api/data',
      body: JSON.stringify({ message: 'success' })
    });
    
    return options;
  }
  
  // Use base response options
  getDefaultResponseOptions(): BaseResponseOptions {
    return new BaseResponseOptions();
  }
  
  // Merge response options
  createMergedResponseOptions(): ResponseOptions {
    const baseOptions = new BaseResponseOptions();
    
    const mergedOptions = baseOptions.merge({
      status: 201,
      statusText: 'Created',
      headers: new Headers({ 'Location': '/api/resource/123' })
    });
    
    return mergedOptions;
  }
}

Option Interfaces

RequestOptionsArgs Interface

Interface defining optional arguments for request configuration.

/**
 * Interface for HTTP request options arguments
 * All properties are optional for flexible configuration
 */
interface RequestOptionsArgs {
  /** Request URL */
  url?: string | null;
  
  /** HTTP method */
  method?: string | RequestMethod | null;
  
  /** @deprecated Use params instead - URL search parameters */
  search?: string | URLSearchParams | {[key: string]: any | any[]} | null;
  
  /** URL search parameters */
  params?: string | URLSearchParams | {[key: string]: any | any[]} | null;
  
  /** Request headers */
  headers?: Headers | null;
  
  /** Request body */
  body?: any;
  
  /** Include credentials with request */
  withCredentials?: boolean | null;
  
  /** Expected response content type */
  responseType?: ResponseContentType | null;
}

ResponseOptionsArgs Interface

Interface defining optional arguments for response configuration.

/**
 * Interface for HTTP response options arguments
 * All properties are optional for flexible configuration
 */
interface ResponseOptionsArgs {
  /** Response body content */
  body?: string | Object | FormData | ArrayBuffer | Blob | null;
  
  /** HTTP status code */
  status?: number | null;
  
  /** HTTP status text */
  statusText?: string | null;
  
  /** Response headers */
  headers?: Headers | null;
  
  /** Response type */
  type?: ResponseType | null;
  
  /** Response URL */
  url?: string | null;
}

Advanced Configuration Examples

Service-Level Configuration

import { Injectable } from '@angular/core';
import { Http, RequestOptions, Headers, URLSearchParams } from '@angular/http';
import { Observable } from 'rxjs';

@Injectable()
export class ConfiguredHttpService {
  private defaultOptions: RequestOptions;
  
  constructor(private http: Http) {
    // Set up default options for this service
    this.defaultOptions = new RequestOptions({
      headers: new Headers({
        'Content-Type': 'application/json',
        'Accept': 'application/json',
        'X-API-Version': '2.0'
      }),
      withCredentials: true
    });
  }
  
  // Use default options
  get(url: string, additionalOptions?: RequestOptionsArgs): Observable<any> {
    const options = this.defaultOptions.merge(additionalOptions);
    return this.http.get(url, options);
  }
  
  // Override specific options
  post(url: string, body: any, additionalOptions?: RequestOptionsArgs): Observable<any> {
    const options = this.defaultOptions.merge({
      method: RequestMethod.Post,
      body: JSON.stringify(body),
      ...additionalOptions
    });
    
    return this.http.request(url, options);
  }
  
  // Authenticated requests
  authenticatedRequest(url: string, token: string, options?: RequestOptionsArgs): Observable<any> {
    const authOptions = this.defaultOptions.merge({
      headers: new Headers({
        'Authorization': `Bearer ${token}`
      }),
      ...options
    });
    
    return this.http.get(url, authOptions);
  }
}

Environment-Based Configuration

import { Injectable } from '@angular/core';
import { RequestOptions, Headers } from '@angular/http';

interface EnvironmentConfig {
  apiVersion: string;
  baseUrl: string;
  timeout: number;
  enableCredentials: boolean;
}

@Injectable()
export class EnvironmentHttpConfig {
  private config: EnvironmentConfig;
  
  constructor() {
    // Load config based on environment
    this.config = this.loadEnvironmentConfig();
  }
  
  createEnvironmentOptions(additionalOptions?: RequestOptionsArgs): RequestOptions {
    const headers = new Headers({
      'Accept': 'application/json',
      'X-API-Version': this.config.apiVersion,
      'X-Client': 'web-app'
    });
    
    const baseOptions = new RequestOptions({
      headers: headers,
      withCredentials: this.config.enableCredentials
    });
    
    return additionalOptions ? baseOptions.merge(additionalOptions) : baseOptions;
  }
  
  private loadEnvironmentConfig(): EnvironmentConfig {
    // Load from environment or config file
    return {
      apiVersion: '2.0',
      baseUrl: '/api',
      timeout: 30000,
      enableCredentials: true
    };
  }
}

Conditional Configuration

class ConditionalConfigService {
  
  createConditionalOptions(userRole: string, isSecure: boolean): RequestOptions {
    const headers = new Headers({
      'Accept': 'application/json'
    });
    
    // Add role-based headers
    if (userRole === 'admin') {
      headers.set('X-Admin-Access', 'true');
    }
    
    // Add security headers
    if (isSecure) {
      headers.set('X-Secure-Request', 'true');
      headers.set('Cache-Control', 'no-cache');
    }
    
    const options = new RequestOptions({
      headers: headers,
      withCredentials: isSecure
    });
    
    return options;
  }
  
  createParameterizedOptions(params: {[key: string]: any}): RequestOptions {
    const urlParams = new URLSearchParams();
    
    // Build parameters dynamically
    Object.keys(params).forEach(key => {
      const value = params[key];
      if (Array.isArray(value)) {
        value.forEach(v => urlParams.append(key, v.toString()));
      } else if (value !== null && value !== undefined) {
        urlParams.set(key, value.toString());
      }
    });
    
    return new RequestOptions({
      params: urlParams
    });
  }
}