{
+ e.stopPropagation();
+ setIsOpen(false);
+ }}
+ aria-hidden="true"
/>
-
-
- {formatVersionDate(version.date)}
-
- {version.expiresInDays !== undefined && (
-
-
-
{translate('modals.versionHistory.expiresInDays', { days: version.expiresInDays })}
+ )}
+
- );
-};
+ return
;
+ }}
+
+
+
+
+
+ );
+ },
+);
diff --git a/src/views/Drive/components/VersionHistory/components/index.ts b/src/views/Drive/components/VersionHistory/components/index.ts
index 58e0f09ed..9bc3ebe77 100644
--- a/src/views/Drive/components/VersionHistory/components/index.ts
+++ b/src/views/Drive/components/VersionHistory/components/index.ts
@@ -2,3 +2,5 @@ export { Header } from './Header';
export { CurrentVersionItem } from './CurrentVersionItem';
export { VersionItem } from './VersionItem';
export { AutosaveSection } from './AutosaveSection';
+export { VersionActionDialog } from './VersionActionDialog';
+export { VersionHistorySkeleton } from './VersionHistorySkeleton';
diff --git a/src/views/Drive/components/VersionHistory/hooks/index.ts b/src/views/Drive/components/VersionHistory/hooks/index.ts
index cb2aeceda..5fb50562c 100644
--- a/src/views/Drive/components/VersionHistory/hooks/index.ts
+++ b/src/views/Drive/components/VersionHistory/hooks/index.ts
@@ -1,2 +1,3 @@
export { useDropdownPositioning } from './useDropdownPositioning';
export { useVersionItemActions } from './useVersionItemActions';
+export { useVersionHistoryMenuConfig } from './useVersionHistoryMenuConfig';
diff --git a/src/views/Drive/components/VersionHistory/hooks/useDropdownPositioning.test.ts b/src/views/Drive/components/VersionHistory/hooks/useDropdownPositioning.test.ts
new file mode 100644
index 000000000..d5ab8abff
--- /dev/null
+++ b/src/views/Drive/components/VersionHistory/hooks/useDropdownPositioning.test.ts
@@ -0,0 +1,87 @@
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { MutableRefObject } from 'react';
+import { useDropdownPositioning } from './useDropdownPositioning';
+
+const originalInnerHeight = window.innerHeight;
+const setRefCurrent =
(ref: React.RefObject, value: T) => {
+ (ref as MutableRefObject).current = value;
+};
+
+describe('Version menu behavior', () => {
+ beforeEach(() => {
+ Object.defineProperty(window, 'innerHeight', { value: originalInnerHeight, writable: true, configurable: true });
+ });
+
+ afterEach(() => {
+ Object.defineProperty(window, 'innerHeight', { value: originalInnerHeight, writable: true, configurable: true });
+ });
+
+ it('when clicking inside the menu, then it stays open', () => {
+ const { result } = renderHook(() => useDropdownPositioning());
+ const dropdownElement = document.createElement('div');
+ const childElement = document.createElement('span');
+ dropdownElement.appendChild(childElement);
+ setRefCurrent(result.current.dropdownRef, dropdownElement);
+
+ act(() => {
+ result.current.setIsOpen(true);
+ });
+
+ act(() => {
+ childElement.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+ });
+
+ expect(result.current.isOpen).toBe(true);
+ });
+
+ it('when clicking outside the menu, then it closes', () => {
+ const { result } = renderHook(() => useDropdownPositioning());
+ const dropdownElement = document.createElement('div');
+ setRefCurrent(result.current.dropdownRef, dropdownElement);
+
+ act(() => {
+ result.current.setIsOpen(true);
+ });
+
+ act(() => {
+ document.body.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+ });
+
+ expect(result.current.isOpen).toBe(false);
+ });
+
+ it('when there is space below the item, then the menu opens below', async () => {
+ Object.defineProperty(window, 'innerHeight', { value: 500, writable: true, configurable: true });
+ const { result } = renderHook(() => useDropdownPositioning());
+ const mockItem = {
+ getBoundingClientRect: () => ({ bottom: 100 }) as DOMRect,
+ } as unknown as HTMLElement;
+ setRefCurrent(result.current.itemRef, mockItem);
+
+ act(() => {
+ result.current.setIsOpen(true);
+ });
+
+ await waitFor(() => {
+ expect(result.current.dropdownPosition).toBe('below');
+ });
+ });
+
+ it('when space is tight below the item, then the menu opens above', async () => {
+ Object.defineProperty(window, 'innerHeight', { value: 150, writable: true, configurable: true });
+ const { result } = renderHook(() => useDropdownPositioning());
+ const mockItem = {
+ getBoundingClientRect: () => ({ bottom: 20 }) as DOMRect,
+ } as unknown as HTMLElement;
+ setRefCurrent(result.current.itemRef, mockItem);
+
+ act(() => {
+ result.current.setIsOpen(true);
+ });
+
+ await waitFor(() => {
+ expect(result.current.dropdownPosition).toBe('above');
+ });
+ });
+});
diff --git a/src/views/Drive/components/VersionHistory/hooks/useVersionHistoryMenuConfig.test.ts b/src/views/Drive/components/VersionHistory/hooks/useVersionHistoryMenuConfig.test.ts
new file mode 100644
index 000000000..d45bb6e59
--- /dev/null
+++ b/src/views/Drive/components/VersionHistory/hooks/useVersionHistoryMenuConfig.test.ts
@@ -0,0 +1,99 @@
+import { renderHook, act } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi, Mock } from 'vitest';
+import { useSelector } from 'react-redux';
+import { useAppDispatch } from 'app/store/hooks';
+import navigationService from 'services/navigation.service';
+import { useVersionHistoryMenuConfig } from './useVersionHistoryMenuConfig';
+import { FileLimitsResponse } from '@internxt/sdk/dist/drive/storage/types';
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+
+vi.mock('react-redux', () => ({
+ useSelector: vi.fn(),
+}));
+
+vi.mock('app/store/hooks', () => ({
+ useAppDispatch: vi.fn(),
+}));
+
+const mockSetIsPreferencesDialogOpen = vi.hoisted(() =>
+ vi.fn((payload: boolean) => ({ type: 'setIsPreferencesDialogOpen', payload })),
+);
+
+vi.mock('app/store/slices/ui', () => ({
+ uiActions: {
+ setIsPreferencesDialogOpen: mockSetIsPreferencesDialogOpen,
+ },
+}));
+
+vi.mock('services/navigation.service', () => ({
+ default: {
+ openPreferencesDialog: vi.fn(),
+ },
+}));
+
+const workspaceMock = {
+ workspaceUser: { workspaceId: 'workspace-1' },
+ workspace: { id: 'workspace-1' },
+} as unknown as WorkspaceData;
+
+const enabledLimits: FileLimitsResponse = {
+ versioning: { enabled: true, maxFileSize: 0, retentionDays: 0, maxVersions: 0 },
+};
+
+const disabledLimits: FileLimitsResponse = {
+ versioning: { enabled: false, maxFileSize: 0, retentionDays: 0, maxVersions: 0 },
+};
+
+describe('Version history menu', () => {
+ const mockUseSelector = useSelector as unknown as Mock;
+ const mockUseAppDispatch = useAppDispatch as unknown as Mock;
+ const dispatch = vi.fn();
+
+ const mockState = (limits: FileLimitsResponse | null) =>
+ ({
+ workspaces: { selectedWorkspace: workspaceMock },
+ fileVersions: { limits },
+ }) as any;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockUseAppDispatch.mockReturnValue(dispatch);
+ });
+
+ it('when versioning is locked, then the upgrade flow opens', () => {
+ mockUseSelector.mockImplementation((selector: (state: any) => unknown) => selector(mockState(disabledLimits)));
+
+ const { result } = renderHook(() => useVersionHistoryMenuConfig({ type: 'pdf' } as any));
+
+ expect(result.current.isLocked).toBe(true);
+ expect(result.current.isExtensionAllowed).toBe(true);
+
+ act(() => {
+ result.current.onUpgradeClick?.();
+ });
+
+ expect(dispatch).toHaveBeenCalledWith({ type: 'setIsPreferencesDialogOpen', payload: true });
+ expect(navigationService.openPreferencesDialog).toHaveBeenCalledWith({
+ section: 'account',
+ subsection: 'plans',
+ workspaceUuid: 'workspace-1',
+ });
+ });
+
+ it('when versioning is enabled and the file is supported, then the menu is unlocked', () => {
+ mockUseSelector.mockImplementation((selector: (state: any) => unknown) => selector(mockState(enabledLimits)));
+
+ const { result } = renderHook(() => useVersionHistoryMenuConfig({ type: 'pdf' } as any));
+
+ expect(result.current.isLocked).toBe(false);
+ expect(result.current.isExtensionAllowed).toBe(true);
+ });
+
+ it('when the file type is unsupported, then it is marked as not allowed', () => {
+ mockUseSelector.mockImplementation((selector: (state: any) => unknown) => selector(mockState(enabledLimits)));
+
+ const { result } = renderHook(() => useVersionHistoryMenuConfig({ type: 'exe' } as any));
+
+ expect(result.current.isExtensionAllowed).toBe(false);
+ });
+});
diff --git a/src/views/Drive/components/VersionHistory/hooks/useVersionHistoryMenuConfig.ts b/src/views/Drive/components/VersionHistory/hooks/useVersionHistoryMenuConfig.ts
new file mode 100644
index 000000000..9b612a67d
--- /dev/null
+++ b/src/views/Drive/components/VersionHistory/hooks/useVersionHistoryMenuConfig.ts
@@ -0,0 +1,30 @@
+import { useSelector } from 'react-redux';
+import { useAppDispatch } from 'app/store/hooks';
+import { uiActions } from 'app/store/slices/ui';
+import workspacesSelectors from 'app/store/slices/workspaces/workspaces.selectors';
+import { fileVersionsSelectors } from 'app/store/slices/fileVersions';
+import navigationService from 'services/navigation.service';
+import { DriveItemData } from 'app/drive/types';
+import { isVersioningExtensionAllowed } from '../utils';
+import { VersionHistoryMenuConfig } from '../../DriveExplorer/components/DriveItemContextMenu';
+
+export const useVersionHistoryMenuConfig = (selectedItem?: DriveItemData): VersionHistoryMenuConfig => {
+ const dispatch = useAppDispatch();
+ const selectedWorkspace = useSelector(workspacesSelectors.getSelectedWorkspace);
+ const limits = useSelector(fileVersionsSelectors.getLimits);
+ const isVersioningEnabled = limits?.versioning?.enabled ?? false;
+ const isExtensionAllowed = selectedItem ? isVersioningExtensionAllowed(selectedItem) : true;
+
+ return {
+ isLocked: !isVersioningEnabled,
+ isExtensionAllowed,
+ onUpgradeClick: () => {
+ dispatch(uiActions.setIsPreferencesDialogOpen(true));
+ navigationService.openPreferencesDialog({
+ section: 'account',
+ subsection: 'plans',
+ workspaceUuid: selectedWorkspace?.workspaceUser.workspaceId,
+ });
+ },
+ };
+};
diff --git a/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.test.ts b/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.test.ts
new file mode 100644
index 000000000..f055c78c9
--- /dev/null
+++ b/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.test.ts
@@ -0,0 +1,165 @@
+import { renderHook, act } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi, Mock } from 'vitest';
+import { Trash, ClockCounterClockwise, DownloadSimple } from '@phosphor-icons/react';
+import { useVersionItemActions } from './useVersionItemActions';
+import fileVersionService from '../services/fileVersion.service';
+import notificationsService, { ToastType } from 'app/notifications/services/notifications.service';
+import { useTranslationContext } from 'app/i18n/provider/TranslationProvider';
+import { useAppDispatch, useAppSelector } from 'app/store/hooks';
+import { FileVersion } from '@internxt/sdk/dist/drive/storage/types';
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { RootState } from 'app/store';
+import { MenuItemType } from '@internxt/ui';
+
+vi.mock('app/i18n/provider/TranslationProvider', () => ({
+ useTranslationContext: vi.fn(),
+}));
+
+vi.mock('app/store/hooks', () => ({
+ useAppDispatch: vi.fn(),
+ useAppSelector: vi.fn(),
+}));
+
+vi.mock('views/Drive/components/VersionHistory/services/fileVersion.service', () => ({
+ default: {
+ downloadVersion: vi.fn(),
+ },
+}));
+
+vi.mock('app/notifications/services/notifications.service', () => ({
+ default: {
+ show: vi.fn(),
+ },
+ ToastType: {
+ Error: 'error',
+ },
+}));
+
+const mockSetVersionToRestore = vi.hoisted(() => vi.fn((payload) => ({ type: 'setVersionToRestore', payload })));
+const mockSetIsRestoreVersionDialogOpen = vi.hoisted(() =>
+ vi.fn((payload) => ({ type: 'setIsRestoreVersionDialogOpen', payload })),
+);
+const mockSetVersionToDelete = vi.hoisted(() => vi.fn((payload) => ({ type: 'setVersionToDelete', payload })));
+const mockSetIsDeleteVersionDialogOpen = vi.hoisted(() =>
+ vi.fn((payload) => ({ type: 'setIsDeleteVersionDialogOpen', payload })),
+);
+
+vi.mock('app/store/slices/ui', () => ({
+ uiActions: {
+ setVersionToRestore: mockSetVersionToRestore,
+ setIsRestoreVersionDialogOpen: mockSetIsRestoreVersionDialogOpen,
+ setVersionToDelete: mockSetVersionToDelete,
+ setIsDeleteVersionDialogOpen: mockSetIsDeleteVersionDialogOpen,
+ },
+}));
+
+describe('Version item menu', () => {
+ const translateMock = vi.fn((key: string) => key);
+ const version = {
+ id: 'version-id',
+ fileId: 'file-uuid',
+ networkFileId: 'network-file-id',
+ size: '5',
+ } as FileVersion;
+ const fileItem = {
+ id: 'file-id',
+ name: 'fallback-name',
+ plainName: 'pretty-name',
+ fileId: 'file-id',
+ } as any;
+ const selectedWorkspace = { workspace: { id: 'workspace-id' } } as WorkspaceData;
+ const workspaceCredentials = { workspaceId: 'workspace-id', token: 'token' } as any;
+ const baseState = {
+ ui: { versionHistoryItem: fileItem },
+ workspaces: { selectedWorkspace, workspaceCredentials },
+ } as unknown as RootState;
+
+ const mockDispatch = vi.fn();
+ const mockUseAppDispatch = useAppDispatch as unknown as Mock;
+ const mockUseAppSelector = useAppSelector as unknown as Mock;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockUseAppDispatch.mockReturnValue(mockDispatch);
+ (useTranslationContext as Mock).mockReturnValue({ translate: translateMock });
+ mockUseAppSelector.mockImplementation((selector: (state: RootState) => unknown) => selector(baseState));
+ });
+
+ const getMenuActionByIcon = (items: Array>, icon: any) => {
+ const item = items.find((item) => 'icon' in item && item.icon === icon);
+ return item && 'action' in item ? (item as any).action : undefined;
+ };
+
+ it('when restore is chosen, then the restore dialog opens', () => {
+ const onDropdownClose = vi.fn();
+ const { result } = renderHook(() => useVersionItemActions({ version, onDropdownClose }));
+ const restoreAction = getMenuActionByIcon(result.current.menuItems, ClockCounterClockwise);
+
+ act(() => {
+ restoreAction();
+ });
+
+ expect(onDropdownClose).toHaveBeenCalled();
+ expect(mockDispatch).toHaveBeenCalledWith({ type: 'setVersionToRestore', payload: version });
+ expect(mockDispatch).toHaveBeenCalledWith({ type: 'setIsRestoreVersionDialogOpen', payload: true });
+ });
+
+ it('when nothing is selected to download, then an error toast is shown', async () => {
+ const onDropdownClose = vi.fn();
+ mockUseAppSelector.mockImplementation((selector: (state: RootState) => unknown) =>
+ selector({
+ ui: { versionHistoryItem: null },
+ workspaces: { selectedWorkspace: null, workspaceCredentials: null },
+ } as unknown as RootState),
+ );
+ const showSpy = vi.spyOn(notificationsService, 'show');
+ const { result } = renderHook(() => useVersionItemActions({ version, onDropdownClose }));
+ const downloadAction = getMenuActionByIcon(result.current.menuItems, DownloadSimple);
+
+ await act(async () => {
+ await downloadAction();
+ });
+
+ expect(onDropdownClose).toHaveBeenCalled();
+ expect(showSpy).toHaveBeenCalledWith({
+ text: 'modals.versionHistory.downloadError',
+ type: ToastType.Error,
+ });
+ expect(fileVersionService.downloadVersion).not.toHaveBeenCalled();
+ });
+
+ it('when a previous version is downloaded, then it uses the readable name and workspace data', async () => {
+ const onDropdownClose = vi.fn();
+ const downloadVersionSpy = vi.spyOn(fileVersionService, 'downloadVersion').mockResolvedValue(undefined as any);
+ const { result } = renderHook(() => useVersionItemActions({ version, onDropdownClose }));
+ const downloadAction = getMenuActionByIcon(result.current.menuItems, DownloadSimple);
+
+ await act(async () => {
+ await downloadAction();
+ });
+
+ expect(onDropdownClose).toHaveBeenCalled();
+ expect(downloadVersionSpy).toHaveBeenCalledWith(
+ version,
+ fileItem,
+ fileItem.plainName,
+ selectedWorkspace,
+ workspaceCredentials,
+ );
+ expect(notificationsService.show).not.toHaveBeenCalled();
+ });
+
+ it('when delete is chosen, then the delete dialog opens', () => {
+ const onDropdownClose = vi.fn();
+ const { result } = renderHook(() => useVersionItemActions({ version, onDropdownClose }));
+ const deleteAction = getMenuActionByIcon(result.current.menuItems, Trash);
+
+ act(() => {
+ deleteAction();
+ });
+
+ expect(onDropdownClose).toHaveBeenCalled();
+ expect(mockDispatch).toHaveBeenCalledWith({ type: 'setVersionToDelete', payload: version });
+ expect(mockDispatch).toHaveBeenCalledWith({ type: 'setIsDeleteVersionDialogOpen', payload: true });
+ });
+});
diff --git a/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.ts b/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.ts
index c4ce61ae1..0400bdd47 100644
--- a/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.ts
+++ b/src/views/Drive/components/VersionHistory/hooks/useVersionItemActions.ts
@@ -1,7 +1,13 @@
import { Trash, ClockCounterClockwise, DownloadSimple } from '@phosphor-icons/react';
import { MenuItemType } from '@internxt/ui';
import { useTranslationContext } from 'app/i18n/provider/TranslationProvider';
-import { FileVersion } from '../types';
+import fileVersionService from '../services/fileVersion.service';
+import notificationsService, { ToastType } from 'app/notifications/services/notifications.service';
+import { useAppDispatch, useAppSelector } from 'app/store/hooks';
+import { uiActions } from 'app/store/slices/ui';
+import { RootState } from 'app/store';
+import workspacesSelectors from 'app/store/slices/workspaces/workspaces.selectors';
+import { FileVersion } from '@internxt/sdk/dist/drive/storage/types';
interface UseVersionItemActionsParams {
version: FileVersion;
@@ -10,24 +16,43 @@ interface UseVersionItemActionsParams {
export const useVersionItemActions = ({ version, onDropdownClose }: UseVersionItemActionsParams) => {
const { translate } = useTranslationContext();
+ const dispatch = useAppDispatch();
+ const item = useAppSelector((state: RootState) => state.ui.versionHistoryItem);
+ const selectedWorkspace = useAppSelector(workspacesSelectors.getSelectedWorkspace);
+ const workspaceCredentials = useAppSelector(workspacesSelectors.getWorkspaceCredentials);
- const handleRestore = () => {
+ const handleRestoreClick = () => {
onDropdownClose();
+ dispatch(uiActions.setVersionToRestore(version));
+ dispatch(uiActions.setIsRestoreVersionDialogOpen(true));
};
- const handleDownload = () => {
+ const handleDownload = async () => {
onDropdownClose();
+
+ if (!item) {
+ notificationsService.show({
+ text: translate('modals.versionHistory.downloadError'),
+ type: ToastType.Error,
+ });
+ return;
+ }
+
+ const fileName = item.plainName || item.name;
+ await fileVersionService.downloadVersion(version, item, fileName, selectedWorkspace, workspaceCredentials);
};
- const handleDelete = () => {
+ const handleDeleteClick = () => {
onDropdownClose();
+ dispatch(uiActions.setVersionToDelete(version));
+ dispatch(uiActions.setIsDeleteVersionDialogOpen(true));
};
const menuItems: Array> = [
{
name: translate('modals.versionHistory.restoreVersion'),
icon: ClockCounterClockwise,
- action: handleRestore,
+ action: handleRestoreClick,
},
{
name: translate('modals.versionHistory.downloadVersion'),
@@ -40,7 +65,7 @@ export const useVersionItemActions = ({ version, onDropdownClose }: UseVersionIt
{
name: translate('modals.versionHistory.deleteVersion'),
icon: Trash,
- action: handleDelete,
+ action: handleDeleteClick,
},
];
diff --git a/src/views/Drive/components/VersionHistory/services/fileVersion.service.test.ts b/src/views/Drive/components/VersionHistory/services/fileVersion.service.test.ts
new file mode 100644
index 000000000..8740e9b14
--- /dev/null
+++ b/src/views/Drive/components/VersionHistory/services/fileVersion.service.test.ts
@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SdkFactory } from 'app/core/factory/sdk';
+import { DownloadManager } from 'app/network/DownloadManager';
+import fileVersionService from './fileVersion.service';
+import { FileVersion, RestoreFileVersionResponse } from '@internxt/sdk/dist/drive/storage/types';
+import { WorkspaceCredentialsDetails, WorkspaceData } from '@internxt/sdk/dist/workspaces';
+
+vi.mock('app/core/factory/sdk', () => ({
+ SdkFactory: {
+ getNewApiInstance: vi.fn(),
+ },
+}));
+
+vi.mock('app/network/DownloadManager', () => ({
+ DownloadManager: {
+ downloadItem: vi.fn(),
+ },
+}));
+
+describe('File version actions', () => {
+ const fileUuid = 'file-uuid';
+ const versionId = 'version-id';
+ let storageClientMock: {
+ getFileVersions: ReturnType;
+ deleteFileVersion: ReturnType;
+ restoreFileVersion: ReturnType;
+ getFileVersionLimits: ReturnType;
+ };
+
+ beforeEach(() => {
+ storageClientMock = {
+ getFileVersions: vi.fn(),
+ deleteFileVersion: vi.fn(),
+ restoreFileVersion: vi.fn(),
+ getFileVersionLimits: vi.fn(),
+ };
+
+ vi.clearAllMocks();
+
+ vi.spyOn(SdkFactory, 'getNewApiInstance').mockReturnValue({
+ createNewStorageClient: () => storageClientMock,
+ } as any);
+ });
+
+ it('when file versions are requested, then the available list is returned', async () => {
+ const versions = [{ id: 'v1' } as FileVersion];
+ storageClientMock.getFileVersions.mockResolvedValueOnce(versions);
+
+ const result = await fileVersionService.getFileVersions(fileUuid);
+
+ expect(storageClientMock.getFileVersions).toHaveBeenCalledWith(fileUuid);
+ expect(result).toBe(versions);
+ });
+
+ it('when a version is deleted, then the delete request is sent', async () => {
+ storageClientMock.deleteFileVersion.mockResolvedValueOnce(undefined);
+
+ await fileVersionService.deleteVersion(fileUuid, versionId);
+
+ expect(storageClientMock.deleteFileVersion).toHaveBeenCalledWith(fileUuid, versionId);
+ });
+
+ it('when a version is restored, then the restore response is returned', async () => {
+ const restoreResponse = { restored: true } as unknown as RestoreFileVersionResponse;
+ storageClientMock.restoreFileVersion.mockResolvedValueOnce(restoreResponse);
+
+ const result = await fileVersionService.restoreVersion(fileUuid, versionId);
+
+ expect(storageClientMock.restoreFileVersion).toHaveBeenCalledWith(fileUuid, versionId);
+ expect(result).toBe(restoreResponse);
+ });
+
+ it('when versioning limits are checked, then the limits are returned', async () => {
+ const limits = { versioning: { enabled: true, maxFileSize: 0, retentionDays: 0, maxVersions: 0 } } as any;
+ storageClientMock.getFileVersionLimits.mockResolvedValueOnce(limits);
+
+ const result = await fileVersionService.getLimits();
+
+ expect(storageClientMock.getFileVersionLimits).toHaveBeenCalled();
+ expect(result).toBe(limits);
+ });
+
+ it('when a previous version is downloaded, then the request uses the version data', async () => {
+ const version = { networkFileId: 'network-file-id', size: '42' } as FileVersion;
+ const fileItem = { fileId: 'file-id', size: 10, name: 'original-name' } as any;
+ const selectedWorkspace = { workspace: { id: 'workspace-id' }, workspaceUser: {} } as unknown as WorkspaceData;
+ const workspaceCredentials = {
+ workspaceId: 'workspace-id',
+ bucket: 'bucket',
+ workspaceUserId: 'workspace-user',
+ email: 'user@example.com',
+ credentials: {} as any,
+ tokenHeader: 'token-header',
+ } as WorkspaceCredentialsDetails;
+ const downloadItemSpy = vi.spyOn(DownloadManager, 'downloadItem').mockResolvedValueOnce(undefined);
+
+ await fileVersionService.downloadVersion(version, fileItem, 'custom-name', selectedWorkspace, workspaceCredentials);
+
+ expect(downloadItemSpy).toHaveBeenCalledWith({
+ payload: [
+ {
+ ...fileItem,
+ fileId: version.networkFileId,
+ size: Number(version.size),
+ name: 'custom-name',
+ },
+ ],
+ selectedWorkspace,
+ workspaceCredentials,
+ });
+ });
+});
diff --git a/src/views/Drive/components/VersionHistory/services/fileVersion.service.ts b/src/views/Drive/components/VersionHistory/services/fileVersion.service.ts
new file mode 100644
index 000000000..a5d085091
--- /dev/null
+++ b/src/views/Drive/components/VersionHistory/services/fileVersion.service.ts
@@ -0,0 +1,54 @@
+import { SdkFactory } from 'app/core/factory/sdk';
+import { DownloadManager } from 'app/network/DownloadManager';
+import { DriveItemData } from 'app/drive/types';
+import { WorkspaceCredentialsDetails, WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { FileLimitsResponse, FileVersion, RestoreFileVersionResponse } from '@internxt/sdk/dist/drive/storage/types';
+
+const getStorageClient = () => SdkFactory.getNewApiInstance().createNewStorageClient();
+
+export async function getFileVersions(fileUuid: string): Promise {
+ return getStorageClient().getFileVersions(fileUuid);
+}
+
+export async function deleteVersion(fileUuid: string, versionId: string): Promise {
+ await getStorageClient().deleteFileVersion(fileUuid, versionId);
+}
+
+export async function restoreVersion(fileUuid: string, versionId: string): Promise {
+ return getStorageClient().restoreFileVersion(fileUuid, versionId);
+}
+
+export async function getLimits(): Promise {
+ return getStorageClient().getFileVersionLimits();
+}
+
+export async function downloadVersion(
+ version: FileVersion,
+ fileItem: DriveItemData,
+ fileName: string,
+ selectedWorkspace: WorkspaceData | null,
+ workspaceCredentials: WorkspaceCredentialsDetails | null,
+): Promise {
+ const versionFileData: DriveItemData = {
+ ...fileItem,
+ fileId: version.networkFileId,
+ size: Number(version.size),
+ name: fileName,
+ };
+
+ await DownloadManager.downloadItem({
+ payload: [versionFileData],
+ selectedWorkspace,
+ workspaceCredentials,
+ });
+}
+
+const fileVersionService = {
+ getFileVersions,
+ deleteVersion,
+ restoreVersion,
+ downloadVersion,
+ getLimits,
+};
+
+export default fileVersionService;
diff --git a/src/views/Drive/components/VersionHistory/types.ts b/src/views/Drive/components/VersionHistory/types.ts
deleted file mode 100644
index 9492b17ff..000000000
--- a/src/views/Drive/components/VersionHistory/types.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export interface FileVersion {
- id: string;
- date: Date;
- userName: string;
- expiresInDays?: number;
- isAutosave?: boolean;
- isCurrent?: boolean;
-}
diff --git a/src/views/Drive/components/VersionHistory/utils/index.ts b/src/views/Drive/components/VersionHistory/utils/index.ts
index 862f81431..0178c4433 100644
--- a/src/views/Drive/components/VersionHistory/utils/index.ts
+++ b/src/views/Drive/components/VersionHistory/utils/index.ts
@@ -1,3 +1,16 @@
import dateService from 'services/date.service';
+import { DriveItemData } from 'app/drive/types';
-export const formatVersionDate = (date: Date): string => dateService.format(date, 'MMM D, h:mm A');
+export const formatVersionDate = (date: string): string => dateService.format(date, 'MMM D, h:mm A');
+
+const ALLOWED_VERSIONING_EXTENSIONS = ['pdf', 'docx', 'xlsx', 'csv'];
+
+export const isVersioningExtensionAllowed = (item?: Pick | null): boolean => {
+ if (!item || !item.type) {
+ return false;
+ }
+ const extension = item.type.toLowerCase();
+ return ALLOWED_VERSIONING_EXTENSIONS.includes(extension);
+};
+
+export const getDaysUntilExpiration = (expiresAt: string): number => dateService.getDaysUntilExpiration(expiresAt);
diff --git a/src/views/Drive/hooks/useDriveItemActions.tsx b/src/views/Drive/hooks/useDriveItemActions.tsx
index a64eb0c71..6460615b7 100644
--- a/src/views/Drive/hooks/useDriveItemActions.tsx
+++ b/src/views/Drive/hooks/useDriveItemActions.tsx
@@ -11,6 +11,7 @@ import { storageActions } from 'app/store/slices/storage';
import { uiActions } from 'app/store/slices/ui';
import workspacesSelectors from 'app/store/slices/workspaces/workspaces.selectors';
import { DownloadManager } from 'app/network/DownloadManager';
+import { useVersionHistoryMenuConfig } from '../components/VersionHistory/hooks';
export interface DriveItemActions {
nameInputRef: React.RefObject;
@@ -38,6 +39,7 @@ const useDriveItemActions = (item): DriveItemActions => {
const selectedWorkspace = useAppSelector(workspacesSelectors.getSelectedWorkspace);
const workspaceCredentials = useAppSelector(workspacesSelectors.getWorkspaceCredentials);
const isWorkspace = !!selectedWorkspace;
+ const versionHistoryConfig = useVersionHistoryMenuConfig(item);
const onRenameItemButtonClicked = () => {
dispatch(storageActions.setItemToRename(item as DriveItemData));
@@ -102,6 +104,10 @@ const useDriveItemActions = (item): DriveItemActions => {
};
const onViewVersionHistoryButtonClicked = () => {
+ if (versionHistoryConfig.locked) {
+ versionHistoryConfig.onLockedClick?.();
+ return;
+ }
dispatch(uiActions.setVersionHistoryItem(item as DriveItemData));
dispatch(uiActions.setIsVersionHistorySidebarOpen(true));
};
diff --git a/src/views/Drive/services/replaceFile.service.ts b/src/views/Drive/services/replaceFile.service.ts
new file mode 100644
index 000000000..b98b40ed6
--- /dev/null
+++ b/src/views/Drive/services/replaceFile.service.ts
@@ -0,0 +1,18 @@
+import { SdkFactory } from 'app/core/factory/sdk';
+import { DriveFileData } from 'app/drive/types';
+
+export interface ReplaceFilePayload {
+ fileId: string;
+ size: number;
+}
+
+export async function replaceFile(fileUuid: string, payload: ReplaceFilePayload): Promise {
+ const storageClient = SdkFactory.getNewApiInstance().createNewStorageClient();
+ return storageClient.replaceFile(fileUuid, payload);
+}
+
+const replaceFileService = {
+ replaceFile,
+};
+
+export default replaceFileService;
diff --git a/yarn.lock b/yarn.lock
index 06da92d17..63686d20e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1906,10 +1906,10 @@
version "1.0.2"
resolved "https://codeload.github.com/internxt/prettier-config/tar.gz/9fa74e9a2805e1538b50c3809324f1c9d0f3e4f9"
-"@internxt/sdk@=1.11.17":
- version "1.11.17"
- resolved "https://registry.yarnpkg.com/@internxt/sdk/-/sdk-1.11.17.tgz#2f5bdada5d3cbf5cfc685a21c24b5df3ff51d8c8"
- integrity sha512-91iEUvZizlwX6KBEFJ3JdFiGrhMBQ9R54sTc3Pei9QtV2FYTU8nTVEPYAg39tLOGzT/kVuplYOtBxfk6wFtSDA==
+"@internxt/sdk@=1.11.24":
+ version "1.11.24"
+ resolved "https://registry.yarnpkg.com/@internxt/sdk/-/sdk-1.11.24.tgz#c0d31f99329f7553a88533bc59ddf8c155cf550b"
+ integrity sha512-GppLvUA6MhyiL/DIYDRhY/YdddrCZYz/d5/lbTHYwTbqrcVZEyAu8YbCEr0LG7GqhRxjnh4m55VAo//VC0dZyg==
dependencies:
axios "1.13.2"
uuid "11.1.0"