refactor: split global type module

src/cmd-add.ts

@@ -1,14 +1,13 @@
 import log from "./logger";
 import url from "url";
 import { isPackageUrl } from "./types/package-url";
-import { GlobalOptions, ScopedRegistry } from "./types/global";
-import { tryGetLatestVersion } from "./utils/pkg-info";
-import { loadManifest, saveManifest } from "./utils/manifest";
+import { tryGetLatestVersion } from "./types/pkg-info";
+import { loadManifest, saveManifest } from "./utils/pkg-manifest-io";
 import { env, parseEnv } from "./utils/env";
 import {
   compareEditorVersion,
   tryParseEditorVersion,
-} from "./utils/editor-version";
+} from "./types/editor-version";
 import { fetchPackageDependencies, fetchPackageInfo } from "./registry-client";
 import { DomainName, isDomainName } from "./types/domain-name";
 import { SemanticVersion } from "./types/semantic-version";
@@ -17,12 +16,19 @@ import {
   PackageReference,
   splitPackageReference,
 } from "./types/package-reference";
+import { scopedRegistry } from "./types/scoped-registry";
+import {
+  addDependency,
+  addScopedRegistry,
+  addTestable,
+  tryGetScopedRegistryByUrl,
+} from "./types/pkg-manifest";
+import { CmdOptions } from "./types/options";
 
-export type AddOptions = {
+export type AddOptions = CmdOptions<{
   test?: boolean;
   force?: boolean;
-  _global: GlobalOptions;
-};
+}>;
 
 type ResultCode = 0 | 1;
 
@@ -76,10 +82,6 @@ const _add = async function ({
   // load manifest
   const manifest = loadManifest();
   if (manifest === null) return { code: 1, dirty };
-  // ensure manifest.dependencies
-  if (!manifest.dependencies) {
-    manifest.dependencies = {};
-  }
   // packages that added to scope registry
   const pkgsInScope: DomainName[] = [];
   if (version === undefined || !isPackageUrl(version)) {
@@ -196,7 +198,7 @@ const _add = async function ({
   }
   // add to dependencies
   const oldVersion = manifest.dependencies[name];
-  manifest.dependencies[name] = version;
+  addDependency(manifest, name, version);
   if (!oldVersion) {
     // Log the added package
     log.notice("manifest", `added ${packageReference(name, version)}`);
@@ -215,22 +217,14 @@ const _add = async function ({
       manifest.scopedRegistries = [];
       dirty = true;
     }
-    const filterEntry = (x: ScopedRegistry): boolean => {
-      let addr = x.url || "";
-      if (addr.endsWith("/")) addr = addr.slice(0, -1);
-      return addr == env.registry;
-    };
-    if (manifest.scopedRegistries.filter(filterEntry).length <= 0) {
+    let entry = tryGetScopedRegistryByUrl(manifest, env.registry);
+    if (entry === null) {
       const name = url.parse(env.registry).hostname;
       if (name === null) throw new Error("Could not resolve registry name");
-      manifest.scopedRegistries.push({
-        name,
-        url: env.registry,
-        scopes: [],
-      });
+      entry = scopedRegistry(name, env.registry);
+      addScopedRegistry(manifest, entry);
       dirty = true;
     }
-    const entry = manifest.scopedRegistries.filter(filterEntry)[0];
     // apply pkgsInScope
     const scopesSet = new Set(entry.scopes || []);
     if (isDomainName(env.namespace)) pkgsInScope.push(env.namespace);
@@ -242,14 +236,7 @@ const _add = async function ({
     });
     entry.scopes = Array.from(scopesSet).sort();
   }
-  if (testables) {
-    if (!manifest.testables) {
-      manifest.testables = [];
-    }
-    if (manifest.testables.indexOf(name) === -1) {
-      manifest.testables.push(name);
-    }
-  }
+  if (testables) addTestable(manifest, name);
   // save manifest
   if (dirty) {
     if (!saveManifest(manifest)) return { code: 1, dirty };

src/cmd-deps.ts

@@ -1,5 +1,4 @@
 import log from "./logger";
-import { GlobalOptions } from "./types/global";
 import { parseEnv } from "./utils/env";
 import { fetchPackageDependencies } from "./registry-client";
 import { DomainName } from "./types/domain-name";
@@ -10,11 +9,11 @@ import {
   splitPackageReference,
   VersionReference,
 } from "./types/package-reference";
+import { CmdOptions } from "./types/options";
 
-export type DepsOptions = {
+export type DepsOptions = CmdOptions<{
   deep?: boolean;
-  _global: GlobalOptions;
-};
+}>;
 
 export const deps = async function (
   pkg: PackageReference,

src/cmd-login.ts

@@ -1,52 +1,48 @@
 import fs from "fs";
 import path from "path";
 import _ from "lodash";
-import promptly from "promptly";
 import { assertIsNpmClientError, getNpmClient } from "./registry-client";
-
 import log from "./logger";
-
-import { GlobalOptions } from "./types/global";
 import {
   getUpmConfigDir,
   loadUpmConfig,
   saveUpmConfig,
-} from "./utils/upm-config";
+} from "./utils/upm-config-io";
 import { parseEnv } from "./utils/env";
+import { encodeBasicAuth } from "./types/upm-config";
+import { Base64 } from "./types/base64";
+import { RegistryUrl, removeTrailingSlash } from "./types/registry-url";
 import {
-  RegistryUrl,
-  registryUrl,
-  removeTrailingSlash,
-} from "./types/registry-url";
+  promptEmail,
+  promptPassword,
+  promptRegistryUrl,
+  promptUsername,
+} from "./utils/prompts";
+import { CmdOptions } from "./types/options";
 
-export type LoginOptions = {
+export type LoginOptions = CmdOptions<{
   username?: string;
   password?: string;
   email?: string;
   basicAuth?: boolean;
   alwaysAuth?: boolean;
-  _global: GlobalOptions;
-};
+}>;
 
 export const login = async function (options: LoginOptions) {
   // parse env
   const envOk = await parseEnv(options, { checkPath: false });
   if (!envOk) return 1;
   // query parameters
-  if (!options.username) options.username = await promptly.prompt("Username: ");
-  if (!options.password)
-    options.password = await promptly.password("Password: ");
-  if (!options.email) options.email = await promptly.prompt("Email: ");
+  if (!options.username) options.username = await promptUsername();
+  if (!options.password) options.password = await promptPassword();
+  if (!options.email) options.email = await promptEmail();
   if (!options._global.registry)
-    options._global.registry = (await promptly.prompt("Registry: ", {
-      validator: [registryUrl],
-    })) as RegistryUrl;
+    options._global.registry = await promptRegistryUrl();
   let token: string | null = null;
-  let _auth: string | null = null;
+  let _auth: Base64 | null = null;
   if (options.basicAuth) {
     // basic auth
-    const userPass = `${options.username}:${options.password}`;
-    _auth = Buffer.from(userPass).toString("base64");
+    _auth = encodeBasicAuth(options.username, options.password);
   } else {
     // npm login
     const result = await npmLogin({
@@ -205,7 +201,7 @@ const writeUnityToken = async function ({
   registry,
   token,
 }: {
-  _auth: string | null;
+  _auth: Base64 | null;
   alwaysAuth: boolean;
   basicAuth: boolean;
   email: string;

src/cmd-remove.ts

@@ -1,17 +1,20 @@
 import log from "./logger";
-import { GlobalOptions, ScopedRegistry } from "./types/global";
-import { loadManifest, saveManifest } from "./utils/manifest";
+import { loadManifest, saveManifest } from "./utils/pkg-manifest-io";
 import { env, parseEnv } from "./utils/env";
 import { isDomainName } from "./types/domain-name";
 import {
   packageReference,
   PackageReference,
   splitPackageReference,
 } from "./types/package-reference";
+import { hasScope, removeScope } from "./types/scoped-registry";
+import {
+  removeDependency,
+  tryGetScopedRegistryByUrl,
+} from "./types/pkg-manifest";
+import { CmdOptions } from "./types/options";
 
-export type RemoveOptions = {
-  _global: GlobalOptions;
-};
+export type RemoveOptions = CmdOptions;
 
 export const remove = async function (
   pkgs: PackageReference[] | PackageReference,
@@ -53,33 +56,21 @@ const _remove = async function (pkg: PackageReference) {
   if (manifest === null) return { code: 1, dirty };
   // not found array
   const pkgsNotFound = [];
-  // remove from dependencies
-  if (manifest.dependencies) {
-    version = manifest.dependencies[name];
-    if (version) {
-      log.notice("manifest", `removed ${packageReference(name, version)}`);
-      delete manifest.dependencies[name];
+  version = manifest.dependencies[name];
+  if (version) {
+    log.notice("manifest", `removed ${packageReference(name, version)}`);
+    removeDependency(manifest, name);
+    dirty = true;
+  } else pkgsNotFound.push(pkg);
+
+  const entry = tryGetScopedRegistryByUrl(manifest, env.registry);
+  if (entry !== null) {
+    if (hasScope(entry, name)) {
+      removeScope(entry, name);
+      const scopesSet = new Set(entry.scopes);
+      if (isDomainName(env.namespace)) scopesSet.add(env.namespace);
+      entry.scopes = Array.from(scopesSet).sort();
       dirty = true;
-    } else pkgsNotFound.push(pkg);
-  }
-  // remove from scopedRegistries
-  if (manifest.scopedRegistries) {
-    const filterEntry = (x: ScopedRegistry) => {
-      let url = x.url || "";
-      if (url.endsWith("/")) url = url.slice(0, -1);
-      return url == env.registry;
-    };
-    const entires = manifest.scopedRegistries.filter(filterEntry);
-    if (entires.length > 0) {
-      const entry = entires[0];
-      const index = entry.scopes.indexOf(name);
-      if (index > -1) {
-        entry.scopes.splice(index, 1);
-        const scopesSet = new Set(entry.scopes);
-        if (isDomainName(env.namespace)) scopesSet.add(env.namespace);
-        entry.scopes = Array.from(scopesSet).sort();
-        dirty = true;
-      }
     }
   }
   // save manifest

src/cmd-search.ts

@@ -5,20 +5,18 @@ import log from "./logger";
 import { is404Error, isHttpError } from "./utils/error-type-guards";
 import * as os from "os";
 import assert from "assert";
-import { GlobalOptions, PkgInfo } from "./types/global";
-import { tryGetLatestVersion } from "./utils/pkg-info";
+import { PkgInfo, tryGetLatestVersion } from "./types/pkg-info";
 import { env, parseEnv } from "./utils/env";
 import { DomainName } from "./types/domain-name";
 import { SemanticVersion } from "./types/semantic-version";
 import { RegistryUrl } from "./types/registry-url";
+import { CmdOptions } from "./types/options";
 
 type DateString = string;
 
 type TableRow = [DomainName, SemanticVersion, DateString, ""];
 
-export type SearchOptions = {
-  _global: GlobalOptions;
-};
+export type SearchOptions = CmdOptions;
 
 export type SearchedPkgInfo = Omit<PkgInfo, "versions"> & {
   versions: Record<SemanticVersion, "latest">;

src/cmd-view.ts

@@ -1,8 +1,7 @@
 import chalk from "chalk";
 import log from "./logger";
 import assert from "assert";
-import { GlobalOptions, PkgInfo } from "./types/global";
-import { tryGetLatestVersion } from "./utils/pkg-info";
+import { PkgInfo, tryGetLatestVersion } from "./types/pkg-info";
 import { env, parseEnv } from "./utils/env";
 import { fetchPackageInfo } from "./registry-client";
 import { DomainName } from "./types/domain-name";
@@ -11,10 +10,9 @@ import {
   PackageReference,
   splitPackageReference,
 } from "./types/package-reference";
+import { CmdOptions } from "./types/options";
 
-export type ViewOptions = {
-  _global: GlobalOptions;
-};
+export type ViewOptions = CmdOptions;
 
 export const view = async function (
   pkg: PackageReference,

src/registry-client.ts

@@ -8,10 +8,9 @@ import RegClient, {
 import log from "./logger";
 import request from "request";
 import assert, { AssertionError } from "assert";
-import { Dependency, NameVersionPair, PkgInfo } from "./types/global";
 import { env } from "./utils/env";
 import _ from "lodash";
-import { tryGetLatestVersion } from "./utils/pkg-info";
+import { PkgInfo, tryGetLatestVersion } from "./types/pkg-info";
 import { DomainName, isInternalPackage } from "./types/domain-name";
 import { SemanticVersion } from "./types/semantic-version";
 import { packageReference } from "./types/package-reference";
@@ -44,6 +43,21 @@ export class NpmClientError extends Error {
   }
 }
 
+export type Dependency = {
+  name: DomainName;
+  version?: SemanticVersion;
+  upstream: boolean;
+  self: boolean;
+  internal: boolean;
+  reason: string | null;
+  resolved?: boolean;
+};
+
+type NameVersionPair = {
+  name: DomainName;
+  version: SemanticVersion | "latest" | undefined;
+};
+
 export function assertIsNpmClientError(
   x: unknown
 ): asserts x is NpmClientError {
@@ -103,6 +117,7 @@ export const fetchPackageInfo = async function (
     // eslint-disable-next-line no-empty
   } catch (err) {}
 };
+
 /* Fetch package [valid dependencies, invalid dependencies] with a structure of
   [
     {

src/types/another-npm-registry-client.d.ts

@@ -1,5 +1,6 @@
 import { Response } from "request";
-import { PkgInfo } from "./global";
+
+import { PkgInfo } from "./pkg-info";
 
 declare module "another-npm-registry-client" {
   export type NpmAuth =

src/types/base64.ts

@@ -0,0 +1,20 @@
+import { Brand } from "ts-brand";
+
+export type Base64 = Brand<string, "Base64">;
+
+/**
+ * Encodes a string using base64
+ * @param s The string
+ */
+export function encodeBase64(s: string): Base64 {
+  return Buffer.from(s).toString("base64") as Base64;
+}
+
+/**
+ * Decodes a base64 string
+ * @param base64 The string
+ */
+export function decodeBase64(base64: Base64): string {
+  const buffer = Buffer.from(base64, "base64");
+  return buffer.toString("utf-8");
+}