@jsenv/package-publish 1.6.1 → 1.7.2

package/main.js

@@ -0,0 +1,8 @@
+/*
+ * This file is the entry point of this codebase
+ * - It is responsible to export the documented API
+ * - It should be kept simple (just re-export) to help reader to
+ *   discover codebase progressively
+ */
+
+export { publishPackage } from "./src/publishPackage.js"

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@jsenv/package-publish",
-  "version": "1.6.1",
+  "version": "1.7.2",
   "description": "Publish package to one or many registry.",
   "license": "MIT",
+  "author": {
+    "name": "dmail",
+    "email": "dmaillard06@gmail.com",
+    "url": "https://twitter.com/damienmaillard"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-package-publish"
+    "url": "https://github.com/jsenv/workflow",
+    "directory": "packages/jsenv-package-publish"
   },
   "engines": {
-    "node": ">=14.17.0"
+    "node": ">=16.13.0"
   },
   "publishConfig": {
     "access": "public",
@@ -17,49 +23,37 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./index.js",
-      "require": "./dist/commonjs/jsenv_package_publish.cjs"
+      "import": "./main.js"
     },
     "./*": "./*"
   },
-  "main": "dist/commonjs/jsenv_package_publish.cjs",
+  "main": "./main.js",
   "files": [
-    "/dist/",
     "/src/",
-    "/index.js"
+    "/main.js"
   ],
   "scripts": {
-    "eslint-check": "node ./node_modules/eslint/bin/eslint.js .",
-    "test": "node ./script/test/test.js",
+    "eslint": "npx eslint . --ext=.js,.mjs",
+    "importmap": "node ./script/importmap/importmap.mjs",
+    "test": "node --experimental-json-modules ./script/test/test.mjs",
     "test-with-coverage": "npm run test -- --coverage",
-    "generate-import-map": "node ./script/generate-import-map/generate-import-map.js",
-    "dist": "npm run build",
-    "prettier-format": "node ./script/prettier-format/prettier-format.js",
-    "prettier-format-stage": "npm run prettier-format -- --staged",
-    "prettier-check": "npm run prettier-format -- --dry-run",
-    "upload-coverage": "node ./script/upload-coverage/upload-coverage.js",
-    "build": "node --experimental-import-meta-resolve ./script/build/build.js",
-    "prepublishOnly": "node ./script/transform-package/remove-postinstall.js && npm run dist",
-    "postpublish": "node ./script/transform-package/restore-postinstall.js"
+    "prettier": "prettier --write ."
   },
   "dependencies": {
-    "@jsenv/cancellation": "2.0.4",
+    "@jsenv/filesystem": "2.7.1",
     "@jsenv/logger": "4.0.1",
-    "@jsenv/server": "6.0.3",
-    "@jsenv/util": "4.1.1",
+    "node-fetch": "2.6.7",
+    "@jsenv/log": "1.5.0",
     "semver": "7.3.5"
   },
   "devDependencies": {
-    "@jsenv/assert": "2.2.5",
-    "@jsenv/codecov-upload": "3.4.3",
-    "@jsenv/core": "18.1.6",
-    "@jsenv/eslint-config": "15.0.1",
-    "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/importmap-eslint-resolver": "5.0.0",
-    "@jsenv/node-module-import-map": "13.4.3",
-    "@jsenv/prettier-check-project": "5.6.1",
-    "eslint": "7.26.0",
-    "eslint-plugin-import": "2.23.2",
-    "prettier": "2.3.0"
+    "@jsenv/assert": "2.4.1",
+    "@jsenv/core": "25.3.0",
+    "@jsenv/eslint-config": "16.0.9",
+    "@jsenv/importmap-eslint-resolver": "5.2.5",
+    "@jsenv/importmap-node-module": "5.1.3",
+    "eslint": "8.7.0",
+    "eslint-plugin-import": "2.25.4",
+    "prettier": "2.5.1"
   }
 }

package/readme.md

@@ -1,30 +1,19 @@
-# 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.
 
-[![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 ci](https://github.com/jsenv/jsenv-package-publish/workflows/ci/badge.svg)](https://github.com/jsenv/jsenv-package-publish/actions?workflow=ci)
-[![codecov coverage](https://codecov.io/gh/jsenv/jsenv-package-publish/branch/master/graph/badge.svg)](https://codecov.io/gh/jsenv/jsenv-package-publish)
-
-# Table of contents
-
-- [Presentation](#Presentation)
-- [Installation](#installation)
-- [Documentation](#Documentation)
-- [publishPackage](#publishPackage)
-
 # Presentation
 
-This package is meant to automate `npm publish` at the end of your continuous workflow. Can be used to publish on both npm and github registries for instance.
+- Can be used to automate "npm publish" during a workflow
+- Allows to publish on many registries: both npm and github registries for instance.
 
-You can use it inside a github workflow or inside any other continuous environment like Travis or Jenkins.
+You can use it inside a GitHub workflow or inside any other continuous environment like Travis or Jenkins.
 
 Screenshot taken inside a github workflow when the package.json version is already published: ![already published github workflow screenshot](./docs/already-published-github-workflow-screenshot.png)
 
 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 uses itself and is configured in the repository workflow file.<br />
-— see [.github/workflows/ci.yml#publish-package](https://github.com/jsenv/jsenv-package-publish/blob/9bc6af39afa8825ff7fcdc475c3ede8e900c7475/.github/workflows/ci.yml#L39)
+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
 
@@ -34,15 +23,15 @@ npm install --save-dev @jsenv/package-publish
 
 # Documentation
 
-The api consist into one function called `publishPackage`.
+The api consist into one function called _publishPackage_.
 
-`publishPackage` is an async function publishing a package on one or many registries.
+_publishPackage_ is an async function publishing a package on one or many registries.
 
 ```js
 import { publishPackage } from "@jsenv/package-publish"
 
 const publishReport = await publishPackage({
-  projectDirectoryUrl: "file:///directory",
+  projectDirectoryUrl: new URL('./', import.meta.url)
   registriesConfig: {
     "https://registry.npmjs.org": {
       token: process.env.NPM_TOKEN,
@@ -54,18 +43,22 @@ const publishReport = await publishPackage({
 })
 ```
 
-— source code at [src/publishPackage.js](./src/publishPackage.js).
+## projectDirectoryUrl
+
+_projectDirectoryUrl_ parameter is a string leading to a directory containing the package.json.
+
+This parameter is **required**.
 
-### projectDirectoryUrl
+## registriesConfig
 
-`projectDirectoryUrl` parameter is a string leading to a directory containing the package.json. This parameter is **required**.
+_registriesConfig_ parameter is an object configuring on which registries you want to publish your package.
 
-### registriesConfig
+This parameter is **required**.
 
-`registriesConfig` parameter is an object configuring on which registries you want to publish your package. This parameter is **required**.
+## logLevel
 
-### logLevel
+_logLevel_ parameter is a string controlling verbosity of logs during the function execution.
 
-`logLevel` parameter is a string controlling verbosity of logs during the function execution.
+This parameter is optional.
 
 — see also https://github.com/jsenv/jsenv-logger#loglevel

package/src/internal/fetchLatestInRegistry.js

@@ -2,25 +2,31 @@
 // 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, packageName, token }) => {
+export const fetchLatestInRegistry = async ({
+  registryUrl,
+  packageName,
+  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}` } : {}),
+      accept:
+        "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*",
+      ...(token
+        ? {
+            authorization: `token ${token}`,
+          }
+        : {}),
     },
   })
-
   const responseStatus = response.status
-
   if (responseStatus === 404) {
     return null
   }
-
   if (responseStatus !== 200) {
     throw new Error(
       writeUnexpectedResponseStatus({
@@ -30,7 +36,6 @@ export const fetchLatestInRegistry = async ({ registryUrl, packageName, token })
       }),
     )
   }
-
   const packageObject = await response.json()
   return packageObject.versions[packageObject["dist-tags"].latest]
 }

package/src/internal/needsPublish.js

@@ -1,8 +1,11 @@
-import { createRequire } from "module"
+import { createRequire } from "node:module"
 
 const require = createRequire(import.meta.url)
 // https://github.com/npm/node-semver#readme
-const { gt: versionGreaterThan, prerelease: versionToPrerelease } = require("semver")
+const {
+  gt: versionGreaterThan,
+  prerelease: versionToPrerelease,
+} = require("semver")
 
 export const PUBLISH_BECAUSE_NEVER_PUBLISHED = "never-published"
 export const PUBLISH_BECAUSE_LATEST_LOWER = "latest-lower"
@@ -15,43 +18,45 @@ export const needsPublish = ({ registryLatestVersion, packageVersion }) => {
   if (registryLatestVersion === null) {
     return PUBLISH_BECAUSE_NEVER_PUBLISHED
   }
-
   if (registryLatestVersion === packageVersion) {
     return NOTHING_BECAUSE_ALREADY_PUBLISHED
   }
-
   if (versionGreaterThan(registryLatestVersion, packageVersion)) {
     return NOTHING_BECAUSE_LATEST_HIGHER
   }
-
-  const registryLatestVersionPrerelease = versionToPrerelease(registryLatestVersion)
+  const registryLatestVersionPrerelease = versionToPrerelease(
+    registryLatestVersion,
+  )
   const packageVersionPrerelease = versionToPrerelease(packageVersion)
-  if (registryLatestVersionPrerelease === null && packageVersionPrerelease === null) {
+  if (
+    registryLatestVersionPrerelease === null &&
+    packageVersionPrerelease === null
+  ) {
     return PUBLISH_BECAUSE_LATEST_LOWER
   }
-
-  if (registryLatestVersionPrerelease === null && packageVersionPrerelease !== null) {
+  if (
+    registryLatestVersionPrerelease === null &&
+    packageVersionPrerelease !== null
+  ) {
     return PUBLISH_BECAUSE_LATEST_LOWER
   }
-
-  if (registryLatestVersionPrerelease !== null && packageVersionPrerelease === null) {
+  if (
+    registryLatestVersionPrerelease !== null &&
+    packageVersionPrerelease === null
+  ) {
     return PUBLISH_BECAUSE_LATEST_LOWER
   }
-
-  const [registryReleaseTag, registryPrereleaseVersion] = registryLatestVersionPrerelease
+  const [registryReleaseTag, registryPrereleaseVersion] =
+    registryLatestVersionPrerelease
   const [packageReleaseTag, packagePreReleaseVersion] = packageVersionPrerelease
-
   if (registryReleaseTag !== packageReleaseTag) {
     return PUBLISH_BECAUSE_TAG_DIFFERS
   }
-
   if (registryPrereleaseVersion === packagePreReleaseVersion) {
     return NOTHING_BECAUSE_ALREADY_PUBLISHED
   }
-
   if (registryPrereleaseVersion > packagePreReleaseVersion) {
     return NOTHING_BECAUSE_LATEST_HIGHER
   }
-
   return PUBLISH_BECAUSE_LATEST_LOWER
 }

package/src/internal/publish.js

@@ -1,140 +1,181 @@
-import { exec } from "child_process"
-
-import { resolveUrl, urlToFileSystemPath, readFile, writeFile } from "@jsenv/util"
+import { exec } from "node:child_process"
+import {
+  resolveUrl,
+  urlToFileSystemPath,
+  readFile,
+  writeFile,
+  removeFileSystemNode,
+} from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
 import { setNpmConfig } from "./setNpmConfig.js"
 
 export const publish = async ({
   logger,
+  packageSlug,
   logNpmPublishOutput,
   projectDirectoryUrl,
   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 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 restoreProjectNpmConfigFile
+      let projectNpmConfigString
+      try {
+        projectNpmConfigString = await readFile(projectNpmConfigFileUrl)
+        restoreProjectNpmConfigFile = () =>
+          writeFile(projectNpmConfigFileUrl, projectNpmConfigString)
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          restoreProjectNpmConfigFile = () =>
+            removeFileSystemNode(projectNpmConfigFileUrl)
+          projectNpmConfigString = ""
+        } else {
+          throw e
+        }
+      }
+      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.
 
-              // 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(),
+          restoreProjectPackageFile(),
+          restoreProjectNpmConfigFile(),
+        ])
+      }
+    } 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) => {
@@ -147,7 +188,9 @@ const computeRegistryTokenKey = (registryUrl) => {
   if (registryUrl.startsWith("//")) {
     return `${registryUrl}/:_authToken`
   }
-  throw new Error(`registryUrl must start with http or https, got ${registryUrl}`)
+  throw new Error(
+    `registryUrl must start with http or https, got ${registryUrl}`,
+  )
 }
 
 const computeRegistryKey = (packageName) => {

package/src/internal/readProjectPackage.js

@@ -1,8 +1,7 @@
-import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/util"
+import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
 export const readProjectPackage = async ({ projectDirectoryUrl }) => {
   const packageFileUrl = resolveUrl("./package.json", projectDirectoryUrl)
-
   let packageObject
   try {
     const packageString = await readFile(packageFileUrl)
@@ -28,6 +27,5 @@ ${urlToFileSystemPath(packageFileUrl)}`,
     }
     throw e
   }
-
   return packageObject
 }