@eik/cli 3.1.3 → 3.1.4

package/classes/login.js

@@ -1,6 +1,6 @@
-import abslog from 'abslog';
-import eik from '@eik/common';
-import { request } from '../utils/http/index.js';
+import abslog from "abslog";
+import eik from "@eik/common";
+import { request } from "../utils/http/index.js";
 
 const { schemas } = eik;
 
@@ -12,52 +12,52 @@ const { schemas } = eik;
  */
 
 export default class Login {
-    /**
-     * @param {LoginOptions} options
-     */
-    constructor({ logger, server, key }) {
-        this.log = abslog(logger);
-        this.server = server;
-        this.key = key;
-    }
+	/**
+	 * @param {LoginOptions} options
+	 */
+	constructor({ logger, server, key }) {
+		this.log = abslog(logger);
+		this.server = server;
+		this.key = key;
+	}
 
-    /**
-     * @returns {Promise<string | false>} Bearer token, or false if login fails
-     */
-    async run() {
-        this.log.debug('Validating input');
+	/**
+	 * @returns {Promise<string | false>} Bearer token, or false if login fails
+	 */
+	async run() {
+		this.log.debug("Validating input");
 
-        try {
-            schemas.assert.server(this.server);
-            if (!this.key || typeof !this.key === 'string') {
-                // @ts-expect-error
-                throw new schemas.ValidationError('"key" must be a string');
-            }
-        } catch (err) {
-            this.log.error(err.message);
-            return false;
-        }
+		try {
+			schemas.assert.server(this.server);
+			if (!this.key || typeof !this.key === "string") {
+				// @ts-expect-error
+				throw new schemas.ValidationError('"key" must be a string');
+			}
+		} catch (err) {
+			this.log.error(err.message);
+			return false;
+		}
 
-        this.log.debug('Requesting jwt token from server');
-        try {
-            const { message } = await request({
-                host: this.server,
-                method: 'POST',
-                pathname: '/auth/login',
-                data: { key: this.key },
-            });
+		this.log.debug("Requesting jwt token from server");
+		try {
+			const { message } = await request({
+				host: this.server,
+				method: "POST",
+				pathname: "/auth/login",
+				data: { key: this.key },
+			});
 
-            this.log.info(`Login successful`);
-            return message.token;
-        } catch (err) {
-            switch (err.statusCode) {
-                case 401:
-                    this.log.info('Login unsuccessful. Invalid credentials.');
-                    return false;
-                default:
-                    this.log.warn('Login unsuccessful. Unknown login error');
-                    return false;
-            }
-        }
-    }
+			this.log.info(`Login successful`);
+			return message.token;
+		} catch (err) {
+			switch (err.statusCode) {
+				case 401:
+					this.log.info("Login unsuccessful. Invalid credentials.");
+					return false;
+				default:
+					this.log.warn("Login unsuccessful. Unknown login error");
+					return false;
+			}
+		}
+	}
 }

package/classes/meta.js

@@ -1,8 +1,8 @@
-import abslog from 'abslog';
-import { schemas } from '@eik/common';
-import { joinUrlPathname } from '../utils/url.js';
+import abslog from "abslog";
+import { schemas } from "@eik/common";
+import { joinUrlPathname } from "../utils/url.js";
 
-const types = ['pkg', 'map', 'npm'];
+const types = ["pkg", "map", "npm"];
 
 /**
  * @typedef {object} MetaOptions
@@ -13,92 +13,87 @@ const types = ['pkg', 'map', 'npm'];
  */
 
 export default class Meta {
-    /**
-     * @param {MetaOptions} options
-     */
-    constructor({ logger, server, name, version }) {
-        this.log = abslog(logger);
-        this.server = server;
-        this.name = name;
-        this.version = version;
-    }
+	/**
+	 * @param {MetaOptions} options
+	 */
+	constructor({ logger, server, name, version }) {
+		this.log = abslog(logger);
+		this.server = server;
+		this.name = name;
+		this.version = version;
+	}
 
-    /**
-     * @returns {Promise<unknown | false>}
-     */
-    async run() {
-        this.log.debug('Validating input');
+	/**
+	 * @returns {Promise<unknown | false>}
+	 */
+	async run() {
+		this.log.debug("Validating input");
 
-        try {
-            schemas.assert.server(this.server);
-        } catch (err) {
-            this.log.error(err.message);
-            return false;
-        }
+		try {
+			schemas.assert.server(this.server);
+		} catch (err) {
+			this.log.error(err.message);
+			return false;
+		}
 
-        this.log.debug('Requesting meta information from asset server');
-        try {
-            const typeFetches = [];
-            for (const type of types) {
-                const url = new URL(
-                    joinUrlPathname(type, this.name),
-                    this.server,
-                );
-                url.search = `?t=${Date.now()}`;
-                typeFetches.push(fetch(url));
-            }
+		this.log.debug("Requesting meta information from asset server");
+		try {
+			const typeFetches = [];
+			for (const type of types) {
+				const url = new URL(joinUrlPathname(type, this.name), this.server);
+				url.search = `?t=${Date.now()}`;
+				typeFetches.push(fetch(url));
+			}
 
-            const responses = await Promise.all(typeFetches);
+			const responses = await Promise.all(typeFetches);
 
-            const data = {};
+			const data = {};
 
-            for (const res of responses) {
-                if (res.ok) {
-                    const { versions, type, name, org } = await res.json();
-                    data[type] = {
-                        versions: Object.values(versions),
-                        type,
-                        name,
-                        org,
-                    };
+			for (const res of responses) {
+				if (res.ok) {
+					const { versions, type, name, org } = await res.json();
+					data[type] = {
+						versions: Object.values(versions),
+						type,
+						name,
+						org,
+					};
 
-                    const vers = new Map(versions);
-                    data[type].versions = Array.from(vers.values());
-                    for (let i = 0; i < data[type].versions.length; i++) {
-                        const { version } = data[type].versions[i];
-                        const url = new URL(
-                            joinUrlPathname(type, name, version),
-                            this.server,
-                        );
+					const vers = new Map(versions);
+					data[type].versions = Array.from(vers.values());
+					for (let i = 0; i < data[type].versions.length; i++) {
+						const { version } = data[type].versions[i];
+						const url = new URL(
+							joinUrlPathname(type, name, version),
+							this.server,
+						);
 
-                        const resp = await fetch(url);
-                        const meta = await resp.json();
+						const resp = await fetch(url);
+						const meta = await resp.json();
 
-                        data[type].versions[i] = {
-                            ...data[type].versions[i],
-                            ...meta,
-                        };
-                    }
-                }
+						data[type].versions[i] = {
+							...data[type].versions[i],
+							...meta,
+						};
+					}
+				}
 
-                if (res.status === 400) {
-                    this.log.warn(
-                        'Client attempted to send an invalid URL parameter',
-                    );
-                    return false;
-                }
+				if (res.status === 400) {
+					this.log.warn("Client attempted to send an invalid URL parameter");
+					return false;
+				}
 
-                if (res.status === 401) {
-                    this.log.warn('Client unauthorized with server');
-                    return false;
-                }
-            }
+				if (res.status === 401) {
+					this.log.warn("Client unauthorized with server");
+					return false;
+				}
+			}
 
-            return data;
-        } catch (err) {
-            this.log.error('Unable to retrieve meta information for package');
-            this.log.warn(err.message);
-            return false;
-        }
-    }
+			return data;
+		} catch (err) {
+			this.log.error("Unable to retrieve meta information for package");
+			this.log.warn(err.message);
+			return false;
+		}
+	}
 }

package/classes/ping.js

@@ -1,5 +1,5 @@
-import abslog from 'abslog';
-import { schemas } from '@eik/common';
+import abslog from "abslog";
+import { schemas } from "@eik/common";
 
 /**
  * @typedef {object} PingOptions
@@ -8,55 +8,55 @@ import { schemas } from '@eik/common';
  */
 
 export default class Ping {
-    /**
-     * @param {PingOptions} options
-     */
-    constructor({ logger, server } = {}) {
-        this.log = abslog(logger);
-        this.server = server;
-    }
-
-    /**
-     * Run the ping command
-     * @returns {Promise<boolean>}
-     */
-    async run() {
-        this.log.debug('Validating input');
-
-        try {
-            schemas.assert.server(this.server);
-        } catch (err) {
-            this.log.error(err.message);
-            return false;
-        }
-
-        this.log.debug('Requesting ping from server');
-        try {
-            const result = await fetch(/** @type {string}*/ (this.server));
-
-            if (!result.ok) {
-                const err = new Error('Ping unsuccessful');
-                // @ts-expect-error
-                err.statusCode = result.status;
-                throw err;
-            }
-
-            this.log.info(`Ping successful`);
-            return true;
-        } catch (err) {
-            if (err.code === 'ENOTFOUND') {
-                this.log.info('Ping unsuccessful. Server not found.');
-                return false;
-            }
-
-            switch (err.statusCode) {
-                case 404:
-                    this.log.info('Ping unsuccessful. Route not found.');
-                    return false;
-                default:
-                    this.log.warn('Ping unsuccessful. Unknown server error');
-                    return false;
-            }
-        }
-    }
+	/**
+	 * @param {PingOptions} options
+	 */
+	constructor({ logger, server } = {}) {
+		this.log = abslog(logger);
+		this.server = server;
+	}
+
+	/**
+	 * Run the ping command
+	 * @returns {Promise<boolean>}
+	 */
+	async run() {
+		this.log.debug("Validating input");
+
+		try {
+			schemas.assert.server(this.server);
+		} catch (err) {
+			this.log.error(err.message);
+			return false;
+		}
+
+		this.log.debug("Requesting ping from server");
+		try {
+			const result = await fetch(/** @type {string}*/ (this.server));
+
+			if (!result.ok) {
+				const err = new Error("Ping unsuccessful");
+				// @ts-expect-error
+				err.statusCode = result.status;
+				throw err;
+			}
+
+			this.log.info(`Ping successful`);
+			return true;
+		} catch (err) {
+			if (err.code === "ENOTFOUND") {
+				this.log.info("Ping unsuccessful. Server not found.");
+				return false;
+			}
+
+			switch (err.statusCode) {
+				case 404:
+					this.log.info("Ping unsuccessful. Route not found.");
+					return false;
+				default:
+					this.log.warn("Ping unsuccessful. Unknown server error");
+					return false;
+			}
+		}
+	}
 }

package/classes/publish/map.js

@@ -1,10 +1,10 @@
-import assert from 'assert';
-import abslog from 'abslog';
-import { join, parse, isAbsolute } from 'path';
-import { existsSync } from 'fs';
-import { schemas } from '@eik/common';
-import { request } from '../../utils/http/index.js';
-import { joinUrlPathname } from '../../utils/url.js';
+import assert from "assert";
+import abslog from "abslog";
+import { join, parse, isAbsolute } from "path";
+import { existsSync } from "fs";
+import { schemas } from "@eik/common";
+import { request } from "../../utils/http/index.js";
+import { joinUrlPathname } from "../../utils/url.js";
 
 /**
  * @typedef {object} PublishMapOptions
@@ -26,95 +26,93 @@ import { joinUrlPathname } from '../../utils/url.js';
  */
 
 export default class PublishMap {
-    /**
-     * @param {PublishMapOptions} options
-     */
-    constructor({
-        logger,
-        cwd = process.cwd(),
-        server,
-        token,
-        file,
-        name,
-        version,
-    }) {
-        this.log = abslog(logger);
-        this.cwd = cwd;
-        this.server = server;
-        this.token = token;
-        this.name = name;
-        this.version = version;
-        this.file = file;
-    }
+	/**
+	 * @param {PublishMapOptions} options
+	 */
+	constructor({
+		logger,
+		cwd = process.cwd(),
+		server,
+		token,
+		file,
+		name,
+		version,
+	}) {
+		this.log = abslog(logger);
+		this.cwd = cwd;
+		this.server = server;
+		this.token = token;
+		this.name = name;
+		this.version = version;
+		this.file = file;
+	}
 
-    /**
-     * @returns {Promise<PublishMapResult>}
-     */
-    async run() {
-        this.log.debug('Running import map publish command');
+	/**
+	 * @returns {Promise<PublishMapResult>}
+	 */
+	async run() {
+		this.log.debug("Running import map publish command");
 
-        this.log.debug('Validating input');
-        parse(this.cwd);
-        schemas.assert.server(this.server);
-        assert(
-            this.token && typeof this.token === 'string',
-            'Parameter "token" is not valid',
-        );
-        schemas.assert.name(this.name);
-        schemas.assert.version(this.version);
-        parse(this.file);
+		this.log.debug("Validating input");
+		parse(this.cwd);
+		schemas.assert.server(this.server);
+		assert(
+			this.token && typeof this.token === "string",
+			'Parameter "token" is not valid',
+		);
+		schemas.assert.name(this.name);
+		schemas.assert.version(this.version);
+		parse(this.file);
 
-        this.absoluteFile = isAbsolute(this.file)
-            ? this.file
-            : join(this.cwd, this.file);
+		this.absoluteFile = isAbsolute(this.file)
+			? this.file
+			: join(this.cwd, this.file);
 
-        assert(
-            existsSync(this.absoluteFile),
-            'Parameter "file" is not valid. File does not exist',
-        );
+		assert(
+			existsSync(this.absoluteFile),
+			'Parameter "file" is not valid. File does not exist',
+		);
 
-        this.log.debug(
-            `Uploading import map "${this.name}" version "${this.version}" to asset server`,
-        );
-        try {
-            await request({
-                method: 'PUT',
-                host: this.server,
-                pathname: joinUrlPathname('map', this.name, this.version),
-                map: this.absoluteFile,
-                token: this.token,
-            });
+		this.log.debug(
+			`Uploading import map "${this.name}" version "${this.version}" to asset server`,
+		);
+		try {
+			await request({
+				method: "PUT",
+				host: this.server,
+				pathname: joinUrlPathname("map", this.name, this.version),
+				map: this.absoluteFile,
+				token: this.token,
+			});
 
-            return {
-                server: this.server,
-                name: this.name,
-                version: this.version,
-                type: 'map',
-            };
-        } catch (err) {
-            const msg = 'Unable to complete upload of import map to server';
-            switch (err.statusCode) {
-                case 400:
-                    throw new Error(
-                        `${msg}: Client attempted to send an invalid URL parameter`,
-                    );
-                case 401:
-                    throw new Error(`${msg}: Client unauthorized with server`);
-                case 409:
-                    throw new Error(
-                        `${msg}: Map with name "${this.name}" and version "${this.version}" already exists on server`,
-                    );
-                case 415:
-                    throw new Error(
-                        `${msg}: Client attempted to send an unsupported file format to server`,
-                    );
-                case 502:
-                    throw new Error(
-                        `${msg}: Server was unable to write file to storage`,
-                    );
-                default:
-                    throw new Error(`${msg}: Server failed`);
-            }
-        }
-    }
+			return {
+				server: this.server,
+				name: this.name,
+				version: this.version,
+				type: "map",
+			};
+		} catch (err) {
+			const msg = "Unable to complete upload of import map to server";
+			switch (err.statusCode) {
+				case 400:
+					throw new Error(
+						`${msg}: Client attempted to send an invalid URL parameter`,
+					);
+				case 401:
+					throw new Error(`${msg}: Client unauthorized with server`);
+				case 409:
+					throw new Error(
+						`${msg}: Map with name "${this.name}" and version "${this.version}" already exists on server`,
+					);
+				case 415:
+					throw new Error(
+						`${msg}: Client attempted to send an unsupported file format to server`,
+					);
+				case 502:
+					throw new Error(`${msg}: Server was unable to write file to storage`);
+				default:
+					throw new Error(`${msg}: Server failed`);
+			}
+		}
+	}
 }