@metigan/angular 1.0.0

package/src/lib/http-client.service.ts

@@ -0,0 +1,156 @@
+/**
+ * HTTP Client Service for Metigan SDK
+ * Wraps Angular HttpClient with retry logic and error handling
+ */
+
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams, HttpErrorResponse } from '@angular/common/http';
+import { Observable, throwError, timer } from 'rxjs';
+import { catchError, retryWhen, mergeMap, map } from 'rxjs/operators';
+import { ApiError, MetiganError } from './errors';
+
+export interface HttpOptions {
+  headers?: HttpHeaders | { [header: string]: string | string[] };
+  params?: HttpParams | { [param: string]: any };
+  timeout?: number;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganHttpClient {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * Make GET request with retry logic
+   */
+  get<T>(url: string, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {
+    const opts = this.buildOptions(options);
+    
+    return (this.http.get<T>(url, opts) as Observable<T>).pipe(
+      map((response: T) => response),
+      retryWhen(errors =>
+        errors.pipe(
+          mergeMap((error: HttpErrorResponse, index: number) => {
+            if (index < retryCount && this.shouldRetry(error)) {
+              return timer(retryDelay * (index + 1));
+            }
+            return throwError(() => error);
+          })
+        )
+      ),
+      catchError(this.handleError)
+    );
+  }
+
+  /**
+   * Make POST request with retry logic
+   */
+  post<T>(url: string, body: any, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {
+    const opts = this.buildOptions(options);
+    
+    return (this.http.post<T>(url, body, opts) as Observable<T>).pipe(
+      map((response: T) => response),
+      retryWhen(errors =>
+        errors.pipe(
+          mergeMap((error: HttpErrorResponse, index: number) => {
+            if (index < retryCount && this.shouldRetry(error)) {
+              return timer(retryDelay * (index + 1));
+            }
+            return throwError(() => error);
+          })
+        )
+      ),
+      catchError(this.handleError)
+    );
+  }
+
+  /**
+   * Make PUT request with retry logic
+   */
+  put<T>(url: string, body: any, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {
+    const opts = this.buildOptions(options);
+    
+    return (this.http.put<T>(url, body, opts) as Observable<T>).pipe(
+      map((response: T) => response),
+      retryWhen(errors =>
+        errors.pipe(
+          mergeMap((error: HttpErrorResponse, index: number) => {
+            if (index < retryCount && this.shouldRetry(error)) {
+              return timer(retryDelay * (index + 1));
+            }
+            return throwError(() => error);
+          })
+        )
+      ),
+      catchError(this.handleError)
+    );
+  }
+
+  /**
+   * Make DELETE request with retry logic
+   */
+  delete<T>(url: string, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {
+    const opts = this.buildOptions(options);
+    
+    return (this.http.delete<T>(url, opts) as Observable<T>).pipe(
+      map((response: T) => response),
+      retryWhen(errors =>
+        errors.pipe(
+          mergeMap((error: HttpErrorResponse, index: number) => {
+            if (index < retryCount && this.shouldRetry(error)) {
+              return timer(retryDelay * (index + 1));
+            }
+            return throwError(() => error);
+          })
+        )
+      ),
+      catchError(this.handleError)
+    );
+  }
+
+  /**
+   * Build HTTP options with timeout
+   */
+  private buildOptions(options?: HttpOptions): any {
+    const opts: any = {
+      observe: 'body' as const
+    };
+    
+    if (options?.headers) {
+      opts.headers = options.headers;
+    }
+    
+    if (options?.params) {
+      opts.params = options.params;
+    }
+
+    // Angular HttpClient doesn't support timeout directly
+    // Timeout should be handled at the interceptor level if needed
+    
+    return opts;
+  }
+
+  /**
+   * Determine if error should trigger retry
+   */
+  private shouldRetry(error: HttpErrorResponse): boolean {
+    // Retry on server errors (5xx) or network errors
+    return error.status >= 500 || error.status === 0 || !error.status;
+  }
+
+  /**
+   * Handle HTTP errors
+   */
+  private handleError = (error: HttpErrorResponse): Observable<never> => {
+    if (error.error instanceof ErrorEvent) {
+      // Client-side error
+      return throwError(() => new MetiganError(`Network error: ${error.error.message}`));
+    } else {
+      // Server-side error
+      const message = error.error?.message || error.error?.error || `Request failed with status ${error.status}`;
+      return throwError(() => new ApiError(message, error.status));
+    }
+  };
+}
+

package/src/lib/metigan.module.ts

@@ -0,0 +1,55 @@
+/**
+ * Metigan Angular Module
+ * Import this module in your Angular app to use Metigan services
+ */
+
+import { NgModule, ModuleWithProviders } from '@angular/core';
+import { HttpClientModule } from '@angular/common/http';
+import { MetiganService, METIGAN_CONFIG } from './metigan.service';
+import { MetiganHttpClient } from './http-client.service';
+import { MetiganEmailService } from './email.service';
+import { MetiganFormsService } from './forms.service';
+import { MetiganContactsService } from './contacts.service';
+import { MetiganAudiencesService } from './audiences.service';
+import { MetiganTemplatesService } from './templates.service';
+import { MetiganClientOptions } from './types';
+
+@NgModule({
+  imports: [HttpClientModule],
+  providers: [
+    MetiganHttpClient,
+    MetiganEmailService,
+    MetiganFormsService,
+    MetiganContactsService,
+    MetiganAudiencesService,
+    MetiganTemplatesService,
+    MetiganService
+  ]
+})
+export class MetiganModule {
+  /**
+   * Configure Metigan with API key and options
+   * Call this in your root module's imports
+   * 
+   * @example
+   * ```typescript
+   * imports: [
+   *   MetiganModule.forRoot({
+   *     apiKey: 'your-api-key'
+   *   })
+   * ]
+   * ```
+   */
+  static forRoot(config: MetiganClientOptions): ModuleWithProviders<MetiganModule> {
+    return {
+      ngModule: MetiganModule,
+      providers: [
+        {
+          provide: METIGAN_CONFIG,
+          useValue: config
+        }
+      ]
+    };
+  }
+}
+

package/src/lib/metigan.service.ts

@@ -0,0 +1,80 @@
+/**
+ * Main Metigan Service
+ * Unified service that provides access to all Metigan modules
+ */
+
+import { Injectable, Inject, Optional } from '@angular/core';
+import { MetiganEmailService } from './email.service';
+import { MetiganFormsService } from './forms.service';
+import { MetiganContactsService } from './contacts.service';
+import { MetiganAudiencesService } from './audiences.service';
+import { MetiganTemplatesService } from './templates.service';
+import { MetiganError } from './errors';
+import { MetiganClientOptions } from './types';
+
+export const METIGAN_CONFIG = 'METIGAN_CONFIG';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganService {
+  public readonly email: MetiganEmailService;
+  public readonly forms: MetiganFormsService;
+  public readonly contacts: MetiganContactsService;
+  public readonly audiences: MetiganAudiencesService;
+  public readonly templates: MetiganTemplatesService;
+
+  private initialized: boolean = false;
+
+  constructor(
+    emailService: MetiganEmailService,
+    formsService: MetiganFormsService,
+    contactsService: MetiganContactsService,
+    audiencesService: MetiganAudiencesService,
+    templatesService: MetiganTemplatesService,
+    @Optional() @Inject(METIGAN_CONFIG) config?: MetiganClientOptions
+  ) {
+    this.email = emailService;
+    this.forms = formsService;
+    this.contacts = contactsService;
+    this.audiences = audiencesService;
+    this.templates = templatesService;
+
+    // Auto-initialize if config is provided via injection
+    if (config) {
+      this.initialize(config);
+    }
+  }
+
+  /**
+   * Initialize all services with API key and options
+   */
+  initialize(options: MetiganClientOptions): void {
+    if (!options.apiKey) {
+      throw new MetiganError('API key is required');
+    }
+
+    const serviceOptions = {
+      apiUrl: options.apiUrl,
+      timeout: options.timeout,
+      retryCount: options.retryCount,
+      retryDelay: options.retryDelay
+    };
+
+    this.email.initialize(options.apiKey, serviceOptions);
+    this.forms.initialize(options.apiKey, serviceOptions);
+    this.contacts.initialize(options.apiKey, serviceOptions);
+    this.audiences.initialize(options.apiKey, serviceOptions);
+    this.templates.initialize(options.apiKey, serviceOptions);
+
+    this.initialized = true;
+  }
+
+  /**
+   * Check if services are initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+}
+

package/src/lib/templates.service.ts

@@ -0,0 +1,103 @@
+/**
+ * Metigan Templates Service
+ * Service for managing email templates
+ */
+
+import { Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { MetiganHttpClient } from './http-client.service';
+import { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY } from './config';
+import { ValidationError, MetiganError } from './errors';
+import {
+  EmailTemplate,
+  EmailTemplateListResponse,
+  PaginationOptions
+} from './types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganTemplatesService {
+  private apiKey: string = '';
+  private apiUrl: string = API_URL;
+  private timeout: number = DEFAULT_TIMEOUT;
+  private retryCount: number = DEFAULT_RETRY_COUNT;
+  private retryDelay: number = DEFAULT_RETRY_DELAY;
+
+  constructor(private http: MetiganHttpClient) {}
+
+  /**
+   * Initialize the service with API key and options
+   */
+  initialize(apiKey: string, options?: { apiUrl?: string; timeout?: number; retryCount?: number; retryDelay?: number }): void {
+    if (!apiKey) {
+      throw new MetiganError('API key is required');
+    }
+
+    this.apiKey = apiKey;
+    this.apiUrl = options?.apiUrl || API_URL;
+    this.timeout = options?.timeout || DEFAULT_TIMEOUT;
+    this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;
+    this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;
+  }
+
+  /**
+   * Get default headers
+   */
+  private getHeaders() {
+    return {
+      'Content-Type': 'application/json',
+      'x-api-key': this.apiKey,
+      'User-Agent': 'AngularSDK/1.0'
+    };
+  }
+
+  /**
+   * List all templates
+   */
+  list(options?: PaginationOptions): Observable<EmailTemplateListResponse> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    let params = new HttpParams();
+    if (options?.page) {
+      params = params.set('page', options.page.toString());
+    }
+    if (options?.limit) {
+      params = params.set('limit', options.limit.toString());
+    }
+
+    return this.http.get<EmailTemplateListResponse>(
+      `${this.apiUrl}/api/templates`,
+      {
+        headers: this.getHeaders(),
+        params: params
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get template by ID
+   */
+  get(templateId: string): Observable<EmailTemplate> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!templateId) {
+      return throwError(() => new ValidationError('Template ID is required'));
+    }
+
+    return this.http.get<EmailTemplate>(
+      `${this.apiUrl}/api/templates/${templateId}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+}
+