verdaccio-memory/lib/memory-handler.mjs

Storage implementation in memory

import { parsePackage, stringifyPackage } from "./utils.mjs";
import { errorUtils } from "@verdaccio/core";
import MemoryFileSystem from "memory-fs";
import path from "node:path";
import { ReadTarball, UploadTarball } from "@verdaccio/streams";
//#region src/memory-handler.ts
var fs = new MemoryFileSystem();
var { getBadRequest, getInternalError, getConflict, getNotFound } = errorUtils;
var MemoryHandler = class {
	data;
	name;
	path;
	logger;
	constructor(packageName, data, logger) {
		this.data = data;
		this.name = packageName;
		this.logger = logger;
		this.path = `/${packageName}`;
	}
	updatePackage(pkgFileName, updateHandler, onWrite, transformPackage, onEnd) {
		const json = this._getStorage(pkgFileName);
		let pkg;
		try {
			pkg = parsePackage(json);
		} catch (err) {
			return onEnd(err);
		}
		updateHandler(pkg, (err) => {
			if (err) return onEnd(err);
			try {
				onWrite(pkgFileName, transformPackage(pkg), onEnd);
			} catch {
				return onEnd(getInternalError("error on parse the metadata"));
			}
		});
	}
	deletePackage(pkgName, callback) {
		delete this.data[pkgName];
		return callback(null);
	}
	removePackage(callback) {
		return callback(null);
	}
	createPackage(name, value, cb) {
		this.savePackage(name, value, cb);
	}
	savePackage(name, value, cb) {
		try {
			const json = stringifyPackage(value);
			this.data[name] = json;
			return cb(null);
		} catch (err) {
			return cb(getInternalError(err.message));
		}
	}
	readPackage(name, cb) {
		const json = this._getStorage(name);
		const isJson = typeof json === "undefined";
		try {
			return cb(isJson ? getNotFound() : null, parsePackage(json));
		} catch {
			return cb(getNotFound());
		}
	}
	writeTarball(name) {
		const uploadStream = new UploadTarball({});
		const temporalName = `${this.path}/${name}`;
		process.nextTick(function() {
			fs.mkdirp(path.dirname(temporalName), function(mkdirpError) {
				if (mkdirpError) return uploadStream.emit("error", mkdirpError);
				fs.stat(temporalName, function(fileError, stats) {
					if (!fileError && stats) return uploadStream.emit("error", getConflict());
					try {
						const file = fs.createWriteStream(temporalName);
						uploadStream.pipe(file);
						uploadStream.done = function() {
							const onEnd = function() {
								uploadStream.emit("success");
							};
							uploadStream.on("end", onEnd);
						};
						uploadStream.abort = function() {
							uploadStream.emit("error", getBadRequest("transmision aborted"));
							file.end();
						};
						uploadStream.emit("open");
						return;
					} catch (err) {
						uploadStream.emit("error", err);
						return;
					}
				});
			});
		});
		return uploadStream;
	}
	readTarball(name) {
		const pathName = `${this.path}/${name}`;
		const readTarballStream = new ReadTarball({});
		process.nextTick(function() {
			fs.stat(pathName, function(fileError, stats) {
				if (fileError && !stats) return readTarballStream.emit("error", getNotFound());
				try {
					const readStream = fs.createReadStream(pathName);
					const pathMeta = fs.meta(pathName);
					const contentLength = pathMeta && pathMeta.length || 0;
					readTarballStream.emit("content-length", contentLength);
					readTarballStream.emit("open");
					readStream.pipe(readTarballStream);
					readStream.on("error", (error) => {
						readTarballStream.emit("error", error);
					});
					readTarballStream.abort = function() {
						readStream.destroy(getBadRequest("read has been aborted"));
					};
					return;
				} catch (err) {
					readTarballStream.emit("error", err);
					return;
				}
			});
		});
		return readTarballStream;
	}
	_getStorage(name = "") {
		return this.data[name];
	}
};
//#endregion
export { MemoryHandler as default };

//# sourceMappingURL=memory-handler.mjs.map