@geekmidas/storage 2.0.4 → 10.0.0-alpha.0

package/src/__tests__/AmazonStorageClient.spec.ts

@@ -1,606 +0,0 @@
-import { S3Client } from '@aws-sdk/client-s3';
-import { InMemoryCache } from '@geekmidas/cache/memory';
-import { beforeAll, describe, expect, it } from 'vitest';
-import {
-	AmazonCannedAccessControlList,
-	AmazonStorageClient,
-} from '../AmazonStorageClient';
-import { StorageProvider } from '../StorageClient';
-
-describe('AmazonStorageClient Integration Tests', () => {
-	let client: AmazonStorageClient;
-	const testBucket = 'geekmidas';
-	const testKey = 'test-files/test.txt';
-	const testContent = 'Hello, World!';
-	const testContentType = 'text/plain';
-
-	beforeAll(async () => {
-		// Create storage client pointing to MinIO
-		client = AmazonStorageClient.create({
-			bucket: testBucket,
-			region: 'us-east-1',
-			accessKeyId: 'geekmidas',
-			secretAccessKey: 'geekmidas',
-			endpoint: 'http://localhost:9000',
-			acl: AmazonCannedAccessControlList.PublicRead,
-			forcePathStyle: true,
-		});
-
-		// Wait for MinIO to be ready
-		await new Promise((resolve) => setTimeout(resolve, 2000));
-	});
-
-	describe('provider property', () => {
-		it('should return AWS S3 provider', () => {
-			expect(client.provider).toBe(StorageProvider.AWSS3);
-		});
-	});
-
-	describe('upload and download workflow', () => {
-		it.skip('should upload a file directly and generate download URL', async () => {
-			// Upload file directly
-			await client.upload(testKey, testContent, testContentType);
-
-			// Generate download URL
-			const downloadUrl = await client.getDownloadURL({ path: testKey });
-
-			expect(downloadUrl).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/test-files\/test\.txt/,
-			);
-			expect(downloadUrl).toContain('X-Amz-Algorithm=AWS4-HMAC-SHA256');
-			expect(downloadUrl).toContain('X-Amz-Credential=');
-			expect(downloadUrl).toContain('X-Amz-Date=');
-			expect(downloadUrl).toContain('X-Amz-SignedHeaders=');
-			expect(downloadUrl).toContain('X-Amz-Signature=');
-
-			// Verify file can be downloaded
-			const response = await fetch(downloadUrl);
-			expect(response.ok).toBe(true);
-
-			const downloadedContent = await response.text();
-			expect(downloadedContent).toBe(testContent);
-		});
-
-		it('should upload a file with filename and generate download URL with content disposition', async () => {
-			const keyWithName = 'test-files/named-file.txt';
-			const fileName = 'my-document.txt';
-
-			await client.upload(keyWithName, testContent, testContentType);
-
-			const downloadUrl = await client.getDownloadURL({
-				path: keyWithName,
-				name: fileName,
-			});
-
-			expect(downloadUrl).toContain(
-				'response-content-disposition=attachment%3B%20filename%3Dmy-document.txt',
-			);
-		});
-
-		it('should generate download URL with inline disposition', async () => {
-			const key = 'test-files/inline-file.txt';
-			await client.upload(key, testContent, testContentType);
-
-			const downloadUrl = await client.getDownloadURL({
-				path: key,
-				disposition: 'inline',
-			});
-
-			expect(downloadUrl).toContain('response-content-disposition=inline');
-		});
-
-		it('should generate download URL with inline disposition and filename', async () => {
-			const key = 'test-files/inline-named.txt';
-			await client.upload(key, testContent, testContentType);
-
-			const downloadUrl = await client.getDownloadURL({
-				path: key,
-				name: 'preview.txt',
-				disposition: 'inline',
-			});
-
-			expect(downloadUrl).toContain(
-				'response-content-disposition=inline%3B%20filename%3Dpreview.txt',
-			);
-		});
-
-		it('should generate download URL with response content type override', async () => {
-			const key = 'test-files/content-type-override.bin';
-			await client.upload(key, testContent, 'application/octet-stream');
-
-			const downloadUrl = await client.getDownloadURL({
-				path: key,
-				responseContentType: 'application/pdf',
-				disposition: 'inline',
-			});
-
-			expect(downloadUrl).toContain('response-content-type=application%2Fpdf');
-		});
-
-		it('should default to attachment disposition when name is set', async () => {
-			const key = 'test-files/default-disposition.txt';
-			await client.upload(key, testContent, testContentType);
-
-			const downloadUrl = await client.getDownloadURL({
-				path: key,
-				name: 'download.txt',
-			});
-
-			expect(downloadUrl).toContain(
-				'response-content-disposition=attachment%3B%20filename%3Ddownload.txt',
-			);
-		});
-
-		it('should handle binary data upload', async () => {
-			const binaryKey = 'test-files/binary.bin';
-			const binaryData = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]); // "Hello" in bytes
-
-			await client.upload(binaryKey, binaryData, 'application/octet-stream');
-
-			const downloadUrl = await client.getDownloadURL({ path: binaryKey });
-			const response = await fetch(downloadUrl);
-			const downloadedBuffer = await response.arrayBuffer();
-
-			expect(new Uint8Array(downloadedBuffer)).toEqual(
-				new Uint8Array(binaryData),
-			);
-		});
-	});
-
-	describe('presigned upload URLs', () => {
-		it('should generate presigned PUT upload URL', async () => {
-			const uploadKey = 'test-files/presigned-upload.txt';
-			const uploadUrl = await client.getUploadURL({
-				path: uploadKey,
-				contentType: testContentType,
-				contentLength: testContent.length,
-			});
-
-			expect(uploadUrl).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/test-files\/presigned-upload\.txt/,
-			);
-			expect(uploadUrl).toContain('X-Amz-Algorithm=AWS4-HMAC-SHA256');
-
-			// Test actual upload using the presigned URL
-			const uploadResponse = await fetch(uploadUrl, {
-				method: 'PUT',
-				headers: {
-					'Content-Type': testContentType,
-					'Content-Length': testContent.length.toString(),
-				},
-				body: testContent,
-			});
-
-			expect(uploadResponse.ok).toBe(true);
-
-			// Verify file was uploaded
-			const downloadUrl = await client.getDownloadURL({ path: uploadKey });
-			const downloadResponse = await fetch(downloadUrl);
-			const downloadedContent = await downloadResponse.text();
-			expect(downloadedContent).toBe(testContent);
-		});
-
-		it('should generate presigned POST upload with form fields', async () => {
-			const uploadKey = 'test-files/presigned-post.txt';
-			const uploadData = await client.getUpload({
-				path: uploadKey,
-				contentType: testContentType,
-				contentLength: testContent.length,
-			});
-
-			expect(uploadData.url).toBe('http://localhost:9000/geekmidas');
-			expect(uploadData.fields).toContainEqual({
-				key: 'key',
-				value: uploadKey,
-			});
-			expect(uploadData.fields).toContainEqual({
-				key: 'acl',
-				value: 'public-read',
-			});
-
-			// Test actual upload using the presigned POST
-			const formData = new FormData();
-			uploadData.fields.forEach(({ key, value }) => {
-				formData.append(key, value);
-			});
-			formData.append(
-				'file',
-				new Blob([testContent], { type: testContentType }),
-			);
-
-			const uploadResponse = await fetch(uploadData.url, {
-				method: 'POST',
-				body: formData,
-			});
-
-			expect(uploadResponse.ok).toBe(true);
-
-			// Verify file was uploaded
-			const downloadUrl = await client.getDownloadURL({ path: uploadKey });
-			const downloadResponse = await fetch(downloadUrl);
-			const downloadedContent = await downloadResponse.blob();
-			expect(downloadedContent).toEqual(
-				new Blob([testContent], { type: testContentType }),
-			);
-		});
-	});
-
-	describe('versioning', () => {
-		it('should handle file versions', async () => {
-			const versionKey = 'test-files/versioned.txt';
-			const content1 = 'Version 1';
-			const content2 = 'Version 2';
-
-			// Upload first version
-			await client.upload(versionKey, content1, testContentType);
-
-			// Upload second version
-			await client.upload(versionKey, content2, testContentType);
-
-			// Get versions - MinIO might not enable versioning by default
-			// This test verifies the method works even if versioning is not enabled
-			const versions = await client.getVersions(versionKey);
-			expect(Array.isArray(versions)).toBe(true);
-
-			// If versioning is enabled, we should have multiple versions
-			// If not, we should have at least the current version
-			if (versions.length > 0) {
-				expect(versions[0]).toHaveProperty('id');
-				expect(versions[0]).toHaveProperty('createdAt');
-				expect(versions[0].createdAt).toBeInstanceOf(Date);
-			}
-		});
-	});
-
-	describe('error handling', () => {
-		it('should handle download URL generation for non-existent files', async () => {
-			// This should not throw - presigned URLs can be generated for non-existent files
-			const downloadUrl = await client.getDownloadURL({
-				path: 'non-existent/file.txt',
-			});
-			expect(downloadUrl).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/non-existent\/file\.txt/,
-			);
-
-			// But accessing the URL should return 404
-			const response = await fetch(downloadUrl);
-			expect(response.status).toBe(404);
-		});
-	});
-
-	describe('custom expiration times', () => {
-		it('should respect custom expiration for download URLs', async () => {
-			const key = 'test-files/expiration-test.txt';
-			await client.upload(key, testContent, testContentType);
-
-			const shortExpirationUrl = await client.getDownloadURL({ path: key }, 1); // 1 second
-			const longExpirationUrl = await client.getDownloadURL(
-				{ path: key },
-				3600,
-			); // 1 hour
-
-			expect(shortExpirationUrl).toContain('X-Amz-Expires=1');
-			expect(longExpirationUrl).toContain('X-Amz-Expires=3600');
-		});
-
-		it('should respect custom expiration for upload URLs', async () => {
-			const key = 'test-files/upload-expiration-test.txt';
-
-			const shortExpirationUrl = await client.getUploadURL(
-				{
-					path: key,
-					contentType: testContentType,
-					contentLength: testContent.length,
-				},
-				1,
-			); // 1 second
-
-			const longExpirationUrl = await client.getUploadURL(
-				{
-					path: key,
-					contentType: testContentType,
-					contentLength: testContent.length,
-				},
-				3600,
-			); // 1 hour
-
-			expect(shortExpirationUrl).toContain('X-Amz-Expires=1');
-			expect(longExpirationUrl).toContain('X-Amz-Expires=3600');
-		});
-	});
-
-	describe('factory method', () => {
-		it('should create client with minimal configuration', () => {
-			const minimalClient = AmazonStorageClient.create({
-				bucket: 'geekmidas',
-			});
-
-			expect(minimalClient).toBeInstanceOf(AmazonStorageClient);
-			expect(minimalClient.provider).toBe(StorageProvider.AWSS3);
-		});
-
-		it('should create client with full configuration', () => {
-			const fullClient = AmazonStorageClient.create({
-				bucket: 'geekmidas',
-				region: 'us-west-2',
-				accessKeyId: 'test-key',
-				secretAccessKey: 'test-secret',
-				endpoint: 'https://custom-s3.example.com',
-				acl: AmazonCannedAccessControlList.Private,
-			});
-
-			expect(fullClient).toBeInstanceOf(AmazonStorageClient);
-			expect(fullClient.provider).toBe(StorageProvider.AWSS3);
-		});
-	});
-
-	describe('different ACL configurations', () => {
-		it('should work with different ACL settings', async () => {
-			const privateClient = AmazonStorageClient.create({
-				bucket: testBucket,
-				region: 'us-east-1',
-				accessKeyId: 'minioadmin',
-				secretAccessKey: 'minioadmin',
-				endpoint: 'http://localhost:9000',
-				acl: AmazonCannedAccessControlList.Private,
-			});
-
-			const uploadData = await privateClient.getUpload({
-				path: 'test-files/private.txt',
-				contentType: testContentType,
-				contentLength: testContent.length,
-			});
-
-			expect(uploadData.fields).toContainEqual({
-				key: 'acl',
-				value: 'private',
-			});
-		});
-	});
-
-	describe('S3Client integration', () => {
-		it('should work with externally created S3Client', () => {
-			const s3Client = new S3Client({
-				region: 'us-east-1',
-				credentials: {
-					accessKeyId: 'minioadmin',
-					secretAccessKey: 'minioadmin',
-				},
-				endpoint: 'http://localhost:9000',
-			});
-
-			const storageClient = new AmazonStorageClient(
-				s3Client,
-				testBucket,
-				AmazonCannedAccessControlList.PublicRead,
-			);
-
-			expect(storageClient).toBeInstanceOf(AmazonStorageClient);
-			expect(storageClient.provider).toBe(StorageProvider.AWSS3);
-		});
-	});
-
-	describe('cache functionality', () => {
-		it('should cache download URLs', async () => {
-			const cache = new InMemoryCache();
-			const clientWithCache = AmazonStorageClient.create({
-				bucket: testBucket,
-				region: 'us-east-1',
-				accessKeyId: 'geekmidas',
-				secretAccessKey: 'geekmidas',
-				endpoint: 'http://localhost:9000',
-				forcePathStyle: true,
-				cache,
-			});
-
-			const key = 'test-files/cache-test.txt';
-			await clientWithCache.upload(key, testContent, testContentType);
-
-			// First call should generate and cache the URL
-			const url1 = await clientWithCache.getDownloadURL({ path: key });
-
-			// Second call should return the cached URL
-			const url2 = await clientWithCache.getDownloadURL({ path: key });
-
-			// URLs should be identical (same cached value)
-			expect(url1).toBe(url2);
-
-			// Verify the URL was cached
-			const cacheKey = `download-url:${key}`;
-			const cachedUrl = await cache.get(cacheKey);
-			expect(cachedUrl).toBe(url1);
-		});
-
-		it('should respect cache expiration based on URL expiry', async () => {
-			const cache = new InMemoryCache();
-			const clientWithCache = AmazonStorageClient.create({
-				bucket: testBucket,
-				region: 'us-east-1',
-				accessKeyId: 'geekmidas',
-				secretAccessKey: 'geekmidas',
-				endpoint: 'http://localhost:9000',
-				forcePathStyle: true,
-				cache,
-			});
-
-			const key = 'test-files/cache-expiry.txt';
-			await clientWithCache.upload(key, testContent, testContentType);
-
-			// Generate URL with short expiry that won't be cached
-			await clientWithCache.getDownloadURL({ path: key }, 30); // 30 seconds
-
-			// Check cache doesn't contain the URL (too short to cache)
-			const cacheKey = `download-url:${key}`;
-			const cachedShortUrl = await cache.get(cacheKey);
-			expect(cachedShortUrl).toBeUndefined();
-
-			// Generate URL with longer expiry that will be cached
-			const longExpiryUrl = await clientWithCache.getDownloadURL(
-				{ path: key },
-				3600,
-			); // 1 hour
-
-			// Check cache contains the URL
-			const cachedLongUrl = await cache.get(cacheKey);
-			expect(cachedLongUrl).toBe(longExpiryUrl);
-		});
-
-		it('should use cached URL when available', async () => {
-			const cache = new InMemoryCache();
-			const clientWithCache = AmazonStorageClient.create({
-				bucket: testBucket,
-				region: 'us-east-1',
-				accessKeyId: 'geekmidas',
-				secretAccessKey: 'geekmidas',
-				endpoint: 'http://localhost:9000',
-				forcePathStyle: true,
-				cache,
-			});
-
-			const key = 'test-files/pre-cached.txt';
-			const cachedUrl = 'https://pre-cached-url.example.com';
-			const cacheKey = `download-url:${key}`;
-
-			// Pre-populate cache
-			await cache.set(cacheKey, cachedUrl);
-
-			// Get download URL should return cached value
-			const url = await clientWithCache.getDownloadURL({ path: key });
-			expect(url).toBe(cachedUrl);
-		});
-
-		it('should work without cache', async () => {
-			// Client without cache should work normally
-			const clientNoCache = AmazonStorageClient.create({
-				bucket: testBucket,
-				region: 'us-east-1',
-				accessKeyId: 'geekmidas',
-				secretAccessKey: 'geekmidas',
-				endpoint: 'http://localhost:9000',
-				forcePathStyle: true,
-			});
-
-			const key = 'test-files/no-cache.txt';
-			await clientNoCache.upload(key, testContent, testContentType);
-
-			const url1 = await clientNoCache.getDownloadURL({ path: key });
-			const url2 = await clientNoCache.getDownloadURL({ path: key });
-
-			// Without cache, new URLs might be generated each time
-			// Both should be valid URLs
-			expect(url1).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/test-files\/no-cache\.txt/,
-			);
-			expect(url2).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/test-files\/no-cache\.txt/,
-			);
-		});
-
-		it('should pass cache to constructor', () => {
-			const cache = new InMemoryCache();
-			const s3Client = new S3Client({
-				region: 'us-east-1',
-				credentials: {
-					accessKeyId: 'geekmidas',
-					secretAccessKey: 'geekmidas',
-				},
-				endpoint: 'http://localhost:9000',
-				forcePathStyle: true,
-			});
-
-			const clientWithCache = new AmazonStorageClient(
-				s3Client,
-				testBucket,
-				AmazonCannedAccessControlList.PublicRead,
-				cache,
-			);
-
-			expect(clientWithCache.cache).toBe(cache);
-		});
-	});
-
-	describe('delete', () => {
-		it('should delete an uploaded file', async () => {
-			const key = 'test-files/delete-test.txt';
-			await client.upload(key, testContent, testContentType);
-
-			// Verify file exists
-			const downloadUrl = await client.getDownloadURL({ path: key });
-			const before = await fetch(downloadUrl);
-			expect(before.ok).toBe(true);
-
-			// Delete file
-			await client.delete(key);
-
-			// Verify file is gone
-			const afterUrl = await client.getDownloadURL({ path: key });
-			const after = await fetch(afterUrl);
-			expect(after.status).toBe(404);
-		});
-
-		it('should not throw when deleting a non-existent file', async () => {
-			await expect(
-				client.delete('non-existent/file.txt'),
-			).resolves.not.toThrow();
-		});
-	});
-
-	describe('getVersionDownloadURL', () => {
-		it('should generate version-specific download URL', async () => {
-			const versionKey = 'test-files/version-download.txt';
-			const versionId = 'test-version-id';
-
-			// Upload a file first
-			await client.upload(versionKey, testContent, testContentType);
-
-			// Generate version-specific download URL
-			const downloadUrl = await client.getVersionDownloadURL(
-				{ path: versionKey, name: 'versioned-file.txt' },
-				versionId,
-			);
-
-			expect(downloadUrl).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/test-files\/version-download\.txt/,
-			);
-			expect(downloadUrl).toContain('X-Amz-Algorithm=AWS4-HMAC-SHA256');
-			expect(downloadUrl).toContain(
-				'response-content-disposition=attachment%3B%20filename%3Dversioned-file.txt',
-			);
-		});
-
-		it('should generate version URL with inline disposition', async () => {
-			const versionKey = 'test-files/version-inline.txt';
-			const versionId = 'test-version-id';
-
-			await client.upload(versionKey, testContent, testContentType);
-
-			const downloadUrl = await client.getVersionDownloadURL(
-				{ path: versionKey, name: 'inline-file.txt', disposition: 'inline' },
-				versionId,
-			);
-
-			expect(downloadUrl).toContain(
-				'response-content-disposition=inline%3B%20filename%3Dinline-file.txt',
-			);
-		});
-
-		it('should generate version URL without filename', async () => {
-			const versionKey = 'test-files/version-no-name.txt';
-			const versionId = 'test-version-id';
-
-			// Upload a file first
-			await client.upload(versionKey, testContent, testContentType);
-
-			// Generate version-specific download URL without filename
-			const downloadUrl = await client.getVersionDownloadURL(
-				{ path: versionKey },
-				versionId,
-			);
-
-			expect(downloadUrl).toMatch(
-				/^http:\/\/localhost:9000\/geekmidas\/test-files\/version-no-name\.txt/,
-			);
-			expect(downloadUrl).not.toContain('response-content-disposition');
-		});
-	});
-});

package/src/__tests__/StorageClient.spec.ts

@@ -1,98 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { StorageProvider } from '../StorageClient';
-
-describe('StorageClient', () => {
-	describe('StorageProvider enum', () => {
-		it('should have correct provider values', () => {
-			expect(StorageProvider.AWSS3).toBe('geekimdas.toolbox.storage.aws.s3');
-			expect(StorageProvider.GCP).toBe('geekimdas.toolbox.storage.gcp');
-			expect(StorageProvider.AZURE).toBe('geekimdas.toolbox.storage.azure');
-		});
-
-		it('should have unique provider values', () => {
-			const values = Object.values(StorageProvider);
-			const uniqueValues = new Set(values);
-			expect(uniqueValues.size).toBe(values.length);
-		});
-	});
-
-	describe('interfaces', () => {
-		it('should define DocumentVersion interface correctly', () => {
-			// This is a compile-time test to ensure the interface exists
-			// and has the correct shape
-			const version: import('../StorageClient').DocumentVersion = {
-				id: 'test-id',
-				createdAt: new Date(),
-			};
-
-			expect(version.id).toBe('test-id');
-			expect(version.createdAt).toBeInstanceOf(Date);
-		});
-
-		it('should define File interface correctly', () => {
-			const file: import('../StorageClient').File = {
-				path: 'test/path.txt',
-			};
-
-			expect(file.path).toBe('test/path.txt');
-			expect(file.name).toBeUndefined();
-
-			const fileWithName: import('../StorageClient').File = {
-				path: 'test/path.txt',
-				name: 'display-name.txt',
-			};
-
-			expect(fileWithName.path).toBe('test/path.txt');
-			expect(fileWithName.name).toBe('display-name.txt');
-
-			const fileWithDisposition: import('../StorageClient').File = {
-				path: 'test/path.txt',
-				disposition: 'inline',
-				responseContentType: 'application/pdf',
-			};
-
-			expect(fileWithDisposition.disposition).toBe('inline');
-			expect(fileWithDisposition.responseContentType).toBe('application/pdf');
-		});
-
-		it('should define GetUploadParams interface correctly', () => {
-			const params: import('../StorageClient').GetUploadParams = {
-				path: 'test/upload.txt',
-				contentType: 'text/plain',
-				contentLength: 100,
-			};
-
-			expect(params.path).toBe('test/upload.txt');
-			expect(params.contentType).toBe('text/plain');
-			expect(params.contentLength).toBe(100);
-		});
-
-		it('should define GetUploadResponse interface correctly', () => {
-			const response: import('../StorageClient').GetUploadResponse = {
-				url: 'https://example.com/upload',
-				fields: [
-					{ key: 'key', value: 'test/path.txt' },
-					{ key: 'acl', value: 'public-read' },
-				],
-			};
-
-			expect(response.url).toBe('https://example.com/upload');
-			expect(response.fields).toHaveLength(2);
-			expect(response.fields[0]).toEqual({
-				key: 'key',
-				value: 'test/path.txt',
-			});
-			expect(response.fields[1]).toEqual({ key: 'acl', value: 'public-read' });
-		});
-
-		it('should define UploadField type correctly', () => {
-			const field: import('../StorageClient').UploadField = {
-				key: 'test-key',
-				value: 'test-value',
-			};
-
-			expect(field.key).toBe('test-key');
-			expect(field.value).toBe('test-value');
-		});
-	});
-});