@alepha/bucket-vercel 0.14.2 → 0.14.4

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.
    */
@@ -935,6 +936,7 @@ declare class Alepha {
     as?: string[];
     module?: string;
   }>;
+  dump(): AlephaDump;
   services<T extends object>(base: Service<T>): Array<T>;
   /**
    * Get all primitives of the specified type.
@@ -950,6 +952,20 @@ interface Hook<T extends keyof Hooks = any> {
   priority?: "first" | "last";
   callback: (payload: Hooks[T]) => Async<void>;
 }
+interface AlephaDump {
+  env: Record<string, AlephaDumpEnvVariable>;
+  providers: Record<string, {
+    from: string[];
+    as?: string[];
+    module?: string;
+  }>;
+}
+interface AlephaDumpEnvVariable {
+  description: string;
+  default?: string;
+  required?: boolean;
+  enum?: Array<string>;
+}
 /**
  * This is how we store services in the Alepha container.
  */
@@ -992,6 +1008,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;
   /**
@@ -1281,7 +1325,7 @@ declare const envSchema$1: TObject$1<{
    * Built-in log formats.
    * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
    * - "pretty" - Simple text format, human-readable, with colors. {@link PrettyFormatterProvider}
-   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
+   * - "raw" - Raw format, no formatting, just the message. {@link RawFormatterProvider}
    */
   LOG_FORMAT: TOptional<TUnsafe<"json" | "pretty" | "raw">>;
 }>;
@@ -1539,6 +1583,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

@@ -10,7 +10,7 @@
     "blob"
   ],
   "author": "Nicolas Foures",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "type": "module",
   "engines": {
     "node": ">=22.0.0"
@@ -27,12 +27,12 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
-    "alepha": "0.14.2",
-    "tsdown": "^0.19.0-beta.2",
+    "alepha": "0.14.4",
+    "tsdown": "^0.19.0-beta.5",
     "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "alepha": "0.14.2"
+    "alepha": "0.14.4"
   },
   "scripts": {
     "lint": "alepha lint",

package/src/providers/MockVercelBlobApi.ts

@@ -0,0 +1,87 @@
+import { vi } from "vitest";
+
+export class MockVercelBlobApi {
+  mockStorage = new Map<string, any>();
+
+  put = vi.fn(async (pathname: string, body: any, options: any = {}) => {
+    // Handle ReadableStream from file.stream()
+    let data: Buffer;
+
+    if (body && typeof body.getReader === "function") {
+      // It's a Web ReadableStream
+      const reader = body.getReader();
+      const chunks: Uint8Array[] = [];
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+
+      // Combine all chunks into a single buffer
+      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const combined = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
+      }
+      data = Buffer.from(combined);
+    } else if (body && body.constructor?.name === "Readable") {
+      // It's a Node.js Readable stream
+      const chunks: Buffer[] = [];
+
+      for await (const chunk of body) {
+        chunks.push(Buffer.from(chunk));
+      }
+
+      data = Buffer.concat(chunks);
+    } else if (Buffer.isBuffer(body)) {
+      data = body;
+    } else if (body instanceof ArrayBuffer) {
+      data = Buffer.from(body);
+    } else {
+      data = Buffer.from(String(body));
+    }
+
+    const blob = {
+      pathname,
+      data,
+      contentType: options.contentType || "application/octet-stream",
+      size: data.length,
+      uploadedAt: new Date(),
+      url: `https://mock-blob.vercel-storage.com${pathname}`,
+    };
+
+    this.mockStorage.set(pathname, blob);
+
+    return {
+      url: blob.url,
+      pathname,
+      size: blob.size,
+      uploadedAt: blob.uploadedAt.toISOString(),
+      contentType: blob.contentType,
+    } as any;
+  });
+
+  head = vi.fn(async (pathname: string, options: any = {}) => {
+    const blob = this.mockStorage.get(pathname);
+
+    if (!blob) {
+      return null;
+    }
+
+    return {
+      url: blob.url,
+      pathname,
+      size: blob.size,
+      uploadedAt: blob.uploadedAt.toISOString(),
+      contentType: blob.contentType,
+    } as any;
+  });
+
+  del = vi.fn(async (pathname: string | string[], options: any = {}) => {
+    const existed = this.mockStorage.delete(String(pathname));
+    return { success: existed } as any;
+  });
+}

package/src/providers/VercelFileStorageProvider.spec.ts

@@ -0,0 +1,161 @@
+import { del } from "@vercel/blob";
+import { Alepha } from "alepha";
+import { afterAll, afterEach, beforeEach, describe, test, vi } from "vitest";
+import {
+  TEST_DOCUMENTS_BUCKET,
+  TEST_IMAGES_BUCKET,
+  TestApp,
+  testDeleteFile,
+  testDeleteNonExistentFile,
+  testDownloadAndMetadata,
+  testFileExistence,
+  testFileStream,
+  testNonExistentFile,
+  testNonExistentFileError,
+  testUploadAndExistence,
+  testUploadIntoBuckets,
+} from "../../../alepha/src/bucket/__tests__/shared.ts";
+import { AlephaBucketVercel, VercelFileStorageProvider } from "../index.ts";
+import { MockVercelBlobApi } from "./MockVercelBlobApi.ts";
+import { VercelBlobApi } from "./VercelBlobProvider.ts";
+
+const withMock =
+  process.env.BLOB_READ_WRITE_TOKEN === "vercel_blob_rw_mock_token_123456789";
+
+const alepha = Alepha.create();
+
+if (withMock) {
+  alepha.with({
+    provide: VercelBlobApi,
+    use: MockVercelBlobApi,
+  });
+
+  // Mock fetch to return blob data
+  const originalFetch = globalThis.fetch;
+  (globalThis as any).fetch = vi.fn(
+    async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === "string" ? input : input.toString();
+
+      if (url.startsWith("https://mock-blob.vercel-storage.com")) {
+        const __mockStorage = alepha.inject(MockVercelBlobApi).mockStorage;
+        const pathname = url.replace(
+          "https://mock-blob.vercel-storage.com",
+          "",
+        );
+        const blob = __mockStorage.get(pathname);
+
+        if (!blob) {
+          return new Response(null, { status: 404, statusText: "Not Found" });
+        }
+
+        const stream = new ReadableStream({
+          start(controller) {
+            controller.enqueue(new Uint8Array(blob.data));
+            controller.close();
+          },
+        });
+
+        return new Response(stream, {
+          status: 200,
+          headers: {
+            "Content-Type": blob.contentType,
+            "Content-Length": blob.size.toString(),
+          },
+        });
+      }
+
+      // For non-mock URLs, use original fetch if available
+      if (originalFetch) {
+        return originalFetch(input, init);
+      }
+
+      throw new Error("fetch is not available in this environment");
+    },
+  );
+}
+
+alepha.with(AlephaBucketVercel).with(TestApp);
+const provider = alepha.inject(VercelFileStorageProvider);
+
+describe("VercelFileStorageProvider", () => {
+  const uploadedFiles: string[] = [];
+
+  const cleanup = async () => {
+    if (!withMock && uploadedFiles.length > 0) {
+      try {
+        await del(uploadedFiles, {
+          token: process.env.BLOB_READ_WRITE_TOKEN,
+        });
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+    uploadedFiles.length = 0;
+  };
+
+  beforeEach(async () => {
+    if (withMock) {
+      alepha.inject(MockVercelBlobApi).mockStorage.clear();
+    }
+  });
+
+  afterEach(async () => {
+    if (withMock) {
+      alepha.inject(MockVercelBlobApi).mockStorage.clear();
+    }
+    await cleanup();
+  });
+
+  afterAll(cleanup);
+
+  const trackFileId = (bucketName: string, fileId: string) => {
+    const storeName = provider.convertName(bucketName);
+    uploadedFiles.push(`${storeName}/${fileId}`);
+  };
+
+  test("should upload a file and return a fileId", async () => {
+    const fileId = await testUploadAndExistence(provider);
+    trackFileId(TEST_IMAGES_BUCKET, fileId);
+  });
+
+  test("should download a file and restore its metadata", async () => {
+    const fileId = await testDownloadAndMetadata(provider);
+    trackFileId(TEST_IMAGES_BUCKET, fileId);
+  });
+
+  test("exists() should return false for a non-existent file", async () => {
+    await testNonExistentFile(provider);
+  });
+
+  test("exists() should return true for an existing file", async () => {
+    const fileId = await testFileExistence(provider);
+    trackFileId(TEST_IMAGES_BUCKET, fileId);
+  });
+
+  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 () => {
+    const { docId, imgId } = await testUploadIntoBuckets(provider);
+    trackFileId(TEST_DOCUMENTS_BUCKET, docId);
+    trackFileId(TEST_IMAGES_BUCKET, imgId);
+  });
+
+  test("should handle empty files correctly", async () => {
+    //	await testEmptyFiles(provider);
+  });
+
+  test("should be able to upload, stream with metadata", async () => {
+    const fileId = await testFileStream(provider);
+    trackFileId(TEST_IMAGES_BUCKET, fileId);
+  });
+});