@eik/core 2.1.46 → 2.1.48

package/lib/handlers/pkg.log.js

@@ -46,6 +46,12 @@ const PkgLog = class PkgLog {
 		return this._metrics;
 	}
 
+	/**
+	 * @param {any} req
+	 * @param {string} type
+	 * @param {string} name
+	 * @param {string} version
+	 */
 	async handler(req, type, name, version) {
 		const end = this._histogram.timer();
 
@@ -57,7 +63,9 @@ const PkgLog = class PkgLog {
 			validators.name(pName);
 			validators.type(type);
 		} catch (error) {
-			this._log.debug(`pkg:log - Validation failed - ${error.message}`);
+			this._log.debug(
+				`pkg:log - Validation failed - ${error instanceof Error ? error.message : String(error)}`,
+			);
 			const e = new HttpError.NotFound();
 			end({ labels: { success: false, status: e.status, type } });
 			throw e;
@@ -83,7 +91,7 @@ const PkgLog = class PkgLog {
 		});
 
 		try {
-			const file = await this._sink.read(path);
+			const file = await (this._sink && this._sink.read(path));
 			const outgoing = new HttpOutgoing();
 			outgoing.cacheControl = this._cacheControl;
 			outgoing.mimeType = "application/json";
@@ -99,14 +107,17 @@ const PkgLog = class PkgLog {
 				outgoing.statusCode = 200;
 				outgoing.stream = file.stream;
 
-				outgoing.stream.on("error", (err) => {
-					this._log.info(`pkg:log - File stream error - ${err}`);
-					end({ labels: { success: false, status: 503, type } });
-				});
-
-				outgoing.stream.on("end", () => {
-					end({ labels: { status: outgoing.statusCode, type } });
-				});
+				const outgoingStream = outgoing.stream;
+				if (outgoingStream) {
+					outgoingStream.on("error", (err) => {
+						this._log.info(`pkg:log - File stream error - ${err}`);
+						end({ labels: { success: false, status: 503, type } });
+					});
+
+					outgoingStream.on("end", () => {
+						end({ labels: { status: outgoing.statusCode, type } });
+					});
+				}
 			}
 
 			this._log.debug(`pkg:log - Package log found - Pathname: ${path}`);

package/lib/handlers/pkg.put.js

@@ -73,18 +73,21 @@ const PkgPut = class PkgPut {
 		return this._metrics;
 	}
 
+	/**
+	 * @param {any} incoming
+	 */
 	async _parser(incoming) {
 		return new Promise((resolve, reject) => {
 			this._multipart
 				.parse(incoming)
 				.then((result) => {
 					const pkg = new Package(incoming);
-					result.forEach((obj) => {
+					result.forEach((/** @type {any} */ obj) => {
 						if (obj.constructor.name === "FormField") {
 							pkg.setMeta(obj);
 						}
 						if (obj.constructor.name === "FormFile") {
-							obj.value.forEach((o) => {
+							obj.value.forEach((/** @type {any} */ o) => {
 								pkg.setAsset(o);
 							});
 						}
@@ -107,6 +110,9 @@ const PkgPut = class PkgPut {
 		});
 	}
 
+	/**
+	 * @param {any} incoming
+	 */
 	async _readVersions(incoming) {
 		const path = createFilePathToVersion(incoming);
 		let versions;
@@ -127,6 +133,9 @@ const PkgPut = class PkgPut {
 		return versions;
 	}
 
+	/**
+	 * @param {any} incoming
+	 */
 	async _readVersion(incoming) {
 		const path = createFilePathToEikJson(incoming);
 		try {
@@ -145,6 +154,10 @@ const PkgPut = class PkgPut {
 		}
 	}
 
+	/**
+	 * @param {any} incoming
+	 * @param {any} versions
+	 */
 	async _writeVersions(incoming, versions) {
 		const path = createFilePathToVersion(incoming);
 		await writeJSON(this._sink, path, versions, "application/json");
@@ -153,6 +166,13 @@ const PkgPut = class PkgPut {
 		);
 	}
 
+	/**
+	 * @param {any} req
+	 * @param {any} user
+	 * @param {string} type
+	 * @param {string} name
+	 * @param {string} version
+	 */
 	async handler(req, user, type, name, version) {
 		const end = this._histogram.timer();
 
@@ -164,7 +184,9 @@ const PkgPut = class PkgPut {
 			validators.name(pName);
 			validators.type(type);
 		} catch (error) {
-			this._log.info(`pkg:put - Validation failed - ${error.message}`);
+			this._log.info(
+				`pkg:put - Validation failed - ${error instanceof Error ? error.message : String(error)}`,
+			);
 			const e = new HttpError.BadRequest();
 			end({ labels: { success: false, status: e.status } });
 			throw e;
@@ -217,7 +239,7 @@ const PkgPut = class PkgPut {
 		}
 
 		const outgoing = new HttpOutgoing();
-		outgoing.cacheControl = this._cacheControl;
+		outgoing.cacheControl = this._cacheControl || "";
 		outgoing.statusCode = 303;
 		outgoing.location = createURIPathToPkgLog(pkg);
 

package/lib/handlers/versions.get.js

@@ -46,6 +46,11 @@ const VersionsGet = class VersionsGet {
 		return this._metrics;
 	}
 
+	/**
+	 * @param {any} req
+	 * @param {string} type
+	 * @param {string} name
+	 */
 	async handler(req, type, name) {
 		const end = this._histogram.timer();
 
@@ -55,7 +60,9 @@ const VersionsGet = class VersionsGet {
 			validators.name(pName);
 			validators.type(type);
 		} catch (error) {
-			this._log.debug(`pkg:latest - Validation failed - ${error.message}`);
+			this._log.debug(
+				`pkg:latest - Validation failed - ${error instanceof Error ? error.message : String(error)}`,
+			);
 			const e = new HttpError.NotFound();
 			end({ labels: { success: false, status: e.status } });
 			throw e;
@@ -75,7 +82,7 @@ const VersionsGet = class VersionsGet {
 		const path = createFilePathToVersion({ org, type, name: pName });
 
 		try {
-			const file = await this._sink.read(path);
+			const file = await (this._sink && this._sink.read(path));
 			const outgoing = new HttpOutgoing();
 			outgoing.cacheControl = this._cacheControl;
 			outgoing.mimeType = "application/json";
@@ -91,14 +98,17 @@ const VersionsGet = class VersionsGet {
 				outgoing.statusCode = 200;
 				outgoing.stream = file.stream;
 
-				outgoing.stream.on("error", (err) => {
-					this._log.info(`pkg:latest - File stream error - ${err}`);
-					end({ labels: { success: false, status: 503, type } });
-				});
-
-				outgoing.stream.on("end", () => {
-					end({ labels: { status: outgoing.statusCode, type } });
-				});
+				const outgoingStream = outgoing.stream;
+				if (outgoingStream) {
+					outgoingStream.on("error", (err) => {
+						this._log.info(`pkg:latest - File stream error - ${err}`);
+						end({ labels: { success: false, status: 503, type } });
+					});
+
+					outgoingStream.on("end", () => {
+						end({ labels: { status: outgoing.statusCode, type } });
+					});
+				}
 			}
 
 			this._log.debug(`pkg:latest - Package log found - Pathname: ${path}`);

package/lib/multipart/form-file.js

@@ -1,4 +1,7 @@
 const FormFile = class FormFile {
+	/**
+	 * @param {{ value?: any[], name?: string }} [options]
+	 */
 	constructor({ value = [], name = "" } = {}) {
 		if (!Array.isArray(value))
 			throw new TypeError('The argument "value" must be of type Array');

package/lib/multipart/parser.js

@@ -35,8 +35,12 @@ const MultipartParser = class MultipartParser {
 		return "MultipartParser";
 	}
 
+	/**
+	 * @param {any} incoming
+	 */
 	parse(incoming) {
 		return new Promise((resolve, reject) => {
+			/** @type {any[]} */
 			const queue = [];
 
 			const busboy = Busboy({
@@ -48,47 +52,57 @@ const MultipartParser = class MultipartParser {
 				},
 			});
 
-			busboy.on("field", (name, value) => {
-				if (!this._legalFields.includes(name.toLowerCase())) {
-					busboy.emit("error", new HttpError.BadRequest());
-					return;
-				}
+			busboy.on(
+				"field",
+				(/** @type {any} */ name, /** @type {any} */ value) => {
+					if (!this._legalFields.includes(name.toLowerCase())) {
+						busboy.emit("error", new HttpError.BadRequest());
+						return;
+					}
 
-				queue.push(
-					this._handleField({
-						value,
-						name,
-					}),
-				);
-			});
+					queue.push(
+						this._handleField({
+							value,
+							name,
+						}),
+					);
+				},
+			);
 
-			busboy.on("file", (fieldname, file, filename) => {
-				if (!this._legalFiles.includes(fieldname.toLowerCase())) {
-					busboy.emit("error", new HttpError.BadRequest());
-					return;
-				}
+			busboy.on(
+				"file",
+				(
+					/** @type {any} */ fieldname,
+					/** @type {any} */ file,
+					/** @type {any} */ filename,
+				) => {
+					if (!this._legalFiles.includes(fieldname.toLowerCase())) {
+						busboy.emit("error", new HttpError.BadRequest());
+						return;
+					}
 
-				queue.push(
-					new Promise((done) => {
-						this._handleFile({
-							fieldname,
-							file,
-							filename,
-							incoming,
-						})
-							.then((item) => {
-								done(item);
+					queue.push(
+						new Promise((done) => {
+							this._handleFile({
+								fieldname,
+								file,
+								filename,
+								incoming,
 							})
-							.catch((error) => {
-								// Emit an error on busboy instead of rejecting
-								// This will break and terminate the stream stright away
-								busboy.emit("error", error);
-							});
-					}),
-				);
-			});
+								.then((item) => {
+									done(item);
+								})
+								.catch((error) => {
+									// Emit an error on busboy instead of rejecting
+									// This will break and terminate the stream stright away
+									busboy.emit("error", error);
+								});
+						}),
+					);
+				},
+			);
 
-			busboy.once("error", (error) => {
+			busboy.once("error", (/** @type {any} */ error) => {
 				reject(error);
 			});
 
@@ -109,6 +123,9 @@ const MultipartParser = class MultipartParser {
 		});
 	}
 
+	/**
+	 * @param {{ name: any, value: any }} options
+	 */
 	_handleField({ name, value }) {
 		this._log.info(
 			`multipart - Input field added - Name: ${name} - Value: ${value}`,
@@ -116,12 +133,16 @@ const MultipartParser = class MultipartParser {
 		return new FormField({ name, value });
 	}
 
+	/**
+	 * @param {{ fieldname: any, file: any, filename: any, incoming: any }} options
+	 */
 	_handleFile({ fieldname, file, filename, incoming }) {
 		return new Promise((resolve, reject) => {
 			this._log.info(
 				`multipart - Start extracting package - Field: ${fieldname} - Filename: ${filename}`,
 			);
 
+			/** @type {Promise<any>[]} */
 			const queue = [];
 
 			file.once("limit", () => {
@@ -179,6 +200,9 @@ const MultipartParser = class MultipartParser {
 		});
 	}
 
+	/**
+	 * @param {{ incoming: any, entry: any }} options
+	 */
 	_persistFile({ incoming, entry }) {
 		// eslint-disable-next-line no-async-promise-executor
 		return new Promise(async (resolve, reject) => {
@@ -198,11 +222,15 @@ const MultipartParser = class MultipartParser {
 			);
 
 			try {
+				if (!this._sink) {
+					reject(new Error("No sink configured"));
+					return;
+				}
 				const writer = await this._sink.write(path, asset.mimeType);
 
 				const integrityStream = ssri.integrityStream({ single: true });
 				let hash = "";
-				integrityStream.once("integrity", (integrity) => {
+				integrityStream.once("integrity", (/** @type {any} */ integrity) => {
 					hash = integrity;
 				});
 

package/lib/sinks/mem-entry.js

@@ -1,6 +1,9 @@
 import crypto from "node:crypto";
 
 const Entry = class Entry {
+	/**
+	 * @param {{ mimeType?: string, payload?: any[] }} [options]
+	 */
 	constructor({ mimeType = "application/octet-stream", payload = [] } = {}) {
 		this._mimeType = mimeType;
 		this._payload = payload;

package/lib/sinks/test.js

@@ -32,16 +32,20 @@ export default class SinkTest extends Sink {
 			},
 		});
 
-		// eslint-disable-next-line no-unused-vars
-		this._writeDelayResolve = (a) => -1;
-		// eslint-disable-next-line no-unused-vars
-		this._writeDelayChunks = (a) => -1;
+		/** @type {(count?: number) => number} */
+		this._writeDelayResolve = () => -1;
+		/** @type {(count?: number) => number} */
+		this._writeDelayChunks = () => -1;
 	}
 
 	get metrics() {
 		return this._metrics;
 	}
 
+	/**
+	 * @param {string} filePath
+	 * @param {any} payload
+	 */
 	set(filePath, payload) {
 		const pathname = toUrlPathname(path.join(this._rootPath, filePath));
 		const mimeType = mime.getType(pathname) || "application/octet-stream";
@@ -57,6 +61,9 @@ export default class SinkTest extends Sink {
 		this._state.set(pathname, entry);
 	}
 
+	/**
+	 * @param {string} filePath
+	 */
 	get(filePath) {
 		const pathname = toUrlPathname(path.join(this._rootPath, filePath));
 		if (this._state.has(pathname)) {
@@ -67,9 +74,12 @@ export default class SinkTest extends Sink {
 	}
 
 	dump() {
-		return Array.from(this._state.entries());
+		return [...this._state.entries()];
 	}
 
+	/**
+	 * @param {any} items
+	 */
 	load(items) {
 		if (!Array.isArray(items)) {
 			throw new Error('Argument "items" must be an Array');
@@ -78,7 +88,7 @@ export default class SinkTest extends Sink {
 	}
 
 	/**
-	 * @param {(count: number) => number} fn
+	 * @param {(count?: number) => number} fn
 	 */
 	set writeDelayResolve(fn) {
 		if (typeof fn !== "function") {
@@ -88,7 +98,7 @@ export default class SinkTest extends Sink {
 	}
 
 	/**
-	 * @param {(count: number) => number} fn
+	 * @param {(count?: number) => number} fn
 	 */
 	set writeDelayChunks(fn) {
 		if (typeof fn !== "function") {
@@ -99,6 +109,10 @@ export default class SinkTest extends Sink {
 
 	// Common SINK API
 
+	/**
+	 * @param {string} filePath
+	 * @param {string} contentType
+	 */
 	write(filePath, contentType) {
 		return new Promise((resolve, reject) => {
 			const operation = "write";
@@ -121,6 +135,7 @@ export default class SinkTest extends Sink {
 			}
 
 			const chunkDelay = this._writeDelayChunks;
+			/** @type {any[]} */
 			const payload = [];
 			let count = 0;
 			const stream = new Writable({
@@ -168,6 +183,9 @@ export default class SinkTest extends Sink {
 		});
 	}
 
+	/**
+	 * @param {string} filePath
+	 */
 	read(filePath) {
 		return new Promise((resolve, reject) => {
 			const operation = "read";
@@ -189,6 +207,10 @@ export default class SinkTest extends Sink {
 			}
 
 			const entry = this._state.get(pathname);
+			if (!entry) {
+				reject(new Error(`${filePath} does not exist`));
+				return;
+			}
 			const payload = entry.payload || [];
 			const file = new ReadFile({
 				mimeType: entry.mimeType,
@@ -200,13 +222,13 @@ export default class SinkTest extends Sink {
 				read() {
 					if (readDelay) {
 						setTimeout(() => {
-							payload.forEach((item) => {
+							payload.forEach((/** @type {any} */ item) => {
 								this.push(item);
 							});
 							this.push(null);
 						}, readDelay);
 					} else {
-						payload.forEach((item) => {
+						payload.forEach((/** @type {any} */ item) => {
 							this.push(item);
 						});
 						this.push(null);
@@ -228,6 +250,10 @@ export default class SinkTest extends Sink {
 		});
 	}
 
+	/**
+	 * @param {string} filePath
+	 * @returns {Promise<void>}
+	 */
 	delete(filePath) {
 		return new Promise((resolve, reject) => {
 			const operation = "delete";
@@ -249,7 +275,7 @@ export default class SinkTest extends Sink {
 			}
 
 			// Delete recursively
-			Array.from(this._state.keys()).forEach((key) => {
+			[...this._state.keys()].forEach((key) => {
 				if (key.startsWith(pathname)) {
 					this._state.delete(key);
 				}
@@ -267,6 +293,10 @@ export default class SinkTest extends Sink {
 		});
 	}
 
+	/**
+	 * @param {string} filePath
+	 * @returns {Promise<void>}
+	 */
 	exist(filePath) {
 		return new Promise((resolve, reject) => {
 			const operation = "exist";

package/lib/utils/healthcheck.js

@@ -1,9 +1,11 @@
 import { Writable, pipeline } from "node:stream";
 import { URL } from "node:url";
 import abslog from "abslog";
-import slug from "unique-slug";
+import { randomBytes } from "node:crypto";
 import fs from "node:fs";
 
+const slug = () => randomBytes(4).toString("hex");
+
 const fileReader = (file = "../../README.md") =>
 	fs.createReadStream(new URL(file, import.meta.url));
 
@@ -23,8 +25,13 @@ const HealthCheck = class HealthCheck {
 		this._log = abslog(logger);
 	}
 
+	/** @returns {Promise<void>} */
 	_write() {
 		return new Promise((resolve, reject) => {
+			if (!this._sink) {
+				reject(new Error("No sink configured"));
+				return;
+			}
 			this._sink
 				.write(this._name, "text/plain")
 				.then((destination) => {
@@ -40,15 +47,20 @@ const HealthCheck = class HealthCheck {
 		});
 	}
 
+	/** @returns {Promise<void>} */
 	_read() {
 		return new Promise((resolve, reject) => {
+			if (!this._sink) {
+				reject(new Error("No sink configured"));
+				return;
+			}
 			this._sink
 				.read(this._name)
 				.then((source) => {
 					const buffer = [];
 					const destination = new Writable({
 						objectMode: false,
-						write(chunk, encoding, callback) {
+						write(chunk, _encoding, callback) {
 							buffer.push(chunk);
 							callback();
 						},
@@ -66,10 +78,12 @@ const HealthCheck = class HealthCheck {
 	}
 
 	_delete() {
+		if (!this._sink) throw new Error("No sink configured");
 		return this._sink.delete(this._name);
 	}
 
 	_exist() {
+		if (!this._sink) throw new Error("No sink configured");
 		return this._sink.exist(this._name);
 	}
 

package/lib/utils/utils.js

@@ -1,9 +1,14 @@
 import { Writable, Readable, pipeline } from "node:stream";
 
+/**
+ * @param {any} sink
+ * @param {string} path
+ */
 const readJSON = (sink, path) =>
 	// eslint-disable-next-line no-async-promise-executor
 	new Promise(async (resolve, reject) => {
 		try {
+			/** @type {any[]} */
 			const buffer = [];
 			const from = await sink.read(path);
 
@@ -29,8 +34,18 @@ const readJSON = (sink, path) =>
 			reject(error);
 		}
 	});
+/**
+ * @param {any} sink
+ * @param {string} path
+ */
 const readEikJson = (sink, path) => sink.exist(path);
 
+/**
+ * @param {any} sink
+ * @param {string} path
+ * @param {any} obj
+ * @param {string} contentType
+ */
 const writeJSON = (sink, path, obj, contentType) =>
 	// eslint-disable-next-line no-async-promise-executor
 	new Promise(async (resolve, reject) => {
@@ -55,8 +70,12 @@ const writeJSON = (sink, path, obj, contentType) =>
 			reject(error);
 		}
 	});
+/**
+ * @param {any} from
+ */
 const streamCollector = (from) =>
 	new Promise((resolve, reject) => {
+		/** @type {any[]} */
 		const buffer = [];
 		const to = new Writable({
 			write(chunk, encoding, cb) {
@@ -71,12 +90,18 @@ const streamCollector = (from) =>
 		});
 	});
 
+/**
+ * @param {any} stat
+ */
 const etagFromFsStat = (stat) => {
 	const mtime = stat.mtime.getTime().toString(16);
 	const size = stat.size.toString(16);
 	return `W/"${size}-${mtime}"`;
 };
 
+/**
+ * @param {any} value
+ */
 const decodeUriComponent = (value) => {
 	if (value === null || value === undefined) return value;
 	return decodeURIComponent(value);