@geekmidas/storage 0.0.4 → 0.1.0

package/src/AmazonStorageClient.ts

@@ -7,6 +7,7 @@ import {
 import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 
+import type { Cache } from '@geekmidas/cache';
 import {
   type DocumentVersion,
   type File,
@@ -18,6 +19,7 @@ import {
 
 export class AmazonStorageClient implements StorageClient {
   readonly provider = StorageProvider.AWSS3;
+
   static create(
     options: AmazonStorageClientCreateOptions,
   ): AmazonStorageClient {
@@ -29,6 +31,7 @@ export class AmazonStorageClient implements StorageClient {
       endpoint,
       secretAccessKey,
       forcePathStyle = false,
+      cache,
     } = options;
     const hasCredentials = accessKeyId && secretAccessKey;
     const credentials = hasCredentials
@@ -42,12 +45,13 @@ export class AmazonStorageClient implements StorageClient {
       forcePathStyle,
     });
 
-    return new AmazonStorageClient(client, bucket, acl);
+    return new AmazonStorageClient(client, bucket, acl, cache);
   }
   constructor(
     private readonly client: S3Client,
     private readonly bucket: string,
     private readonly acl = AmazonCannedAccessControlList.AuthenticatedRead,
+    readonly cache?: Cache<string>,
   ) {}
 
   getVersionDownloadURL(file: File, versionId: string): Promise<string> {
@@ -79,7 +83,14 @@ export class AmazonStorageClient implements StorageClient {
     }));
   }
 
-  getDownloadURL(file: File, expiresIn = 60 * 60): Promise<string> {
+  async getDownloadURL(file: File, expiresIn = 60 * 60): Promise<string> {
+    const cacheKey = `download-url:${file.path}`;
+    const cachedURL = await this.cache?.get(cacheKey);
+
+    if (cachedURL) {
+      return cachedURL;
+    }
+
     const ResponseContentDisposition = file.name
       ? `attachment; filename=${encodeURIComponent(file.name)}`
       : undefined;
@@ -90,7 +101,14 @@ export class AmazonStorageClient implements StorageClient {
       ResponseContentDisposition,
     });
 
-    return getSignedUrl(this.client, command, { expiresIn });
+    const url = await getSignedUrl(this.client, command, { expiresIn });
+    const cacheExpiration = Math.max(expiresIn - 60, 0);
+
+    if (cacheExpiration) {
+      await this.cache?.set(cacheKey, url, cacheExpiration);
+    }
+
+    return url;
   }
 
   async getUploadURL(
@@ -173,4 +191,5 @@ interface AmazonStorageClientCreateOptions {
   secretAccessKey?: string;
   endpoint?: string;
   forcePathStyle?: boolean;
+  cache?: Cache<string>;
 }

package/src/StorageClient.ts

@@ -1,3 +1,4 @@
+import type { Cache } from '@geekmidas/cache';
 export interface DocumentVersion {
   id: string;
   createdAt: Date;
@@ -11,6 +12,7 @@ export enum StorageProvider {
 
 export interface StorageClient {
   readonly provider: StorageProvider;
+  readonly cache?: Cache<string>;
   /**
    * Get a URL to upload a file to.
    *

package/src/__tests__/AmazonStorageClient.spec.ts

@@ -1,4 +1,5 @@
 import { S3Client } from '@aws-sdk/client-s3';
+import { InMemoryCache } from '@geekmidas/cache/memory';
 import { beforeAll, describe, expect, it } from 'vitest';
 import {
   AmazonCannedAccessControlList,
@@ -324,4 +325,186 @@ describe('AmazonStorageClient Integration Tests', () => {
       expect(storageClient.provider).toBe(StorageProvider.AWSS3);
     });
   });
+
+  describe('cache functionality', () => {
+    it('should cache download URLs', async () => {
+      const cache = new InMemoryCache<string>();
+      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<string>();
+      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<string>();
+      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<string>();
+      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('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 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/dist/__tests__/AmazonStorageClient.spec.cjs

@@ -1,234 +0,0 @@
-const require_chunk = require('../chunk-DWy1uDak.cjs');
-const require_StorageClient = require('../StorageClient-BDRVrMJj.cjs');
-const require_AmazonStorageClient = require('../AmazonStorageClient-DT9DeKVz.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-D0m6qImj.cjs');
-const __aws_sdk_client_s3 = require_chunk.__toESM(require("@aws-sdk/client-s3"));
-
-//#region src/__tests__/AmazonStorageClient.spec.ts
-require_vi_bdSIJ99Y.describe("AmazonStorageClient Integration Tests", () => {
-	let client;
-	const testBucket = "geekmidas";
-	const testKey = "test-files/test.txt";
-	const testContent = "Hello, World!";
-	const testContentType = "text/plain";
-	require_vi_bdSIJ99Y.beforeAll(async () => {
-		client = require_AmazonStorageClient.AmazonStorageClient.create({
-			bucket: testBucket,
-			region: "us-east-1",
-			accessKeyId: "geekmidas",
-			secretAccessKey: "geekmidas",
-			endpoint: "http://localhost:9000",
-			acl: require_AmazonStorageClient.AmazonCannedAccessControlList.PublicRead,
-			forcePathStyle: true
-		});
-		await new Promise((resolve) => setTimeout(resolve, 2e3));
-	});
-	require_vi_bdSIJ99Y.describe("provider property", () => {
-		require_vi_bdSIJ99Y.it("should return AWS S3 provider", () => {
-			require_vi_bdSIJ99Y.globalExpect(client.provider).toBe(require_StorageClient.StorageProvider.AWSS3);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("upload and download workflow", () => {
-		require_vi_bdSIJ99Y.it.skip("should upload a file directly and generate download URL", async () => {
-			await client.upload(testKey, testContent, testContentType);
-			const downloadUrl = await client.getDownloadURL({ path: testKey });
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/test\.txt/);
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toContain("X-Amz-Algorithm=AWS4-HMAC-SHA256");
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toContain("X-Amz-Credential=");
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toContain("X-Amz-Date=");
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toContain("X-Amz-SignedHeaders=");
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toContain("X-Amz-Signature=");
-			const response = await fetch(downloadUrl);
-			require_vi_bdSIJ99Y.globalExpect(response.ok).toBe(true);
-			const downloadedContent = await response.text();
-			require_vi_bdSIJ99Y.globalExpect(downloadedContent).toBe(testContent);
-		});
-		require_vi_bdSIJ99Y.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
-			});
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toContain("response-content-disposition=attachment%3B%20filename%3Dmy-document.txt");
-		});
-		require_vi_bdSIJ99Y.it("should handle binary data upload", async () => {
-			const binaryKey = "test-files/binary.bin";
-			const binaryData = Buffer.from([
-				72,
-				101,
-				108,
-				108,
-				111
-			]);
-			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();
-			require_vi_bdSIJ99Y.globalExpect(new Uint8Array(downloadedBuffer)).toEqual(new Uint8Array(binaryData));
-		});
-	});
-	require_vi_bdSIJ99Y.describe("presigned upload URLs", () => {
-		require_vi_bdSIJ99Y.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
-			});
-			require_vi_bdSIJ99Y.globalExpect(uploadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/presigned-upload\.txt/);
-			require_vi_bdSIJ99Y.globalExpect(uploadUrl).toContain("X-Amz-Algorithm=AWS4-HMAC-SHA256");
-			const uploadResponse = await fetch(uploadUrl, {
-				method: "PUT",
-				headers: {
-					"Content-Type": testContentType,
-					"Content-Length": testContent.length.toString()
-				},
-				body: testContent
-			});
-			require_vi_bdSIJ99Y.globalExpect(uploadResponse.ok).toBe(true);
-			const downloadUrl = await client.getDownloadURL({ path: uploadKey });
-			const downloadResponse = await fetch(downloadUrl);
-			const downloadedContent = await downloadResponse.text();
-			require_vi_bdSIJ99Y.globalExpect(downloadedContent).toBe(testContent);
-		});
-		require_vi_bdSIJ99Y.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
-			});
-			require_vi_bdSIJ99Y.globalExpect(uploadData.url).toBe("http://localhost:9000/geekmidas");
-			require_vi_bdSIJ99Y.globalExpect(uploadData.fields).toContainEqual({
-				key: "key",
-				value: uploadKey
-			});
-			require_vi_bdSIJ99Y.globalExpect(uploadData.fields).toContainEqual({
-				key: "acl",
-				value: "public-read"
-			});
-			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
-			});
-			require_vi_bdSIJ99Y.globalExpect(uploadResponse.ok).toBe(true);
-			const downloadUrl = await client.getDownloadURL({ path: uploadKey });
-			const downloadResponse = await fetch(downloadUrl);
-			const downloadedContent = await downloadResponse.blob();
-			require_vi_bdSIJ99Y.globalExpect(downloadedContent).toEqual(new Blob([testContent], { type: testContentType }));
-		});
-	});
-	require_vi_bdSIJ99Y.describe("versioning", () => {
-		require_vi_bdSIJ99Y.it("should handle file versions", async () => {
-			const versionKey = "test-files/versioned.txt";
-			const content1 = "Version 1";
-			const content2 = "Version 2";
-			await client.upload(versionKey, content1, testContentType);
-			await client.upload(versionKey, content2, testContentType);
-			const versions = await client.getVersions(versionKey);
-			require_vi_bdSIJ99Y.globalExpect(Array.isArray(versions)).toBe(true);
-			if (versions.length > 0) {
-				require_vi_bdSIJ99Y.globalExpect(versions[0]).toHaveProperty("id");
-				require_vi_bdSIJ99Y.globalExpect(versions[0]).toHaveProperty("createdAt");
-				require_vi_bdSIJ99Y.globalExpect(versions[0].createdAt).toBeInstanceOf(Date);
-			}
-		});
-	});
-	require_vi_bdSIJ99Y.describe("error handling", () => {
-		require_vi_bdSIJ99Y.it("should handle download URL generation for non-existent files", async () => {
-			const downloadUrl = await client.getDownloadURL({ path: "non-existent/file.txt" });
-			require_vi_bdSIJ99Y.globalExpect(downloadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/non-existent\/file\.txt/);
-			const response = await fetch(downloadUrl);
-			require_vi_bdSIJ99Y.globalExpect(response.status).toBe(404);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("custom expiration times", () => {
-		require_vi_bdSIJ99Y.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);
-			const longExpirationUrl = await client.getDownloadURL({ path: key }, 3600);
-			require_vi_bdSIJ99Y.globalExpect(shortExpirationUrl).toContain("X-Amz-Expires=1");
-			require_vi_bdSIJ99Y.globalExpect(longExpirationUrl).toContain("X-Amz-Expires=3600");
-		});
-		require_vi_bdSIJ99Y.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);
-			const longExpirationUrl = await client.getUploadURL({
-				path: key,
-				contentType: testContentType,
-				contentLength: testContent.length
-			}, 3600);
-			require_vi_bdSIJ99Y.globalExpect(shortExpirationUrl).toContain("X-Amz-Expires=1");
-			require_vi_bdSIJ99Y.globalExpect(longExpirationUrl).toContain("X-Amz-Expires=3600");
-		});
-	});
-	require_vi_bdSIJ99Y.describe("factory method", () => {
-		require_vi_bdSIJ99Y.it("should create client with minimal configuration", () => {
-			const minimalClient = require_AmazonStorageClient.AmazonStorageClient.create({ bucket: "geekmidas" });
-			require_vi_bdSIJ99Y.globalExpect(minimalClient).toBeInstanceOf(require_AmazonStorageClient.AmazonStorageClient);
-			require_vi_bdSIJ99Y.globalExpect(minimalClient.provider).toBe(require_StorageClient.StorageProvider.AWSS3);
-		});
-		require_vi_bdSIJ99Y.it("should create client with full configuration", () => {
-			const fullClient = require_AmazonStorageClient.AmazonStorageClient.create({
-				bucket: "geekmidas",
-				region: "us-west-2",
-				accessKeyId: "test-key",
-				secretAccessKey: "test-secret",
-				endpoint: "https://custom-s3.example.com",
-				acl: require_AmazonStorageClient.AmazonCannedAccessControlList.Private
-			});
-			require_vi_bdSIJ99Y.globalExpect(fullClient).toBeInstanceOf(require_AmazonStorageClient.AmazonStorageClient);
-			require_vi_bdSIJ99Y.globalExpect(fullClient.provider).toBe(require_StorageClient.StorageProvider.AWSS3);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("different ACL configurations", () => {
-		require_vi_bdSIJ99Y.it("should work with different ACL settings", async () => {
-			const privateClient = require_AmazonStorageClient.AmazonStorageClient.create({
-				bucket: testBucket,
-				region: "us-east-1",
-				accessKeyId: "minioadmin",
-				secretAccessKey: "minioadmin",
-				endpoint: "http://localhost:9000",
-				acl: require_AmazonStorageClient.AmazonCannedAccessControlList.Private
-			});
-			const uploadData = await privateClient.getUpload({
-				path: "test-files/private.txt",
-				contentType: testContentType,
-				contentLength: testContent.length
-			});
-			require_vi_bdSIJ99Y.globalExpect(uploadData.fields).toContainEqual({
-				key: "acl",
-				value: "private"
-			});
-		});
-	});
-	require_vi_bdSIJ99Y.describe("S3Client integration", () => {
-		require_vi_bdSIJ99Y.it("should work with externally created S3Client", () => {
-			const s3Client = new __aws_sdk_client_s3.S3Client({
-				region: "us-east-1",
-				credentials: {
-					accessKeyId: "minioadmin",
-					secretAccessKey: "minioadmin"
-				},
-				endpoint: "http://localhost:9000"
-			});
-			const storageClient = new require_AmazonStorageClient.AmazonStorageClient(s3Client, testBucket, require_AmazonStorageClient.AmazonCannedAccessControlList.PublicRead);
-			require_vi_bdSIJ99Y.globalExpect(storageClient).toBeInstanceOf(require_AmazonStorageClient.AmazonStorageClient);
-			require_vi_bdSIJ99Y.globalExpect(storageClient.provider).toBe(require_StorageClient.StorageProvider.AWSS3);
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/AmazonStorageClient.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/AmazonStorageClient.spec.d.mts

@@ -1 +0,0 @@
-export { };