@geekmidas/storage 0.0.5 → 0.1.0

package/dist/__tests__/AmazonStorageClient.spec.mjs

@@ -1,347 +0,0 @@
-import { beforeAll, describe, globalExpect, it } from "../vi.bdSIJ99Y-CucmVasy.mjs";
-import { StorageProvider } from "../StorageClient-CZGIC_fz.mjs";
-import { AmazonCannedAccessControlList, AmazonStorageClient } from "../AmazonStorageClient-Bkw-x2o2.mjs";
-import { S3Client } from "@aws-sdk/client-s3";
-import { InMemoryCache } from "@geekmidas/cache/memory";
-
-//#region src/__tests__/AmazonStorageClient.spec.ts
-describe("AmazonStorageClient Integration Tests", () => {
-	let client;
-	const testBucket = "geekmidas";
-	const testKey = "test-files/test.txt";
-	const testContent = "Hello, World!";
-	const testContentType = "text/plain";
-	beforeAll(async () => {
-		client = AmazonStorageClient.create({
-			bucket: testBucket,
-			region: "us-east-1",
-			accessKeyId: "geekmidas",
-			secretAccessKey: "geekmidas",
-			endpoint: "http://localhost:9000",
-			acl: AmazonCannedAccessControlList.PublicRead,
-			forcePathStyle: true
-		});
-		await new Promise((resolve) => setTimeout(resolve, 2e3));
-	});
-	describe("provider property", () => {
-		it("should return AWS S3 provider", () => {
-			globalExpect(client.provider).toBe(StorageProvider.AWSS3);
-		});
-	});
-	describe("upload and download workflow", () => {
-		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 });
-			globalExpect(downloadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/test\.txt/);
-			globalExpect(downloadUrl).toContain("X-Amz-Algorithm=AWS4-HMAC-SHA256");
-			globalExpect(downloadUrl).toContain("X-Amz-Credential=");
-			globalExpect(downloadUrl).toContain("X-Amz-Date=");
-			globalExpect(downloadUrl).toContain("X-Amz-SignedHeaders=");
-			globalExpect(downloadUrl).toContain("X-Amz-Signature=");
-			const response = await fetch(downloadUrl);
-			globalExpect(response.ok).toBe(true);
-			const downloadedContent = await response.text();
-			globalExpect(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
-			});
-			globalExpect(downloadUrl).toContain("response-content-disposition=attachment%3B%20filename%3Dmy-document.txt");
-		});
-		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();
-			globalExpect(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
-			});
-			globalExpect(uploadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/presigned-upload\.txt/);
-			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
-			});
-			globalExpect(uploadResponse.ok).toBe(true);
-			const downloadUrl = await client.getDownloadURL({ path: uploadKey });
-			const downloadResponse = await fetch(downloadUrl);
-			const downloadedContent = await downloadResponse.text();
-			globalExpect(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
-			});
-			globalExpect(uploadData.url).toBe("http://localhost:9000/geekmidas");
-			globalExpect(uploadData.fields).toContainEqual({
-				key: "key",
-				value: uploadKey
-			});
-			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
-			});
-			globalExpect(uploadResponse.ok).toBe(true);
-			const downloadUrl = await client.getDownloadURL({ path: uploadKey });
-			const downloadResponse = await fetch(downloadUrl);
-			const downloadedContent = await downloadResponse.blob();
-			globalExpect(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";
-			await client.upload(versionKey, content1, testContentType);
-			await client.upload(versionKey, content2, testContentType);
-			const versions = await client.getVersions(versionKey);
-			globalExpect(Array.isArray(versions)).toBe(true);
-			if (versions.length > 0) {
-				globalExpect(versions[0]).toHaveProperty("id");
-				globalExpect(versions[0]).toHaveProperty("createdAt");
-				globalExpect(versions[0].createdAt).toBeInstanceOf(Date);
-			}
-		});
-	});
-	describe("error handling", () => {
-		it("should handle download URL generation for non-existent files", async () => {
-			const downloadUrl = await client.getDownloadURL({ path: "non-existent/file.txt" });
-			globalExpect(downloadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/non-existent\/file\.txt/);
-			const response = await fetch(downloadUrl);
-			globalExpect(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);
-			const longExpirationUrl = await client.getDownloadURL({ path: key }, 3600);
-			globalExpect(shortExpirationUrl).toContain("X-Amz-Expires=1");
-			globalExpect(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);
-			const longExpirationUrl = await client.getUploadURL({
-				path: key,
-				contentType: testContentType,
-				contentLength: testContent.length
-			}, 3600);
-			globalExpect(shortExpirationUrl).toContain("X-Amz-Expires=1");
-			globalExpect(longExpirationUrl).toContain("X-Amz-Expires=3600");
-		});
-	});
-	describe("factory method", () => {
-		it("should create client with minimal configuration", () => {
-			const minimalClient = AmazonStorageClient.create({ bucket: "geekmidas" });
-			globalExpect(minimalClient).toBeInstanceOf(AmazonStorageClient);
-			globalExpect(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
-			});
-			globalExpect(fullClient).toBeInstanceOf(AmazonStorageClient);
-			globalExpect(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
-			});
-			globalExpect(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);
-			globalExpect(storageClient).toBeInstanceOf(AmazonStorageClient);
-			globalExpect(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);
-			const url1 = await clientWithCache.getDownloadURL({ path: key });
-			const url2 = await clientWithCache.getDownloadURL({ path: key });
-			globalExpect(url1).toBe(url2);
-			const cacheKey = `download-url:${key}`;
-			const cachedUrl = await cache.get(cacheKey);
-			globalExpect(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);
-			await clientWithCache.getDownloadURL({ path: key }, 30);
-			const cacheKey = `download-url:${key}`;
-			const cachedShortUrl = await cache.get(cacheKey);
-			globalExpect(cachedShortUrl).toBeUndefined();
-			const longExpiryUrl = await clientWithCache.getDownloadURL({ path: key }, 3600);
-			const cachedLongUrl = await cache.get(cacheKey);
-			globalExpect(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}`;
-			await cache.set(cacheKey, cachedUrl);
-			const url = await clientWithCache.getDownloadURL({ path: key });
-			globalExpect(url).toBe(cachedUrl);
-		});
-		it("should work without cache", async () => {
-			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 });
-			globalExpect(url1).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/no-cache\.txt/);
-			globalExpect(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);
-			globalExpect(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";
-			await client.upload(versionKey, testContent, testContentType);
-			const downloadUrl = await client.getVersionDownloadURL({
-				path: versionKey,
-				name: "versioned-file.txt"
-			}, versionId);
-			globalExpect(downloadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/version-download\.txt/);
-			globalExpect(downloadUrl).toContain("X-Amz-Algorithm=AWS4-HMAC-SHA256");
-			globalExpect(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";
-			await client.upload(versionKey, testContent, testContentType);
-			const downloadUrl = await client.getVersionDownloadURL({ path: versionKey }, versionId);
-			globalExpect(downloadUrl).toMatch(/^http:\/\/localhost:9000\/geekmidas\/test-files\/version-no-name\.txt/);
-			globalExpect(downloadUrl).not.toContain("response-content-disposition");
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/StorageClient.spec.cjs

@@ -1,81 +0,0 @@
-const require_StorageClient = require('../StorageClient-BDRVrMJj.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-D0m6qImj.cjs');
-
-//#region src/__tests__/StorageClient.spec.ts
-require_vi_bdSIJ99Y.describe("StorageClient", () => {
-	require_vi_bdSIJ99Y.describe("StorageProvider enum", () => {
-		require_vi_bdSIJ99Y.it("should have correct provider values", () => {
-			require_vi_bdSIJ99Y.globalExpect(require_StorageClient.StorageProvider.AWSS3).toBe("geekimdas.toolbox.storage.aws.s3");
-			require_vi_bdSIJ99Y.globalExpect(require_StorageClient.StorageProvider.GCP).toBe("geekimdas.toolbox.storage.gcp");
-			require_vi_bdSIJ99Y.globalExpect(require_StorageClient.StorageProvider.AZURE).toBe("geekimdas.toolbox.storage.azure");
-		});
-		require_vi_bdSIJ99Y.it("should have unique provider values", () => {
-			const values = Object.values(require_StorageClient.StorageProvider);
-			const uniqueValues = new Set(values);
-			require_vi_bdSIJ99Y.globalExpect(uniqueValues.size).toBe(values.length);
-		});
-	});
-	require_vi_bdSIJ99Y.describe("interfaces", () => {
-		require_vi_bdSIJ99Y.it("should define DocumentVersion interface correctly", () => {
-			const version = {
-				id: "test-id",
-				createdAt: /* @__PURE__ */ new Date()
-			};
-			require_vi_bdSIJ99Y.globalExpect(version.id).toBe("test-id");
-			require_vi_bdSIJ99Y.globalExpect(version.createdAt).toBeInstanceOf(Date);
-		});
-		require_vi_bdSIJ99Y.it("should define File interface correctly", () => {
-			const file = { path: "test/path.txt" };
-			require_vi_bdSIJ99Y.globalExpect(file.path).toBe("test/path.txt");
-			require_vi_bdSIJ99Y.globalExpect(file.name).toBeUndefined();
-			const fileWithName = {
-				path: "test/path.txt",
-				name: "display-name.txt"
-			};
-			require_vi_bdSIJ99Y.globalExpect(fileWithName.path).toBe("test/path.txt");
-			require_vi_bdSIJ99Y.globalExpect(fileWithName.name).toBe("display-name.txt");
-		});
-		require_vi_bdSIJ99Y.it("should define GetUploadParams interface correctly", () => {
-			const params = {
-				path: "test/upload.txt",
-				contentType: "text/plain",
-				contentLength: 100
-			};
-			require_vi_bdSIJ99Y.globalExpect(params.path).toBe("test/upload.txt");
-			require_vi_bdSIJ99Y.globalExpect(params.contentType).toBe("text/plain");
-			require_vi_bdSIJ99Y.globalExpect(params.contentLength).toBe(100);
-		});
-		require_vi_bdSIJ99Y.it("should define GetUploadResponse interface correctly", () => {
-			const response = {
-				url: "https://example.com/upload",
-				fields: [{
-					key: "key",
-					value: "test/path.txt"
-				}, {
-					key: "acl",
-					value: "public-read"
-				}]
-			};
-			require_vi_bdSIJ99Y.globalExpect(response.url).toBe("https://example.com/upload");
-			require_vi_bdSIJ99Y.globalExpect(response.fields).toHaveLength(2);
-			require_vi_bdSIJ99Y.globalExpect(response.fields[0]).toEqual({
-				key: "key",
-				value: "test/path.txt"
-			});
-			require_vi_bdSIJ99Y.globalExpect(response.fields[1]).toEqual({
-				key: "acl",
-				value: "public-read"
-			});
-		});
-		require_vi_bdSIJ99Y.it("should define UploadField type correctly", () => {
-			const field = {
-				key: "test-key",
-				value: "test-value"
-			};
-			require_vi_bdSIJ99Y.globalExpect(field.key).toBe("test-key");
-			require_vi_bdSIJ99Y.globalExpect(field.value).toBe("test-value");
-		});
-	});
-});
-
-//#endregion

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

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

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

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

package/dist/__tests__/StorageClient.spec.mjs

@@ -1,81 +0,0 @@
-import { describe, globalExpect, it } from "../vi.bdSIJ99Y-CucmVasy.mjs";
-import { StorageProvider } from "../StorageClient-CZGIC_fz.mjs";
-
-//#region src/__tests__/StorageClient.spec.ts
-describe("StorageClient", () => {
-	describe("StorageProvider enum", () => {
-		it("should have correct provider values", () => {
-			globalExpect(StorageProvider.AWSS3).toBe("geekimdas.toolbox.storage.aws.s3");
-			globalExpect(StorageProvider.GCP).toBe("geekimdas.toolbox.storage.gcp");
-			globalExpect(StorageProvider.AZURE).toBe("geekimdas.toolbox.storage.azure");
-		});
-		it("should have unique provider values", () => {
-			const values = Object.values(StorageProvider);
-			const uniqueValues = new Set(values);
-			globalExpect(uniqueValues.size).toBe(values.length);
-		});
-	});
-	describe("interfaces", () => {
-		it("should define DocumentVersion interface correctly", () => {
-			const version = {
-				id: "test-id",
-				createdAt: /* @__PURE__ */ new Date()
-			};
-			globalExpect(version.id).toBe("test-id");
-			globalExpect(version.createdAt).toBeInstanceOf(Date);
-		});
-		it("should define File interface correctly", () => {
-			const file = { path: "test/path.txt" };
-			globalExpect(file.path).toBe("test/path.txt");
-			globalExpect(file.name).toBeUndefined();
-			const fileWithName = {
-				path: "test/path.txt",
-				name: "display-name.txt"
-			};
-			globalExpect(fileWithName.path).toBe("test/path.txt");
-			globalExpect(fileWithName.name).toBe("display-name.txt");
-		});
-		it("should define GetUploadParams interface correctly", () => {
-			const params = {
-				path: "test/upload.txt",
-				contentType: "text/plain",
-				contentLength: 100
-			};
-			globalExpect(params.path).toBe("test/upload.txt");
-			globalExpect(params.contentType).toBe("text/plain");
-			globalExpect(params.contentLength).toBe(100);
-		});
-		it("should define GetUploadResponse interface correctly", () => {
-			const response = {
-				url: "https://example.com/upload",
-				fields: [{
-					key: "key",
-					value: "test/path.txt"
-				}, {
-					key: "acl",
-					value: "public-read"
-				}]
-			};
-			globalExpect(response.url).toBe("https://example.com/upload");
-			globalExpect(response.fields).toHaveLength(2);
-			globalExpect(response.fields[0]).toEqual({
-				key: "key",
-				value: "test/path.txt"
-			});
-			globalExpect(response.fields[1]).toEqual({
-				key: "acl",
-				value: "public-read"
-			});
-		});
-		it("should define UploadField type correctly", () => {
-			const field = {
-				key: "test-key",
-				value: "test-value"
-			};
-			globalExpect(field.key).toBe("test-key");
-			globalExpect(field.value).toBe("test-value");
-		});
-	});
-});
-
-//#endregion

package/dist/chunk-DWy1uDak.cjs

@@ -1,39 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-Object.defineProperty(exports, '__commonJS', {
-  enumerable: true,
-  get: function () {
-    return __commonJS;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});