@arc-e-tect/api-only-publisher 0.15.0 → 0.16.1

package/README.adoc

@@ -6,7 +6,7 @@
 :source-highlighter: rouge
 // The released version of this component: its snippets use it. The release
 // workflow updates it; do not change it by hand.
-:api-only-publisher-version: 0.15.0
+:api-only-publisher-version: 0.16.1
 
 [NOTE]
 .About this documentation
@@ -182,7 +182,7 @@ At a terminal it asks the same shape of question `init` would, offering what is
 Without `--target`, it also fails on a fragment no target reaches, as <<unreferenced,A fragment no target reaches fails the lint §>> describes.
 
 |`targets`
-|List the declared targets, what each one builds, and whether it is published.
+|List the declared targets, what each one builds, whether it is published, and to which channels.
 
 |`closure [--target <t>]...`
 |Show each target's dependency closure: how many files it reaches, and the hash of their content.
@@ -195,7 +195,7 @@ A target whose closure is untouched needs no new version, however much else in t
 |Archive each built, published target with a `manifest.json`, at the version its version file declares.
 
 |`publish [--pre-release <ids>] [--target <t>]... [--channel <c>]... [--out <dir>]`
-|Pack once, then ship those same bytes to every configured channel, or to each `--channel`.
+|Pack each target once, then ship those same bytes to each of its channels, or only to those of them each `--channel` names (<<channel-routing,Which channels a target goes to §>>).
 
 |`split [--out <dir>] [--by kind\|target]`
 |Make the library safe to break into separate repositories.
@@ -660,6 +660,43 @@ In a GitLab CI job it needs no settings at all. See <<gitlab-package,The `gitlab
 Native for .NET consumers: a `PackageReference` at a version, restored from a feed. See <<nuget,The `nuget` channel §>>.
 |===
 
+[#channel-routing]
+=== Which channels a target goes to
+
+A channel has a *name*, the key under `channels`, and a *type*, one of those above.
+A channel named after a type is that type; any other name -- lowercase words joined by single hyphens, such as `partner-a` -- says its type with `type`.
+So one `apionly.yaml` can hold several channels of one type, each with its own destination, settings and token:
+
+[source,yaml]
+----
+channels:
+  maven:                                # a Maven channel, named after its type
+    groupId: com.example.api
+    repository: https://maven.example.com/internal
+  partner-a:                            # another one, for one partner
+    type: maven
+    groupId: com.example.partner
+    repository: https://maven.partner-a.example
+    tokenEnv: PARTNER_A_TOKEN
+
+targets:
+  orders:
+    channels: [maven, partner-a]        # published to these two
+    openapi:
+      bundle: bundles/orders_openapi_structure.yaml
+  billing:                              # no list: every configured channel
+    openapi:
+      bundle: bundles/billing_openapi_structure.yaml
+----
+
+* A target with a `channels` list is published to those channels; a target without one, to every configured channel.
+* Everything is checked when `apionly.yaml` is read: a channel name that is not kebab-case, a name that is not a type without a `type`, a `type` that is not one, a type name given another `type`, and a target that lists a channel `apionly.yaml` does not configure, lists one twice, lists none (`channels: []`, where `publish: false` is meant), or is never published -- `publish: false`, or an aggregate.
+* `--channel` narrows each target to the named channels it is routed to.
+A target that is not routed to one is skipped, and `publish` says so: `payments: not published to npm (not in targets.payments.channels)`.
+A run that would publish nothing at all fails instead of succeeding quietly.
+* A `--channel` that `apionly.yaml` does not configure is refused, unless it is a type's name: `--channel github-release` is that channel with no settings, as it has always been.
+* `targets` lists each published target with its channels.
+
 [#idempotent]
 === Publishing the same version again
 
@@ -712,7 +749,7 @@ Error: API_ONLY_PUBLISHER_REMOTE=never refuses the remote channels maven, github
 ----
 
 Any other value fails `publish`, whatever its channels: a typo in a switch that keeps the Publisher sealed is not ignored.
-`--channel` narrows what is checked: `publish --channel file` succeeds under `never`, whatever else `apionly.yaml` configures.
+Only the channels a run would publish to are checked, by type: a channel named `partner-a` with `type: maven` and a URL is remote; `publish --channel file`, or a target routed only to local channels, succeeds under `never`, whatever else `apionly.yaml` configures.
 The Publisher used as a library keeps the same rule.
 
 The switch is a promise the Publisher keeps, not an enforcement: whoever runs it can change the variable.
@@ -728,7 +765,7 @@ Every `publish` run lists each file its channels wrote locally, with its SHA-256
 | File | Content
 
 | `packages.json`
-| `schemaVersion`, and `files`: for each file, its `path`, `sha256`, `target`, `version` and `channel`.
+| `schemaVersion`, and `files`: for each file, its `path`, `sha256`, `target`, `version`, `channel` -- the channel's name -- and `type`, the channel's type.
 
 | `packages.sha256`
 | The same files in the format `sha256sum -c` checks.
@@ -990,6 +1027,7 @@ channels:
 
 targets:
   orders:
+    # channels: [file]   # the channels it is published to; default: every one
     # versionFile: versions/orders.properties
     #              default: orders.bundle.properties beside the first bundle root
     openapi:
@@ -1161,20 +1199,30 @@ They are starting points, not boundaries: the situations describe where each sha
 [#recipes-two-facts]
 === Two facts every recipe rests on
 
-*A channel is named after its type.*
-`channels.maven` is the Maven channel, `channels.npm` the npm channel, and so on, so one `apionly.yaml` has at most one channel of each type, with one destination each.
-Two consumers who both read Maven get the same Maven repository; <<recipe-business-partners,Business partners §>> shows what to do when they each need their own.
+*A channel has a name and a type.*
+A channel named after a type is that type -- `channels.maven` is a Maven channel -- and any other name says its type with `type`, so one `apionly.yaml` can hold two channels of one type, each with a destination of its own:
+
+[source,yaml]
+----
+channels:
+  partner-a: { type: maven, groupId: com.example.partner, repository: https://maven.partner-a.example }
+  partner-b: { type: maven, groupId: com.example.partner, repository: https://maven.partner-b.example }
+----
 
-*`apionly.yaml` says which channels exist, not which target goes where.*
-Without `--channel`, `publish` ships every published target to every configured channel, packing each target once and sending the same bytes everywhere.
-`--target` and `--channel` narrow a run, and both may be repeated:
+*`apionly.yaml` says which target goes where.*
+A target with a `channels` list is published to those channels; a target without one is published to every configured channel.
+`publish` packs each target once, and sends the same bytes to each of its channels:
 
-[source,console]
+[source,yaml]
 ----
-npm run apionly -- publish --target payments --channel nuget
+targets:
+  payments:
+    channels: [partner-a]
+    openapi:
+      bundle: bundles/payments_openapi_structure.yaml
 ----
 
-So when different targets go to different channels, the routing lives in the commands that run `publish`, as <<recipe-ecosystem,Eco-system §>> shows, and not in `apionly.yaml`.
+`--target` and `--channel` narrow a run, and both may be repeated; `--channel` publishes each target only to the named channels it is routed to, and says which targets it skipped (<<channel-routing,Which channels a target goes to §>>).
 
 The excerpts below show only `channels` and `targets`; the rest of `apionly.yaml` is as <<configuration,Configuration §>> describes, and as `init` writes it.
 Every published target also needs its version file, as <<versions,Versions §>> describes, and a `build` before its `publish`.
@@ -1311,8 +1359,8 @@ The other channels already have the version, and would leave it alone anyway.
 * A pre-release, `publish --pre-release rc.1`, is how a partner gets an unfinished contract to start building against, without any partner's production build picking it up by accident (<<pre-releases,Pre-releases §>>).
 * Each channel takes its credential from the environment, never from `apionly.yaml`: `MAVEN_TOKEN`, `NUGET_API_KEY` and `GITLAB_TOKEN` by default, npm's own configuration for `npm`, and the GitHub CLI's for `github-release` (<<channel-text,What a package says about itself §>>).
 * A partner without a package manager gets a download: `github-release` where the library is on GitHub, `gitlab-package` where it is on GitLab.
-* Partners that each need a repository of *the same type* -- two Maven repositories, one per partner -- cannot be two `maven` channels.
-Publish to a local destination instead, `repository` or `directory` set to a directory, and let the pipeline copy the files it lists in `packages.sha256` to each partner's repository, as <<handoff,The hand-off §>> describes.
+* Partners that each need a repository of *the same type* -- two Maven repositories, one per partner -- are two channels with names of their own and `type: maven`, as <<recipes-two-facts,the two facts §>> show.
+* A partner that may see only some contracts gets only those: list its channel on those targets (<<recipe-ecosystem,Eco-system §>>).
 
 [#recipe-platform]
 === Platform: several targets, several channels, every target on every channel
@@ -1391,7 +1439,7 @@ Start from a routing table: which target goes to which channel.
 |`payments` |Yes |    |Yes
 |===
 
-`apionly.yaml` declares the channels and the targets, as for a <<recipe-platform,platform §>>:
+The routing table goes into `apionly.yaml` as it stands: each target lists the channels it is published to.
 
 .apionly.yaml (excerpt)
 [source,yaml]
@@ -1409,52 +1457,39 @@ channels:
 
 targets:
   catalog:
+    channels: [maven, npm]
     openapi:
       bundle: bundles/catalog_openapi_structure.yaml
   customers:
+    channels: [maven]
     openapi:
       bundle: bundles/customers_openapi_structure.yaml
   orders:
+    channels: [maven, npm]
     openapi:
       bundle: bundles/orders_openapi_structure.yaml
   payments:
+    channels: [maven, nuget]
     openapi:
       bundle: bundles/payments_openapi_structure.yaml
 ----
 
-The routing table becomes one `publish` per channel, each naming its targets.
-Keeping those commands as scripts in the library's `package.json` keeps the routing in one place, reviewed with the library, rather than spread across pipeline files:
-
-.package.json (excerpt)
-[source,json]
-----
-{
-  "scripts": {
-    "apionly": "api-only-publisher",
-    "publish:maven": "api-only-publisher publish --channel maven",
-    "publish:npm": "api-only-publisher publish --channel npm --target catalog --target orders",
-    "publish:nuget": "api-only-publisher publish --channel nuget --target payments",
-    "publish:all": "npm run publish:maven && npm run publish:npm && npm run publish:nuget"
-  }
-}
-----
-
 [source,console]
 ----
 npm run apionly -- build
-npm run publish:all
+npm run apionly -- publish
 ----
 
-`publish:maven` names no target, because every target goes there; a channel that takes only some names each of them.
+One `publish` sends each target to its own channels, packing it once.
+`npm run apionly -- targets` lists each target with its channels, so the routing can be read back.
 
 *Worth knowing.*
 
-* A new target goes only where a script sends it.
-`publish:maven` picks it up because it names no target; the npm and NuGet consumers do not see it until it is added to their script, which is the deliberate step an eco-system wants.
-* Each script passes its arguments on: `npm run publish:npm -- --pre-release rc.1` publishes a pre-release of the npm targets alone.
-* Each run packs again, and the archives are the same bytes every time (<<idempotent,Publishing the same version again §>>), so a target on two channels is identical on both.
-* Each run replaces the hand-off files in the packages directory (<<handoff,The hand-off §>>).
-A pipeline that publishes the files itself gives each run its own `--out`, such as `--out build/packages/npm`, and keeps every channel's list.
+* A target without a `channels` list goes to every configured channel.
+In an eco-system, give every target a list: a new target then goes nowhere until someone decides where, which is the deliberate step an eco-system wants.
+* `--channel` publishes to one channel alone, say after its registry was unreachable: `npm run apionly -- publish --channel npm` sends `catalog` and `orders`, says that it skipped `customers` and `payments`, and fails if it would publish nothing at all.
+* The routing is checked when `apionly.yaml` is read: a target that lists a channel `apionly.yaml` does not configure is refused, naming both, before anything is built.
+* A third party that needs a registry of a type another party already uses -- a second Maven repository -- gets a channel of its own, with `type: maven` (<<recipes-two-facts,the two facts §>>).
 
 [#behaviour]
 == Behaviour worth knowing about

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arc-e-tect/api-only-publisher",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Builds, packs and publishes API description documents from a library of reusable fragments.",
   "license": "MIT",
   "author": "Arc-E-Tect",

package/src/channel-types.js

@@ -0,0 +1,13 @@
+"use strict";
+
+// The channel types, in a module of their own so that the configuration can check a
+// channel's type without requiring the channels themselves.
+
+const CHANNEL_TYPES = Object.freeze(["file", "maven", "npm", "github-release", "nuget", "gitlab-package"]);
+
+/** The types as a sentence names them: "file, maven, ... or gitlab-package". */
+function describeTypes() {
+    return `${CHANNEL_TYPES.slice(0, -1).join(", ")} or ${CHANNEL_TYPES[CHANNEL_TYPES.length - 1]}`;
+}
+
+module.exports = { CHANNEL_TYPES, describeTypes };

package/src/channels.js

@@ -456,8 +456,13 @@ const CHANNELS = {
     "gitlab-package": publishGitlabPackage,
 };
 
+/**
+ * Publishes to the channel named `channel`, of the type its settings' `type` names, or
+ * of the type it is named after -- `maven` is a Maven channel, as it has always been.
+ */
 function publish(archive, manifest, channel, options, log = () => {}) {
-    const handler = CHANNELS[channel];
+    const { type = channel, ...settings } = options || {};
+    const handler = CHANNELS[type];
     if (!handler) {
         throw new ChannelError(
             `unknown channel '${channel}'; available channels are ${Object.keys(CHANNELS).join(", ")}`
@@ -465,7 +470,7 @@ function publish(archive, manifest, channel, options, log = () => {}) {
     }
     // Here as well as in the CLI, so the Publisher used as a library keeps it too.
     refuseRemote([channel], { [channel]: options || {} });
-    return handler(archive, manifest, options || {}, log);
+    return handler(archive, manifest, settings, log);
 }
 
 module.exports = { publish, CHANNELS, ChannelError, pom, format, DEFAULT_DESCRIPTION };

package/src/cli.js

@@ -18,6 +18,7 @@ const { changedSince, ChangedError } = require("./changed");
 const { split, SplitError } = require("./split");
 const { publish, ChannelError } = require("./channels");
 const { refuseRemote } = require("./remote");
+const { CHANNEL_TYPES } = require("./channel-types");
 const { VersionError: PolicyError, describe } = require("./version-policy");
 const { versionOf, BundleVersionError } = require("./bundle-version");
 const { unreferenced } = require("./unreferenced");
@@ -324,7 +325,9 @@ async function main(argv, io = {}) {
             for (const name of Object.keys(config.targets)) {
                 const kinds = ["openapi", "asyncapi"].filter((k) => config.targets[name][k]);
                 const published = config.isPublished(name) ? "" : "  (publish: false)";
-                console.log(`${name}  [${kinds.join(", ")}]${published}`);
+                const routed = config.isPublished(name) && Object.keys(config.channels || {}).length > 0
+                    ? `  channels: ${config.channelsOf(name).join(", ")}` : "";
+                console.log(`${name}  [${kinds.join(", ")}]${published}${routed}`);
             }
             return 0;
         }
@@ -448,20 +451,43 @@ async function main(argv, io = {}) {
         case "publish": {
             const outDir = options.out ? path.resolve(options.dir, options.out) : config.packagesDir();
             const configured = config.channels || {};
-            const names = options.channels || Object.keys(configured);
-            if (names.length === 0) {
+            for (const name of options.channels || []) {
+                // An unconfigured channel named after a type is that channel with no settings.
+                if (!configured[name] && !(name in configured) && !CHANNEL_TYPES.includes(name)) {
+                    const names = Object.keys(configured);
+                    throw new ConfigError(`--channel '${name}' is not a configured channel; ` +
+                        `apionly.yaml configures ${names.length ? names.join(", ") : "no channels"}`);
+                }
+            }
+            if (!options.channels && Object.keys(configured).length === 0) {
                 throw new ConfigError("no channels configured; add a `channels:` block or pass --channel");
             }
+            // Each target's channels: its own list, or every configured one, narrowed by --channel.
+            const shippable = shippedTargets(config, targets);
+            const routes = new Map(shippable.map((target) => {
+                const own = config.targets[target].channels;
+                return [target, options.channels
+                    ? options.channels.filter((name) => !own || own.includes(name))
+                    : config.channelsOf(target)];
+            }));
+            for (const target of shippable) {
+                const own = config.targets[target].channels;
+                for (const name of (own && options.channels) || []) {
+                    if (!own.includes(name)) log(`${target}: not published to ${name} (not in targets.${target}.channels)`);
+                }
+            }
+            const shipped = shippable.filter((target) => routes.get(target).length > 0);
+            if (options.channels && shippable.length > 0 && shipped.length === 0) {
+                throw new ConfigError(`nothing was published: no target in this run is routed to ${options.channels.join(", ")}`);
+            }
             // Every channel this run uses, before anything is read, packed or sent.
-            refuseRemote(names, configured);
-            const shipped = shippedTargets(config, targets);
+            refuseRemote([...new Set(shipped.flatMap((target) => routes.get(target)))], configured);
             const versions = versionsOf(config, shipped, options.preRelease);
             const closures = forTargets(config, undefined, shipped);
             let published = 0;
             const handoff = [];
             for (const target of Object.keys(config.targets)) {
-                if (targets && !targets.includes(target)) continue;
-                if (!config.isPublished(target)) continue;
+                if (!shipped.includes(target)) continue;
                 const closure = closures.get(target);
                 // Packed once, then shipped unchanged to every channel.
                 const { archive, manifest } = pack(config, target, {
@@ -469,11 +495,11 @@ async function main(argv, io = {}) {
                     closureSha256: closure ? closure.sha256 : null,
                     outDir, log,
                 });
-                for (const name of names) {
+                for (const name of routes.get(target)) {
                     // A remote channel returns a promise; a local one does not.
                     const result = await publish(archive, manifest, name, { ...(configured[name] || {}), baseDir: config.root }, log);
                     for (const file of result.files || []) {
-                        handoff.push({ file, target, version: manifest.version, channel: name });
+                        handoff.push({ file, target, version: manifest.version, channel: name, type: config.channelType(name) });
                     }
                     published += 1;
                 }

package/src/config.js

@@ -9,6 +9,8 @@ const fs = require("fs");
 const path = require("path");
 const YAML = require("yaml");
 
+const { CHANNEL_TYPES, describeTypes } = require("./channel-types");
+
 const CONFIG_NAME = "apionly.yaml";
 const SUPPORTED_SCHEMA_VERSION = 1;
 
@@ -30,7 +32,7 @@ const REPORTS_KEYS = ["lint"];
 const LINT_KEYS = ["unreferenced", "examples"];
 const LINT_EXAMPLES_KEYS = ["openapi", "asyncapi"];
 const DISTRIBUTION_KEYS = ["root", "layout"];
-const TARGET_KEYS = ["openapi", "asyncapi", "publish", "versionFile"];
+const TARGET_KEYS = ["openapi", "asyncapi", "publish", "versionFile", "channels"];
 const TARGET_KIND_KEYS = ["bundle", "aggregate", "info"];
 const PORTFOLIO_KEYS = ["openapi", "security", "location"];
 const PORTFOLIO_OPENAPI_KEYS = ["paths", "operationIds", "tags"];
@@ -49,6 +51,73 @@ const PATH_STRATEGIES = ["target-prefix", "none"];
 
 class ConfigError extends Error {}
 
+// A channel's name, as init asks of a target's: lowercase words joined by single hyphens.
+const CHANNEL_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+
+/**
+ * Each configured channel's type, by name. A channel named after a type is that type;
+ * any other name says its type with `type`, which is how one apionly.yaml has two
+ * channels of one type -- a Maven repository per partner.
+ */
+function channelTypes(channels) {
+    if (typeof channels !== "object" || Array.isArray(channels)) {
+        throw new ConfigError("channels must be a mapping of channel names to their settings");
+    }
+    const types = {};
+    for (const [name, settings] of Object.entries(channels)) {
+        if (!CHANNEL_NAME.test(name)) {
+            throw new ConfigError(`channel name '${name}': use lowercase letters and digits, in words joined by single ` +
+                "hyphens, starting with a letter, such as partner-a");
+        }
+        if (settings !== null && (typeof settings !== "object" || Array.isArray(settings))) {
+            throw new ConfigError(`channels.${name} must be a mapping of settings`);
+        }
+        const declared = settings ? settings.type : undefined;
+        if (CHANNEL_TYPES.includes(name)) {
+            if (declared !== undefined && declared !== name) {
+                throw new ConfigError(`channel '${name}' is named after a channel type, so its type is ${name}, ` +
+                    `not ${declared}; give it another name`);
+            }
+            types[name] = name;
+        } else if (declared === undefined) {
+            throw new ConfigError(`channel '${name}' is not a channel type; say which one it is with type: ${describeTypes()}`);
+        } else if (!CHANNEL_TYPES.includes(declared)) {
+            throw new ConfigError(`channels.${name}.type '${declared}' is not a channel type: ${describeTypes()}`);
+        } else {
+            types[name] = declared;
+        }
+    }
+    return types;
+}
+
+/** Refuses a target's `channels` that cannot be what it means. */
+function checkTargetChannels(name, target, channels, isAggregate) {
+    const list = target.channels;
+    if (list === undefined) return;
+    if (!Array.isArray(list) || list.some((c) => typeof c !== "string")) {
+        throw new ConfigError(`targets.${name}.channels must be a list of channel names`);
+    }
+    if (list.length === 0) {
+        throw new ConfigError(`targets.${name}.channels is empty; a target that is published nowhere says so with publish: false`);
+    }
+    if (isAggregate) {
+        throw new ConfigError(`target '${name}' is an aggregate, which is never published, so it has no channels`);
+    }
+    if (target.publish === false) {
+        throw new ConfigError(`target '${name}' is not published (publish: false), so it has no channels`);
+    }
+    const seen = new Set();
+    for (const channel of list) {
+        if (seen.has(channel)) throw new ConfigError(`target '${name}' lists channel '${channel}' twice`);
+        seen.add(channel);
+        if (!Object.prototype.hasOwnProperty.call(channels, channel)) {
+            const configured = Object.keys(channels);
+            throw new ConfigError(`target '${name}' lists channel '${channel}', which apionly.yaml does not configure; ` +
+                `it configures ${configured.length ? configured.join(", ") : "no channels"}`);
+        }
+    }
+}
+
 /** Refuses a key `obj` has that is not in `allowed`, naming the key and where it is. */
 function checkKeys(obj, allowed, where) {
     if (!obj || typeof obj !== "object") return;
@@ -135,6 +204,9 @@ function load(configPath) {
         );
     }
 
+    const channels = parsed.channels || {};
+    const types = channelTypes(channels);
+
     const targets = parsed.targets;
     if (!targets || typeof targets !== "object" || Object.keys(targets).length === 0) {
         throw new ConfigError(`${configPath} declares no targets`);
@@ -176,6 +248,8 @@ function load(configPath) {
             );
         }
 
+        checkTargetChannels(name, target, channels, aggregateKinds.length > 0);
+
         for (const kind of kinds) {
             checkKeys(target[kind], TARGET_KIND_KEYS, `targets.${name}.${kind}`);
             if (target[kind].aggregate !== undefined) {
@@ -238,7 +312,7 @@ function load(configPath) {
         reports,
         lint,
         distribution: parsed.distribution || null,
-        channels: parsed.channels || {},
+        channels,
         portfolio,
         targets,
 
@@ -326,6 +400,15 @@ function load(configPath) {
         // An aggregate is never published either, whether or not it says so --
         // load() already refuses the one case that would contradict this, `publish:
         // true` alongside an aggregate, so nothing here needs to re-check that.
+        // A configured channel's type; a name that is not configured is taken for a type,
+        // as `publish --channel github-release` has always meant that channel unconfigured.
+        channelType(name) {
+            return types[name] || name;
+        },
+        // The channels a target is published to: its own list, or every configured one.
+        channelsOf(target) {
+            return this.targets[target].channels || Object.keys(this.channels);
+        },
         isPublished(target) {
             return this.targets[target].publish !== false && !this.isAggregate(target);
         },

package/src/handoff.js

@@ -25,10 +25,10 @@ const HANDOFF_SCHEMA_VERSION = 1;
  */
 function writeHandoff(root, outDir, entries) {
     const files = entries
-        .map(({ file, target, version, channel }) => ({
+        .map(({ file, target, version, channel, type = channel }) => ({
             path: path.relative(root, file).split(path.sep).join("/"),
             sha256: crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex"),
-            target, version, channel,
+            target, version, channel, type,
         }))
         .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
 

package/src/remote.js

@@ -50,7 +50,11 @@ function isRemote(channel, settings = {}) {
  */
 function refuseRemote(names, configured = {}, env = process.env) {
     if (remoteMode(env) === "allow") return;
-    const remote = names.filter((name) => isRemote(name, configured[name] || {}));
+    // Judged by type: a channel named partner-a may be a Maven repository at a URL.
+    const remote = names.filter((name) => {
+        const settings = configured[name] || {};
+        return isRemote(settings.type || name, settings);
+    });
     if (remote.length === 0) return;
     throw new ChannelError(
         `${REMOTE_ENV}=never refuses the remote channels ${remote.join(", ")}, so nothing was built, packed or sent. ` +