@alepha/bucket-s3 0.14.2 → 0.14.3

package/dist/index.d.ts

@@ -460,6 +460,7 @@ declare class EventManager {
   protected events: Record<string, Array<Hook>>;
   constructor(logFn?: () => LoggerInterface | undefined);
   protected get log(): LoggerInterface | undefined;
+  clear(): void;
   /**
    * Registers a hook for the specified event.
    */
@@ -992,6 +993,34 @@ interface State {
   "alepha.logger"?: LoggerInterface;
   /**
    * If defined, the Alepha container will only register this service and its dependencies.
+   *
+   * @example
+   * ```ts
+   * class MigrateCmd {
+   *   db = $inject(DatabaseProvider);
+   *   alepha = $inject(Alepha);
+   *   env = $env(
+   *     t.object({
+   *       MIGRATE: t.optional(t.boolean()),
+   *     }),
+   *   );
+   *
+   *   constructor() {
+   *     if (this.env.MIGRATE) {
+   *       this.alepha.set("alepha.target", MigrateCmd);
+   *     }
+   *   }
+   *
+   *   ready = $hook({
+   *     on: "ready",
+   *     handler: async () => {
+   *       if (this.env.MIGRATE) {
+   *         await this.db.migrate();
+   *       }
+   *     },
+   *   });
+   * }
+   * ```
    */
   "alepha.target"?: Service;
   /**
@@ -1539,6 +1568,13 @@ interface LsOptions {
  * FileSystem interface providing utilities for working with files.
  */
 declare abstract class FileSystemProvider {
+  /**
+   * Joins multiple path segments into a single path.
+   *
+   * @param paths - The path segments to join
+   * @returns The joined path
+   */
+  abstract join(...paths: string[]): string;
   /**
    * Creates a FileLike object from various sources.
    *

package/package.json

@@ -13,7 +13,7 @@
     "minio"
   ],
   "author": "Nicolas Foures",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "type": "module",
   "engines": {
     "node": ">=22.0.0"
@@ -26,17 +26,17 @@
     "src"
   ],
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.962.0"
+    "@aws-sdk/client-s3": "^3.965.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",
-    "alepha": "0.14.2",
-    "tsdown": "^0.19.0-beta.2",
+    "alepha": "0.14.3",
+    "tsdown": "^0.19.0-beta.5",
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "alepha": "0.14.2"
+    "alepha": "0.14.3"
   },
   "scripts": {
     "lint": "alepha lint",

package/src/providers/S3FileStorageProvider.spec.ts

@@ -0,0 +1,67 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import {
+  TestApp,
+  testCustomFileId,
+  testDeleteFile,
+  testDeleteNonExistentFile,
+  testDownloadAndMetadata,
+  testEmptyFiles,
+  testFileExistence,
+  testFileStream,
+  testNonExistentFile,
+  testNonExistentFileError,
+  testUploadAndExistence,
+  testUploadIntoBuckets,
+} from "../../../alepha/src/bucket/__tests__/shared.ts";
+import { AlephaBucketS3, S3FileStorageProvider } from "../index.ts";
+
+const alepha = Alepha.create().with(AlephaBucketS3).with(TestApp);
+
+const provider = alepha.inject(S3FileStorageProvider);
+
+describe("S3FileStorageProvider", () => {
+  test("should upload a file and return a fileId", async () => {
+    await testUploadAndExistence(provider);
+  });
+
+  test("should download a file and restore its metadata", async () => {
+    await testDownloadAndMetadata(provider);
+  });
+
+  test("exists() should return false for a non-existent file", async () => {
+    await testNonExistentFile(provider);
+  });
+
+  test("exists() should return true for an existing file", async () => {
+    await testFileExistence(provider);
+  });
+
+  test("should delete a file", async () => {
+    await testDeleteFile(provider);
+  });
+
+  test("delete() should not throw for a non-existent file", async () => {
+    await testDeleteNonExistentFile(provider);
+  });
+
+  test("download() should throw FileNotFoundError for a non-existent file", async () => {
+    await testNonExistentFileError(provider);
+  });
+
+  test("should handle uploading to different buckets", async () => {
+    await testUploadIntoBuckets(provider);
+  });
+
+  test("should handle empty files correctly", async () => {
+    await testEmptyFiles(provider);
+  });
+
+  test("should be able to upload with a specific fileId", async () => {
+    await testCustomFileId(provider);
+  });
+
+  test("should be able to upload, stream with metadata", async () => {
+    await testFileStream(provider);
+  });
+});