OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
import {
type QueryClient,
type UseQueryOptions,
useMutation,
useQuery,
useQueryClient,
} from "@tanstack/react-query";
import { toast } from "sonner";
import { useAuth } from "@/contexts/auth-context";
import { useBrand, useIsCloudBrand } from "@/contexts/brand-context";
import { apiClient } from "@/lib/api-client";
import {
isConnectorShownInWorkspace,
isConnectorTypeVisible,
isSaasPolicyContext,
} from "@/lib/brand";
/** Prefix for all connector list queries (see `connectorsQueryKey`). */
const CONNECTORS_QUERY_KEY_ROOT = ["connectors"] as const;
/**
* Cache key from policy + deployment filter context (inputs to `getConnectors`).
* `cloudContext`: backend `/api/connectors` filtering (server policy).
* `applyWorkspacePolicy`: SaaS workspace policy path in the query fn.
* `isCloudBrand` / `isIbmAuthMode`: client deployment visibility (`isConnectorTypeVisible`).
*/
function connectorsQueryKey(
cloudContext: boolean,
applyWorkspacePolicy: boolean,
isCloudBrand: boolean,
isIbmAuthMode: boolean,
) {
return [
...CONNECTORS_QUERY_KEY_ROOT,
cloudContext,
applyWorkspacePolicy,
isCloudBrand,
isIbmAuthMode,
] as const;
}
export type ConnectorsQueryKey = ReturnType<typeof connectorsQueryKey>;
/** Snapshot of every cached connector list — safe across policy key changes. */
export type ConnectorsMutationContext = {
previousByKey: Array<[ConnectorsQueryKey, Connector[] | undefined]>;
};
export function snapshotConnectorQueries(
queryClient: QueryClient,
): ConnectorsMutationContext {
return {
previousByKey: queryClient
.getQueriesData<Connector[]>(connectorsQueryFilter)
.map(([queryKey, data]) => [queryKey as ConnectorsQueryKey, data]),
};
}
export function restoreConnectorQueries(
queryClient: QueryClient,
context?: ConnectorsMutationContext,
): void {
context?.previousByKey.forEach(([queryKey, data]) => {
if (data !== undefined) {
queryClient.setQueryData(queryKey, data);
}
});
}
export function updateAllConnectorQueries(
queryClient: QueryClient,
updater: (connectors: Connector[]) => Connector[],
): void {
queryClient
.getQueriesData<Connector[]>(connectorsQueryFilter)
.forEach(([queryKey, data]) => {
if (data !== undefined) {
queryClient.setQueryData(queryKey as ConnectorsQueryKey, updater(data));
}
});
}
/** Shared policy context for connector list query key + optimistic updates. */
function useConnectorsQueryKey() {
const { isIbmAuthMode, cloudContext } = useAuth();
const { brand } = useBrand();
const isCloudBrand = useIsCloudBrand();
const applyWorkspacePolicy = isSaasPolicyContext({
isIbmAuthMode,
cloudContext,
brand,
});
return {
cloudContext,
applyWorkspacePolicy,
isCloudBrand,
isIbmAuthMode,
queryKey: connectorsQueryKey(
cloudContext,
applyWorkspacePolicy,
isCloudBrand,
isIbmAuthMode,
),
};
}
/** Match every `["connectors", …]` query — required for invalidate/cancel after key shape change. */
export const connectorsQueryFilter = {
queryKey: CONNECTORS_QUERY_KEY_ROOT,
exact: false,
} as const;
interface GoogleDriveFile {
id: string;
name: string;
mimeType: string;
webViewLink?: string;
iconLink?: string;
}
interface OneDriveFile {
id: string;
name: string;
mimeType?: string;
webUrl?: string;
driveItem?: {
file?: { mimeType: string };
folder?: unknown;
};
}
export interface Connector {
id: string;
name: string;
description: string;
icon: string; // The icon name from the API
status: "not_connected" | "configured" | "connected" | "error";
type: string;
connectionId?: string;
clientId?: string;
baseUrl?: string;
access_token?: string;
selectedFiles?: GoogleDriveFile[] | OneDriveFile[];
available?: boolean;
requiresOAuth?: boolean;
alwaysConnected?: boolean;
}
interface Connection {
connection_id: string;
is_active: boolean;
is_authenticated?: boolean;
created_at: string;
last_sync?: string;
client_id?: string;
base_url?: string;
}
export interface GetConnectorsResponse {
connectors: Connector[];
}
async function fetchWorkspaceConnectorAccess(): Promise<
Record<string, boolean>
> {
const response = await apiClient.get("/connectors/workspace-policy");
if (response.status < 200 || response.status >= 300) return {};
const data = response.data;
return data?.access && typeof data.access === "object" ? data.access : {};
}
export const useGetConnectorsQuery = (
options?: Omit<UseQueryOptions<Connector[]>, "queryKey" | "queryFn">,
) => {
const { applyWorkspacePolicy, isCloudBrand, isIbmAuthMode, queryKey } =
useConnectorsQueryKey();
async function getConnectors(): Promise<Connector[]> {
const connectorsResponse = await apiClient.get<{
connectors: Record<
string,
{
kind?: string;
name: string;
description: string;
icon: string;
available?: boolean;
always_connected?: boolean;
}
>;
}>("/connectors");
if (connectorsResponse.status < 200 || connectorsResponse.status >= 300) {
throw new Error("Failed to fetch available connectors");
}
const { connectors: connectorsMap } = connectorsResponse.data;
const connectorTypes = Object.keys(connectorsMap);
const connectorsWithStatus = await Promise.all(
connectorTypes.map(async (type) => {
const connectorData = connectorsMap[type];
// Determine if this connector requires OAuth based on connector kind
// "oauth" connectors require OAuth flow (Google Drive, OneDrive, SharePoint)
// "bucket" connectors use credential-based auth (Azure Blob, S3, IBM COS)
const requiresOAuth = connectorData.kind === "oauth";
const alwaysConnected = connectorData.always_connected === true;
if (alwaysConnected) {
return {
id: type,
name: connectorData.name,
description: connectorData.description,
icon: connectorData.icon,
status: "connected",
type,
connectionId: type,
available: connectorData.available,
requiresOAuth,
alwaysConnected,
} as Connector;
}
const statusResponse = await apiClient.get(
`/connectors/${type}/status`,
);
let status: Connector["status"] = "not_connected";
let connectionId: string | undefined;
if (statusResponse.status >= 200 && statusResponse.status < 300) {
const statusData = statusResponse.data;
const connections = statusData.connections || [];
const activeConnection = connections.find(
(conn: Connection) => conn.is_active && conn.is_authenticated,
);
if (activeConnection) {
status = "connected";
connectionId = activeConnection.connection_id;
return {
id: type,
name: connectorData.name,
description: connectorData.description,
icon: connectorData.icon,
status,
type,
connectionId,
clientId: activeConnection.client_id,
baseUrl: activeConnection.base_url,
available: connectorData.available,
requiresOAuth,
} as Connector;
}
// For OAuth connectors: check if credentials are configured in .env
if (requiresOAuth && statusData.has_env_credentials) {
status = "configured";
}
}
return {
id: type,
name: connectorData.name,
description: connectorData.description,
icon: connectorData.icon,
status,
type,
connectionId,
available: connectorData.available,
requiresOAuth,
} as Connector;
}),
);
let result = connectorsWithStatus;
const deploymentCtx = { isCloudBrand, isIbmAuthMode };
if (applyWorkspacePolicy) {
const storedAccess = await fetchWorkspaceConnectorAccess();
result = result.filter((c) =>
isConnectorShownInWorkspace(c.type, storedAccess, deploymentCtx),
);
} else {
result = result.filter((c) =>
isConnectorTypeVisible(c.type, deploymentCtx),
);
}
return result;
}
return useQuery({
queryKey,
queryFn: getConnectors,
refetchOnMount: "always",
...options,
});
};
export interface ConnectorAccessItem {
type: string;
name: string;
enabled: boolean;
}
export const CONNECTOR_USER_ACCESS_KEY = ["connector-user-access"] as const;
function connectorUserAccessQueryKey(
isCloudBrand: boolean,
isIbmAuthMode: boolean,
) {
return [...CONNECTOR_USER_ACCESS_KEY, isCloudBrand, isIbmAuthMode] as const;
}
function filterConnectorAccessItems(
connectors: ConnectorAccessItem[],
deploymentCtx: { isCloudBrand: boolean; isIbmAuthMode: boolean },
): ConnectorAccessItem[] {
return connectors.filter((c) =>
isConnectorTypeVisible(c.type, deploymentCtx),
);
}
export const useGetConnectorAccessQuery = (
options?: Omit<
UseQueryOptions<ConnectorAccessItem[]>,
"queryKey" | "queryFn"
>,
) => {
const isCloudBrand = useIsCloudBrand();
const { isIbmAuthMode } = useAuth();
async function fetchConnectorAccess(): Promise<ConnectorAccessItem[]> {
const response = await apiClient.get("/connectors/user-access");
if (response.status < 200 || response.status >= 300) {
throw new Error(
`Failed to fetch connectors permission (${response.status})`,
);
}
const data = response.data;
const connectors = Array.isArray(data.connectors) ? data.connectors : [];
const deploymentCtx = { isCloudBrand, isIbmAuthMode };
return filterConnectorAccessItems(connectors, deploymentCtx);
}
return useQuery({
queryKey: connectorUserAccessQueryKey(isCloudBrand, isIbmAuthMode),
queryFn: fetchConnectorAccess,
refetchOnWindowFocus: false,
...options,
});
};
export const useUpdateConnectorAccessMutation = () => {
const queryClient = useQueryClient();
const isCloudBrand = useIsCloudBrand();
const { isIbmAuthMode } = useAuth();
const deploymentCtx = { isCloudBrand, isIbmAuthMode };
const accessQueryKey = connectorUserAccessQueryKey(
isCloudBrand,
isIbmAuthMode,
);
return useMutation({
mutationFn: async (
access: Record<string, boolean>,
): Promise<ConnectorAccessItem[]> => {
const response = await apiClient.put("/connectors/user-access", {
access,
});
if (response.status < 200 || response.status >= 300) {
const result = response.data ?? {};
throw new Error(
result.error || "Failed to update connectors permission",
);
}
const data = response.data;
const connectors = Array.isArray(data.connectors) ? data.connectors : [];
return filterConnectorAccessItems(connectors, deploymentCtx);
},
onSuccess: (connectors) => {
queryClient.setQueryData(accessQueryKey, connectors);
queryClient.invalidateQueries(connectorsQueryFilter);
toast.success("Connectors permission saved");
},
onError: (error: Error) => {
toast.error(error.message);
},
});
};