@titus-system/syncdesk 0.5.0 → 0.5.2

package/.github/workflows/notify-main.yml

@@ -1,17 +0,0 @@
-name: Notify Main Repo
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Repository Dispatch
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.PAT_TOKEN }}
-          repository: Titus-System/SyncDesk
-          event-type: submodule_update

package/CHANGELOG.md

@@ -1,29 +0,0 @@
-# CHANGELOG
-
-All notable changes to this project will be documented in this file.
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-### Added
-
-### Changed
-
-### Deprecated
-
-### Removed
-
-### Fixed
-
-### Security
-
-### Dev Notes
-
----
-
-# 0.5.0 - 2026-04-04
-
-### Added
-
-- Get a specific client's conversations.

package/src/api/client.ts

@@ -1,135 +0,0 @@
-import axios, { InternalAxiosRequestConfig } from "axios";
-import { config, LibraryConfig } from "../config";
-
-export const apiClient = axios.create();
-
-/**
- * Configure the library with user-provided settings.
- */
-export const configureLibrary = (userConfig: LibraryConfig) => {
-  // Overwrite the default internal config with the user's settings
-  Object.assign(config, userConfig);
-
-  apiClient.defaults.baseURL = config.baseURL;
-  apiClient.defaults.timeout = config.timeout;
-};
-
-// INTERCEPTORS
-
-/**
- * Request Interceptor.
- * Automatically adds the access token to the Authorization header of every request if it's available.
- */
-apiClient.interceptors.request.use(
-  async (reqConfig) => {
-    const token = await config.getAccessToken();
-    if (token && reqConfig.headers) {
-      reqConfig.headers.Authorization = `Bearer ${token}`;
-    }
-    return reqConfig;
-  },
-  (error) => Promise.reject(error),
-);
-
-/**
- * Response Interceptor.
- */
-let isRefreshing = false; // Flag to prevent multiple simultaneous refresh attempts
-let failedQueue: Array<{
-  // Queue to hold requests that come in while we're refreshing tokens
-  resolve: (token: string) => void;
-  reject: (error: any) => void;
-}> = [];
-/** Processes the queue of failed requests after token refresh. */
-const processQueue = (error: any, token: string | null = null) => {
-  failedQueue.forEach((promise) => {
-    if (error) {
-      promise.reject(error);
-    } else {
-      promise.resolve(token as string);
-    }
-  });
-  failedQueue = [];
-};
-
-/**
- * This interceptor watches for 401 responses. If it sees one, it tries to get a new access token using
- * the refresh token.
- *
- * Meanwhile, it queues up any new requests that also fail with 401, and once it gets a new token,
- * it retries all the failed requests with the new token. If the refresh token is also expired/invalid,
- * it calls the onUnauthorized callback to let the app know they need to log in again.
- */
-apiClient.interceptors.response.use(
-  (response) => response, // success
-  async (error) => {
-    const originalRequest = error.config as InternalAxiosRequestConfig & {
-      _retry?: boolean;
-    };
-
-    // if 401 and not retried
-    if (error.response?.status === 401 && !originalRequest._retry) {
-      if (
-        originalRequest.url?.includes("/refresh") ||
-        originalRequest.url?.includes("/login")
-      ) {
-        config.onUnauthorized();
-        return Promise.reject(error);
-      }
-
-      // If another request is currently refreshing the token, pause this request and add to queue
-      if (isRefreshing) {
-        return (
-          new Promise((resolve, reject) => {
-            failedQueue.push({ resolve, reject });
-          })
-            .then((token) => {
-              // on success, add the new token to the request header and return the client
-              originalRequest.headers.Authorization = `Bearer ${token}`;
-              return apiClient(originalRequest);
-            })
-            // on error, reject the request
-            .catch((err) => Promise.reject(err))
-        );
-      }
-
-      // Mark that we are starting the refresh process
-      originalRequest._retry = true;
-      isRefreshing = true;
-
-      try {
-        const refreshToken = await config.getRefreshToken();
-
-        if (!refreshToken) {
-          throw new Error("No refresh token available.");
-        }
-
-        // Do a standard axios call to get the new token, so the interceptors are not called again.
-        const refreshResponse = await axios.post(`${config.baseURL}/refresh`, {
-          refresh_token: refreshToken,
-        });
-
-        const newAccessToken = refreshResponse.data.data.access_token;
-        const newRefreshToken = refreshResponse.data.data.refresh_token;
-
-        await config.onTokensRefreshed(newAccessToken, newRefreshToken);
-
-        // Resume all the other paused requests with the new token
-        processQueue(null, newAccessToken);
-
-        // Retry the original request that failed
-        originalRequest.headers.Authorization = `Bearer ${newAccessToken}`;
-        return apiClient(originalRequest);
-      } catch (refreshError) {
-        // If the refresh token is completely expired, kill the queue and log them out
-        processQueue(refreshError, null);
-        config.onUnauthorized();
-        return Promise.reject(refreshError);
-      } finally {
-        isRefreshing = false;
-      }
-    }
-
-    return Promise.reject(error);
-  },
-);

package/src/api/typings.ts

@@ -1,3 +0,0 @@
-export interface ApiResponse<T> {
-  data: T;
-}

package/src/auth/hooks/useAuth.ts

@@ -1,173 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiClient, ApiResponse } from "../../api";
-import {
-  AdminRegisterUserRequest,
-  ChangePasswordRequest,
-  ForgotPasswordRequest,
-  ForgotPasswordResponse,
-  LoginResponse,
-  RegisterUserRequest,
-  ResetPasswordRequest,
-  UserCreatedResponse,
-  UserLoginRequest,
-  UserWithRoles,
-} from "../types/auth";
-import { User } from "../../users/types/user";
-
-const PATH = "auth";
-
-/**
- * Get the currently authenticated user's profile.
- * @returns {UseQueryResult<UserWithRoles, Error>} The query result.
- */
-export const useGetMe = () => {
-  return useQuery({
-    queryKey: ["me"],
-    queryFn: async (): Promise<UserWithRoles> => {
-      const response = await apiClient.get<ApiResponse<UserWithRoles>>(
-        `${PATH}/me`,
-      );
-
-      return response.data.data;
-    },
-    // if the user isn't logged in (401)
-    retry: false,
-  });
-};
-
-/**
- * Log in a user.
- *
- * Refresh tokens are handled automatically using Interceptors.
- * @param {UserLoginRequest} credentials The user login credentials.
- * @returns {UseMutationResult<LoginResponse, Error, UserLoginRequest>} The mutation result.
- */
-export const useLogin = () => {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (
-      credentials: UserLoginRequest,
-    ): Promise<LoginResponse> => {
-      const response = await apiClient.post<ApiResponse<LoginResponse>>(
-        `${PATH}/login`,
-        credentials,
-      );
-      return response.data.data;
-    },
-    onSuccess: () => {
-      // After a successful login, fetch the new user's profile
-      queryClient.invalidateQueries({ queryKey: ["me"] });
-    },
-  });
-};
-
-/**
- * Register a new user.
- * @param {RegisterUserRequest} userData The user registration details.
- * @returns {UseMutationResult<UserCreatedResponse, Error, RegisterUserRequest>} The mutation result.
- */
-export const useRegister = () => {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (
-      userData: RegisterUserRequest,
-    ): Promise<UserCreatedResponse> => {
-      const response = await apiClient.post<ApiResponse<UserCreatedResponse>>(
-        `${PATH}/register`,
-        userData,
-      );
-      return response.data.data;
-    },
-    onSuccess: () => {
-      // Registration also logs them in (returns tokens), so fetch their profile
-      queryClient.invalidateQueries({ queryKey: ["me"] });
-    },
-  });
-};
-
-/**
- * Log out the current user.
- * @returns {UseMutationResult<void, Error, void>} The mutation result.
- */
-export const useLogout = () => {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (): Promise<void> => {
-      await apiClient.post(`${PATH}/logout`);
-    },
-    onSuccess: () => {
-      // clear cache
-      queryClient.setQueryData(["me"], null);
-      queryClient.clear();
-    },
-  });
-};
-
-/**
- * Register a new user as admin.
- * @param {AdminRegisterUserRequest} userData The admin user registration details.
- * @returns {UseMutationResult<User, Error, AdminRegisterUserRequest>} The mutation result.
- */
-export const useAdminRegister = () => {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (userData: AdminRegisterUserRequest): Promise<User> => {
-      const response = await apiClient.post<ApiResponse<User>>(
-        `${PATH}/admin/register`,
-        userData,
-      );
-      return response.data.data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["users"] });
-    },
-  });
-};
-
-/**
- * Change the current user's password.
- * @param {ChangePasswordRequest} data The password change request details.
- * @returns {UseMutationResult<void, Error, ChangePasswordRequest>} The mutation result.
- */
-export const useChangePassword = () => {
-  return useMutation({
-    mutationFn: async (data: ChangePasswordRequest): Promise<void> => {
-      await apiClient.post(`${PATH}/change-password`, data);
-    },
-  });
-};
-
-/**
- * Request a password reset.
- * @param {ForgotPasswordRequest} data The forgot password request details.
- * @returns {UseMutationResult<ForgotPasswordResponse, Error, ForgotPasswordRequest>} The mutation result.
- */
-export const useForgotPassword = () => {
-  return useMutation({
-    mutationFn: async (
-      data: ForgotPasswordRequest,
-    ): Promise<ForgotPasswordResponse> => {
-      const response = await apiClient.post<
-        ApiResponse<ForgotPasswordResponse>
-      >(`${PATH}/forgot-password`, data);
-      return response.data.data;
-    },
-  });
-};
-
-/**
- * Reset the current user's password using a valid reset token.
- * @param {ResetPasswordRequest} data The reset password request details.
- * @returns {UseMutationResult<void, Error, ResetPasswordRequest>} The mutation result.
- */
-export const useResetPassword = () => {
-  return useMutation({
-    mutationFn: async (data: ResetPasswordRequest): Promise<void> => {
-      await apiClient.post(`${PATH}/reset-password`, data);
-    },
-  });
-};

package/src/auth/index.ts

@@ -1,12 +0,0 @@
-export { useGetMe, useLogin, useRegister, useLogout } from "./hooks/useAuth";
-
-export type {
-  OAuthProvider,
-  LoginResponse,
-  UserCreatedResponse,
-  UserLoginRequest,
-  RegisterUserRequest,
-  UserWithRoles,
-} from "./types/auth";
-
-export type { Status, Session } from "./types/session";

package/src/auth/types/auth.ts

@@ -1,61 +0,0 @@
-export type OAuthProvider = "local" | "google" | "microsoft";
-
-export interface LoginResponse {
-  access_token: string;
-  refresh_token: string;
-  must_change_password?: boolean;
-  must_accept_terms?: boolean;
-}
-
-export interface UserCreatedResponse {
-  id: string;
-  email: string;
-  username: string;
-  access_token: string;
-  refresh_token: string;
-}
-
-export interface UserLoginRequest {
-  email: string;
-  password: string;
-}
-
-export interface RegisterUserRequest {
-  email: string;
-  name?: string;
-  username?: string;
-  password: string;
-}
-
-export interface AdminRegisterUserRequest {
-  email: string;
-  name?: string | null;
-  role_ids?: number[];
-}
-
-export interface ChangePasswordRequest {
-  current_password: string;
-  new_password: string;
-}
-
-export interface ForgotPasswordRequest {
-  email: string;
-}
-
-export interface ResetPasswordRequest {
-  token: string;
-  new_password: string;
-}
-
-export interface ForgotPasswordResponse {
-  message: string;
-}
-
-// I am making a safe assumption for your /me route based on "user_with_roles"
-export interface UserWithRoles {
-  id: string;
-  email: string;
-  username: string;
-  name?: string | null;
-  roles: string[];
-}

package/src/auth/types/session.ts

@@ -1,12 +0,0 @@
-export type Status = "active" | "expired" | "invalid" | "revoked";
-
-export interface Session {
-  id: string;
-  user_id: string;
-  refresh_token_hash: string;
-  status: Status;
-  device_info: Record<string, unknown>;
-  expires_at: Date | string;
-  last_used_at: Date | string;
-  revoked_at: Date | string;
-}

package/src/config.ts

@@ -1,31 +0,0 @@
-export interface LibraryConfig {
-  /** API URL */
-  baseURL: string;
-  timeout?: number;
-
-  /* Get current access token */
-  getAccessToken: () => string | null | Promise<string | null>;
-
-  /** Get the refresh token when it needs a new one */
-  getRefreshToken: () => string | null | Promise<string | null>;
-
-  /** Callback fired when the library successfully gets new tokens from the backend */
-  onTokensRefreshed: (
-    accessToken: string,
-    refreshToken: string,
-  ) => void | Promise<void>;
-
-  /** Fired if the user is not authenticated and refresh token fails. */
-  onUnauthorized: () => void;
-}
-
-export const config: Required<LibraryConfig> = {
-  baseURL: "",
-  timeout: 10000,
-  getAccessToken: () => null,
-  getRefreshToken: () => null,
-  onTokensRefreshed: () => {},
-  onUnauthorized: () => {
-    console.warn("Unauthorized error caught. No handler provided.");
-  },
-};

package/src/health/hooks/useHealth.ts

@@ -1,57 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { apiClient, ApiResponse } from "../../api";
-import type {
-  PingResponse,
-  HealthResponse,
-  ReadyResponse,
-} from "../types/health";
-
-const PATH = "";
-
-/**
- * Ping the server to check for basic connectivity.
- * @returns {UseQueryResult<PingResponse, Error>} The result.
- */
-export const usePing = () => {
-  return useQuery({
-    queryKey: ["health", "ping"],
-    queryFn: async (): Promise<PingResponse> => {
-      const response = await apiClient.get<ApiResponse<PingResponse>>(
-        `${PATH}/ping`,
-      );
-      return response.data.data;
-    },
-  });
-};
-
-/**
- * Check the detailed health of the server and its dependencies (e.g. databases).
- * @returns {UseQueryResult<HealthResponse, Error>} The result.
- */
-export const useHealth = () => {
-  return useQuery({
-    queryKey: ["health", "status"],
-    queryFn: async (): Promise<HealthResponse> => {
-      const response = await apiClient.get<ApiResponse<HealthResponse>>(
-        `${PATH}/health`,
-      );
-      return response.data.data;
-    },
-  });
-};
-
-/**
- * Check if the server is ready to accept traffic.
- * @returns {UseQueryResult<ReadyResponse, Error>} The result.
- */
-export const useReady = () => {
-  return useQuery({
-    queryKey: ["health", "ready"],
-    queryFn: async (): Promise<ReadyResponse> => {
-      const response = await apiClient.get<ApiResponse<ReadyResponse>>(
-        `${PATH}/ready`,
-      );
-      return response.data.data;
-    },
-  });
-};

package/src/health/types/health.ts

@@ -1,10 +0,0 @@
-export interface PingResponse {
-  message: string;
-}
-
-export interface HealthResponse {
-  postgres_status: "connected" | "degraded";
-  mongo_status: "connected" | "degraded";
-}
-
-export interface ReadyResponse {}

package/src/live_chat/hooks/useLiveChat.ts

@@ -1,124 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiClient, ApiResponse } from "../../api";
-import {
-  Conversation,
-  CreateConversationDTO,
-  PaginatedMessages,
-} from "../types/live_chat";
-
-const PATH = "/conversations";
-
-/**
- * Get all conversations of a ticket.
- * @param {string} ticket_id ticket_id parameter.
- * @returns {UseQueryResult<Conversation[]>} The query result.
- */
-export const useGetConversations = (ticket_id: string) => {
-  return useQuery({
-    queryKey: ["conversations", "ticket", ticket_id],
-    queryFn: async (): Promise<Conversation[]> => {
-      const response = await apiClient.get<ApiResponse<Conversation[]>>(
-        `${PATH}/ticket/${ticket_id}`,
-      );
-      return response.data.data;
-    },
-    enabled: !!ticket_id,
-  });
-};
-
-/**
- * Get a specific client's conversations.
- * @param {string} client_id client_id parameter.
- * @returns {UseQueryResult<Conversation[]>} The query result.
- */
-export const useGetClientConversations = (client_id: string) => {
-  return useQuery({
-    queryKey: ["conversations", "client", client_id],
-    queryFn: async (): Promise<Conversation[]> => {
-      const response = await apiClient.get<ApiResponse<Conversation[]>>(
-        `${PATH}/client/${client_id}`,
-      );
-      return response.data.data;
-    },
-    enabled: !!client_id,
-  });
-};
-
-/**
- * Get ticket messages with pagination.
- * @param {string} ticket_id ticket_id parameter.
- * @param {number} page page parameter.
- * @param {number} limit limit parameter.
- * @returns {UseQueryResult<PaginatedMessages>} The query result.
- */
-export const useGetPaginatedMessages = (
-  ticket_id: string,
-  page = 1,
-  limit = 10,
-) => {
-  return useQuery({
-    queryKey: [
-      "conversations",
-      "ticket",
-      ticket_id,
-      "messages",
-      { page, limit },
-    ],
-    queryFn: async (): Promise<PaginatedMessages> => {
-      const response = await apiClient.get<ApiResponse<PaginatedMessages>>(
-        `${PATH}/ticket/${ticket_id}/messages`,
-        { params: { page, limit } },
-      );
-      return response.data.data;
-    },
-    enabled: !!ticket_id,
-  });
-};
-
-/**
- * Create a new conversation.
- * @param {CreateConversationDTO} dto The conversation creation details.
- * @returns {UseMutationResult<Conversation, Error, CreateConversationDTO>} The mutation result.
- */
-export const useCreateConversation = () => {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (dto: CreateConversationDTO): Promise<Conversation> => {
-      const response = await apiClient.post<ApiResponse<Conversation>>(
-        PATH,
-        dto,
-      );
-      return response.data.data;
-    },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({
-        queryKey: ["conversations", "ticket", variables.ticket_id],
-      });
-    },
-  });
-};
-
-/**
- * Assign an agent to a conversation.
- * @param {{ chat_id: string; agent_id: string }} params The chat ID and agent ID payload.
- * @returns {UseMutationResult<void, Error, { chat_id: string; agent_id: string }>} The mutation result.
- */
-export const useSetConversationAgent = () => {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      chat_id,
-      agent_id,
-    }: {
-      chat_id: string;
-      agent_id: string;
-    }): Promise<void> => {
-      await apiClient.patch(`${PATH}/${chat_id}/set-agent/${agent_id}`);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["conversations"] });
-    },
-  });
-};