@jsenv/package-publish 1.7.5 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/package-publish",
-  "version": "1.7.5",
+  "version": "1.10.0",
   "description": "Publish package to one or many registry.",
   "license": "MIT",
   "author": {
@@ -17,33 +17,26 @@
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
     ".": {
-      "import": "./main.js"
+      "import": "./src/main.js"
     },
     "./*": "./*"
   },
-  "main": "./main.js",
+  "main": "./src/main.js",
   "files": [
-    "/src/",
-    "/main.js"
+    "/src/"
   ],
   "scripts": {
-    "eslint": "npx eslint . --ext=.js,.mjs",
-    "test": "node --experimental-json-modules ./script/test/test.mjs",
-    "test-with-coverage": "npm run test -- --coverage",
-    "prettier": "prettier --write ."
+    "test": "node --experimental-json-modules ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/filesystem": "4.0.0",
-    "@jsenv/urls": "1.1.0",
-    "@jsenv/logger": "4.0.1",
-    "node-fetch": "2.6.7",
-    "@jsenv/log": "1.6.3",
-    "semver": "7.3.5"
+    "@jsenv/fetch": "1.1.3",
+    "@jsenv/filesystem": "4.1.0",
+    "@jsenv/log": "3.0.0",
+    "semver": "7.3.7"
   }
-}
+}

package/src/internal/fetchLatestInRegistry.js

@@ -2,7 +2,7 @@
 // https://github.com/npm/registry-issue-archive/issues/34
 // https://stackoverflow.com/questions/53212849/querying-information-about-specific-version-of-scoped-npm-package
 
-import nodeFetch from "node-fetch"
+import { fetchUrl } from "@jsenv/fetch"
 
 export const fetchLatestInRegistry = async ({
   registryUrl,
@@ -10,7 +10,7 @@ export const fetchLatestInRegistry = async ({
   token,
 }) => {
   const requestUrl = `${registryUrl}/${packageName}`
-  const response = await nodeFetch(requestUrl, {
+  const response = await fetchUrl(requestUrl, {
     method: "GET",
     headers: {
       // "user-agent": "jsenv",

package/src/internal/publish.js

@@ -1,7 +1,8 @@
+import { fileURLToPath } from "node:url"
+import { readFileSync, writeFileSync } from "node:fs"
 import { exec } from "node:child_process"
-import { readFile, writeFile, removeEntry } from "@jsenv/filesystem"
-import { resolveUrl, urlToFileSystemPath } from "@jsenv/urls"
-import { UNICODE } from "@jsenv/log"
+import { createTaskLog } from "@jsenv/log"
+import { removeEntry } from "@jsenv/filesystem"
 
 import { setNpmConfig } from "./setNpmConfig.js"
 
@@ -13,156 +14,152 @@ export const publish = async ({
   registryUrl,
   token,
 }) => {
-  const getResult = async () => {
-    try {
-      const promises = []
-      const previousValue = process.env.NODE_AUTH_TOKEN
-      const restoreProcessEnv = () => {
-        process.env.NODE_AUTH_TOKEN = previousValue
-      }
-      process.env.NODE_AUTH_TOKEN = token
-      const rootPackageFileUrl = resolveUrl("./package.json", rootDirectoryUrl)
-      const rootPackageString = await readFile(rootPackageFileUrl)
-      const restorePackageFile = () =>
-        writeFile(rootPackageFileUrl, rootPackageString)
-      const packageObject = JSON.parse(rootPackageString)
+  const publishTask = createTaskLog(`publish ${packageSlug} on ${registryUrl}`)
+  try {
+    // process.env.NODE_AUTH_TOKEN
+    const previousValue = process.env.NODE_AUTH_TOKEN
+    const restoreProcessEnv = () => {
+      process.env.NODE_AUTH_TOKEN = previousValue
+    }
+    process.env.NODE_AUTH_TOKEN = token
+    // updating package.json to publish on the correct registry
+    let restorePackageFile = () => {}
+    const rootPackageFileUrl = new URL("./package.json", rootDirectoryUrl)
+    const rootPackageFileContent = readFileSync(rootPackageFileUrl)
+    const packageObject = JSON.parse(String(rootPackageFileContent))
+    const { publishConfig } = packageObject
+    const registerUrlFromPackage = publishConfig
+      ? publishConfig.registry || "https://registry.npmjs.org"
+      : "https://registry.npmjs.org"
+    if (registryUrl !== registerUrlFromPackage) {
+      restorePackageFile = () =>
+        writeFileSync(rootPackageFileUrl, rootPackageFileContent)
       packageObject.publishConfig = packageObject.publishConfig || {}
       packageObject.publishConfig.registry = registryUrl
-      promises.push(
-        writeFile(
-          rootPackageFileUrl,
-          JSON.stringify(packageObject, null, "  "),
-        ),
+      writeFileSync(
+        rootPackageFileUrl,
+        JSON.stringify(packageObject, null, "  "),
       )
-      const npmConfigFileUrl = resolveUrl("./.npmrc", rootDirectoryUrl)
-      let restoreNpmConfigFile
-      let projectNpmConfigString
-      try {
-        projectNpmConfigString = await readFile(npmConfigFileUrl)
-        restoreNpmConfigFile = () =>
-          writeFile(npmConfigFileUrl, projectNpmConfigString)
-      } catch (e) {
-        if (e.code === "ENOENT") {
-          restoreNpmConfigFile = () => removeEntry(npmConfigFileUrl)
-          projectNpmConfigString = ""
-        } else {
-          throw e
-        }
+    }
+    // updating .npmrc to add the token
+    const npmConfigFileUrl = new URL("./.npmrc", rootDirectoryUrl)
+    let restoreNpmConfigFile
+    let npmConfigFileContent
+    try {
+      npmConfigFileContent = String(readFileSync(npmConfigFileUrl))
+      restoreNpmConfigFile = () =>
+        writeFileSync(npmConfigFileUrl, npmConfigFileContent)
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        restoreNpmConfigFile = () => removeEntry(npmConfigFileUrl)
+        npmConfigFileContent = ""
+      } else {
+        throw e
       }
-      promises.push(
-        writeFile(
-          npmConfigFileUrl,
-          setNpmConfig(projectNpmConfigString, {
-            [computeRegistryTokenKey(registryUrl)]: token,
-            [computeRegistryKey(packageObject.name)]: registryUrl,
-          }),
-        ),
-      )
-      await Promise.all(promises)
-      try {
-        return await new Promise((resolve, reject) => {
-          const command = exec(
-            "npm publish --no-workspaces",
-            {
-              cwd: urlToFileSystemPath(rootDirectoryUrl),
-              stdio: "silent",
-            },
-            (error) => {
-              if (error) {
-                // publish conflict generally occurs because servers
-                // returns 200 after npm publish
-                // but returns previous version if asked immediatly
-                // after for the last published version.
+    }
+    writeFileSync(
+      npmConfigFileUrl,
+      setNpmConfig(npmConfigFileContent, {
+        [computeRegistryTokenKey(registryUrl)]: token,
+        [computeRegistryKey(packageObject.name)]: registryUrl,
+      }),
+    )
+    try {
+      const reason = await new Promise((resolve, reject) => {
+        const command = exec(
+          "npm publish --no-workspaces",
+          {
+            cwd: fileURLToPath(rootDirectoryUrl),
+            stdio: "silent",
+          },
+          (error) => {
+            if (error) {
+              // publish conflict generally occurs because servers
+              // returns 200 after npm publish
+              // but returns previous version if asked immediatly
+              // after for the last published version.
 
-                // TODO: ideally we should catch 404 error returned from npm
-                // it happens it the token is not allowed to publish
-                // a repository. And when we detect this we display a more useful message
-                // suggesting the token rights are insufficient to publish the package
+              // TODO: ideally we should catch 404 error returned from npm
+              // it happens it the token is not allowed to publish
+              // a repository. And when we detect this we display a more useful message
+              // suggesting the token rights are insufficient to publish the package
 
-                // npm publish conclit
-                if (error.message.includes("EPUBLISHCONFLICT")) {
-                  resolve({
-                    success: true,
-                    reason: "already-published",
-                  })
-                } else if (
-                  error.message.includes("Cannot publish over existing version")
-                ) {
-                  resolve({
-                    success: true,
-                    reason: "already-published",
-                  })
-                } else if (
-                  error.message.includes(
-                    "You cannot publish over the previously published versions",
-                  )
-                ) {
-                  resolve({
-                    success: true,
-                    reason: "already-published",
-                  })
-                }
-                // github publish conflict
-                else if (
-                  error.message.includes(
-                    "ambiguous package version in package.json",
-                  )
-                ) {
-                  resolve({
-                    success: true,
-                    reason: "already-published",
-                  })
-                } else {
-                  reject(error)
-                }
-              } else {
+              // npm publish conclit
+              if (error.message.includes("EPUBLISHCONFLICT")) {
+                resolve({
+                  success: true,
+                  reason: "already-published",
+                })
+              } else if (
+                error.message.includes("Cannot publish over existing version")
+              ) {
+                resolve({
+                  success: true,
+                  reason: "already-published",
+                })
+              } else if (
+                error.message.includes(
+                  "You cannot publish over the previously published versions",
+                )
+              ) {
                 resolve({
                   success: true,
-                  reason: "published",
+                  reason: "already-published",
                 })
               }
-            },
-          )
-          if (logNpmPublishOutput) {
-            command.stdout.on("data", (data) => {
-              logger.debug(data)
-            })
-            command.stderr.on("data", (data) => {
-              // debug because this output is part of
-              // the error message generated by a failing npm publish
-              logger.debug(data)
-            })
-          }
-        })
-      } finally {
-        await Promise.all([
-          restoreProcessEnv(),
-          restorePackageFile(),
-          restoreNpmConfigFile(),
-        ])
+              // github publish conflict
+              else if (
+                error.message.includes(
+                  "ambiguous package version in package.json",
+                )
+              ) {
+                resolve({
+                  success: true,
+                  reason: "already-published",
+                })
+              } else {
+                reject(error)
+              }
+            } else {
+              resolve({
+                success: true,
+                reason: "published",
+              })
+            }
+          },
+        )
+        if (logNpmPublishOutput) {
+          command.stdout.on("data", (data) => {
+            logger.debug(data)
+          })
+          command.stderr.on("data", (data) => {
+            // debug because this output is part of
+            // the error message generated by a failing npm publish
+            logger.debug(data)
+          })
+        }
+      })
+      if (reason === "already-published") {
+        publishTask.setRightText(`(already published)`)
       }
-    } catch (e) {
+      publishTask.done()
       return {
-        success: false,
-        reason: e,
+        success: true,
+        reason,
       }
+    } finally {
+      restoreProcessEnv()
+      restorePackageFile()
+      restoreNpmConfigFile()
     }
-  }
-  const { success, reason } = await getResult()
-  if (success) {
-    if (reason === "already-published") {
-      logger.info(
-        `${UNICODE.INFO} ${packageSlug} was already published on ${registryUrl}`,
-      )
-    } else {
-      logger.info(`${UNICODE.OK} ${packageSlug} published on ${registryUrl}`)
+  } catch (e) {
+    publishTask.fail()
+    console.error(e.stack)
+    return {
+      success: false,
+      reason: e,
     }
-  } else {
-    logger.error(`${UNICODE.FAILURE} error when publishing ${packageSlug} in ${registryUrl}
-  --- error stack ---
-  ${reason.stack}`)
   }
-  return { success, reason }
 }
 
 const computeRegistryTokenKey = (registryUrl) => {

package/src/internal/readProjectPackage.js

@@ -1,20 +1,20 @@
-import { resolveUrl, urlToFileSystemPath } from "@jsenv/urls"
-import { readFile } from "@jsenv/filesystem"
+import { fileURLToPath } from "node:url"
+import { readFileSync } from "node:fs"
 
-export const readProjectPackage = async ({ rootDirectoryUrl }) => {
-  const packageFileUrl = resolveUrl("./package.json", rootDirectoryUrl)
-  let packageObject
+export const readProjectPackage = ({ rootDirectoryUrl }) => {
+  const packageFileUrlObject = new URL("./package.json", rootDirectoryUrl)
+  let packageInProject
   try {
-    const packageString = await readFile(packageFileUrl, { as: "string" })
+    const packageString = String(readFileSync(packageFileUrlObject))
     try {
-      packageObject = JSON.parse(packageString)
+      packageInProject = JSON.parse(packageString)
     } catch (e) {
       if (e.name === "SyntaxError") {
         throw new Error(`syntax error while parsing project package.json
 --- syntax error stack ---
 ${e.stack}
 --- package.json path ---
-${urlToFileSystemPath(packageFileUrl)}`)
+${fileURLToPath(packageFileUrlObject)}`)
       }
       throw e
     }
@@ -23,10 +23,10 @@ ${urlToFileSystemPath(packageFileUrl)}`)
       throw new Error(
         `cannot find project package.json
 --- package.json path ---
-${urlToFileSystemPath(packageFileUrl)}`,
+${fileURLToPath(packageFileUrlObject)}`,
       )
     }
     throw e
   }
-  return packageObject
+  return packageInProject
 }

package/{main.js → src/main.js}

@@ -5,4 +5,4 @@
  *   discover codebase progressively
  */
 
-export { publishPackage } from "./src/publishPackage.js"
+export { publishPackage } from "./publishPackage.js"

package/src/publishPackage.js

@@ -1,5 +1,5 @@
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/logger"
+import { createLogger } from "@jsenv/log"
 
 import { fetchLatestInRegistry } from "./internal/fetchLatestInRegistry.js"
 import { publish } from "./internal/publish.js"
@@ -32,9 +32,7 @@ export const publishPackage = async ({
   assertRegistriesConfig(registriesConfig)
 
   logger.debug(`reading project package.json`)
-  const packageInProject = await readProjectPackage({
-    rootDirectoryUrl,
-  })
+  const packageInProject = readProjectPackage({ rootDirectoryUrl })
 
   const { name: packageName, version: packageVersion } = packageInProject
   logger.info(`${packageName}@${packageVersion} found in package.json`)