reorganized storage adapter and added test suites for adapter and fields (#124)

* reorganized storage adapter and added test suites for adapter and fields

* added build command in ci pipeline

* updated workflow to also run node tests

* updated workflow: try with separate tasks

* updated workflow: try with separate tasks

* updated workflow: added tsx as dev dependency

* updated workflow: try with find instead of glob

app/src/adapter/cloudflare/StorageR2Adapter.ts

@@ -1,7 +1,8 @@
 import { registries } from "bknd";
 import { isDebug } from "bknd/core";
 import { StringEnum, Type } from "bknd/utils";
-import type { FileBody, StorageAdapter } from "media/storage/Storage";
+import type { FileBody } from "media/storage/Storage";
+import { StorageAdapter } from "media/storage/StorageAdapter";
 import { guess } from "media/storage/mime-types-tiny";
 import { getBindings } from "./bindings";
 
@@ -47,8 +48,10 @@ export function registerMedia(env: Record<string, any>) {
  * Adapter for R2 storage
  * @todo: add tests (bun tests won't work, need node native tests)
  */
-export class StorageR2Adapter implements StorageAdapter {
-   constructor(private readonly bucket: R2Bucket) {}
+export class StorageR2Adapter extends StorageAdapter {
+   constructor(private readonly bucket: R2Bucket) {
+      super();
+   }
 
    getName(): string {
       return "r2";

app/src/adapter/node/index.ts

@@ -1,11 +1,9 @@
 import { registries } from "bknd";
-import {
-   type LocalAdapterConfig,
-   StorageLocalAdapter,
-} from "../../media/storage/adapters/StorageLocalAdapter";
+import { type LocalAdapterConfig, StorageLocalAdapter } from "./storage/StorageLocalAdapter";
 
 export * from "./node.adapter";
 export { StorageLocalAdapter, type LocalAdapterConfig };
+export { nodeTestRunner } from "./test";
 
 export function registerLocalMediaAdapter() {
    registries.media.register("local", StorageLocalAdapter);

app/src/adapter/node/storage/StorageLocalAdapter.native-spec.ts

@@ -0,0 +1,17 @@
+import { describe } from "node:test";
+import { StorageLocalAdapter, nodeTestRunner } from "adapter/node";
+import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+describe("StorageLocalAdapter (node)", async () => {
+   const basePath = path.resolve(import.meta.dirname, "../../../../__test__/_assets");
+   const buffer = readFileSync(path.join(basePath, "image.png"));
+   const file = new File([buffer], "image.png", { type: "image/png" });
+
+   const adapter = new StorageLocalAdapter({
+      path: path.join(basePath, "tmp"),
+   });
+
+   await adapterTestSuite(nodeTestRunner, adapter, file);
+});

app/src/adapter/node/storage/StorageLocalAdapter.spec.ts

@@ -0,0 +1,14 @@
+import { describe, test, expect } from "bun:test";
+import { StorageLocalAdapter } from "./StorageLocalAdapter";
+// @ts-ignore
+import { assetsPath, assetsTmpPath } from "../../../../__test__/helper";
+import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
+
+describe("StorageLocalAdapter (bun)", async () => {
+   const adapter = new StorageLocalAdapter({
+      path: assetsTmpPath,
+   });
+
+   const file = Bun.file(`${assetsPath}/image.png`);
+   await adapterTestSuite({ test, expect }, adapter, file);
+});

app/src/adapter/node/storage/StorageLocalAdapter.ts

@@ -0,0 +1,120 @@
+import { readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { type Static, Type, isFile, parse } from "bknd/utils";
+import type { FileBody, FileListObject, FileMeta, FileUploadPayload } from "bknd/media";
+import { StorageAdapter, guessMimeType as guess } from "bknd/media";
+
+export const localAdapterConfig = Type.Object(
+   {
+      path: Type.String({ default: "./" }),
+   },
+   { title: "Local", description: "Local file system storage" },
+);
+export type LocalAdapterConfig = Static<typeof localAdapterConfig>;
+
+export class StorageLocalAdapter extends StorageAdapter {
+   private config: LocalAdapterConfig;
+
+   constructor(config: any) {
+      super();
+      this.config = parse(localAdapterConfig, config);
+   }
+
+   getSchema() {
+      return localAdapterConfig;
+   }
+
+   getName(): string {
+      return "local";
+   }
+
+   async listObjects(prefix?: string): Promise<FileListObject[]> {
+      const files = await readdir(this.config.path);
+      const fileStats = await Promise.all(
+         files
+            .filter((file) => !prefix || file.startsWith(prefix))
+            .map(async (file) => {
+               const stats = await stat(`${this.config.path}/${file}`);
+               return {
+                  key: file,
+                  last_modified: stats.mtime,
+                  size: stats.size,
+               };
+            }),
+      );
+      return fileStats;
+   }
+
+   private async computeEtag(body: FileBody): Promise<string> {
+      const content = isFile(body) ? body : new Response(body);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", await content.arrayBuffer());
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const hashHex = hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+      // Wrap the hex string in quotes for ETag format
+      return `"${hashHex}"`;
+   }
+
+   async putObject(key: string, body: FileBody): Promise<string | FileUploadPayload> {
+      if (body === null) {
+         throw new Error("Body is empty");
+      }
+
+      const filePath = `${this.config.path}/${key}`;
+      const is_file = isFile(body);
+      await writeFile(filePath, is_file ? body.stream() : body);
+
+      return await this.computeEtag(body);
+   }
+
+   async deleteObject(key: string): Promise<void> {
+      try {
+         await unlink(`${this.config.path}/${key}`);
+      } catch (e) {}
+   }
+
+   async objectExists(key: string): Promise<boolean> {
+      try {
+         const stats = await stat(`${this.config.path}/${key}`);
+         return stats.isFile();
+      } catch (error) {
+         return false;
+      }
+   }
+
+   async getObject(key: string, headers: Headers): Promise<Response> {
+      try {
+         const content = await readFile(`${this.config.path}/${key}`);
+         const mimeType = guess(key);
+
+         return new Response(content, {
+            status: 200,
+            headers: {
+               "Content-Type": mimeType || "application/octet-stream",
+               "Content-Length": content.length.toString(),
+            },
+         });
+      } catch (error) {
+         // Handle file reading errors
+         return new Response("", { status: 404 });
+      }
+   }
+
+   getObjectUrl(key: string): string {
+      throw new Error("Method not implemented.");
+   }
+
+   async getObjectMeta(key: string): Promise<FileMeta> {
+      const stats = await stat(`${this.config.path}/${key}`);
+      return {
+         type: guess(key) || "application/octet-stream",
+         size: stats.size,
+      };
+   }
+
+   toJSON(secrets?: boolean) {
+      return {
+         type: this.getName(),
+         config: this.config,
+      };
+   }
+}

app/src/adapter/node/test.ts

@@ -0,0 +1,75 @@
+import nodeAssert from "node:assert/strict";
+import { test } from "node:test";
+import type { Matcher, Test, TestFn, TestRunner } from "core/test";
+
+const nodeTestMatcher = <T = unknown>(actual: T, parentFailMsg?: string) =>
+   ({
+      toEqual: (expected: T, failMsg = parentFailMsg) => {
+         nodeAssert.deepEqual(actual, expected, failMsg);
+      },
+      toBe: (expected: T, failMsg = parentFailMsg) => {
+         nodeAssert.strictEqual(actual, expected, failMsg);
+      },
+      toBeString: (failMsg = parentFailMsg) => {
+         nodeAssert.strictEqual(typeof actual, "string", failMsg);
+      },
+      toBeUndefined: (failMsg = parentFailMsg) => {
+         nodeAssert.strictEqual(actual, undefined, failMsg);
+      },
+      toBeDefined: (failMsg = parentFailMsg) => {
+         nodeAssert.notStrictEqual(actual, undefined, failMsg);
+      },
+      toBeOneOf: (expected: T | Array<T> | Iterable<T>, failMsg = parentFailMsg) => {
+         const e = Array.isArray(expected) ? expected : [expected];
+         nodeAssert.ok(e.includes(actual), failMsg);
+      },
+   }) satisfies Matcher<T>;
+
+const nodeTestResolverProxy = <T = unknown>(
+   actual: Promise<T>,
+   handler: { resolve?: any; reject?: any },
+) => {
+   return new Proxy(
+      {},
+      {
+         get: (_, prop) => {
+            if (prop === "then") {
+               return actual.then(handler.resolve, handler.reject);
+            }
+            return actual;
+         },
+      },
+   ) as Matcher<Awaited<T>>;
+};
+
+function nodeTest(label: string, fn: TestFn, options?: any) {
+   return test(label, fn as any);
+}
+nodeTest.if = (condition: boolean): Test => {
+   if (condition) {
+      return nodeTest;
+   }
+   return (() => {}) as any;
+};
+nodeTest.skip = (label: string, fn: TestFn) => {
+   return test.skip(label, fn as any);
+};
+nodeTest.skipIf = (condition: boolean): Test => {
+   if (condition) {
+      return (() => {}) as any;
+   }
+   return nodeTest;
+};
+
+export const nodeTestRunner: TestRunner = {
+   test: nodeTest,
+   expect: <T = unknown>(actual?: T, failMsg?: string) => ({
+      ...nodeTestMatcher(actual, failMsg),
+      resolves: nodeTestResolverProxy(actual as Promise<T>, {
+         resolve: (r) => nodeTestMatcher(r, failMsg),
+      }),
+      rejects: nodeTestResolverProxy(actual as Promise<T>, {
+         reject: (r) => nodeTestMatcher(r, failMsg),
+      }),
+   }),
+};