@jmruthers/pace-core 0.2.7 → 0.5.1

package/src/utils/storage/__tests__/helpers.unit.test.ts

@@ -1,648 +0,0 @@
-/**
- * @file Storage Helpers Unit Tests
- * @package @jmruthers/pace-core
- * @module Utils/Storage/Helpers
- * @since 0.4.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { StorageUploadOptions, StorageUrlOptions, StorageListOptions } from '../types';
-
-// Mock the config module
-vi.mock('../config', () => ({
-  STORAGE_CONFIG: {
-    bucketName: 'files',
-    fileSizeLimits: {
-      'image/jpeg': 5 * 1024 * 1024,
-      'application/pdf': 50 * 1024 * 1024,
-    },
-    defaultFileSizeLimit: 10 * 1024 * 1024
-  },
-  getFileSizeLimit: vi.fn((mimeType: string) => {
-    const limits = {
-      'image/jpeg': 5 * 1024 * 1024,
-      'application/pdf': 50 * 1024 * 1024,
-    };
-    return limits[mimeType] || 10 * 1024 * 1024;
-  }),
-  validateFileSize: vi.fn((file: File) => {
-    const limits = {
-      'image/jpeg': 5 * 1024 * 1024,
-      'application/pdf': 50 * 1024 * 1024,
-    };
-    const limit = limits[file.type] || 10 * 1024 * 1024;
-    if (file.size > limit) {
-      return { isValid: false, error: `File too large` };
-    }
-    return { isValid: true };
-  }),
-  formatFileSize: vi.fn((bytes: number) => {
-    if (bytes === 0) return '0 Bytes';
-    if (bytes < 0) return `${bytes} Bytes`;
-    const k = 1024;
-    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    const sizeIndex = Math.min(Math.max(i, 0), sizes.length - 1);
-    return parseFloat((bytes / Math.pow(k, sizeIndex)).toFixed(2)) + ' ' + sizes[sizeIndex];
-  })
-}));
-
-// Mock Supabase client methods
-const mockStorageMethods = {
-  upload: vi.fn(),
-  getPublicUrl: vi.fn(),
-  createSignedUrl: vi.fn(),
-  remove: vi.fn(),
-  list: vi.fn(),
-  copy: vi.fn()
-};
-
-const mockSupabaseClient = {
-  storage: {
-    from: vi.fn().mockReturnValue(mockStorageMethods)
-  }
-} as any;
-
-// Mock the Supabase client module
-vi.mock('@supabase/supabase-js', () => ({
-  SupabaseClient: vi.fn(() => mockSupabaseClient)
-}));
-
-// Import helpers after mocks are set up
-import {
-  generateFilePath,
-  generateUniqueFileName,
-  extractFileMetadata,
-  uploadFile,
-  getPublicUrl,
-  getSignedUrl,
-  deleteFile,
-  listFiles,
-  archiveFile
-} from '../helpers';
-
-// Date mocking is handled globally in vitest.setup.ts
-
-// Mock crypto.randomUUID
-const mockRandomUUID = vi.fn(() => 'test-uuid-123');
-
-// Mock URL.createObjectURL
-const mockCreateObjectURL = vi.fn(() => 'blob:mock-url');
-const mockRevokeObjectURL = vi.fn();
-vi.stubGlobal('URL', {
-  ...URL,
-  createObjectURL: mockCreateObjectURL,
-  revokeObjectURL: mockRevokeObjectURL
-});
-
-// Mock crypto.subtle.digest
-const mockDigest = vi.fn().mockResolvedValue(new ArrayBuffer(32));
-
-// Mock crypto globally
-Object.defineProperty(global, 'crypto', {
-  value: {
-    randomUUID: mockRandomUUID,
-    subtle: {
-      digest: mockDigest
-    }
-  },
-  writable: true
-});
-
-// Date mocking is handled globally in vitest.setup.ts
-
-// Mock Image constructor
-class MockImage {
-  width = 800;
-  height = 600;
-  onload: (() => void) | null = null;
-  onerror: ((error: Event) => void) | null = null;
-  src = '';
-
-  constructor() {
-    // Simulate immediate loading for tests
-    setTimeout(() => {
-      if (this.onload) {
-        this.width = 800;
-        this.height = 600;
-        this.onload();
-      }
-    }, 0);
-  }
-}
-
-vi.stubGlobal('Image', MockImage);
-
-// Helper function to create mock File objects
-function createMockFile(name: string, type: string, size: number): File {
-  const file = new File(['test content'], name, { type });
-  Object.defineProperty(file, 'size', { value: size });
-  
-  // Add arrayBuffer method for hash generation
-  const testContent = new Uint8Array([116, 101, 115, 116, 32, 99, 111, 110, 116, 101, 110, 116]); // "test content"
-  file.arrayBuffer = vi.fn().mockResolvedValue(testContent.buffer);
-  
-  return file;
-}
-
-describe('Storage Helpers', () => {
-  const baseOptions: StorageUploadOptions = {
-    appName: 'test-app',
-    orgId: 'org-123',
-    isPublic: false
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockRandomUUID.mockReturnValue('test-uuid-123');
-    mockCreateObjectURL.mockReturnValue('blob:mock-url');
-    mockDigest.mockResolvedValue(new ArrayBuffer(32));
-
-    // Reset Supabase mocks
-    mockStorageMethods.upload.mockClear();
-    mockStorageMethods.getPublicUrl.mockClear();
-    mockStorageMethods.createSignedUrl.mockClear();
-    mockStorageMethods.remove.mockClear();
-    mockStorageMethods.list.mockClear();
-    mockStorageMethods.copy.mockClear();
-
-    // Ensure the mock Supabase client is properly configured
-    mockSupabaseClient.storage.from.mockReturnValue(mockStorageMethods);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  describe('generateFilePath', () => {
-    it('should generate path for private files with default structure', () => {
-      // Import here to avoid hoisting issues
-      const result = generateFilePath(baseOptions, 'test.jpg');
-      expect(result).toBe('apps/test-app/org-123/files/test.jpg');
-    });
-
-    it('should generate path for public files with default structure', () => {
-      const options = { ...baseOptions, isPublic: true };
-      const result = generateFilePath(options, 'test.jpg');
-      expect(result).toBe('public/assets/test-app/test.jpg');
-    });
-
-    it('should generate path with custom path for private files', () => {
-      const options = { ...baseOptions, customPath: 'uploads' };
-      const result = generateFilePath(options, 'test.jpg');
-      expect(result).toBe('apps/test-app/org-123/uploads/test.jpg');
-    });
-
-    it('should generate path with custom path for public files', () => {
-      const options = { ...baseOptions, isPublic: true, customPath: 'images' };
-      const result = generateFilePath(options, 'test.jpg');
-      expect(result).toBe('public/images/test.jpg');
-    });
-  });
-
-  describe('generateUniqueFileName', () => {
-    it('should generate unique filename with timestamp and UUID', () => {
-      const result = generateUniqueFileName('test.jpg');
-      expect(result).toMatch(/^\d+-test-uuid-123-test\.jpg$/);
-    });
-
-    it('should handle filename without extension', () => {
-      const result = generateUniqueFileName('test');
-      expect(result).toMatch(/^\d+-test-uuid-123-test\.test$/);
-    });
-
-    it('should handle empty filename', () => {
-      const result = generateUniqueFileName('');
-      expect(result).toMatch(/^\d+-test-uuid-123-\.$/);
-    });
-
-    it('should handle filename with multiple dots', () => {
-      const result = generateUniqueFileName('test.backup.jpg');
-      expect(result).toMatch(/^\d+-test-uuid-123-test\.backup\.jpg$/);
-    });
-  });
-
-  describe('extractFileMetadata', () => {
-    it('should extract basic metadata for non-image files', async () => {
-      const file = createMockFile('test.pdf', 'application/pdf', 1024);
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-
-      expect(result).toEqual({
-        mimeType: 'application/pdf',
-        size: 1024,
-        orgId: 'org-123',
-        appName: 'test-app',
-        uploadedBy: 'user-123',
-        uploadedAt: expect.any(String),
-        tags: [],
-        isPublic: false,
-        customMetadata: {},
-        hash: expect.any(String)
-      });
-    });
-
-    it('should extract metadata with image dimensions for image files', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-
-      expect(result.mimeType).toBe('image/jpeg');
-      expect(result.size).toBe(1024);
-      expect(result.orgId).toBe('org-123');
-      expect(result.appName).toBe('test-app');
-      expect(result.uploadedBy).toBe('user-123');
-      expect(result.uploadedAt).toBeDefined();
-      expect(result.tags).toEqual([]);
-      expect(result.isPublic).toBe(false);
-      expect(result.customMetadata).toEqual({});
-      expect(result.hash).toBeDefined();
-      expect(result.width).toBe(800);
-      expect(result.height).toBe(600);
-    }, 1000);
-
-    it('should handle image loading errors gracefully', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-
-      // Check basic metadata
-      expect(result.mimeType).toBe('image/jpeg');
-      expect(result.size).toBe(1024);
-      expect(result.hash).toBeDefined();
-      expect(result.width).toBe(800);
-      expect(result.height).toBe(600);
-    }, 1000);
-
-    it('should include custom metadata and tags', async () => {
-      const file = createMockFile('test.pdf', 'application/pdf', 1024);
-      const options = {
-        ...baseOptions,
-        tags: ['document', 'important'],
-        metadata: { category: 'legal' }
-      };
-      const result = await extractFileMetadata(file, options, 'user-123');
-
-      expect(result.tags).toEqual(['document', 'important']);
-      expect(result.customMetadata).toEqual({ category: 'legal' });
-    });
-
-    it('should handle hash generation errors gracefully', async () => {
-      const file = createMockFile('test.pdf', 'application/pdf', 1024);
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-
-      // Hash generation is working, so expect it to be defined
-      expect(result.hash).toBeDefined();
-      expect(typeof result.hash).toBe('string');
-      expect(result.hash).toMatch(/^sha256:/);
-    });
-  });
-
-  describe('uploadFile', () => {
-    it('should upload file successfully', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const mockUploadResponse = { data: { path: 'test-path' }, error: null };
-      mockStorageMethods.upload.mockResolvedValue(mockUploadResponse);
-
-      const result = await uploadFile(mockSupabaseClient, file, baseOptions);
-
-      expect(result.success).toBe(true);
-      expect(result.path).toMatch(/^apps\/test-app\/org-123\/files\/\d+-test-uuid-123-test\.jpg$/);
-      expect(result.metadata).toBeDefined();
-      expect(mockStorageMethods.upload).toHaveBeenCalled();
-    }, 1000);
-
-    it('should generate public URL for public files', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const options = { ...baseOptions, isPublic: true };
-      const mockUploadResponse = { data: { path: 'test-path' }, error: null };
-      const mockPublicUrl = 'https://example.com/public-url';
-      
-      mockStorageMethods.upload.mockResolvedValue(mockUploadResponse);
-      mockStorageMethods.getPublicUrl.mockReturnValue({ data: { publicUrl: mockPublicUrl } });
-
-      const result = await uploadFile(mockSupabaseClient, file, options);
-
-      expect(result.success).toBe(true);
-      expect(result.publicUrl).toBe(mockPublicUrl);
-    }, 1000);
-
-    it('should handle upload errors', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const mockUploadResponse = { data: null, error: { message: 'Upload failed' } };
-      mockStorageMethods.upload.mockResolvedValue(mockUploadResponse);
-
-      const result = await uploadFile(mockSupabaseClient, file, baseOptions);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Upload failed: Upload failed');
-    }, 1000);
-
-    it('should handle unexpected errors', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      mockStorageMethods.upload.mockRejectedValue(new Error('Network error'));
-
-      const result = await uploadFile(mockSupabaseClient, file, baseOptions);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Upload failed: Network error');
-    }, 1000);
-
-    it('should handle non-Error exceptions', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      mockStorageMethods.upload.mockRejectedValue('String error');
-
-      const result = await uploadFile(mockSupabaseClient, file, baseOptions);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Upload failed: Unknown error');
-    }, 1000);
-  });
-
-  describe('getPublicUrl', () => {
-    it('should return public URL for given path', () => {
-      const mockPublicUrl = 'https://example.com/public-url';
-      mockStorageMethods.getPublicUrl.mockReturnValue({ data: { publicUrl: mockPublicUrl } });
-
-      const result = getPublicUrl(mockSupabaseClient, 'test.jpg');
-
-      expect(result).toBe(mockPublicUrl);
-      expect(mockStorageMethods.getPublicUrl).toHaveBeenCalledWith('test.jpg');
-    });
-  });
-
-  describe('getSignedUrl', () => {
-    it('should create signed URL successfully', async () => {
-      const mockSignedUrl = 'https://example.com/signed-url';
-      const mockResponse = { data: { signedUrl: mockSignedUrl }, error: null };
-      mockStorageMethods.createSignedUrl.mockResolvedValue(mockResponse);
-
-      const options: StorageUrlOptions = { expiresIn: 3600 };
-      const result = await getSignedUrl(mockSupabaseClient, 'test.jpg', options);
-
-      expect(result).toEqual({
-        url: mockSignedUrl,
-        expiresAt: expect.any(String)
-      });
-      expect(mockStorageMethods.createSignedUrl).toHaveBeenCalledWith('test.jpg', 3600);
-    });
-
-    it('should use default expiry time when not provided', async () => {
-      const mockSignedUrl = 'https://example.com/signed-url';
-      const mockResponse = { data: { signedUrl: mockSignedUrl }, error: null };
-      mockStorageMethods.createSignedUrl.mockResolvedValue(mockResponse);
-
-      const result = await getSignedUrl(mockSupabaseClient, 'test.jpg', {});
-
-      expect(result).toBeDefined();
-      expect(mockStorageMethods.createSignedUrl).toHaveBeenCalledWith('test.jpg', 3600);
-    });
-
-    it('should return null on error', async () => {
-      const mockResponse = { data: null, error: { message: 'Failed to create signed URL' } };
-      mockStorageMethods.createSignedUrl.mockResolvedValue(mockResponse);
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      const result = await getSignedUrl(mockSupabaseClient, 'test.jpg', {});
-
-      expect(result).toBeNull();
-      expect(consoleSpy).toHaveBeenCalledWith('Failed to create signed URL:', expect.any(Object));
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle exceptions', async () => {
-      mockStorageMethods.createSignedUrl.mockRejectedValue(new Error('Network error'));
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      const result = await getSignedUrl(mockSupabaseClient, 'test.jpg', {});
-
-      expect(result).toBeNull();
-      expect(consoleSpy).toHaveBeenCalledWith('Failed to create signed URL:', expect.any(Error));
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('deleteFile', () => {
-    it('should delete file successfully', async () => {
-      const mockResponse = { data: null, error: null };
-      mockStorageMethods.remove.mockResolvedValue(mockResponse);
-
-      const result = await deleteFile(mockSupabaseClient, 'test.jpg');
-
-      expect(result.success).toBe(true);
-      expect(mockStorageMethods.remove).toHaveBeenCalledWith(['test.jpg']);
-    });
-
-    it('should handle delete errors', async () => {
-      const mockResponse = { data: null, error: { message: 'Delete failed' } };
-      mockStorageMethods.remove.mockResolvedValue(mockResponse);
-
-      const result = await deleteFile(mockSupabaseClient, 'test.jpg');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Delete failed: Delete failed');
-    });
-
-    it('should handle unexpected errors', async () => {
-      mockStorageMethods.remove.mockRejectedValue(new Error('Network error'));
-
-      const result = await deleteFile(mockSupabaseClient, 'test.jpg');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Delete failed: Network error');
-    });
-
-    it('should handle non-Error exceptions', async () => {
-      mockStorageMethods.remove.mockRejectedValue('String error');
-
-      const result = await deleteFile(mockSupabaseClient, 'test.jpg');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Delete failed: Unknown error');
-    });
-  });
-
-  describe('listFiles', () => {
-    const options: StorageListOptions = {
-      appName: 'test-app',
-      orgId: 'org-123'
-    };
-
-    it('should list files successfully', async () => {
-      const mockFiles = [
-        {
-          name: 'file1.jpg',
-          created_at: '2023-01-01T00:00:00Z',
-          updated_at: '2023-01-01T00:00:00Z',
-          metadata: { size: 1024, mimetype: 'image/jpeg' }
-        },
-        {
-          name: 'file2.pdf',
-          created_at: '2023-01-02T00:00:00Z',
-          updated_at: '2023-01-02T00:00:00Z',
-          metadata: { size: 2048, mimetype: 'application/pdf' }
-        }
-      ];
-      const mockResponse = { data: mockFiles, error: null };
-      mockStorageMethods.list.mockResolvedValue(mockResponse);
-
-      const result = await listFiles(mockSupabaseClient, options);
-
-      expect(result.files).toHaveLength(2);
-      expect(result.totalCount).toBe(2);
-      expect(result.hasMore).toBe(false);
-      expect(mockStorageMethods.list).toHaveBeenCalledWith(
-        'apps/test-app/org-123/',
-        expect.any(Object)
-      );
-    });
-
-    it('should handle list errors', async () => {
-      const mockResponse = { data: null, error: { message: 'List failed' } };
-      mockStorageMethods.list.mockResolvedValue(mockResponse);
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      const result = await listFiles(mockSupabaseClient, options);
-
-      expect(result.files).toEqual([]);
-      expect(result.totalCount).toBe(0);
-      expect(result.hasMore).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith('Failed to list files:', expect.any(Object));
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle unexpected errors', async () => {
-      mockStorageMethods.list.mockRejectedValue(new Error('Network error'));
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      const result = await listFiles(mockSupabaseClient, options);
-
-      expect(result.files).toEqual([]);
-      expect(result.totalCount).toBe(0);
-      expect(result.hasMore).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith('Failed to list files:', expect.any(Error));
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle files with missing metadata', async () => {
-      const mockFiles = [
-        {
-          name: 'file1.jpg',
-          created_at: '2023-01-01T00:00:00Z',
-          updated_at: '2023-01-01T00:00:00Z',
-          metadata: null
-        }
-      ];
-      const mockResponse = { data: mockFiles, error: null };
-      mockStorageMethods.list.mockResolvedValue(mockResponse);
-
-      const result = await listFiles(mockSupabaseClient, options);
-
-      expect(result.files[0].size).toBe(0);
-      expect(result.files[0].mimeType).toBe('application/octet-stream');
-    });
-
-    it('should use custom path prefix', async () => {
-      const optionsWithPrefix = { ...options, pathPrefix: 'uploads/images' };
-      const mockResponse = { data: [], error: null };
-      mockStorageMethods.list.mockResolvedValue(mockResponse);
-
-      await listFiles(mockSupabaseClient, optionsWithPrefix);
-
-      expect(mockStorageMethods.list).toHaveBeenCalledWith(
-        'apps/test-app/org-123/uploads/images',
-        expect.any(Object)
-      );
-    });
-
-    it('should determine hasMore correctly', async () => {
-      const mockFiles = Array(100).fill(null).map((_, i) => ({
-        name: `file${i}.jpg`,
-        created_at: '2023-01-01T00:00:00Z',
-        updated_at: '2023-01-01T00:00:00Z',
-        metadata: { size: 1024, mimetype: 'image/jpeg' }
-      }));
-      const mockResponse = { data: mockFiles, error: null };
-      mockStorageMethods.list.mockResolvedValue(mockResponse);
-
-      const optionsWithLimit = { ...options, limit: 50 };
-      const result = await listFiles(mockSupabaseClient, optionsWithLimit);
-
-      expect(result.hasMore).toBe(true);
-    });
-  });
-
-  describe('archiveFile', () => {
-    it('should archive file successfully', async () => {
-      const mockCopyResponse = { data: null, error: null };
-      const mockDeleteResponse = { data: null, error: null };
-      mockStorageMethods.copy.mockResolvedValue(mockCopyResponse);
-      mockStorageMethods.remove.mockResolvedValue(mockDeleteResponse);
-
-      const result = await archiveFile(mockSupabaseClient, 'apps/test-app/org-123/files/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-
-      expect(result.success).toBe(true);
-      expect(mockStorageMethods.copy).toHaveBeenCalledWith(
-        'apps/test-app/org-123/files/test.jpg',
-        'archived/test-app/org-123/files/test.jpg'
-      );
-      expect(mockStorageMethods.remove).toHaveBeenCalledWith(['apps/test-app/org-123/files/test.jpg']);
-    });
-
-    it('should handle copy errors', async () => {
-      const mockCopyResponse = { data: null, error: { message: 'Copy failed' } };
-      mockStorageMethods.copy.mockResolvedValue(mockCopyResponse);
-
-      const result = await archiveFile(mockSupabaseClient, 'apps/test-app/org-123/files/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Archive failed: Copy failed');
-    });
-
-    it('should handle delete errors', async () => {
-      const mockCopyResponse = { data: null, error: null };
-      const mockDeleteResponse = { data: null, error: { message: 'Delete failed' } };
-      mockStorageMethods.copy.mockResolvedValue(mockCopyResponse);
-      mockStorageMethods.remove.mockResolvedValue(mockDeleteResponse);
-
-      const result = await archiveFile(mockSupabaseClient, 'apps/test-app/org-123/files/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Delete failed: Delete failed');
-    });
-
-    it('should handle unexpected errors', async () => {
-      mockStorageMethods.copy.mockRejectedValue(new Error('Network error'));
-
-      const result = await archiveFile(mockSupabaseClient, 'apps/test-app/org-123/files/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Archive failed: Network error');
-    });
-
-    it('should handle non-Error exceptions', async () => {
-      mockStorageMethods.copy.mockRejectedValue('String error');
-
-      const result = await archiveFile(mockSupabaseClient, 'apps/test-app/org-123/files/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Archive failed: Unknown error');
-    });
-  });
-});