@jsenv/package-publish 1.7.0 → 1.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/package-publish",
-  "version": "1.7.0",
+  "version": "1.7.3",
   "description": "Publish package to one or many registry.",
   "license": "MIT",
   "author": {
@@ -10,7 +10,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/package-publish"
+    "url": "https://github.com/jsenv/workflow",
+    "directory": "packages/jsenv-package-publish"
   },
   "engines": {
     "node": ">=16.13.0"
@@ -32,27 +33,16 @@
     "/main.js"
   ],
   "scripts": {
-    "eslint": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
-    "importmap": "node ./script/importmap/importmap.mjs",
+    "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 ."
   },
   "dependencies": {
-    "@jsenv/filesystem": "2.7.1",
+    "@jsenv/filesystem": "3.1.0",
     "@jsenv/logger": "4.0.1",
-    "@jsenv/server": "12.4.0",
+    "node-fetch": "2.6.7",
+    "@jsenv/log": "1.5.0",
     "semver": "7.3.5"
-  },
-  "devDependencies": {
-    "@jsenv/assert": "2.4.1",
-    "@jsenv/core": "25.3.0",
-    "@jsenv/eslint-config": "16.0.9",
-    "@jsenv/github-release-package": "1.3.0",
-    "@jsenv/importmap-eslint-resolver": "5.2.5",
-    "@jsenv/importmap-node-module": "5.1.0",
-    "eslint": "8.7.0",
-    "eslint-plugin-import": "2.25.4",
-    "prettier": "2.5.1"
   }
 }

package/{README.md → readme.md}

@@ -1,4 +1,4 @@
-# Package publish [![npm package](https://img.shields.io/npm/v/@jsenv/package-publish.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/package-publish) [![github main](https://github.com/jsenv/package-publish/workflows/main/badge.svg)](https://github.com/jsenv/package-publish/actions?workflow=main) [![codecov coverage](https://codecov.io/gh/jsenv/package-publish/branch/master/graph/badge.svg)](https://codecov.io/gh/jsenv/package-publish)
+# Package publish [![npm package](https://img.shields.io/npm/v/@jsenv/package-publish.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/package-publish)
 
 Publish package to one or many registry.
 
@@ -13,8 +13,6 @@ Screenshot taken inside a github workflow when the package.json version is alrea
 
 Screenshot taken inside a github workflow when the package.json version is not published: ![publishing github workflow screenshot](./docs/publishing-github-workflow-screenshot.png)
 
-This package is using itself to be published on NPM. It is done during ["publish package" step](https://github.com/jsenv/package-publish/blob/0170a5c859c4732203ff2f3e70b85e705396ccc7/.github/workflows/main.yml#L70-L74) in GitHub worflow.
-
 # Installation
 
 ```console
@@ -31,7 +29,7 @@ _publishPackage_ is an async function publishing a package on one or many regist
 import { publishPackage } from "@jsenv/package-publish"
 
 const publishReport = await publishPackage({
-  projectDirectoryUrl: new URL('./', import.meta.url)
+  rootDirectoryUrl: new URL('./', import.meta.url)
   registriesConfig: {
     "https://registry.npmjs.org": {
       token: process.env.NPM_TOKEN,
@@ -43,9 +41,9 @@ const publishReport = await publishPackage({
 })
 ```
 
-## projectDirectoryUrl
+## rootDirectoryUrl
 
-_projectDirectoryUrl_ parameter is a string leading to a directory containing the package.json.
+_rootDirectoryUrl_ parameter is a string leading to a directory containing the package.json.
 
 This parameter is **required**.
 

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 { fetchUrl } from "@jsenv/server"
+import nodeFetch from "node-fetch"
 
 export const fetchLatestInRegistry = async ({
   registryUrl,
@@ -10,13 +10,17 @@ export const fetchLatestInRegistry = async ({
   token,
 }) => {
   const requestUrl = `${registryUrl}/${packageName}`
-  const response = await fetchUrl(requestUrl, {
+  const response = await nodeFetch(requestUrl, {
     method: "GET",
     headers: {
       // "user-agent": "jsenv",
       accept:
         "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*",
-      ...(token ? { authorization: `token ${token}` } : {}),
+      ...(token
+        ? {
+            authorization: `token ${token}`,
+          }
+        : {}),
     },
   })
   const responseStatus = response.status

package/src/internal/publish.js

@@ -4,152 +4,170 @@ import {
   urlToFileSystemPath,
   readFile,
   writeFile,
+  removeEntry,
 } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
 import { setNpmConfig } from "./setNpmConfig.js"
 
 export const publish = async ({
   logger,
+  packageSlug,
   logNpmPublishOutput,
-  projectDirectoryUrl,
+  rootDirectoryUrl,
   registryUrl,
   token,
 }) => {
-  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 projectPackageFileUrl = resolveUrl(
-      "./package.json",
-      projectDirectoryUrl,
-    )
-    const projectPackageString = await readFile(projectPackageFileUrl)
-    const restoreProjectPackageFile = () =>
-      writeFile(projectPackageFileUrl, projectPackageString)
-    const projectPackageObject = JSON.parse(projectPackageString)
-    projectPackageObject.publishConfig =
-      projectPackageObject.publishConfig || {}
-    projectPackageObject.publishConfig.registry = registryUrl
-    promises.push(
-      writeFile(
-        projectPackageFileUrl,
-        JSON.stringify(projectPackageObject, null, "  "),
-      ),
-    )
-    const projectNpmConfigFileUrl = resolveUrl("./.npmrc", projectDirectoryUrl)
-    let projectNpmConfigString
+  const getResult = async () => {
     try {
-      projectNpmConfigString = await readFile(projectNpmConfigFileUrl)
-    } catch (e) {
-      if (e.code === "ENOENT") {
-        projectNpmConfigString = ""
-      } else {
-        throw e
+      const promises = []
+      const previousValue = process.env.NODE_AUTH_TOKEN
+      const restoreProcessEnv = () => {
+        process.env.NODE_AUTH_TOKEN = previousValue
       }
-    }
-    const restoreProjectNpmConfigFile = () =>
-      writeFile(projectNpmConfigFileUrl, projectNpmConfigString)
-    promises.push(
-      writeFile(
-        projectNpmConfigFileUrl,
-        setNpmConfig(projectNpmConfigString, {
-          [computeRegistryTokenKey(registryUrl)]: token,
-          [computeRegistryKey(projectPackageObject.name)]: registryUrl,
-        }),
-      ),
-    )
-    await Promise.all(promises)
-    try {
-      return await new Promise((resolve, reject) => {
-        const command = exec(
-          "npm publish",
-          {
-            cwd: urlToFileSystemPath(projectDirectoryUrl),
-            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.
+      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)
+      packageObject.publishConfig = packageObject.publishConfig || {}
+      packageObject.publishConfig.registry = registryUrl
+      promises.push(
+        writeFile(
+          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
+        }
+      }
+      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",
+            {
+              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.
 
-              // 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",
-                )
-              ) {
+                // 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 {
                 resolve({
                   success: true,
-                  reason: "already-published",
+                  reason: "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)
-          })
-        }
-      })
-    } finally {
-      await Promise.all([
-        restoreProcessEnv(),
-        restoreProjectPackageFile(),
-        restoreProjectNpmConfigFile(),
-      ])
+            },
+          )
+          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(),
+        ])
+      }
+    } catch (e) {
+      return {
+        success: false,
+        reason: e,
+      }
     }
-  } catch (e) {
-    return {
-      success: false,
-      reason: e,
+  }
+  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}`)
     }
+  } 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,10 +1,10 @@
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
-export const readProjectPackage = async ({ projectDirectoryUrl }) => {
-  const packageFileUrl = resolveUrl("./package.json", projectDirectoryUrl)
+export const readProjectPackage = async ({ rootDirectoryUrl }) => {
+  const packageFileUrl = resolveUrl("./package.json", rootDirectoryUrl)
   let packageObject
   try {
-    const packageString = await readFile(packageFileUrl)
+    const packageString = await readFile(packageFileUrl, { as: "string" })
     try {
       packageObject = JSON.parse(packageString)
     } catch (e) {

package/src/publishPackage.js

@@ -15,7 +15,7 @@ import {
 
 export const publishPackage = async ({
   logLevel,
-  projectDirectoryUrl,
+  rootDirectoryUrl,
   registriesConfig,
   logNpmPublishOutput = true,
   updateProcessExitCode = true,
@@ -23,17 +23,17 @@ export const publishPackage = async ({
   const logger = createLogger({ logLevel })
   logger.debug(
     `publishPackage(${JSON.stringify(
-      { projectDirectoryUrl, logLevel, registriesConfig },
+      { rootDirectoryUrl, logLevel, registriesConfig },
       null,
       "  ",
     )})`,
   )
-  projectDirectoryUrl = assertAndNormalizeDirectoryUrl(projectDirectoryUrl)
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
   assertRegistriesConfig(registriesConfig)
 
   logger.debug(`reading project package.json`)
   const packageInProject = await readProjectPackage({
-    projectDirectoryUrl,
+    rootDirectoryUrl,
   })
 
   const { name: packageName, version: packageVersion } = packageInProject
@@ -138,29 +138,15 @@ ${actionReason.stack}`)
 
     const { success, reason } = await publish({
       logger,
+      packageSlug: `${packageName}@${packageVersion}`,
       logNpmPublishOutput,
-      projectDirectoryUrl,
+      rootDirectoryUrl,
       registryUrl,
       ...registriesConfig[registryUrl],
     })
     registryReport.actionResult = { success, reason }
-    if (success) {
-      if (reason === "already-published") {
-        logger.info(
-          `${packageName}@${packageVersion} was already published on ${registryUrl}`,
-        )
-      } else {
-        logger.info(
-          `${packageName}@${packageVersion} published on ${registryUrl}`,
-        )
-      }
-    } else {
-      logger.error(`error when publishing ${packageName}@${packageVersion} in ${registryUrl}
---- error stack ---
-${reason.stack}`)
-      if (updateProcessExitCode) {
-        process.exitCode = 1
-      }
+    if (!success && updateProcessExitCode) {
+      process.exitCode = 1
     }
   }, Promise.resolve())