@metigan/angular 1.0.0

package/src/lib/audiences.service.ts

@@ -0,0 +1,230 @@
+/**
+ * Metigan Audiences Service
+ * Service for audience/list management
+ */
+
+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 {
+  Audience,
+  CreateAudienceOptions,
+  UpdateAudienceOptions,
+  AudienceListResponse,
+  AudienceStats,
+  PaginationOptions
+} from './types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganAudiencesService {
+  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'
+    };
+  }
+
+  /**
+   * Create a new audience
+   */
+  create(options: CreateAudienceOptions): Observable<Audience> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!options.name) {
+      return throwError(() => new ValidationError('Audience name is required'));
+    }
+
+    return this.http.post<Audience>(
+      `${this.apiUrl}/api/audiences`,
+      options,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get audience by ID
+   */
+  get(audienceId: string): Observable<Audience> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.get<Audience>(
+      `${this.apiUrl}/api/audiences/${audienceId}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Update an audience
+   */
+  update(audienceId: string, options: UpdateAudienceOptions): Observable<Audience> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.put<Audience>(
+      `${this.apiUrl}/api/audiences/${audienceId}`,
+      options,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Delete an audience
+   */
+  delete(audienceId: string): Observable<void> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.delete<void>(
+      `${this.apiUrl}/api/audiences/${audienceId}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * List all audiences
+   */
+  list(options?: PaginationOptions): Observable<AudienceListResponse> {
+    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<AudienceListResponse>(
+      `${this.apiUrl}/api/audiences`,
+      {
+        headers: this.getHeaders(),
+        params: params
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get audience statistics
+   */
+  getStats(audienceId: string): Observable<AudienceStats> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.get<AudienceStats>(
+      `${this.apiUrl}/api/audiences/${audienceId}/stats`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Clean audience (remove bounced/unsubscribed contacts)
+   */
+  clean(audienceId: string): Observable<{ removed: number }> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.post<{ removed: number }>(
+      `${this.apiUrl}/api/audiences/${audienceId}/clean`,
+      {},
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Merge audiences (source into target)
+   */
+  merge(sourceAudienceId: string, targetAudienceId: string): Observable<Audience> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!sourceAudienceId || !targetAudienceId) {
+      return throwError(() => new ValidationError('Source and target audience IDs are required'));
+    }
+
+    return this.http.post<Audience>(
+      `${this.apiUrl}/api/audiences/${sourceAudienceId}/merge`,
+      { targetAudienceId },
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+}
+

package/src/lib/config.ts

@@ -0,0 +1,35 @@
+/**
+ * Metigan Library Configuration
+ * Central configuration file for all modules
+ */
+
+/**
+ * Default API URL for Metigan services
+ * All API calls are routed through this single endpoint
+ * 
+ * Can be overridden with METIGAN_API_URL environment variable for testing
+ */
+export const API_URL = (typeof process !== 'undefined' && process.env?.['METIGAN_API_URL']) 
+  || 'https://api.metigan.com';
+
+/**
+ * SDK Version
+ */
+export const SDK_VERSION = '1.0.0';
+
+/**
+ * Default timeout for API requests (in milliseconds)
+ */
+export const DEFAULT_TIMEOUT = 30000;
+
+/**
+ * Default retry configuration
+ */
+export const DEFAULT_RETRY_COUNT = 3;
+export const DEFAULT_RETRY_DELAY = 1000;
+
+/**
+ * Maximum file size for attachments (7MB)
+ */
+export const MAX_FILE_SIZE = 7 * 1024 * 1024;
+

package/src/lib/contacts.service.ts

@@ -0,0 +1,377 @@
+/**
+ * Metigan Contacts Service
+ * Service for contact/subscriber management
+ */
+
+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 {
+  Contact,
+  CreateContactOptions,
+  UpdateContactOptions,
+  ContactListFilters,
+  ContactListResponse,
+  BulkContactResult
+} from './types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganContactsService {
+  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'
+    };
+  }
+
+  /**
+   * Validate email format
+   */
+  private validateEmail(email: string): boolean {
+    if (!email || typeof email !== 'string') return false;
+    const parts = email.split('@');
+    if (parts.length !== 2) return false;
+    if (parts[0].length === 0) return false;
+    const domainParts = parts[1].split('.');
+    if (domainParts.length < 2) return false;
+    if (domainParts.some(part => part.length === 0)) return false;
+    return true;
+  }
+
+  /**
+   * Create a new contact
+   */
+  create(options: CreateContactOptions): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!options.email || !this.validateEmail(options.email)) {
+      return throwError(() => new ValidationError('Valid email is required'));
+    }
+
+    if (!options.audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.post<Contact>(
+      `${this.apiUrl}/api/contacts`,
+      options,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get contact by ID
+   */
+  get(contactId: string): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    return this.http.get<Contact>(
+      `${this.apiUrl}/api/contacts/${contactId}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get contact by email
+   */
+  getByEmail(email: string, audienceId: string): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!email || !this.validateEmail(email)) {
+      return throwError(() => new ValidationError('Valid email is required'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    let params = new HttpParams();
+    params = params.set('email', email);
+    params = params.set('audienceId', audienceId);
+
+    return this.http.get<Contact>(
+      `${this.apiUrl}/api/contacts`,
+      {
+        headers: this.getHeaders(),
+        params: params
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Update a contact
+   */
+  update(contactId: string, options: UpdateContactOptions): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    return this.http.put<Contact>(
+      `${this.apiUrl}/api/contacts/${contactId}`,
+      options,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Delete a contact
+   */
+  delete(contactId: string): Observable<void> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    return this.http.delete<void>(
+      `${this.apiUrl}/api/contacts/${contactId}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * List contacts with filters
+   */
+  list(filters?: ContactListFilters): Observable<ContactListResponse> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    let params = new HttpParams();
+    if (filters?.audienceId) {
+      params = params.set('audienceId', filters.audienceId);
+    }
+    if (filters?.status) {
+      params = params.set('status', filters.status);
+    }
+    if (filters?.tag) {
+      params = params.set('tag', filters.tag);
+    }
+    if (filters?.search) {
+      params = params.set('search', filters.search);
+    }
+    if (filters?.page) {
+      params = params.set('page', filters.page.toString());
+    }
+    if (filters?.limit) {
+      params = params.set('limit', filters.limit.toString());
+    }
+
+    return this.http.get<ContactListResponse>(
+      `${this.apiUrl}/api/contacts`,
+      {
+        headers: this.getHeaders(),
+        params: params
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Search contacts
+   */
+  search(query: string, audienceId?: string): Observable<Contact[]> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!query) {
+      return throwError(() => new ValidationError('Search query is required'));
+    }
+
+    let params = new HttpParams();
+    params = params.set('search', query);
+    if (audienceId) {
+      params = params.set('audienceId', audienceId);
+    }
+
+    return this.http.get<Contact[]>(
+      `${this.apiUrl}/api/contacts/search`,
+      {
+        headers: this.getHeaders(),
+        params: params
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Bulk import contacts
+   */
+  bulkImport(contacts: CreateContactOptions[], audienceId: string): Observable<BulkContactResult> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contacts || contacts.length === 0) {
+      return throwError(() => new ValidationError('Contacts array is required'));
+    }
+
+    if (!audienceId) {
+      return throwError(() => new ValidationError('Audience ID is required'));
+    }
+
+    return this.http.post<BulkContactResult>(
+      `${this.apiUrl}/api/contacts/bulk`,
+      { contacts, audienceId },
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Subscribe a contact
+   */
+  subscribe(contactId: string): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    return this.http.post<Contact>(
+      `${this.apiUrl}/api/contacts/${contactId}/subscribe`,
+      {},
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Unsubscribe a contact
+   */
+  unsubscribe(contactId: string): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    return this.http.post<Contact>(
+      `${this.apiUrl}/api/contacts/${contactId}/unsubscribe`,
+      {},
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Add tags to a contact
+   */
+  addTags(contactId: string, tags: string[]): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    if (!tags || tags.length === 0) {
+      return throwError(() => new ValidationError('Tags array is required'));
+    }
+
+    return this.http.post<Contact>(
+      `${this.apiUrl}/api/contacts/${contactId}/tags`,
+      { tags },
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Remove tags from a contact
+   */
+  removeTags(contactId: string, tags: string[]): Observable<Contact> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!contactId) {
+      return throwError(() => new ValidationError('Contact ID is required'));
+    }
+
+    if (!tags || tags.length === 0) {
+      return throwError(() => new ValidationError('Tags array is required'));
+    }
+
+    return this.http.delete<Contact>(
+      `${this.apiUrl}/api/contacts/${contactId}/tags`,
+      {
+        headers: this.getHeaders(),
+        params: { tags: tags.join(',') }
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+}
+