@metigan/angular 1.0.0

package/src/lib/email.service.ts

@@ -0,0 +1,286 @@
+/**
+ * Metigan Email Service
+ * Service for sending emails through the Metigan API
+ */
+
+import { Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { MetiganHttpClient } from './http-client.service';
+import { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY, MAX_FILE_SIZE } from './config';
+import { ValidationError, MetiganError } from './errors';
+import { EmailOptions, EmailApiResponse, EmailSuccessResponse, EmailAttachment } from './types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganEmailService {
+  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;
+  }
+
+  /**
+   * Validate email address 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;
+  }
+
+  /**
+   * Extract email address from "Name <email>" format
+   */
+  private extractEmailAddress(from: string): string {
+    if (!from) return '';
+    const angleMatch = from.match(/<([^>]+)>/);
+    if (angleMatch) {
+      return angleMatch[1].trim();
+    }
+    return from.trim();
+  }
+
+  /**
+   * Validate email options
+   */
+  private validateOptions(options: EmailOptions): void {
+    if (!options.from) {
+      throw new ValidationError('Sender email (from) is required');
+    }
+
+    if (!options.recipients || !Array.isArray(options.recipients) || options.recipients.length === 0) {
+      throw new ValidationError('Recipients must be a non-empty array');
+    }
+
+    if (!options.subject) {
+      throw new ValidationError('Subject is required');
+    }
+
+    if (!options.content && !options.templateId) {
+      throw new ValidationError('Either content or templateId is required');
+    }
+
+    const fromEmail = this.extractEmailAddress(options.from);
+    if (!this.validateEmail(fromEmail)) {
+      throw new ValidationError(`Invalid sender email format: ${fromEmail}`);
+    }
+
+    for (const recipient of options.recipients) {
+      const recipientEmail = this.extractEmailAddress(recipient);
+      if (!this.validateEmail(recipientEmail)) {
+        throw new ValidationError(`Invalid recipient email format: ${recipientEmail}`);
+      }
+    }
+
+    if (options.cc) {
+      for (const cc of options.cc) {
+        const ccEmail = this.extractEmailAddress(cc);
+        if (!this.validateEmail(ccEmail)) {
+          throw new ValidationError(`Invalid CC email format: ${ccEmail}`);
+        }
+      }
+    }
+
+    if (options.bcc) {
+      for (const bcc of options.bcc) {
+        const bccEmail = this.extractEmailAddress(bcc);
+        if (!this.validateEmail(bccEmail)) {
+          throw new ValidationError(`Invalid BCC email format: ${bccEmail}`);
+        }
+      }
+    }
+
+    if (options.replyTo) {
+      const replyToEmail = this.extractEmailAddress(options.replyTo);
+      if (!this.validateEmail(replyToEmail)) {
+        throw new ValidationError(`Invalid reply-to email format: ${replyToEmail}`);
+      }
+    }
+  }
+
+  /**
+   * Process attachments for FormData
+   */
+  private async processAttachments(attachments: File[] | EmailAttachment[]): Promise<FormData> {
+    const formData = new FormData();
+
+    for (const file of attachments) {
+      if (file instanceof File) {
+        if (file.size > MAX_FILE_SIZE) {
+          throw new MetiganError(`File ${file.name} exceeds the maximum size of 7MB`);
+        }
+        formData.append('files', file);
+      } else {
+        const attachment = file as EmailAttachment;
+        
+        // Convert content to Blob
+        let blob: Blob;
+        if (attachment.content instanceof ArrayBuffer) {
+          blob = new Blob([attachment.content], { type: attachment.contentType });
+        } else if (attachment.content instanceof Uint8Array) {
+          blob = new Blob([attachment.content], { type: attachment.contentType });
+        } else if (typeof attachment.content === 'string') {
+          // Base64 string
+          const byteCharacters = atob(attachment.content);
+          const byteNumbers = new Array(byteCharacters.length);
+          for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+          }
+          const byteArray = new Uint8Array(byteNumbers);
+          blob = new Blob([byteArray], { type: attachment.contentType });
+        } else {
+          throw new MetiganError('Invalid attachment content type');
+        }
+
+        if (blob.size > MAX_FILE_SIZE) {
+          throw new MetiganError(`File ${attachment.filename} exceeds the maximum size of 7MB`);
+        }
+
+        const fileObj = new File([blob], attachment.filename, { type: attachment.contentType });
+        formData.append('files', fileObj);
+      }
+    }
+
+    return formData;
+  }
+
+  /**
+   * Send an email
+   */
+  sendEmail(options: EmailOptions): Observable<EmailSuccessResponse> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    try {
+      this.validateOptions(options);
+    } catch (error) {
+      return throwError(() => error);
+    }
+
+    const headers = {
+      'x-api-key': this.apiKey,
+      'User-Agent': 'AngularSDK/1.0'
+    };
+
+    // If attachments, use FormData
+    if (options.attachments && options.attachments.length > 0) {
+      return new Observable(observer => {
+        this.processAttachments(options.attachments!).then(formData => {
+          formData.append('from', options.from);
+          formData.append('recipients', JSON.stringify(options.recipients));
+          formData.append('subject', options.subject);
+          
+          if (options.templateId) {
+            formData.append('useTemplate', 'true');
+            formData.append('templateId', options.templateId);
+          } else if (options.content) {
+            formData.append('content', options.content);
+          }
+
+          if (options.cc && options.cc.length > 0) {
+            formData.append('cc', JSON.stringify(options.cc));
+          }
+
+          if (options.bcc && options.bcc.length > 0) {
+            formData.append('bcc', JSON.stringify(options.bcc));
+          }
+
+          if (options.replyTo) {
+            formData.append('replyTo', options.replyTo);
+          }
+
+          const httpOptions = {
+            headers: headers
+          };
+
+          this.http.post<EmailApiResponse>(`${this.apiUrl}/api/email/send`, formData, httpOptions, this.retryCount, this.retryDelay)
+            .pipe(
+              map(response => {
+                if ('success' in response && response.success) {
+                  return response as EmailSuccessResponse;
+                } else {
+                  throw new MetiganError((response as any).message || 'Failed to send email');
+                }
+              })
+            )
+            .subscribe({
+              next: (response) => observer.next(response),
+              error: (error) => observer.error(error),
+              complete: () => observer.complete()
+            });
+        }).catch(error => observer.error(error));
+      });
+    } else {
+      // No attachments, use JSON
+      const body = {
+        from: options.from,
+        recipients: options.recipients,
+        subject: options.subject
+      };
+
+      if (options.templateId) {
+        (body as any).useTemplate = 'true';
+        (body as any).templateId = options.templateId;
+      } else if (options.content) {
+        (body as any).content = options.content;
+      }
+
+      if (options.cc && options.cc.length > 0) {
+        (body as any).cc = options.cc;
+      }
+
+      if (options.bcc && options.bcc.length > 0) {
+        (body as any).bcc = options.bcc;
+      }
+
+      if (options.replyTo) {
+        (body as any).replyTo = options.replyTo;
+      }
+
+      const httpOptions = {
+        headers: {
+          ...headers,
+          'Content-Type': 'application/json'
+        }
+      };
+
+      return this.http.post<EmailApiResponse>(`${this.apiUrl}/api/email/send`, body, httpOptions, this.retryCount, this.retryDelay)
+        .pipe(
+          map(response => {
+            if ('success' in response && response.success) {
+              return response as EmailSuccessResponse;
+            } else {
+              throw new MetiganError((response as any).message || 'Failed to send email');
+            }
+          })
+        );
+    }
+  }
+}
+
+

package/src/lib/errors.ts

@@ -0,0 +1,45 @@
+/**
+ * Custom error classes for Metigan SDK
+ */
+
+/**
+ * Base error class for all Metigan errors
+ */
+export class MetiganError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'MetiganError';
+    Object.setPrototypeOf(this, MetiganError.prototype);
+  }
+}
+
+/**
+ * Validation error - thrown when input validation fails
+ */
+export class ValidationError extends MetiganError {
+  public field?: string;
+
+  constructor(message: string, field?: string) {
+    super(message);
+    this.name = 'ValidationError';
+    this.field = field;
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+}
+
+/**
+ * API error - thrown when API request fails
+ */
+export class ApiError extends MetiganError {
+  public statusCode?: number;
+  public status?: number;
+
+  constructor(message: string, statusCode?: number) {
+    super(message);
+    this.name = 'ApiError';
+    this.statusCode = statusCode || statusCode;
+    this.status = statusCode;
+    Object.setPrototypeOf(this, ApiError.prototype);
+  }
+}
+

package/src/lib/forms.service.ts

@@ -0,0 +1,263 @@
+/**
+ * Metigan Forms Service
+ * Service for form management and submissions
+ */
+
+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 {
+  FormConfig,
+  FormSubmissionOptions,
+  FormSubmissionResponse,
+  FormListResponse,
+  PaginationOptions
+} from './types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetiganFormsService {
+  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'
+    };
+  }
+
+  /**
+   * Submit form data
+   */
+  submit(options: FormSubmissionOptions): Observable<FormSubmissionResponse> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!options.formId) {
+      return throwError(() => new ValidationError('Form ID is required'));
+    }
+
+    if (!options.data || Object.keys(options.data).length === 0) {
+      return throwError(() => new ValidationError('Submission data is required'));
+    }
+
+    const body = {
+      formId: options.formId,
+      data: options.data
+    };
+
+    return this.http.post<FormSubmissionResponse>(
+      `${this.apiUrl}/api/submissions`,
+      body,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get form by ID or slug
+   */
+  getForm(formIdOrSlug: string): Observable<FormConfig> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!formIdOrSlug) {
+      return throwError(() => new ValidationError('Form ID or slug is required'));
+    }
+
+    return this.http.get<FormConfig>(
+      `${this.apiUrl}/api/forms/${formIdOrSlug}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get public form by slug
+   */
+  getPublicForm(slug: string): Observable<FormConfig> {
+    if (!slug) {
+      return throwError(() => new ValidationError('Form slug is required'));
+    }
+
+    // Public forms don't require API key
+    return this.http.get<FormConfig>(
+      `${this.apiUrl}/f/${slug}/api`,
+      {},
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * List all forms
+   */
+  listForms(options?: PaginationOptions): Observable<FormListResponse> {
+    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<FormListResponse>(
+      `${this.apiUrl}/api/forms`,
+      {
+        headers: this.getHeaders(),
+        params: params
+      },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Create a new form
+   */
+  createForm(config: Omit<FormConfig, 'id'>): Observable<FormConfig> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!config.title) {
+      return throwError(() => new ValidationError('Form title is required'));
+    }
+
+    if (!config.fields || config.fields.length === 0) {
+      return throwError(() => new ValidationError('At least one field is required'));
+    }
+
+    return this.http.post<FormConfig>(
+      `${this.apiUrl}/api/forms`,
+      config,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Update an existing form
+   */
+  updateForm(formId: string, config: Partial<FormConfig>): Observable<FormConfig> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!formId) {
+      return throwError(() => new ValidationError('Form ID is required'));
+    }
+
+    return this.http.put<FormConfig>(
+      `${this.apiUrl}/api/forms/${formId}`,
+      config,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Delete a form
+   */
+  deleteForm(formId: string): Observable<void> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!formId) {
+      return throwError(() => new ValidationError('Form ID is required'));
+    }
+
+    return this.http.delete<void>(
+      `${this.apiUrl}/api/forms/${formId}`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Get form analytics
+   */
+  getAnalytics(formId: string): Observable<any> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!formId) {
+      return throwError(() => new ValidationError('Form ID is required'));
+    }
+
+    return this.http.get<any>(
+      `${this.apiUrl}/api/forms/${formId}/analytics`,
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+
+  /**
+   * Publish a form
+   */
+  publishForm(formId: string, slug: string): Observable<{ publishedUrl: string; slug: string }> {
+    if (!this.apiKey) {
+      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
+    }
+
+    if (!formId) {
+      return throwError(() => new ValidationError('Form ID is required'));
+    }
+
+    if (!slug) {
+      return throwError(() => new ValidationError('Slug is required'));
+    }
+
+    return this.http.post<{ publishedUrl: string; slug: string }>(
+      `${this.apiUrl}/api/forms/${formId}/publish`,
+      { slug },
+      { headers: this.getHeaders() },
+      this.retryCount,
+      this.retryDelay
+    );
+  }
+}
+