bridgex 1.0.0 → 2.0.1

package/src/errors.ts

@@ -1,37 +1,71 @@
 class SMSClientError extends Error {
   public code: string;
   public details?: unknown;
+  public isClientError: boolean;
+  public isServerError: boolean;
 
-  constructor(message: string, code: string, details?: unknown) {
+  constructor(
+    message: string,
+    code: string,
+    details?: unknown,
+    isClientError = false,
+    isServerError = false,
+  ) {
     super(message);
     this.name = this.constructor.name;
     this.code = code;
     this.details = details;
-
+    this.isClientError = isClientError;
+    this.isServerError = isServerError;
     Object.setPrototypeOf(this, new.target.prototype);
   }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      isClientError: this.isClientError,
+      isServerError: this.isServerError,
+    };
+  }
 }
 
 export class ServerError extends SMSClientError {
   constructor(message: string, details?: unknown) {
-    super(message, "SERVER_ERROR", details);
+    super(message, "SERVER_ERROR", details, false, true);
   }
 }
 
 export class ValidationError extends SMSClientError {
   constructor(message: string, details?: unknown) {
-    super(message, "VALIDATION_ERROR", details);
+    super(message, "VALIDATION_ERROR", details, true, false);
   }
 }
 
 export class TemplateError extends SMSClientError {
   constructor(message: string, details?: unknown) {
-    super(message, "TEMPLATE_ERROR", details);
+    super(message, "TEMPLATE_ERROR", details, true, false);
   }
 }
 
 export class NetworkError extends SMSClientError {
   constructor(message: string, details?: unknown) {
-    super(message, "NETWORK_ERROR", details);
+    super(message, "NETWORK_ERROR", details, false, false);
+  }
+}
+
+export class RateLimitError extends SMSClientError {
+  public retryAfter?: number;
+  constructor(message: string, retryAfter?: number, details?: unknown) {
+    super(message, "RATE_LIMIT_ERROR", details, false, true);
+    this.retryAfter = retryAfter;
+  }
+}
+
+export class CircuitOpenError extends SMSClientError {
+  constructor(message: string, details?: unknown) {
+    super(message, "CIRCUIT_OPEN", details, false, false);
   }
 }

package/src/helpers.ts

@@ -0,0 +1,31 @@
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function flattenObject(
+  obj: Record<string, unknown>,
+  prefix = "",
+  separator = ".",
+): Record<string, string> {
+  const result: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}${separator}${key}` : key;
+
+    if (isObject(value)) {
+      Object.assign(result, flattenObject(value, fullKey, separator));
+    } else if (value !== null && value !== undefined) {
+      result[fullKey] = String(value);
+    }
+  }
+
+  return result;
+}
+
+export function chunkArray<T>(array: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}

package/src/main.ts

@@ -1 +1,61 @@
-export { SMSClient } from "./client/SMSManager.js";
+// Core client
+export { default as SMSClient } from "./SMSClient.js";
+export type { SMSClientOptions } from "./SMSClient.js";
+
+// Config builder
+export { default as SendConfig } from "./SendConfig.js";
+export type { SendMeta } from "./SendConfig.js";
+
+// Microservice
+export { default as SMSService } from "./SMSService.js";
+export type { SMSServiceOptions } from "./SMSService.js";
+
+// Queue & Scheduler
+export { default as SMSQueue } from "./SMSQueue.js";
+export type { QueueOptions, QueueStats, QueueJob } from "./SMSQueue.js";
+
+export { default as SMSScheduler } from "./SMSScheduler.js";
+export type { ScheduledJob } from "./SMSScheduler.js";
+
+// Plugins
+export {
+  default as PluginManager,
+  LoggerPlugin,
+  MetricsPlugin,
+} from "./PluginManager.js";
+export type { Plugin, PluginHooks, MetricsSnapshot } from "./PluginManager.js";
+
+// Credential provisioning
+export {
+  default as CredentialProvisioner,
+  type ProvisionOptions,
+  type Credentials,
+} from "./CredentialProvisioner.js";
+
+// Lower-level building blocks (advanced use)
+export { default as CircuitBreaker } from "./CircuitBreaker.js";
+export type { CircuitBreakerOptions } from "./CircuitBreaker.js";
+
+export { default as RetryHandler } from "./RetryHandler.js";
+export type { RetryOptions } from "./RetryHandler.js";
+
+export { default as MessageFormatter } from "./MessageFormatter.js";
+
+// Errors
+export {
+  ServerError,
+  ValidationError,
+  TemplateError,
+  NetworkError,
+  RateLimitError,
+  CircuitOpenError,
+} from "./errors.js";
+
+// Types
+export type {
+  Result,
+  ErrorLog,
+  SendParams,
+  SendObjectParams,
+  BatchResult,
+} from "./types.js";

package/src/types.ts

@@ -0,0 +1,33 @@
+export type Result<T> =
+  | { ok: true; data: T; error: null }
+  | { ok: false; data: null; error: ErrorLog };
+
+export interface ErrorLog {
+  name: string;
+  message: string;
+  code: string;
+  isClientError: boolean;
+  isServerError: boolean;
+  details?: unknown;
+  timestamp: string;
+}
+
+export interface SendParams {
+  to: string;
+  template: string;
+  variables?: Record<string, unknown>;
+}
+
+export interface SendObjectParams<T extends Record<string, unknown>> {
+  to: string;
+  object: T;
+  template?: string;
+}
+
+export interface BatchResult<T> {
+  succeeded: Array<{ index: number; to: string; data: T }>;
+  failed: Array<{ index: number; to: string; error: ErrorLog }>;
+  total: number;
+  successCount: number;
+  failureCount: number;
+}

package/src/client/SMSManager.ts

@@ -1,67 +0,0 @@
-import HttpClient from "../HttpClient.js";
-import RetryHandler, { type RetryOptions } from "../RetryHandler.js";
-import MessageFormatter from "../MessageFormatter.js";
-import { ValidationError } from "../errors.js";
-
-interface SMSClientOptions {
-  baseUrl: string;
-  apiKey: string;
-  projectKey: string;
-  retry?: RetryOptions;
-}
-
-export class SMSClient {
-  private http: HttpClient;
-  private retry: RetryHandler;
-  private formatter: MessageFormatter;
-
-  constructor(private options: SMSClientOptions) {
-    this.validateOptions(options);
-
-    this.http = new HttpClient({
-      baseUrl: options.baseUrl,
-      apiKey: options.apiKey,
-      projectKey: options.projectKey,
-    });
-
-    this.retry = new RetryHandler(options.retry);
-    this.formatter = new MessageFormatter();
-  }
-
-  private validateOptions(options: SMSClientOptions): void {
-    const { baseUrl, apiKey, projectKey } = options;
-
-    if (!baseUrl) {
-      throw new ValidationError("baseUrl is required");
-    }
-
-    if (!apiKey) {
-      throw new ValidationError("apiKey is required");
-    }
-
-    if (!projectKey) {
-      throw new ValidationError("projectKey is required");
-    }
-  }
-
-  async send(params: {
-    to: string;
-    template: string;
-    variables?: Record<string, unknown>;
-  }): Promise<any> {
-    const { to, template, variables = {} } = params;
-
-    if (!to) {
-      throw new ValidationError("Recipient phone number is required");
-    }
-
-    const message = this.formatter.format(template, variables);
-
-    const payload = {
-      to,
-      message,
-    };
-
-    return this.retry.execute(() => this.http.post("/sms/send", payload));
-  }
-}

package/src/client/types.ts

@@ -1,24 +0,0 @@
-type SMSClientConfigMode = "BASE" | "FAULT_TOLERANT";
-
-type RetryOptions = {};
-
-type CircuitBreakerOptions = {};
-
-type BatchingOptions = {};
-
-type QueueOptions = {};
-
-export default class SMSClientConfig {
-  constructor(
-    public baseUrl: string,
-    public apiKey: string,
-    public mode: SMSClientConfigMode,
-    public timeout: number,
-    public retryOptions: RetryOptions,
-    public circuitBreakerOptions: CircuitBreakerOptions,
-    public batchingOptions: BatchingOptions,
-    public queueOptions: QueueOptions,
-  ) {}
-}
-
-export type Result = [string, Error | null];

package/src/help.ts

@@ -1,3 +0,0 @@
-export function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}