@replyke/core
Version:
Replyke: Build interactive apps with social features like comments, votes, feeds, user lists, notifications, and more.
223 lines • 8.99 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useRequestConnection_1 = __importDefault(require("./useRequestConnection"));
const useAcceptConnection_1 = __importDefault(require("./useAcceptConnection"));
const useDeclineConnection_1 = __importDefault(require("./useDeclineConnection"));
const useRemoveConnection_1 = __importDefault(require("./useRemoveConnection"));
const useRemoveConnectionByUserId_1 = __importDefault(require("./useRemoveConnectionByUserId"));
const useFetchConnectionStatus_1 = __importDefault(require("./useFetchConnectionStatus"));
const useUser_1 = __importDefault(require("../../user/useUser"));
function useConnectionManager({ userId }) {
const { user } = (0, useUser_1.default)();
const [connectionStatus, setConnectionStatus] = (0, react_1.useState)("none");
const [connectionData, setConnectionData] = (0, react_1.useState)({
connectionId: null,
});
const [isLoading, setIsLoading] = (0, react_1.useState)(true);
const requestConnection = (0, useRequestConnection_1.default)();
const acceptConnection = (0, useAcceptConnection_1.default)();
const declineConnection = (0, useDeclineConnection_1.default)();
const removeConnection = (0, useRemoveConnection_1.default)();
const removeConnectionByUserId = (0, useRemoveConnectionByUserId_1.default)();
const getConnectionStatus = (0, useFetchConnectionStatus_1.default)();
const loadConnectionStatus = (0, react_1.useCallback)(async () => {
if (!userId || user?.id === userId) {
setConnectionStatus("none");
setConnectionData({ connectionId: null });
setIsLoading(false);
return;
}
try {
setIsLoading(true);
const statusResponse = await getConnectionStatus({ userId });
switch (statusResponse.status) {
case "none":
setConnectionStatus("none");
setConnectionData({ connectionId: null });
break;
case "pending":
setConnectionStatus(statusResponse.type === "sent" ? "pending-sent" : "pending-received");
setConnectionData({
connectionId: statusResponse.connectionId,
createdAt: statusResponse.createdAt,
type: statusResponse.type,
});
break;
case "connected":
setConnectionStatus("connected");
setConnectionData({
connectionId: statusResponse.connectionId,
connectedAt: statusResponse.connectedAt,
requestedAt: statusResponse.requestedAt,
});
break;
case "declined":
setConnectionStatus(statusResponse.type === "sent" ? "declined-sent" : "declined-received");
setConnectionData({
connectionId: statusResponse.connectionId,
respondedAt: statusResponse.respondedAt,
type: statusResponse.type,
});
break;
default:
setConnectionStatus("none");
setConnectionData({ connectionId: null });
}
}
catch (error) {
console.error("Failed to fetch connection status:", error);
setConnectionStatus("none");
setConnectionData({ connectionId: null });
}
finally {
setIsLoading(false);
}
}, [userId, user?.id, getConnectionStatus]);
(0, react_1.useEffect)(() => {
loadConnectionStatus();
}, [loadConnectionStatus]);
const sendConnectionRequest = (0, react_1.useCallback)(async (message) => {
if ((connectionStatus !== "none" && connectionStatus !== "declined-received") ||
isLoading ||
user?.id === userId)
return;
try {
const result = await requestConnection({ userId, message });
setConnectionStatus("pending-sent");
setConnectionData({
connectionId: result.id,
type: "sent",
createdAt: result.createdAt,
});
}
catch (error) {
console.error("Failed to send connection request:", error);
throw error;
}
}, [connectionStatus, isLoading, userId, user?.id, requestConnection]);
const acceptConnectionRequest = (0, react_1.useCallback)(async () => {
if (connectionStatus !== "pending-received" ||
!connectionData.connectionId ||
isLoading)
return;
try {
await acceptConnection({
connectionId: connectionData.connectionId,
});
setConnectionStatus("connected");
// Reload to get the updated connection data with dates
await loadConnectionStatus();
}
catch (error) {
console.error("Failed to accept connection request:", error);
throw error;
}
}, [
connectionStatus,
connectionData.connectionId,
isLoading,
acceptConnection,
loadConnectionStatus,
]);
const declineConnectionRequest = (0, react_1.useCallback)(async () => {
if (connectionStatus !== "pending-received" ||
!connectionData.connectionId ||
isLoading)
return;
try {
const result = await declineConnection({ connectionId: connectionData.connectionId });
// When you decline someone, from your perspective it's "declined-received"
// (you received and declined their request)
setConnectionStatus("declined-received");
setConnectionData({
connectionId: connectionData.connectionId,
respondedAt: result.respondedAt,
type: "received",
});
}
catch (error) {
console.error("Failed to decline connection request:", error);
throw error;
}
}, [
connectionStatus,
connectionData.connectionId,
isLoading,
declineConnection,
]);
const withdrawConnectionRequest = (0, react_1.useCallback)(async () => {
if (connectionStatus !== "pending-sent" ||
!connectionData.connectionId ||
isLoading)
return;
try {
await removeConnection({ connectionId: connectionData.connectionId });
setConnectionStatus("none");
setConnectionData({ connectionId: null });
}
catch (error) {
console.error("Failed to withdraw connection request:", error);
throw error;
}
}, [
connectionStatus,
connectionData.connectionId,
isLoading,
removeConnection,
]);
const disconnectUser = (0, react_1.useCallback)(async () => {
if (connectionStatus !== "connected" ||
!connectionData.connectionId ||
isLoading)
return;
try {
await removeConnection({ connectionId: connectionData.connectionId });
setConnectionStatus("none");
setConnectionData({ connectionId: null });
}
catch (error) {
console.error("Failed to disconnect user:", error);
throw error;
}
}, [
connectionStatus,
connectionData.connectionId,
isLoading,
removeConnection,
]);
const removeConnectionSmart = (0, react_1.useCallback)(async () => {
if (connectionStatus === "none" ||
connectionStatus === "declined-sent" ||
isLoading ||
user?.id === userId)
return;
try {
await removeConnectionByUserId({ userId });
setConnectionStatus("none");
setConnectionData({ connectionId: null });
}
catch (error) {
console.error("Failed to remove connection:", error);
throw error;
}
}, [connectionStatus, isLoading, userId, user?.id, removeConnectionByUserId]);
return {
connectionStatus,
connectionId: connectionData.connectionId,
connectionData,
isLoading,
sendConnectionRequest,
acceptConnectionRequest,
declineConnectionRequest,
withdrawConnectionRequest,
disconnectUser,
removeConnectionSmart,
refreshConnectionStatus: loadConnectionStatus,
};
}
exports.default = useConnectionManager;
//# sourceMappingURL=useConnectionManager.js.map