alepha 0.14.2 → 0.14.3

package/src/bin/index.ts

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import "tsx";
 import { Alepha, run } from "alepha";
 import { AlephaCli, version } from "alepha/cli";
 

package/src/bucket/__tests__/shared.ts

@@ -0,0 +1,194 @@
+import { Alepha } from "alepha";
+import { FileSystemProvider } from "alepha/file";
+import { expect } from "vitest";
+import {
+  $bucket,
+  FileNotFoundError,
+  type FileStorageProvider,
+} from "../index.ts";
+
+export const TEST_IMAGES_BUCKET = "test-images";
+export const TEST_DOCUMENTS_BUCKET = "test-documents";
+export class TestApp {
+  images = $bucket({ name: TEST_IMAGES_BUCKET });
+  documents = $bucket({ name: TEST_DOCUMENTS_BUCKET });
+}
+
+const BUCKET_NAME = TEST_IMAGES_BUCKET;
+
+// Helper to create file system instance
+const getFileSystem = () => Alepha.create().inject(FileSystemProvider);
+
+export const testUploadAndExistence = async (
+  provider: FileStorageProvider,
+): Promise<string> => {
+  const content = "This is a test image.";
+  const file = getFileSystem().createFile({
+    text: content,
+    name: "test.jpg",
+    type: "image/jpeg",
+  });
+
+  const fileId = await provider.upload(BUCKET_NAME, file);
+
+  expect(fileId).toBeTypeOf("string");
+  expect(fileId.length).toBeGreaterThan(0);
+
+  // Verify the file physically exists
+  const fileExists = await provider.exists(BUCKET_NAME, fileId);
+  expect(fileExists).toBe(true);
+
+  return fileId;
+};
+
+export const testDownloadAndMetadata = async (
+  provider: FileStorageProvider,
+): Promise<string> => {
+  const content = "<h1>Hello Alepha</h1>";
+  const originalFile = getFileSystem().createFile({
+    text: content,
+    name: "index.html",
+    type: "text/html",
+  });
+
+  const fileId = await provider.upload(BUCKET_NAME, originalFile);
+  const downloadedFile = await provider.download(BUCKET_NAME, fileId);
+
+  // Check metadata
+  expect(downloadedFile.type).toBe("text/html");
+  expect(downloadedFile.size).toBe(content.length);
+
+  // Check content
+  const downloadedContent = await downloadedFile.text();
+  expect(downloadedContent).toBe(content);
+
+  return fileId;
+};
+
+export const testFileExistence = async (
+  provider: FileStorageProvider,
+): Promise<string> => {
+  const file = getFileSystem().createFile({
+    text: "exists",
+    name: "exists.txt",
+  });
+  const fileId = await provider.upload(BUCKET_NAME, file);
+  const fileExists = await provider.exists(BUCKET_NAME, fileId);
+  expect(fileExists).toBe(true);
+  return fileId;
+};
+
+export const testNonExistentFile = async (provider: FileStorageProvider) => {
+  const fileExists = await provider.exists(BUCKET_NAME, "non-existent-file-id");
+  expect(fileExists).toBe(false);
+};
+
+export const testDeleteNonExistentFile = async (
+  provider: FileStorageProvider,
+) => {
+  const file = getFileSystem().createFile({
+    text: "exists",
+    name: "exists.txt",
+  });
+  const fileId = await provider.upload(BUCKET_NAME, file);
+  const fileExists = await provider.exists(BUCKET_NAME, fileId);
+  expect(fileExists).toBe(true);
+  await provider.delete(BUCKET_NAME, fileId);
+  const fileExists2 = await provider.exists(BUCKET_NAME, fileId);
+  expect(fileExists2).toBe(false);
+};
+
+export const testDeleteFile = async (provider: FileStorageProvider) => {
+  const file = getFileSystem().createFile({
+    text: "to be deleted",
+    name: "delete_me.txt",
+  });
+  const fileId = await provider.upload(BUCKET_NAME, file);
+
+  // Verify it exists before deleting
+  expect(await provider.exists(BUCKET_NAME, fileId)).toBe(true);
+
+  await provider.delete(BUCKET_NAME, fileId);
+
+  // Verify it no longer exists after deletion
+  expect(await provider.exists(BUCKET_NAME, fileId)).toBe(false);
+};
+
+export const testNonExistentFileError = async (
+  provider: FileStorageProvider,
+) => {
+  await expect(
+    provider.download(BUCKET_NAME, "i-do-not-exist"),
+  ).rejects.toThrow(FileNotFoundError);
+};
+
+export const testUploadIntoBuckets = async (
+  provider: FileStorageProvider,
+): Promise<{ docId: string; imgId: string }> => {
+  const fs = getFileSystem();
+  const docFile = fs.createFile({ text: "report", name: "report.pdf" });
+  const imgFile = fs.createFile({ text: "logo", name: "logo.png" });
+
+  const docId = await provider.upload(TEST_DOCUMENTS_BUCKET, docFile);
+  const imgId = await provider.upload(TEST_IMAGES_BUCKET, imgFile);
+
+  expect(await provider.exists(TEST_DOCUMENTS_BUCKET, docId)).toBe(true);
+  expect(await provider.exists(TEST_IMAGES_BUCKET, imgId)).toBe(true);
+
+  // Ensure files are in separate directories and not mixed up
+  expect(await provider.exists(TEST_DOCUMENTS_BUCKET, imgId)).toBe(false);
+  expect(await provider.exists(TEST_IMAGES_BUCKET, docId)).toBe(false);
+
+  return { docId, imgId };
+};
+
+export const testFileStream = async (
+  provider: FileStorageProvider,
+): Promise<string> => {
+  const content = "Streaming content test.";
+  const file = getFileSystem().createFile({
+    text: content,
+    name: "stream.txt",
+    type: "text/plain",
+  });
+
+  const fileId = await provider.upload(BUCKET_NAME, file);
+  const stream = await provider.download(BUCKET_NAME, fileId);
+
+  expect(stream.type).toBe("text/plain");
+
+  const streamContent = await stream.text();
+  expect(streamContent).toBe(content);
+
+  return fileId;
+};
+
+export const testEmptyFiles = async (provider: FileStorageProvider) => {
+  const emptyFile = getFileSystem().createFile({
+    text: "",
+    name: "empty.txt",
+    type: "text/plain",
+  });
+
+  const fileId = await provider.upload(BUCKET_NAME, emptyFile);
+  const downloadedFile = await provider.download(BUCKET_NAME, fileId);
+
+  expect(downloadedFile.type).toBe("text/plain");
+  expect(downloadedFile.size).toBe(0);
+  expect(await downloadedFile.text()).toBe("");
+};
+
+export const testCustomFileId = async (provider: FileStorageProvider) => {
+  const file = getFileSystem().createFile({
+    text: "custom id",
+    name: "custom.txt",
+  });
+  const customFileId = "custom-file-id";
+
+  const uploadedFileId = await provider.upload(BUCKET_NAME, file, customFileId);
+
+  expect(uploadedFileId).toBe(customFileId);
+
+  const fileExists = await provider.exists(BUCKET_NAME, customFileId);
+  expect(fileExists).toBe(true);
+};

package/src/bucket/primitives/$bucket.spec.ts

@@ -0,0 +1,104 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import { InvalidFileError } from "../errors/InvalidFileError.ts";
+import {
+  $bucket,
+  AlephaBucket,
+  FileStorageProvider,
+  MemoryFileStorageProvider,
+} from "../index.ts";
+
+class TestApp {
+  images = $bucket({
+    maxSize: 1, // MB
+    mimeTypes: ["image/png", "image/jpeg"],
+  });
+}
+
+const alepha = Alepha.create().with(AlephaBucket).with(TestApp);
+
+describe("$bucket", () => {
+  test("should reject mimeTypes", async ({ expect }) => {
+    const app = alepha.inject(TestApp);
+    const file = new File(["test content"], "test.txt", { type: "text/plain" });
+
+    await expect(app.images.upload(file)).rejects.toThrow(InvalidFileError);
+  });
+
+  test("should reject file size", async ({ expect }) => {
+    const app = alepha.inject(TestApp);
+    const largeFile = new File(["a".repeat(2 * 1024 * 1024)], "large.png", {
+      type: "image/png",
+    });
+
+    await expect(() => app.images.upload(largeFile)).rejects.toThrow(
+      InvalidFileError,
+    );
+  });
+
+  test("should upload and download files", async ({ expect }) => {
+    const app = alepha.inject(TestApp);
+    const file = new File(["test content"], "test.png", { type: "image/png" });
+
+    const fileId = await app.images.upload(file);
+    expect(fileId).toBeDefined();
+
+    const downloadedFile = await app.images.download(fileId);
+    // Name is now the fileId, type is determined from extension
+    expect(downloadedFile.type).toBe("image/png");
+    expect(downloadedFile.size).toBe(file.size);
+  });
+
+  test("should call events on upload and delete", async ({ expect }) => {
+    const app = alepha.inject(TestApp);
+    const file = new File(["test content"], "test.png");
+
+    let uploadEventCalled = false;
+    let deleteEventCalled = false;
+
+    alepha.events.on("bucket:file:uploaded", ({ id, file, options }) => {
+      expect(id).toBeDefined();
+      expect(file.name).toBe("test.png");
+      expect(file.type).toBe("image/png");
+      expect(file.size).toBe(file.size);
+      expect(options).toEqual({
+        maxSize: 2,
+        mimeTypes: ["image/png", "image/jpeg"],
+      });
+      uploadEventCalled = true;
+    });
+
+    alepha.events.on("bucket:file:deleted", ({ id }) => {
+      expect(id).toBeDefined();
+      deleteEventCalled = true;
+    });
+
+    const fileId = await app.images.upload(file, { maxSize: 2 });
+    expect(uploadEventCalled).toBe(true);
+
+    await app.images.delete(fileId);
+    expect(deleteEventCalled).toBe(true);
+  });
+
+  test("should use many providers", async ({ expect }) => {
+    class MySecondMemoryProvider extends MemoryFileStorageProvider {}
+    class AnotherApp {
+      gn = $bucket({
+        provider: MySecondMemoryProvider,
+      });
+    }
+
+    const alepha = Alepha.create().with(AlephaBucket).with(AnotherApp);
+    await alepha.start();
+
+    const app = alepha.inject(AnotherApp);
+    const file = new File(["test content"], "test.png", { type: "image/png" });
+    const fileId = await app.gn.upload(file);
+    await expect(
+      alepha.inject(FileStorageProvider).exists(app.gn.name, fileId),
+    ).resolves.toBe(false);
+    await expect(
+      alepha.inject(MySecondMemoryProvider).exists(app.gn.name, fileId),
+    ).resolves.toBe(true);
+  });
+});

package/src/bucket/providers/FileStorageProvider.spec.ts

@@ -0,0 +1,13 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import { AlephaBucket } from "../index.ts";
+import { FileStorageProvider } from "../providers/FileStorageProvider.ts";
+import { MemoryFileStorageProvider } from "../providers/MemoryFileStorageProvider.ts";
+
+describe("FileStorageProvider", () => {
+  test("create default provider", async ({ expect }) => {
+    const alepha = Alepha.create().with(AlephaBucket);
+    const fileStorageProvider = alepha.inject(FileStorageProvider);
+    expect(fileStorageProvider).toBeInstanceOf(MemoryFileStorageProvider);
+  });
+});

package/src/bucket/providers/LocalFileStorageProvider.spec.ts

@@ -0,0 +1,77 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import {
+  TestApp,
+  testCustomFileId,
+  testDeleteFile,
+  testDeleteNonExistentFile,
+  testDownloadAndMetadata,
+  testEmptyFiles,
+  testFileExistence,
+  testFileStream,
+  testNonExistentFile,
+  testNonExistentFileError,
+  testUploadAndExistence,
+  testUploadIntoBuckets,
+} from "../__tests__/shared.ts";
+import {
+  AlephaBucket,
+  FileStorageProvider,
+  LocalFileStorageProvider,
+} from "../index.ts";
+
+const alepha = Alepha.create()
+  .with({
+    provide: FileStorageProvider,
+    use: LocalFileStorageProvider,
+  })
+  .with(AlephaBucket)
+  .with(TestApp);
+
+const provider = alepha.inject(LocalFileStorageProvider);
+
+describe("LocalFileStorageProvider", () => {
+  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);
+  });
+});

package/src/bucket/providers/MemoryFileStorageProvider.spec.ts

@@ -0,0 +1,82 @@
+import { Alepha } from "alepha";
+import { beforeEach, describe, test } from "vitest";
+import {
+  TestApp,
+  testCustomFileId,
+  testDeleteFile,
+  testDeleteNonExistentFile,
+  testDownloadAndMetadata,
+  testEmptyFiles,
+  testFileExistence,
+  testFileStream,
+  testNonExistentFile,
+  testNonExistentFileError,
+  testUploadAndExistence,
+  testUploadIntoBuckets,
+} from "../__tests__/shared.ts";
+import {
+  AlephaBucket,
+  FileStorageProvider,
+  MemoryFileStorageProvider,
+} from "../index.ts";
+
+let alepha: Alepha;
+let provider: MemoryFileStorageProvider;
+
+beforeEach(() => {
+  alepha = Alepha.create()
+    .with({
+      provide: FileStorageProvider,
+      use: MemoryFileStorageProvider,
+    })
+    .with(AlephaBucket)
+    .with(TestApp);
+
+  provider = alepha.inject(MemoryFileStorageProvider);
+});
+
+describe("MemoryFileStorageProvider", () => {
+  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);
+  });
+});