verdaccio-memory/lib/memory-handler.js

Storage implementation in memory

const require_runtime = require("./_virtual/_rolldown/runtime.js");
const require_utils = require("./utils.js");
let _verdaccio_core = require("@verdaccio/core");
let memory_fs = require("memory-fs");
memory_fs = require_runtime.__toESM(memory_fs);
let node_path = require("node:path");
node_path = require_runtime.__toESM(node_path);
let _verdaccio_streams = require("@verdaccio/streams");
//#region src/memory-handler.ts
var fs = new memory_fs.default();
var { getBadRequest, getInternalError, getConflict, getNotFound } = _verdaccio_core.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 = require_utils.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 = require_utils.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, require_utils.parsePackage(json));
		} catch {
			return cb(getNotFound());
		}
	}
	writeTarball(name) {
		const uploadStream = new _verdaccio_streams.UploadTarball({});
		const temporalName = `${this.path}/${name}`;
		process.nextTick(function() {
			fs.mkdirp(node_path.default.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 _verdaccio_streams.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
exports.default = MemoryHandler;

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