@chunkflowjs/upload-server 0.0.1-alpha.1

package/README.md

@@ -0,0 +1,20 @@
+# @chunkflowjs/upload-server
+
+Server-side SDK for ChunkFlow Upload with storage adapters and upload service.
+
+## Installation
+
+```bash
+pnpm add @chunkflowjs/upload-server
+```
+
+## Features
+
+- Storage adapters (Local, OSS, S3)
+- Database adapters
+- Upload service implementation
+- Token management
+
+## License
+
+MIT

package/dist/database-adapter.d.ts

@@ -0,0 +1,65 @@
+export interface FileMetadata {
+    fileId: string;
+    filename: string;
+    size: number;
+    mimeType: string;
+    fileHash: string;
+    uploadToken: string;
+    chunkSize: number;
+    totalChunks: number;
+    uploadedChunks: number;
+    status: "pending" | "uploading" | "completed" | "failed";
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+    url?: string;
+}
+export interface ChunkEntity {
+    chunkHash: string;
+    size: number;
+    refCount: number;
+    createdAt: Date;
+}
+export interface FileChunkEntity {
+    fileId: string;
+    chunkHash: string;
+    chunkIndex: number;
+    createdAt: Date;
+}
+export interface CreateFileOptions {
+    filename: string;
+    size: number;
+    mimeType: string;
+    fileHash: string;
+    uploadToken: string;
+    chunkSize: number;
+    totalChunks: number;
+}
+export interface UpdateFileOptions {
+    uploadedChunks?: number;
+    status?: "pending" | "uploading" | "completed" | "failed";
+    completedAt?: Date;
+    url?: string;
+    fileHash?: string;
+}
+export interface DatabaseAdapter {
+    initialize(): Promise<void>;
+    createFile(fileId: string, options: CreateFileOptions): Promise<FileMetadata>;
+    getFile(fileId: string): Promise<FileMetadata | null>;
+    getFileByHash(fileHash: string): Promise<FileMetadata | null>;
+    getFileByToken(uploadToken: string): Promise<FileMetadata | null>;
+    updateFile(fileId: string, options: UpdateFileOptions): Promise<FileMetadata>;
+    deleteFile(fileId: string): Promise<void>;
+    upsertChunk(chunkHash: string, size: number): Promise<ChunkEntity>;
+    getChunk(chunkHash: string): Promise<ChunkEntity | null>;
+    chunkExists(chunkHash: string): Promise<boolean>;
+    chunksExist(chunkHashes: string[]): Promise<boolean[]>;
+    decrementChunkRef(chunkHash: string): Promise<void>;
+    createFileChunk(fileId: string, chunkHash: string, chunkIndex: number): Promise<FileChunkEntity>;
+    getFileChunks(fileId: string): Promise<FileChunkEntity[]>;
+    getFileChunkHashes(fileId: string): Promise<string[]>;
+    deleteFileChunks(fileId: string): Promise<void>;
+    transaction<T>(callback: () => Promise<T>): Promise<T>;
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=database-adapter.d.ts.map

package/dist/database-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-adapter.d.ts","sourceRoot":"","sources":["../src/database-adapter.ts"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,537 @@
+let fs = require("fs");
+let path = require("path");
+let crypto = require("crypto");
+let jsonwebtoken = require("jsonwebtoken");
+
+//#region src/local-storage-adapter.ts
+/**
+* Local filesystem storage adapter
+*
+* Stores chunks in the local filesystem using a directory structure
+* based on the first two characters of the chunk hash for better performance.
+*
+* Directory structure: baseDir/ab/abcdef123456...
+*/
+var LocalStorageAdapter = class {
+	baseDir;
+	initialized = false;
+	constructor(options = {}) {
+		this.baseDir = options.baseDir || "./uploads";
+	}
+	/**
+	* Initialize the storage adapter by creating the base directory
+	*/
+	async initialize() {
+		if (this.initialized) return;
+		try {
+			await fs.promises.mkdir(this.baseDir, { recursive: true });
+			this.initialized = true;
+		} catch (error) {
+			throw new Error(`Failed to initialize local storage: ${error.message}`);
+		}
+	}
+	/**
+	* Get the file path for a chunk hash
+	* Uses the first two characters as a subdirectory for better performance
+	*/
+	getChunkPath(chunkHash) {
+		if (chunkHash.length < 2) throw new Error("Chunk hash must be at least 2 characters long");
+		const subDir = chunkHash.substring(0, 2);
+		return (0, path.join)(this.baseDir, subDir, chunkHash);
+	}
+	/**
+	* Save a chunk to the local filesystem
+	*/
+	async saveChunk(chunkHash, data) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		const chunkDir = (0, path.dirname)(chunkPath);
+		try {
+			await fs.promises.mkdir(chunkDir, { recursive: true });
+			await fs.promises.writeFile(chunkPath, data);
+		} catch (error) {
+			throw new Error(`Failed to save chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Get a chunk from the local filesystem
+	*/
+	async getChunk(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		try {
+			return await fs.promises.readFile(chunkPath);
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw new Error(`Failed to get chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Check if a chunk exists in the local filesystem
+	*/
+	async chunkExists(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		try {
+			await fs.promises.access(chunkPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Check if multiple chunks exist in the local filesystem
+	*/
+	async chunksExist(chunkHashes) {
+		if (!this.initialized) await this.initialize();
+		return await Promise.all(chunkHashes.map((hash) => this.chunkExists(hash)));
+	}
+	/**
+	* Get a readable stream for a chunk
+	*/
+	async getChunkStream(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		if (!(0, fs.existsSync)(chunkPath)) return null;
+		try {
+			return (0, fs.createReadStream)(chunkPath);
+		} catch (error) {
+			throw new Error(`Failed to create stream for chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Delete a chunk from the local filesystem
+	*/
+	async deleteChunk(chunkHash) {
+		if (!this.initialized) await this.initialize();
+		const chunkPath = this.getChunkPath(chunkHash);
+		try {
+			await fs.promises.unlink(chunkPath);
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw new Error(`Failed to delete chunk ${chunkHash}: ${error.message}`);
+		}
+	}
+	/**
+	* Clean up resources (no-op for local storage)
+	*/
+	async cleanup() {
+		this.initialized = false;
+	}
+};
+
+//#endregion
+//#region src/memory-database-adapter.ts
+/**
+* In-memory database adapter for testing and development
+*
+* This adapter stores all data in memory and is useful for:
+* - Unit testing without database dependencies
+* - Development and prototyping
+* - Simple deployments that don't require persistence
+*/
+var MemoryDatabaseAdapter = class {
+	files = /* @__PURE__ */ new Map();
+	chunks = /* @__PURE__ */ new Map();
+	fileChunks = /* @__PURE__ */ new Map();
+	async initialize() {}
+	async createFile(fileId, options) {
+		if (this.files.has(fileId)) throw new Error(`File ${fileId} already exists`);
+		const now = /* @__PURE__ */ new Date();
+		const file = {
+			fileId,
+			filename: options.filename,
+			size: options.size,
+			mimeType: options.mimeType,
+			fileHash: options.fileHash,
+			uploadToken: options.uploadToken,
+			chunkSize: options.chunkSize,
+			totalChunks: options.totalChunks,
+			uploadedChunks: 0,
+			status: "pending",
+			createdAt: now,
+			updatedAt: now
+		};
+		this.files.set(fileId, file);
+		return { ...file };
+	}
+	async getFile(fileId) {
+		const file = this.files.get(fileId);
+		return file ? { ...file } : null;
+	}
+	async getFileByHash(fileHash) {
+		for (const file of this.files.values()) if (file.fileHash === fileHash) return { ...file };
+		return null;
+	}
+	async getFileByToken(uploadToken) {
+		for (const file of this.files.values()) if (file.uploadToken === uploadToken) return { ...file };
+		return null;
+	}
+	async updateFile(fileId, options) {
+		const file = this.files.get(fileId);
+		if (!file) throw new Error(`File ${fileId} not found`);
+		const updated = {
+			...file,
+			...options,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		this.files.set(fileId, updated);
+		return { ...updated };
+	}
+	async deleteFile(fileId) {
+		this.files.delete(fileId);
+	}
+	async upsertChunk(chunkHash, size) {
+		const existing = this.chunks.get(chunkHash);
+		if (existing) {
+			const updated = {
+				...existing,
+				refCount: existing.refCount + 1
+			};
+			this.chunks.set(chunkHash, updated);
+			return { ...updated };
+		}
+		const chunk = {
+			chunkHash,
+			size,
+			refCount: 1,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		this.chunks.set(chunkHash, chunk);
+		return { ...chunk };
+	}
+	async getChunk(chunkHash) {
+		const chunk = this.chunks.get(chunkHash);
+		return chunk ? { ...chunk } : null;
+	}
+	async chunkExists(chunkHash) {
+		return this.chunks.has(chunkHash);
+	}
+	async chunksExist(chunkHashes) {
+		return chunkHashes.map((hash) => this.chunks.has(hash));
+	}
+	async decrementChunkRef(chunkHash) {
+		const chunk = this.chunks.get(chunkHash);
+		if (!chunk) return;
+		if (chunk.refCount <= 1) this.chunks.delete(chunkHash);
+		else {
+			const updated = {
+				...chunk,
+				refCount: chunk.refCount - 1
+			};
+			this.chunks.set(chunkHash, updated);
+		}
+	}
+	async createFileChunk(fileId, chunkHash, chunkIndex) {
+		const fileChunk = {
+			fileId,
+			chunkHash,
+			chunkIndex,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		const fileChunks = this.fileChunks.get(fileId) || [];
+		fileChunks.push(fileChunk);
+		this.fileChunks.set(fileId, fileChunks);
+		return { ...fileChunk };
+	}
+	async getFileChunks(fileId) {
+		return (this.fileChunks.get(fileId) || []).slice().sort((a, b) => a.chunkIndex - b.chunkIndex).map((fc) => ({ ...fc }));
+	}
+	async getFileChunkHashes(fileId) {
+		return (await this.getFileChunks(fileId)).map((fc) => fc.chunkHash);
+	}
+	async deleteFileChunks(fileId) {
+		this.fileChunks.delete(fileId);
+	}
+	async transaction(callback) {
+		return callback();
+	}
+	async cleanup() {
+		this.files.clear();
+		this.chunks.clear();
+		this.fileChunks.clear();
+	}
+};
+
+//#endregion
+//#region src/upload-service.ts
+/**
+* Upload service for handling file uploads with chunking and deduplication
+*/
+var UploadService = class {
+	storageAdapter;
+	databaseAdapter;
+	jwtSecret;
+	tokenExpiration;
+	minChunkSize;
+	maxChunkSize;
+	constructor(options) {
+		this.storageAdapter = options.storageAdapter;
+		this.databaseAdapter = options.databaseAdapter;
+		this.jwtSecret = options.jwtSecret;
+		this.tokenExpiration = options.tokenExpiration || 1440 * 60;
+		this.minChunkSize = options.minChunkSize || 256 * 1024;
+		this.maxChunkSize = options.maxChunkSize || 10 * 1024 * 1024;
+	}
+	/**
+	* Initialize the upload service
+	*/
+	async initialize() {
+		await this.storageAdapter.initialize();
+		await this.databaseAdapter.initialize();
+	}
+	/**
+	* Clean up resources
+	*/
+	async cleanup() {
+		await this.storageAdapter.cleanup();
+		await this.databaseAdapter.cleanup();
+	}
+	/**
+	* Generate a unique file ID
+	*/
+	generateFileId() {
+		return (0, crypto.randomBytes)(16).toString("hex");
+	}
+	/**
+	* Generate an upload token
+	*/
+	generateUploadToken(fileId) {
+		return (0, jsonwebtoken.sign)({
+			fileId,
+			type: "upload"
+		}, this.jwtSecret, { expiresIn: this.tokenExpiration });
+	}
+	/**
+	* Verify an upload token
+	*/
+	verifyUploadToken(token) {
+		try {
+			const payload = (0, jsonwebtoken.verify)(token, this.jwtSecret);
+			if (payload.type !== "upload") throw new Error("Invalid token type");
+			return { fileId: payload.fileId };
+		} catch (error) {
+			throw new Error(`Invalid upload token: ${error.message}`);
+		}
+	}
+	/**
+	* Negotiate chunk size based on file size and client preference
+	*/
+	negotiateChunkSize(fileSize, clientChunkSize) {
+		if (clientChunkSize) {
+			if (clientChunkSize > this.maxChunkSize) return this.maxChunkSize;
+			return clientChunkSize;
+		}
+		if (fileSize < 10 * 1024 * 1024) return Math.max(256 * 1024, this.minChunkSize);
+		else if (fileSize < 100 * 1024 * 1024) return Math.max(1024 * 1024, this.minChunkSize);
+		else if (fileSize < 1024 * 1024 * 1024) return Math.max(2 * 1024 * 1024, this.minChunkSize);
+		else return Math.max(5 * 1024 * 1024, this.minChunkSize);
+	}
+	/**
+	* Create a new file upload session
+	*
+	* Generates a unique file ID and upload token, negotiates chunk size,
+	* and saves file metadata to the database.
+	*/
+	async createFile(request) {
+		const fileId = this.generateFileId();
+		const uploadToken = this.generateUploadToken(fileId);
+		const chunkSize = this.negotiateChunkSize(request.fileSize, request.preferredChunkSize);
+		const totalChunks = Math.ceil(request.fileSize / chunkSize);
+		await this.databaseAdapter.createFile(fileId, {
+			filename: request.fileName,
+			size: request.fileSize,
+			mimeType: request.fileType,
+			fileHash: "",
+			uploadToken,
+			chunkSize,
+			totalChunks
+		});
+		return {
+			uploadToken,
+			negotiatedChunkSize: chunkSize
+		};
+	}
+	/**
+	* Verify file and chunk hashes for instant upload (秒传)
+	*
+	* Checks if the file hash already exists (full instant upload)
+	* or if any chunks already exist (partial instant upload).
+	* For existing chunks, automatically creates file-chunk relationships.
+	*/
+	async verifyHash(request) {
+		const { fileId } = this.verifyUploadToken(request.uploadToken);
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file) throw new Error("File not found");
+		if (request.fileHash) {
+			const existingFile = await this.databaseAdapter.getFileByHash(request.fileHash);
+			if (existingFile && existingFile.status === "completed") return {
+				fileExists: true,
+				fileUrl: existingFile.url,
+				existingChunks: [],
+				missingChunks: []
+			};
+		}
+		if (request.chunkHashes && request.chunkHashes.length > 0) {
+			const chunkExistence = await this.databaseAdapter.chunksExist(request.chunkHashes);
+			const existingChunks = [];
+			const missingChunks = [];
+			for (let index = 0; index < chunkExistence.length; index++) if (chunkExistence[index]) {
+				existingChunks.push(index);
+				const chunkHash = request.chunkHashes[index];
+				try {
+					if (!(await this.databaseAdapter.getFileChunks(fileId)).some((fc) => fc.chunkIndex === index && fc.chunkHash === chunkHash)) {
+						await this.databaseAdapter.createFileChunk(fileId, chunkHash, index);
+						const chunk = await this.databaseAdapter.getChunk(chunkHash);
+						if (chunk) await this.databaseAdapter.upsertChunk(chunkHash, chunk.size);
+					}
+				} catch (error) {
+					console.error(`Failed to create file-chunk relationship for chunk ${index}:`, error);
+				}
+			} else missingChunks.push(index);
+			const uploadedChunks = (await this.databaseAdapter.getFileChunks(fileId)).length;
+			const status = uploadedChunks === file.totalChunks ? "completed" : uploadedChunks > 0 ? "uploading" : "pending";
+			await this.databaseAdapter.updateFile(fileId, {
+				uploadedChunks,
+				status
+			});
+			return {
+				fileExists: false,
+				existingChunks,
+				missingChunks
+			};
+		}
+		return {
+			fileExists: false,
+			existingChunks: [],
+			missingChunks: []
+		};
+	}
+	/**
+	* Upload a chunk
+	*
+	* Validates the upload token and chunk hash, saves the chunk to storage
+	* with deduplication, and updates file metadata.
+	*/
+	async uploadChunk(request) {
+		const { fileId } = this.verifyUploadToken(request.uploadToken);
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file) throw new Error("File not found");
+		let chunkBuffer;
+		if (Buffer.isBuffer(request.chunk)) chunkBuffer = request.chunk;
+		else {
+			const arrayBuffer = await request.chunk.arrayBuffer();
+			chunkBuffer = Buffer.from(arrayBuffer);
+		}
+		if ((await import("spark-md5")).default.ArrayBuffer.hash(chunkBuffer) !== request.chunkHash) throw new Error("Chunk hash mismatch");
+		if (!await this.storageAdapter.chunkExists(request.chunkHash)) await this.storageAdapter.saveChunk(request.chunkHash, chunkBuffer);
+		await this.databaseAdapter.upsertChunk(request.chunkHash, chunkBuffer.length);
+		await this.databaseAdapter.createFileChunk(fileId, request.chunkHash, request.chunkIndex);
+		const uploadedChunks = (await this.databaseAdapter.getFileChunks(fileId)).length;
+		const status = uploadedChunks === file.totalChunks ? "completed" : "uploading";
+		await this.databaseAdapter.updateFile(fileId, {
+			uploadedChunks,
+			status
+		});
+		return {
+			success: true,
+			chunkHash: request.chunkHash
+		};
+	}
+	/**
+	* Merge file chunks (logical merge)
+	*
+	* Verifies all chunks are uploaded and updates file status to completed.
+	* Generates a file access URL.
+	*/
+	async mergeFile(request) {
+		const { fileId } = this.verifyUploadToken(request.uploadToken);
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file) throw new Error("File not found");
+		if (file.uploadedChunks !== file.totalChunks) throw new Error(`Not all chunks uploaded: ${file.uploadedChunks}/${file.totalChunks}`);
+		const url = `/upload/files/${fileId}`;
+		await this.databaseAdapter.updateFile(fileId, {
+			fileHash: request.fileHash,
+			status: "completed",
+			completedAt: /* @__PURE__ */ new Date(),
+			url
+		});
+		return {
+			success: true,
+			fileUrl: url,
+			fileId
+		};
+	}
+	/**
+	* Get file metadata
+	*
+	* Retrieves file metadata from database without creating a stream.
+	*/
+	async getFileMetadata(fileId) {
+		return await this.databaseAdapter.getFile(fileId);
+	}
+	/**
+	* Get file stream for download
+	*
+	* Reads chunks in order and creates a stream pipeline for file output.
+	* Supports Range requests for partial content.
+	*/
+	async getFileStream(fileId, range) {
+		const file = await this.databaseAdapter.getFile(fileId);
+		if (!file || file.status !== "completed") return null;
+		const chunkHashes = await this.databaseAdapter.getFileChunkHashes(fileId);
+		const { Readable } = await import("stream");
+		const storageAdapter = this.storageAdapter;
+		let currentChunkIndex = 0;
+		let bytesRead = 0;
+		const startByte = range?.start || 0;
+		const endByte = range?.end || file.size - 1;
+		return {
+			stream: new Readable({ async read() {
+				try {
+					while (currentChunkIndex < chunkHashes.length) {
+						const chunkHash = chunkHashes[currentChunkIndex];
+						const chunkData = await storageAdapter.getChunk(chunkHash);
+						if (!chunkData) {
+							this.destroy(/* @__PURE__ */ new Error(`Chunk ${chunkHash} not found`));
+							return;
+						}
+						const chunkStart = currentChunkIndex * file.chunkSize;
+						const chunkEnd = chunkStart + chunkData.length - 1;
+						if (chunkEnd < startByte) {
+							currentChunkIndex++;
+							continue;
+						}
+						if (chunkStart > endByte) {
+							this.push(null);
+							return;
+						}
+						let sliceStart = 0;
+						let sliceEnd = chunkData.length;
+						if (chunkStart < startByte) sliceStart = startByte - chunkStart;
+						if (chunkEnd > endByte) sliceEnd = endByte - chunkStart + 1;
+						const slicedData = chunkData.slice(sliceStart, sliceEnd);
+						this.push(slicedData);
+						bytesRead += slicedData.length;
+						currentChunkIndex++;
+						if (bytesRead >= endByte - startByte + 1) {
+							this.push(null);
+							return;
+						}
+						return;
+					}
+					this.push(null);
+				} catch (error) {
+					this.destroy(error);
+				}
+			} }),
+			size: range ? endByte - startByte + 1 : file.size,
+			mimeType: file.mimeType
+		};
+	}
+};
+
+//#endregion
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryDatabaseAdapter = MemoryDatabaseAdapter;
+exports.UploadService = UploadService;