@titus-system/syncdesk 0.3.1

package/src/live_chat/hooks/useLiveChatWebSocket.ts

@@ -0,0 +1,86 @@
+import { useEffect, useState, useCallback } from "react";
+import useWebSocket, { ReadyState } from "react-use-websocket";
+import { config } from "../../config";
+import type { ChatMessage, SendMessagePayload } from "../types/live_chat";
+import type { ApiResponse } from "../../api";
+
+export function useLiveChatWebSocket(chatId: string | null | undefined) {
+  const [token, setToken] = useState<string | null>(null);
+
+  // We need the token resolved before connecting to WebSocket
+  useEffect(() => {
+    if (!chatId) return;
+
+    const fetchToken = async () => {
+      const t = await config.getAccessToken();
+      setToken(t);
+    };
+    fetchToken();
+  }, [chatId]);
+
+  // Construct WebSocket URL from the configured baseURL
+  const wsUrl = () => {
+    if (!config.baseURL || !chatId || !token) return null;
+    try {
+      const url = new URL(config.baseURL);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      url.pathname = `${url.pathname.replace(/\/$/, "")}/live_chat/room/${chatId}`;
+      return url.toString();
+    } catch {
+      // If baseURL is relative (e.g. "/api"), use window location
+      const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+      const host = window.location.host;
+      return `${protocol}//${host}${config.baseURL.replace(/\/$/, "")}/live_chat/room/${chatId}`;
+    }
+  };
+
+  const finalUrl = wsUrl();
+
+  const { sendMessage, lastJsonMessage, readyState } = useWebSocket<
+    ApiResponse<ChatMessage>
+  >(
+    finalUrl,
+    {
+      // Using token as a subprotocol to pass it due to WebSocket standard not allowing custom headers in browsers.
+      // E.g. Sec-WebSocket-Protocol: access_token, <token>
+      protocols: token ? ["access_token", token] : [],
+      shouldReconnect: (closeEvent) => {
+        // Do not reconnect on unauthorized or permission denied errors
+        if (
+          closeEvent.code === 1008 ||
+          closeEvent.code === 403 ||
+          closeEvent.code === 1011
+        )
+          return false;
+        return true;
+      },
+      reconnectAttempts: 10,
+      reconnectInterval: 3000,
+    },
+    // Only connect if we have a valid URL (meaning chat id and token exist)
+    !!finalUrl,
+  );
+
+  const connectionStatus = {
+    [ReadyState.CONNECTING]: "Connecting",
+    [ReadyState.OPEN]: "Open",
+    [ReadyState.CLOSING]: "Closing",
+    [ReadyState.CLOSED]: "Closed",
+    [ReadyState.UNINSTANTIATED]: "Uninstantiated",
+  }[readyState];
+
+  const sendPayload = useCallback(
+    (payload: SendMessagePayload) => {
+      sendMessage(JSON.stringify(payload));
+    },
+    [sendMessage],
+  );
+
+  return {
+    sendMessage: sendPayload,
+    lastMessage: lastJsonMessage?.data || null,
+    rawLastMessage: lastJsonMessage,
+    connectionStatus,
+    readyState,
+  };
+}

package/src/live_chat/index.ts

@@ -0,0 +1,15 @@
+export {
+  useGetConversations,
+  useGetPaginatedMessages,
+  useCreateConversation,
+  useSetConversationAgent,
+} from "./hooks/useLiveChat";
+
+export { useLiveChatWebSocket } from "./hooks/useLiveChatWebSocket";
+
+export type {
+  ChatMessage,
+  Conversation,
+  CreateConversationDTO,
+  PaginatedMessages,
+} from "./types/live_chat";

package/src/live_chat/types/live_chat.ts

@@ -0,0 +1,48 @@
+export interface SendMessagePayload {
+  type: "text" | "file";
+  content: string;
+  mime_type?: string | null;
+  filename?: string | null;
+  responding_to?: string | null;
+}
+
+export interface ChatMessage {
+  id: string;
+  conversation_id: string;
+  sender_id: string | "System";
+  timestamp: string;
+  type: "text" | "file";
+  content: string;
+  mime_type?: string | null;
+  filename?: string | null;
+  responding_to?: string | null;
+}
+
+export interface Conversation {
+  _id: string;
+  ticket_id: string;
+  agent_id?: string | null;
+  client_id: string;
+  sequential_index: number;
+  parent_id?: string | null;
+  children_ids: string[];
+  started_at: string;
+  finished_at?: string | null;
+  messages: ChatMessage[];
+}
+
+export interface CreateConversationDTO {
+  ticket_id: string;
+  agent_id?: string | null;
+  client_id: string;
+  sequential_index?: number;
+  parent_id?: string | null;
+}
+
+export interface PaginatedMessages {
+  messages: ChatMessage[];
+  total: number;
+  page: number;
+  limit: number;
+  has_next: boolean;
+}

package/src/permissions/hooks/usePermissions.ts

@@ -0,0 +1,141 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient } from "../../api";
+import type { ApiResponse } from "../../api";
+import type {
+  Permission,
+  CreatePermissionDTO,
+  ReplacePermissionDTO,
+  UpdatePermissionDTO,
+  AddPermissionRolesDTO,
+} from "../types/permission";
+
+export function usePermissions() {
+  return useQuery<Permission[]>({
+    queryKey: ["permissions"],
+    queryFn: async () => {
+      const response =
+        await apiClient.get<ApiResponse<Permission[]>>("/permissions/");
+      return response.data.data;
+    },
+  });
+}
+
+export function usePermission(id: number) {
+  return useQuery<Permission>({
+    queryKey: ["permissions", id],
+    queryFn: async () => {
+      const response = await apiClient.get<ApiResponse<Permission>>(
+        `/permissions/${id}`,
+      );
+      return response.data.data;
+    },
+    enabled: !!id,
+  });
+}
+
+export function useCreatePermission() {
+  const queryClient = useQueryClient();
+  return useMutation<Permission, Error, CreatePermissionDTO>({
+    mutationFn: async (dto) => {
+      const response = await apiClient.post<ApiResponse<Permission>>(
+        "/permissions/",
+        dto,
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["permissions"] });
+    },
+  });
+}
+
+export function useReplacePermission() {
+  const queryClient = useQueryClient();
+  return useMutation<
+    Permission,
+    Error,
+    { id: number; dto: ReplacePermissionDTO }
+  >({
+    mutationFn: async ({ id, dto }) => {
+      const response = await apiClient.put<ApiResponse<Permission>>(
+        `/permissions/${id}`,
+        dto,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ["permissions"] });
+      queryClient.invalidateQueries({ queryKey: ["permissions", id] });
+    },
+  });
+}
+
+export function useUpdatePermission() {
+  const queryClient = useQueryClient();
+  return useMutation<
+    Permission,
+    Error,
+    { id: number; dto: UpdatePermissionDTO }
+  >({
+    mutationFn: async ({ id, dto }) => {
+      const response = await apiClient.patch<ApiResponse<Permission>>(
+        `/permissions/${id}`,
+        dto,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ["permissions"] });
+      queryClient.invalidateQueries({ queryKey: ["permissions", id] });
+    },
+  });
+}
+
+export function useDeletePermission() {
+  const queryClient = useQueryClient();
+  return useMutation<Permission, Error, number>({
+    mutationFn: async (id) => {
+      const response = await apiClient.delete<ApiResponse<Permission>>(
+        `/permissions/${id}`,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: ["permissions"] });
+      queryClient.invalidateQueries({ queryKey: ["permissions", id] });
+    },
+  });
+}
+
+export function usePermissionRoles(id: number) {
+  return useQuery<Permission>({
+    queryKey: ["permissions", id, "roles"],
+    queryFn: async () => {
+      const response = await apiClient.get<ApiResponse<Permission>>(
+        `/permissions/${id}/roles`,
+      );
+      return response.data.data;
+    },
+    enabled: !!id,
+  });
+}
+
+export function useAddPermissionRoles() {
+  const queryClient = useQueryClient();
+  return useMutation<
+    Permission,
+    Error,
+    { id: number; dto: AddPermissionRolesDTO }
+  >({
+    mutationFn: async ({ id, dto }) => {
+      const response = await apiClient.post<ApiResponse<Permission>>(
+        `/permissions/${id}/roles`,
+        dto,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ["permissions", id, "roles"] });
+    },
+  });
+}

package/src/permissions/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./hooks/usePermissions";

package/src/permissions/types/index.ts

@@ -0,0 +1 @@
+export * from "./permission";

package/src/permissions/types/permission.ts

@@ -0,0 +1,27 @@
+import type { Role } from "../../roles/types/role";
+
+export interface Permission {
+  id: number;
+  name: string;
+  description?: string | null;
+  roles?: Role[];
+}
+
+export interface CreatePermissionDTO {
+  name: string;
+  description?: string | null;
+}
+
+export interface ReplacePermissionDTO {
+  name: string;
+  description?: string | null;
+}
+
+export interface UpdatePermissionDTO {
+  name?: string | null;
+  description?: string | null;
+}
+
+export interface AddPermissionRolesDTO {
+  ids: number[];
+}

package/src/roles/hooks/useRoles.ts

@@ -0,0 +1,103 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient, ApiResponse } from "../../api";
+import type { Role, CreateRoleDTO, ReplaceRoleDTO, UpdateRoleDTO, AddRolePermissionsDTO } from "../types/role";
+
+export function useRoles() {
+  return useQuery<Role[]>({
+    queryKey: ["roles"],
+    queryFn: async () => {
+      const response = await apiClient.get<ApiResponse<Role[]>>("/roles/");
+      return response.data.data;
+    },
+  });
+}
+
+export function useRole(id: number) {
+  return useQuery<Role>({
+    queryKey: ["roles", id],
+    queryFn: async () => {
+      const response = await apiClient.get<ApiResponse<Role>>(`/roles/${id}`);
+      return response.data.data;
+    },
+    enabled: !!id,
+  });
+}
+
+export function useCreateRole() {
+  const queryClient = useQueryClient();
+  return useMutation<Role, Error, CreateRoleDTO>({
+    mutationFn: async (dto) => {
+      const response = await apiClient.post<ApiResponse<Role>>("/roles/", dto);
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["roles"] });
+    },
+  });
+}
+
+export function useReplaceRole() {
+  const queryClient = useQueryClient();
+  return useMutation<Role, Error, { id: number; dto: ReplaceRoleDTO }>({
+    mutationFn: async ({ id, dto }) => {
+      const response = await apiClient.put<ApiResponse<Role>>(`/roles/${id}`, dto);
+      return response.data.data;
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ["roles"] });
+      queryClient.invalidateQueries({ queryKey: ["roles", id] });
+    },
+  });
+}
+
+export function useUpdateRole() {
+  const queryClient = useQueryClient();
+  return useMutation<Role, Error, { id: number; dto: UpdateRoleDTO }>({
+    mutationFn: async ({ id, dto }) => {
+      const response = await apiClient.patch<ApiResponse<Role>>(`/roles/${id}`, dto);
+      return response.data.data;
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ["roles"] });
+      queryClient.invalidateQueries({ queryKey: ["roles", id] });
+    },
+  });
+}
+
+export function useDeleteRole() {
+  const queryClient = useQueryClient();
+  return useMutation<Role, Error, number>({
+    mutationFn: async (id) => {
+      const response = await apiClient.delete<ApiResponse<Role>>(`/roles/${id}`);
+      return response.data.data;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: ["roles"] });
+      queryClient.invalidateQueries({ queryKey: ["roles", id] });
+    },
+  });
+}
+
+export function useRolePermissions(id: number) {
+  return useQuery<Role>({
+    queryKey: ["roles", id, "permissions"],
+    queryFn: async () => {
+      const response = await apiClient.get<ApiResponse<Role>>(`/roles/${id}/permissions`);
+      return response.data.data;
+    },
+    enabled: !!id,
+  });
+}
+
+export function useAddRolePermissions() {
+  const queryClient = useQueryClient();
+  return useMutation<Role, Error, { id: number; dto: AddRolePermissionsDTO }>({
+    mutationFn: async ({ id, dto }) => {
+      const response = await apiClient.post<ApiResponse<Role>>(`/roles/${id}/permissions`, dto);
+      return response.data.data;
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ["roles", id, "permissions"] });
+    },
+  });
+}

package/src/roles/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./hooks/useRoles";

package/src/roles/types/index.ts

@@ -0,0 +1 @@
+export * from "./role";

package/src/roles/types/role.ts

@@ -0,0 +1,28 @@
+export interface Role {
+  id: number;
+  name: string;
+  description?: string | null;
+  permissions?: Permission[];
+}
+
+export interface CreateRoleDTO {
+  name: string;
+  description?: string | null;
+}
+
+export interface ReplaceRoleDTO {
+  name: string;
+  description?: string | null;
+}
+
+export interface UpdateRoleDTO {
+  name?: string | null;
+  description?: string | null;
+}
+
+export interface AddRolePermissionsDTO {
+  ids: number[];
+}
+
+// Importing Permission here to avoid circular dependency issues, or we can just redefine it as any or import it.
+import type { Permission } from "../../permissions/types/permission";

package/src/users/hooks/useUsers.ts

@@ -0,0 +1,146 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient, ApiResponse } from "../../api";
+import {
+  User,
+  CreateUserDTO,
+  ReplaceUserDTO,
+  UpdateUserDTO,
+  AddUserRolesDTO,
+} from "../types/user";
+
+const PATH = "/users";
+
+/**
+ * Get all users.
+ * @returns
+ */
+export const useGetUsers = () => {
+  return useQuery({
+    queryKey: ["users"],
+    queryFn: async (): Promise<User[]> => {
+      const response = await apiClient.get<ApiResponse<User[]>>(PATH);
+      return response.data.data;
+    },
+    // staleTime: // ms
+    // gcTime: ,  //
+  });
+};
+
+/**
+ * Get one user.
+ * @param id
+ * @returns
+ */
+export const useGetUser = (id: string) => {
+  return useQuery({
+    queryKey: ["users", id],
+    queryFn: async (): Promise<User> => {
+      const response = await apiClient.get<ApiResponse<User>>(`${PATH}/${id}`);
+      return response.data.data;
+    },
+    enabled: !!id, // Prevent the query from running if the ID is missing
+  });
+};
+
+/**
+ * Create a user.
+ * @returns
+ */
+export const useCreateUser = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (user: CreateUserDTO): Promise<User> => {
+      const response = await apiClient.post<ApiResponse<User>>(PATH, user);
+      return response.data.data;
+    },
+    // Tell React Query to refresh the 'users' list after a successful creation.
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  });
+};
+
+/**
+ * Replace an entire user.
+ * @returns
+ */
+export const useUpdateUser = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      id,
+      data,
+    }: {
+      id: string;
+      data: ReplaceUserDTO;
+    }): Promise<User> => {
+      const response = await apiClient.put<ApiResponse<User>>(
+        `${PATH}/${id}`,
+        data,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+      queryClient.invalidateQueries({ queryKey: ["users", variables.id] });
+    },
+  });
+};
+
+/**
+ * Update specific fields of a user.
+ * @returns
+ */
+export const usePatchUser = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      id,
+      data,
+    }: {
+      id: string;
+      data: UpdateUserDTO;
+    }): Promise<User> => {
+      const response = await apiClient.patch<ApiResponse<User>>(
+        `${PATH}/${id}`,
+        data,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+      queryClient.invalidateQueries({ queryKey: ["users", variables.id] });
+    },
+  });
+};
+
+/**
+ * Add roles to a user.
+ * @returns
+ */
+export const useAddUserRoles = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      id,
+      data,
+    }: {
+      id: string;
+      data: AddUserRolesDTO;
+    }): Promise<User> => {
+      const response = await apiClient.post<ApiResponse<User>>(
+        `${PATH}/${id}/roles`,
+        data,
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+      queryClient.invalidateQueries({ queryKey: ["users", variables.id] });
+    },
+  });
+};

package/src/users/index.ts

@@ -0,0 +1,22 @@
+export {
+  useGetUsers,
+  useGetUser,
+  useCreateUser,
+  useUpdateUser,
+  usePatchUser,
+  useAddUserRoles,
+} from "./hooks/useUsers";
+
+export type {
+  User,
+  CreateUserDTO,
+  UpdateUserDTO,
+  ReplaceUserDTO,
+  AddUserRolesDTO,
+} from "./types/user";
+
+// # syncdesk-api/app/api/api_router
+// - /auth/ -- /app/domains/auth/routers/auth_router
+// | `/api/users/`             | User management (CRUD)       |
+// | `/api/roles/`             | Role management (CRUD)       |
+// | `/api/permissions/`       | Permission management (CRUD) |

package/src/users/types/user.ts

@@ -0,0 +1,36 @@
+import { OAuthProvider } from "../../auth/types/auth";
+
+export interface User {
+  id: string;
+  email: string;
+  username?: string | null;
+  name?: string | null;
+  oauth_provider?: OAuthProvider | null;
+  oauth_provider_id?: string | null;
+  is_active: boolean;
+  is_verified: boolean;
+  roles?: Role[];
+}
+
+import type { Role } from "../../roles/types/role";
+import type { Permission } from "../../permissions/types/permission";
+
+export interface CreateUserDTO {
+  email: string;
+  password_hash?: string | null;
+  username?: string | null;
+  name?: string | null;
+  oauth_provider?: OAuthProvider | null;
+  oauth_provider_id?: string | null;
+  is_active?: boolean;
+  is_verified?: boolean;
+  role_ids?: number[];
+}
+
+export type UpdateUserDTO = Partial<CreateUserDTO>;
+
+export type ReplaceUserDTO = CreateUserDTO;
+
+export interface AddUserRolesDTO {
+  role_ids: number[];
+}