bridgex 1.0.0

package/dist/HttpClient.d.ts

@@ -0,0 +1,12 @@
+interface HttpClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    projectKey: string;
+    timeout?: number;
+}
+export default class HttpClient {
+    private options;
+    constructor(options: HttpClientOptions);
+    post(endpoint: string, body: unknown): Promise<any>;
+}
+export {};

package/dist/HttpClient.js

@@ -0,0 +1,38 @@
+import { NetworkError, ServerError } from "./errors.js";
+export default class HttpClient {
+    constructor(options) {
+        this.options = options;
+    }
+    async post(endpoint, body) {
+        const { baseUrl, apiKey, projectKey, timeout = 5000 } = this.options;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(`${baseUrl}${endpoint}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "x-project-key": projectKey,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const text = await response.text();
+                throw new ServerError(`Server responded with ${response.status}`, text);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new NetworkError("Request timed out");
+            }
+            if (error instanceof ServerError) {
+                throw error;
+            }
+            throw new NetworkError("Network request failed", error);
+        }
+    }
+}

package/dist/MessageFormatter.d.ts

@@ -0,0 +1,4 @@
+export default class MessageFormatter {
+    format(template: string, params?: Record<string, unknown>): string;
+    fromObject(obj: Record<string, unknown>): string;
+}

package/dist/MessageFormatter.js

@@ -0,0 +1,21 @@
+import { TemplateError, ValidationError } from "./errors.js";
+import { isObject } from "./help.js";
+export default class MessageFormatter {
+    format(template, params = {}) {
+        if (typeof template !== "string" || template.trim() === "") {
+            throw new ValidationError("Message template must be a non-empty string");
+        }
+        return template.replace(/\{(\w+)\}/g, (_, key) => {
+            if (!(key in params)) {
+                throw new TemplateError(`Missing template variable: ${key}`);
+            }
+            return String(params[key]);
+        });
+    }
+    fromObject(obj) {
+        if (!isObject(obj)) {
+            throw new ValidationError("Message object must be a valid object");
+        }
+        return JSON.stringify(obj);
+    }
+}

package/dist/RetryHandler.d.ts

@@ -0,0 +1,10 @@
+export interface RetryOptions {
+    maxAttempts?: number;
+    delay?: number;
+    strategy?: "fixed" | "exponential";
+}
+export default class RetryHandler {
+    private options;
+    constructor(options?: RetryOptions);
+    execute<T>(operation: () => Promise<T>): Promise<T>;
+}

package/dist/RetryHandler.js

@@ -0,0 +1,24 @@
+import { setTimeout } from "node:timers/promises";
+export default class RetryHandler {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async execute(operation) {
+        const { maxAttempts = 3, delay = 500, strategy = "fixed" } = this.options;
+        let attempt = 0;
+        while (attempt < maxAttempts) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                attempt++;
+                if (attempt >= maxAttempts) {
+                    throw error;
+                }
+                const waitTime = strategy === "exponential" ? delay * 2 ** (attempt - 1) : delay;
+                await setTimeout(waitTime);
+            }
+        }
+        throw new Error("Retry failed unexpectedly");
+    }
+}

package/dist/client/SMSManager.d.ts

@@ -0,0 +1,21 @@
+import { type RetryOptions } from "../RetryHandler.js";
+interface SMSClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    projectKey: string;
+    retry?: RetryOptions;
+}
+export declare class SMSClient {
+    private options;
+    private http;
+    private retry;
+    private formatter;
+    constructor(options: SMSClientOptions);
+    private validateOptions;
+    send(params: {
+        to: string;
+        template: string;
+        variables?: Record<string, unknown>;
+    }): Promise<any>;
+}
+export {};

package/dist/client/SMSManager.js

@@ -0,0 +1,41 @@
+import HttpClient from "../HttpClient.js";
+import RetryHandler from "../RetryHandler.js";
+import MessageFormatter from "../MessageFormatter.js";
+import { ValidationError } from "../errors.js";
+export class SMSClient {
+    constructor(options) {
+        this.options = options;
+        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();
+    }
+    validateOptions(options) {
+        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) {
+        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/dist/client/types.d.ts

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

package/dist/client/types.js

@@ -0,0 +1,12 @@
+export default class SMSClientConfig {
+    constructor(baseUrl, apiKey, mode, timeout, retryOptions, circuitBreakerOptions, batchingOptions, queueOptions) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.mode = mode;
+        this.timeout = timeout;
+        this.retryOptions = retryOptions;
+        this.circuitBreakerOptions = circuitBreakerOptions;
+        this.batchingOptions = batchingOptions;
+        this.queueOptions = queueOptions;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+declare class SMSClientError extends Error {
+    code: string;
+    details?: unknown;
+    constructor(message: string, code: string, details?: unknown);
+}
+export declare class ServerError extends SMSClientError {
+    constructor(message: string, details?: unknown);
+}
+export declare class ValidationError extends SMSClientError {
+    constructor(message: string, details?: unknown);
+}
+export declare class TemplateError extends SMSClientError {
+    constructor(message: string, details?: unknown);
+}
+export declare class NetworkError extends SMSClientError {
+    constructor(message: string, details?: unknown);
+}
+export {};

package/dist/errors.js

@@ -0,0 +1,29 @@
+class SMSClientError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.details = details;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class ServerError extends SMSClientError {
+    constructor(message, details) {
+        super(message, "SERVER_ERROR", details);
+    }
+}
+export class ValidationError extends SMSClientError {
+    constructor(message, details) {
+        super(message, "VALIDATION_ERROR", details);
+    }
+}
+export class TemplateError extends SMSClientError {
+    constructor(message, details) {
+        super(message, "TEMPLATE_ERROR", details);
+    }
+}
+export class NetworkError extends SMSClientError {
+    constructor(message, details) {
+        super(message, "NETWORK_ERROR", details);
+    }
+}

package/dist/help.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: unknown): value is Record<string, unknown>;

package/dist/help.js

@@ -0,0 +1,3 @@
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export { SMSClient } from "./client/SMSManager.js";

package/dist/main.js

@@ -0,0 +1 @@
+export { SMSClient } from "./client/SMSManager.js";

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "bridgex",
+  "version": "1.0.0",
+  "description": "a library for mazz app or a bridge for messaging that allow and automate the use of our service",
+  "keywords": [
+    "messaging",
+    "sms"
+  ],
+  "license": "ISC",
+  "author": "MouadhBNB7741",
+  "type": "module",
+  "main": "main.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/HttpClient.ts

@@ -0,0 +1,51 @@
+import { NetworkError, ServerError } from "./errors.js";
+
+interface HttpClientOptions {
+  baseUrl: string;
+  apiKey: string;
+  projectKey: string;
+  timeout?: number;
+}
+
+export default class HttpClient {
+  constructor(private options: HttpClientOptions) {}
+
+  async post(endpoint: string, body: unknown): Promise<any> {
+    const { baseUrl, apiKey, projectKey, timeout = 5000 } = this.options;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(`${baseUrl}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "x-project-key": projectKey,
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const text = await response.text();
+        throw new ServerError(`Server responded with ${response.status}`, text);
+      }
+
+      return await response.json();
+    } catch (error: any) {
+      if (error.name === "AbortError") {
+        throw new NetworkError("Request timed out");
+      }
+
+      if (error instanceof ServerError) {
+        throw error;
+      }
+
+      throw new NetworkError("Network request failed", error);
+    }
+  }
+}

package/src/MessageFormatter.ts

@@ -0,0 +1,26 @@
+import { TemplateError, ValidationError } from "./errors.js";
+import { isObject } from "./help.js";
+
+export default class MessageFormatter {
+  format(template: string, params: Record<string, unknown> = {}): string {
+    if (typeof template !== "string" || template.trim() === "") {
+      throw new ValidationError("Message template must be a non-empty string");
+    }
+
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+      if (!(key in params)) {
+        throw new TemplateError(`Missing template variable: ${key}`);
+      }
+
+      return String(params[key]);
+    });
+  }
+
+  fromObject(obj: Record<string, unknown>): string {
+    if (!isObject(obj)) {
+      throw new ValidationError("Message object must be a valid object");
+    }
+
+    return JSON.stringify(obj);
+  }
+}

package/src/RetryHandler.ts

@@ -0,0 +1,36 @@
+import { setTimeout } from "node:timers/promises";
+
+export interface RetryOptions {
+  maxAttempts?: number;
+  delay?: number;
+  strategy?: "fixed" | "exponential";
+}
+
+export default class RetryHandler {
+  constructor(private options: RetryOptions = {}) {}
+
+  async execute<T>(operation: () => Promise<T>): Promise<T> {
+    const { maxAttempts = 3, delay = 500, strategy = "fixed" } = this.options;
+
+    let attempt = 0;
+
+    while (attempt < maxAttempts) {
+      try {
+        return await operation();
+      } catch (error) {
+        attempt++;
+
+        if (attempt >= maxAttempts) {
+          throw error;
+        }
+
+        const waitTime =
+          strategy === "exponential" ? delay * 2 ** (attempt - 1) : delay;
+
+        await setTimeout(waitTime);
+      }
+    }
+
+    throw new Error("Retry failed unexpectedly");
+  }
+}

package/src/client/SMSManager.ts

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,24 @@
+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/errors.ts

@@ -0,0 +1,37 @@
+class SMSClientError extends Error {
+  public code: string;
+  public details?: unknown;
+
+  constructor(message: string, code: string, details?: unknown) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = details;
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class ServerError extends SMSClientError {
+  constructor(message: string, details?: unknown) {
+    super(message, "SERVER_ERROR", details);
+  }
+}
+
+export class ValidationError extends SMSClientError {
+  constructor(message: string, details?: unknown) {
+    super(message, "VALIDATION_ERROR", details);
+  }
+}
+
+export class TemplateError extends SMSClientError {
+  constructor(message: string, details?: unknown) {
+    super(message, "TEMPLATE_ERROR", details);
+  }
+}
+
+export class NetworkError extends SMSClientError {
+  constructor(message: string, details?: unknown) {
+    super(message, "NETWORK_ERROR", details);
+  }
+}

package/src/help.ts

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

package/src/main.ts

@@ -0,0 +1 @@
+export { SMSClient } from "./client/SMSManager.js";

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}