@zyratalk1/zyra-twilio-wrapper 1.2.0

package/types/interface.ts

@@ -0,0 +1,322 @@
+import type { AxiosInstance } from "axios";
+
+export interface Config {
+  serverUrl: string,
+  identity: string,
+  waitUrl ?: string,
+  sdkToken: string,
+  accessToken?: string,
+  requestTimeoutMs?: number,
+  retry?: {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterRatio?: number;
+    circuitBreakerThreshold?: number;
+    circuitBreakerCooldownMs?: number;
+  }
+}
+
+export interface TwilioConferenceParticipant {
+accountSid: string;
+callSid: string;
+callSidToCoach: string | null;
+coaching: boolean;
+conferenceSid: string;
+dateCreated: string; // ISO 8601 date string
+dateUpdated: string; // ISO 8601 date string
+endConferenceOnExit: boolean;
+hold: boolean;
+label: string | null;
+muted: boolean;
+queueTime: string | null; // Twilio may return seconds as a string or null
+startConferenceOnEnter: boolean;
+status: 'queued' | 'ringing' | 'in-progress' | 'connected' | 'completed' | string;
+uri: string;
+}
+
+export interface TwilioConference {
+conferenceSid: string; // Your own wrapper ID
+conferences: TwilioConferenceDetails;
+}
+
+export interface TwilioConferenceDetails {
+accountSid: string;
+apiVersion: string;
+callSidEndingConference: string | null;
+dateCreated: string; // ISO 8601 date
+dateUpdated: string; // ISO 8601 date
+friendlyName: string;
+reasonConferenceEnded: string | null;
+region: string;
+sid: string; // Conference SID (same as conferenceSid)
+status: 'init' | 'in-progress' | 'completed' | 'terminated' | string;
+subresourceUris: {
+  participants: string;
+  recordings: string;
+  [key: string]: string;
+};
+uri: string;
+}
+
+export interface TokenRequestPayload {
+identity: string;
+ttl: number;
+incomingAllow: boolean;
+}
+
+export interface TokenResponse {
+result: {
+  data: {
+    token: string;
+  };
+};
+}
+
+export interface CallResult {
+message: string;
+status: boolean;
+}
+
+export interface HoldCallPayload {
+callSid: string;
+conferenceName: string;
+waitUrl: string;
+}
+
+export interface ResumeCallPayload {
+callSid: string;
+conferenceName: string;
+}
+
+
+export interface MergeCallPayload {
+callSid: string;
+conferenceName: string;
+}
+
+export interface HoldPayload {
+callSid: string;
+conferenceName: string;
+waitUrl: string;
+}
+
+export interface AddParticipantPayload {
+conferenceName: string;
+newParticipantNo: string;
+}
+
+export interface AddParticipantPayloadIncoming {
+callSid: string;
+newParticipantNo: string;
+}
+export interface HoldAndAddResult extends CallResult {
+holdResponse?: any;
+addParticipantResponse?: any;
+}
+
+export interface GetConferencePayload {
+conferenceName: string;
+}
+
+export interface GetConferenceResult extends CallResult {
+conferenceDetail?: TwilioConference;
+}
+
+export interface GetParticipantsPayload {
+conferenceSid: string;
+}
+
+export interface GetParticipantsResult extends CallResult {
+participants?: TwilioConferenceParticipant[];
+}
+
+export interface RemoveParticipantPayload {
+conferenceSid: string;
+callSid: string;
+}
+
+export interface RemoveParticipantResult extends CallResult {
+// Optionally, you can include server response data
+data?: any;
+}
+
+export interface RegisterWebhookPayload {
+webhookUrl: string;
+}
+
+export interface DeregisterWebhookPayload {
+// No body required; API deregisters based on sdkToken/tenant context.
+}
+
+export interface WebhookConfigResult {
+configured: boolean;
+webhookUrl: string | null;
+}
+
+export type CallResponse<T = void> =
+| { success: true; message: string; data: T }
+| { success: false; error: Error };
+
+
+
+/**
+ * Dependencies (same pattern as webhook)
+ */
+export interface WelcomeConfigDeps {
+    axiosInstance: AxiosInstance;
+    serverUrl: string;
+    sdkToken: string;
+    ensureAuthenticated: () => void;
+}
+
+/**
+ * Input types
+ */
+export type WelcomeType = "audio" | "tts";
+
+export interface UpsertWelcomeConfigInput {
+    welcomeType: WelcomeType;
+    welcomeMessage: string;
+}
+
+/**
+ * Output type (matches backend output)
+ */
+export interface WelcomeConfigResult {
+    success: boolean;
+    message: string;
+    welcomeType: WelcomeType;
+    routingConfigId: number;
+}
+
+/**
+ * Routing Config
+ */
+
+export type RoutingStrategy = "RING_ALL" | "RING_SEQUENCE";
+
+export type FallbackActionType = "TRANSFER" | "AI" | "VOICEMAIL";
+
+export interface FallbackAction {
+  type: FallbackActionType;
+  target: {
+    phoneNumber: string;
+  } | null;
+}
+export interface RoutingMember {
+  id: number;
+  priorityOrder: number;
+  isEnabled: boolean;
+  userType: "PHONE" | "DESKTOP";
+  identifier: string | null;
+  email: string | null;
+  phoneNumber: string | null;
+  ringDuration: number | null;
+}
+
+
+export interface GetRoutingConfigResult {
+  strategy: RoutingStrategy;
+  defaultRingTimeout: number | null;
+  maxAttempts: number | null;
+  fallbackAction: FallbackAction;
+  members: RoutingMember[];
+}
+
+export interface SetRoutingMember {
+  priorityOrder: number;
+  enabled: boolean;
+  userType: "PHONE" | "DESKTOP";
+  identifier: string;
+  ringDuration: number;
+  contact: {
+    email: string | null;
+    phoneNumber: string | null;
+  };
+}
+
+export interface SetRoutingConfigInput {
+  strategy: {
+    type: RoutingStrategy;
+    defaultRingTimeout?: number;
+    maxAttempts?: number;
+  };
+  routingMembers: SetRoutingMember[];
+  fallbackAction: FallbackAction;
+}
+
+
+export interface SetRoutingConfigResult {
+    success: boolean;
+    message: string;
+    strategy: RoutingStrategy;
+    memberCount: number;
+}
+
+export interface RoutingConfigDeps {
+    axiosInstance: any;
+    serverUrl: string;
+    sdkToken: string;
+    ensureAuthenticated: () => void;
+}
+
+
+// Parse Rules 
+export interface ParseRuleDeps {
+  axiosInstance: any;
+  serverUrl: string;
+  sdkToken: string;
+  ensureAuthenticated: () => void;
+}
+
+export interface CreateParseRuleEntry {
+  dataType: "rule" | "parseData";
+  fieldName: string;
+  parseOptions?: unknown;
+  parseOptionCode?: unknown;
+  fieldRules?: unknown;
+}
+
+export interface ParseRuleRow {
+  id: number;
+  userId: number;
+  dataType: string | string[];
+  fieldName: string[];
+  fieldRules: string | null;
+  fieldRulesParsed: Record<string, any> | null;
+  parseOptions?: string | null;
+  parseOptionCode?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+export interface ListParseRulesInput {
+  page?: number;
+  limit?: number;
+  dataType?: "rule" | "parseData";
+  activeOnly?: boolean;
+}
+
+export interface ListParseRulesResult {
+  data: ParseRuleRow[];
+  total: number;
+  page: number;
+  limit: number;
+}
+
+export interface CreateParseRuleInput {
+  parseDataEntries: CreateParseRuleEntry[];
+}
+
+export interface CreateParseRuleResult {
+  id: number;
+  userId: number;
+  dataType: string;
+  fieldName: string[];
+  fieldRules: string | null;
+  fieldRulesParsed?: Record<string, unknown> | null;
+  parseOptions?: string | null;
+  parseOptionCode?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}

package/utils/errorHandler.ts

@@ -0,0 +1,37 @@
+import axios, { AxiosError } from "axios";
+
+/**
+ * Handles errors from Axios requests in a consistent way.
+ * 
+ * @param error - The error thrown by Axios or any other source.
+ * @param onErrorCallback - Optional callback to handle the error externally.
+ * @param contextMessage - Optional custom message to provide context for the error.
+ */
+export function handleAxiosError(
+  error: unknown,
+  onErrorCallback?: (error: Error) => void,
+  contextMessage = "Request failed"
+): void {
+  let finalError: Error;
+
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError;
+    const status = axiosError.response?.status ?? "Unknown";
+    const statusText = axiosError.response?.statusText ?? "No status text";
+    const responseData = axiosError.response?.data
+      ? JSON.stringify(axiosError.response.data)
+      : "No response data";
+
+    finalError = new Error(
+      `[AxiosError] ${contextMessage}: ${status} ${statusText} | Response: ${responseData}`
+    );
+  } else if (error instanceof Error) {
+    finalError = new Error(`[Error] ${contextMessage}: ${error.message}`);
+  } else {
+    finalError = new Error(`[Unknown Error] ${contextMessage}: ${String(error)}`);
+  }
+
+  console.error(finalError); // Optional: log for debugging
+  onErrorCallback?.(finalError);
+}
+

package/utils/helper.ts

@@ -0,0 +1,20 @@
+// src/utils/helper.ts
+
+import type { CallResponse } from "../types/interface"; // adjust path if needed
+
+/**
+ * Helper to create success result
+ */
+export function createSuccessResult<T>(message: string, data: T): CallResponse<T> {
+  return { success : true, message : message, data };
+}
+
+/**
+ * Helper to create error result
+ */
+export function createErrorResult<T = void>(error: Error | string): CallResponse<T> {
+  return {
+    success: false,
+    error: error instanceof Error ? error : new Error(error),
+  };
+}