@bgord/bun 0.22.1 → 0.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "0.12.17",
+    "@bgord/tools": "0.12.18",
     "@hono/ua-blocker": "0.1.8",
     "better-auth": "1.3.7",
     "check-disk-space": "3.4.0",

package/readme.md

@@ -56,6 +56,9 @@ src/
 ├── event.types.ts
 ├── file-draft-zip.service.ts
 ├── file-draft.service.ts
+├── file-hash-noop.adapter.ts
+├── file-hash-sha256-bun.adapter.ts
+├── file-hash.port.ts
 ├── file-uploader.middleware.ts
 ├── graceful-shutdown.service.ts
 ├── gzip.service.ts
@@ -159,6 +162,9 @@ src/
 ├── prerequisites.service.ts
 ├── rate-limit-store-node-cache.adapter.ts
 ├── rate-limit-store.port.ts
+├── remote-file-storage-disk.adapter.ts
+├── remote-file-storage-noop.adapter.ts
+├── remote-file-storage.port.ts
 ├── safe-parse-body.service.ts
 ├── setup.service.ts
 ├── shield-api-key.middleware.ts

package/src/file-hash-noop.adapter.ts

@@ -0,0 +1,8 @@
+import * as tools from "@bgord/tools";
+import type { FileHashPort } from "./file-hash.port";
+
+export class FileHashNoopAdapter implements FileHashPort {
+  async hash(_path: tools.FilePathAbsolute | tools.FilePathRelative) {
+    return { etag: "noop", size: tools.Size.fromBytes(0), lastModified: tools.Timestamp.parse(1000) };
+  }
+}

package/src/file-hash-sha256-bun.adapter.ts

@@ -0,0 +1,18 @@
+import * as tools from "@bgord/tools";
+import type { FileHashPort } from "./file-hash.port";
+
+export class FileHashSha256BunAdapter implements FileHashPort {
+  async hash(path: tools.FilePathAbsolute | tools.FilePathRelative) {
+    const file = Bun.file(path.get());
+
+    const arrayBuffer = await file.arrayBuffer();
+    const digest = await crypto.subtle.digest("SHA-256", arrayBuffer);
+    const etag = Buffer.from(digest).toString("hex");
+
+    return {
+      etag,
+      size: tools.Size.fromBytes(arrayBuffer.byteLength),
+      lastModified: tools.Timestamp.parse(file.lastModified),
+    };
+  }
+}

package/src/file-hash.port.ts

@@ -0,0 +1,7 @@
+import type * as tools from "@bgord/tools";
+
+export type FileHashResult = { etag: string; size: tools.Size; lastModified: tools.TimestampType };
+
+export interface FileHashPort {
+  hash(path: tools.FilePathAbsolute | tools.FilePathRelative): Promise<FileHashResult>;
+}

package/src/image-info.port.ts

@@ -1,6 +1,11 @@
 import type * as tools from "@bgord/tools";
 
-type ImageInfoType = { height: tools.HeightType; width: tools.WidthType; mime: tools.Mime; size: tools.Size };
+export type ImageInfoType = {
+  height: tools.HeightType;
+  width: tools.WidthType;
+  mime: tools.Mime;
+  size: tools.Size;
+};
 
 export interface ImageInfoPort {
   inspect(filePath: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType>;

package/src/index.ts

@@ -29,6 +29,9 @@ export * from "./event-store-like.types";
 export * from "./event-stream.vo";
 export * from "./file-draft.service";
 export * from "./file-draft-zip.service";
+export * from "./file-hash.port";
+export * from "./file-hash-noop.adapter";
+export * from "./file-hash-sha256-bun.adapter";
 export * from "./file-uploader.middleware";
 export * from "./graceful-shutdown.service";
 export * from "./gzip.service";
@@ -83,6 +86,9 @@ export * from "./prerequisites/index";
 export * from "./prerequisites.service";
 export * from "./rate-limit-store.port";
 export * from "./rate-limit-store-node-cache.adapter";
+export * from "./remote-file-storage.port";
+export * from "./remote-file-storage-disk.adapter";
+export * from "./remote-file-storage-noop.adapter";
 export * from "./safe-parse-body.service";
 export * from "./setup.service";
 export * from "./shield-api-key.middleware";

package/src/remote-file-storage-disk.adapter.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import * as tools from "@bgord/tools";
+import type { FileHashPort } from "./file-hash.port";
+import type {
+  RemoteFileStoragePort,
+  RemoteHeadResult,
+  RemotePutFromPathInput,
+  RemotePutFromPathResult,
+} from "./remote-file-storage.port";
+
+type RemoteFileStorageDiskConfig = {
+  root: tools.DirectoryPathAbsoluteType;
+  hasher: FileHashPort;
+  publicBaseUrl?: string;
+};
+
+export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
+  constructor(private readonly config: RemoteFileStorageDiskConfig) {}
+
+  private resolveKeyToAbsoluteFilePath(key: tools.ObjectKeyType): tools.FilePathAbsolute {
+    const parts = key.split("/");
+    const filename = tools.Filename.fromString(parts.pop()!);
+
+    const directory = tools.DirectoryPathAbsoluteSchema.parse(`${this.config.root}/${parts.join("/")}`);
+
+    return tools.FilePathAbsolute.fromPartsSafe(directory, filename);
+  }
+
+  publicUrl(key: tools.ObjectKeyType): string {
+    if (!this.config.publicBaseUrl) return `/${key}`;
+    return `${this.config.publicBaseUrl}/${key}`;
+  }
+
+  async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
+    const final = this.resolveKeyToAbsoluteFilePath(input.key);
+    const temporary = final.withFilename(final.getFilename().withSuffix("-part"));
+
+    await fs.mkdir(final.getDirectory(), { recursive: true });
+
+    const source = Bun.file(input.path.get());
+    await Bun.write(temporary.get(), source);
+    await fs.rename(temporary.get(), final.get());
+
+    return this.config.hasher.hash(final);
+  }
+
+  async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
+    const path = this.resolveKeyToAbsoluteFilePath(key);
+
+    try {
+      return { exists: true, ...(await this.config.hasher.hash(path)) };
+    } catch {
+      return { exists: false };
+    }
+  }
+
+  async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
+    const path = this.resolveKeyToAbsoluteFilePath(key);
+
+    try {
+      return Bun.file(path.get()).stream();
+    } catch {
+      return null;
+    }
+  }
+
+  async delete(key: tools.ObjectKeyType): Promise<void> {
+    const path = this.resolveKeyToAbsoluteFilePath(key);
+
+    try {
+      await fs.unlink(path.get());
+    } catch (error) {}
+  }
+}

package/src/remote-file-storage-noop.adapter.ts

@@ -0,0 +1,65 @@
+import * as tools from "@bgord/tools";
+import type { LoggerPort } from "./logger.port";
+import type {
+  RemoteFileStoragePort,
+  RemoteHeadResult,
+  RemotePutFromPathInput,
+  RemotePutFromPathResult,
+} from "./remote-file-storage.port";
+
+type RemoteFileStorageNoopConfig = { logger: LoggerPort; publicBaseUrl?: string };
+
+export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
+  constructor(private readonly config: RemoteFileStorageNoopConfig) {}
+
+  publicUrl(key: tools.ObjectKeyType): string {
+    if (!this.config.publicBaseUrl) return `/${key}`;
+    return `${this.config.publicBaseUrl}/${key}`;
+  }
+
+  async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
+    this.config.logger.info({
+      message: "[NOOP] RemoteFileStorageNoopAdapter putFromPath",
+      component: "infra",
+      operation: "RemoteFileStorageNoopAdapter.putFromPath",
+      metadata: { input },
+    });
+
+    return {
+      etag: "noop",
+      size: tools.Size.fromBytes(0),
+      lastModified: tools.Timestamp.parse(Date.now()),
+    };
+  }
+
+  async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
+    this.config.logger.info({
+      message: "[NOOP] RemoteFileStorageNoopAdapter head",
+      component: "infra",
+      operation: "RemoteFileStorageNoopAdapter.head",
+      metadata: { key },
+    });
+
+    return { exists: false };
+  }
+
+  async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
+    this.config.logger.info({
+      message: "[NOOP] RemoteFileStorageNoopAdapter getStream",
+      component: "infra",
+      operation: "RemoteFileStorageNoopAdapter.getStream",
+      metadata: { key },
+    });
+
+    return null;
+  }
+
+  async delete(key: tools.ObjectKeyType): Promise<void> {
+    this.config.logger.info({
+      message: "[NOOP] RemoteFileStorageNoopAdapter delete",
+      component: "infra",
+      operation: "RemoteFileStorageNoopAdapter.delete",
+      metadata: { key },
+    });
+  }
+}

package/src/remote-file-storage.port.ts

@@ -0,0 +1,19 @@
+import type * as tools from "@bgord/tools";
+import type { FileHashResult } from "./file-hash.port";
+
+export type RemotePutFromPathInput = {
+  key: tools.ObjectKeyType;
+  path: tools.FilePathRelative | tools.FilePathAbsolute;
+};
+
+export type RemotePutFromPathResult = FileHashResult;
+
+export type RemoteHeadResult = { exists: false } | ({ exists: true } & FileHashResult);
+
+export interface RemoteFileStoragePort {
+  putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult>;
+  head(key: tools.ObjectKeyType): Promise<RemoteHeadResult>;
+  getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null>;
+  delete(key: tools.ObjectKeyType): Promise<void>;
+  publicUrl(key: tools.ObjectKeyType): string;
+}