@concavejs/blobstore-node-fs 0.0.1-alpha.4

package/dist/fs-storage.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Filesystem-based Storage implementation for Node.js
+ *
+ * Implements the platform-agnostic BlobStore interface using Node.js fs APIs
+ */
+import type { BlobStore, StorageMetadata, StorageOptions } from "@concavejs/core/abstractions";
+export declare class FsBlobStore implements BlobStore {
+    private storageDir;
+    private metadataDir;
+    constructor(baseDir?: string);
+    private ensureDirectories;
+    private pathExists;
+    private generateStorageId;
+    private getObjectPath;
+    private getMetadataPath;
+    private calculateSha256;
+    store(blob: Blob | ArrayBuffer, options?: StorageOptions): Promise<StorageMetadata>;
+    get(storageId: string): Promise<Blob | null>;
+    delete(storageId: string): Promise<void>;
+    getUrl(storageId: string): Promise<string | null>;
+    /**
+     * Get metadata for a stored object
+     */
+    getMetadata(storageId: string): Promise<StorageMetadata | null>;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { FsBlobStore } from "./fs-storage";

package/dist/index.js

@@ -0,0 +1,117 @@
+// src/fs-storage.ts
+import { mkdir, writeFile, readFile, unlink, access } from "node:fs/promises";
+import { join } from "node:path";
+import { constants as fsConstants } from "node:fs";
+
+class FsBlobStore {
+  storageDir;
+  metadataDir;
+  constructor(baseDir = "./.concave/local/storage") {
+    this.storageDir = join(baseDir, "objects");
+    this.metadataDir = join(baseDir, "metadata");
+  }
+  async ensureDirectories() {
+    await mkdir(this.storageDir, { recursive: true });
+    await mkdir(this.metadataDir, { recursive: true });
+  }
+  async pathExists(path) {
+    try {
+      await access(path, fsConstants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  generateStorageId() {
+    return crypto.randomUUID();
+  }
+  getObjectPath(storageId) {
+    const shard = storageId.substring(0, 2);
+    return join(this.storageDir, shard, storageId);
+  }
+  getMetadataPath(storageId) {
+    const shard = storageId.substring(0, 2);
+    return join(this.metadataDir, shard, `${storageId}.json`);
+  }
+  async calculateSha256(data) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashArray = new Uint8Array(hashBuffer);
+    return Buffer.from(hashArray).toString("base64");
+  }
+  async store(blob, options) {
+    await this.ensureDirectories();
+    const storageId = options?.storageId ?? this.generateStorageId();
+    const objectPath = this.getObjectPath(storageId);
+    const metadataPath = this.getMetadataPath(storageId);
+    await mkdir(join(this.storageDir, storageId.substring(0, 2)), { recursive: true });
+    await mkdir(join(this.metadataDir, storageId.substring(0, 2)), { recursive: true });
+    const arrayBuffer = blob instanceof ArrayBuffer ? blob : await blob.arrayBuffer();
+    const sha256 = await this.calculateSha256(arrayBuffer);
+    await writeFile(objectPath, new Uint8Array(arrayBuffer));
+    const uploadedAt = Date.now();
+    const metadata = {
+      _id: storageId,
+      sha256,
+      size: arrayBuffer.byteLength,
+      contentType: options?.contentType || (blob instanceof Blob ? blob.type : undefined) || "application/octet-stream",
+      uploadedAt
+    };
+    await writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    return metadata;
+  }
+  async get(storageId) {
+    const objectPath = this.getObjectPath(storageId);
+    try {
+      const fileExists = await this.pathExists(objectPath);
+      if (!fileExists) {
+        return null;
+      }
+      const data = await readFile(objectPath);
+      const metadata = await this.getMetadata(storageId);
+      const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      return new Blob([arrayBuffer], { type: metadata?.contentType || "application/octet-stream" });
+    } catch (error) {
+      console.error("Error reading object from filesystem:", error);
+      return null;
+    }
+  }
+  async delete(storageId) {
+    const objectPath = this.getObjectPath(storageId);
+    const metadataPath = this.getMetadataPath(storageId);
+    try {
+      await Promise.all([
+        unlink(objectPath).catch(() => {}),
+        unlink(metadataPath).catch(() => {})
+      ]);
+    } catch (error) {
+      console.error("Error deleting object from filesystem:", error);
+      throw error;
+    }
+  }
+  async getUrl(storageId) {
+    const objectPath = this.getObjectPath(storageId);
+    const fileExists = await this.pathExists(objectPath);
+    if (!fileExists) {
+      return null;
+    }
+    const host = process.env.CONVEX_CLOUD_URL || "http://localhost:8799";
+    return `${host}/api/storage/${storageId}`;
+  }
+  async getMetadata(storageId) {
+    const metadataPath = this.getMetadataPath(storageId);
+    try {
+      const fileExists = await this.pathExists(metadataPath);
+      if (!fileExists) {
+        return null;
+      }
+      const data = await readFile(metadataPath, "utf-8");
+      return JSON.parse(data);
+    } catch (error) {
+      console.error("Error reading metadata from filesystem:", error);
+      return null;
+    }
+  }
+}
+export {
+  FsBlobStore
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@concavejs/blobstore-node-fs",
+  "version": "0.0.1-alpha.4",
+  "license": "FSL-1.1-Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts --outfile dist/index.js --target node --format esm && tsc -p tsconfig.json --emitDeclarationOnly --declaration --declarationMap false --outDir dist",
+    "test": "vitest --run --passWithNoTests"
+  },
+  "dependencies": {
+    "@concavejs/core": "0.0.1-alpha.4"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1"
+  }
+}