rman 1.0.7 → 1.0.8

package/commands/changelog.command.js

@@ -29,6 +29,10 @@ export function initCli(repository, program) {
             describe: 'Generate for the whole repository even when the current directory is inside a single ' +
                 'package (which otherwise scopes it to just that package). No effect elsewhere.',
             type: 'boolean',
+        })
+            .option('include-skipped', {
+            describe: 'Also generate for a package with .rmanrc "publish.skip" - excluded by default',
+            type: 'boolean',
         }),
         handler: async (args) => {
             const from = args.from;
@@ -44,6 +48,7 @@ export function initCli(repository, program) {
                 from,
                 filePath: args.filePath,
                 root: args.root,
+                includeSkipped: args.includeSkipped,
             };
             const entries = args.write
                 ? await ChangelogService.generateToFile(repository, options)

package/constants.js

@@ -1 +1 @@
-export const version = '1.0.7';
+export const version = '1.0.8';

package/core/config.d.ts

@@ -63,6 +63,13 @@ export declare namespace RmanConfig {
          *  one that publishes both sets `['npm', 'docker']`. */
         target?: PublishTarget | PublishTarget[];
         docker?: DockerPublishOptions;
+        /** Excludes this package from `publish` entirely (npm and docker both), regardless of
+         *  `target`/`"private"` - a single, explicit "never published" statement, e.g. for a package
+         *  released through some separate, unrelated process. `changelog` also skips it by default
+         *  (see its own `--include-skipped`) - there's little point changelogging something that's
+         *  never actually released. Independent of `version`, which never consults this at all - a
+         *  package can still be meaningfully versioned without ever being published. */
+        skip?: boolean;
     }
     type PublishTarget = 'npm' | 'docker';
     /** Required once `"docker"` is one of this package's `publish.target`s - `publish --target

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/rmanrc.schema.json

@@ -120,6 +120,11 @@
         "docker": {
           "$ref": "#/definitions/dockerPublishConfig",
           "description": "Required once \"docker\" is one of this package's \"publish.target\"s."
+        },
+        "skip": {
+          "type": "boolean",
+          "default": false,
+          "description": "Excludes this package from \"publish\" entirely (npm and docker both), regardless of \"target\"/\"private\" - a single, explicit \"never published\" statement. \"changelog\" also skips it by default (see its own --include-skipped). Independent of \"version\", which never consults this."
         }
       }
     },

package/services/changelog.service.d.ts

@@ -28,6 +28,9 @@ export declare namespace ChangelogService {
          *  what's actually published) doesn't get changes silently skipped over - see
          *  `detectChangeHash`'s `catchUpFile`. */
         filePath?: string;
+        /** A package with `.rmanrc "publish.skip"` is excluded by default - little point changelogging
+         *  something that's never actually released. Set true to generate for it anyway. */
+        includeSkipped?: boolean;
     }
     /** One package's (root included) generated changelog entry - what `getEntries`/`generate`
      *  return. */

package/services/changelog.service.js

@@ -63,7 +63,7 @@ export var ChangelogService;
     async function getEntries(repository, options = {}, deps = {}) {
         const cwdScope = options.root ? undefined : repository.currentPackage;
         const packages = repository.getPackages().filter(p => p !== repository.rootPackage);
-        const targets = cwdScope ? [cwdScope] : filterPackages([repository.rootPackage, ...packages], options);
+        const targets = (cwdScope ? [cwdScope] : filterPackages([repository.rootPackage, ...packages], options)).filter(pkg => options.includeSkipped || !pkg.config.publish?.skip);
         const git = new GitHelper({ cwd: repository.dirname });
         // dropped up front, not just while grouping - a package whose only commits are version bumps
         // should get no entry at all, rather than a heading with nothing real underneath it.

package/services/docker-publish.service.js

@@ -22,7 +22,7 @@ export var DockerPublishService;
      */
     async function getPlan(repository, options = {}, deps = {}) {
         const git = new GitHelper({ cwd: repository.dirname });
-        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(targetsDocker);
+        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(pkg => targetsDocker(pkg) && !pkg.config.publish?.skip);
         const dirtyFiles = await git.listDirtyFiles({ absolute: true });
         const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
         const imageExists = deps.imageExists ?? defaultImageExists;

package/services/publish.service.js

@@ -41,7 +41,15 @@ export var PublishService;
         const entries = new Map();
         const toCheck = [];
         for (const pkg of packages) {
-            if (pkg.isPrivate) {
+            if (pkg.config.publish?.skip) {
+                entries.set(pkg.name, {
+                    package: pkg,
+                    version: pkg.version,
+                    status: 'skip',
+                    reason: 'excluded via .rmanrc "publish.skip"',
+                });
+            }
+            else if (pkg.isPrivate) {
                 entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
             }
             else if (isDirty(pkg)) {

package/services/version.service.js

@@ -172,6 +172,10 @@ export var VersionService;
                     scope: entry.package.name,
                     root: true,
                     from,
+                    // version doesn't consult "publish.skip" at all (a package can still be meaningfully
+                    // versioned/changelogged without ever being published) - this entry was already decided
+                    // to bump, so its folded-in changelog shouldn't then be silently dropped by that flag.
+                    includeSkipped: true,
                 });
                 for (const ce of changelogEntries) {
                     changelogFileByPackage.set(ce.package.name, path.relative(repository.dirname, path.join(ce.package.dirname, ce.filePath)));

package/utils/change-hash.d.ts

@@ -43,13 +43,17 @@ export interface DetectChangeHashOptions {
  * Resolves the commit/hash a package's changes should be measured "since" - the boundary
  * `changelog --from` uses, but reusable anywhere a command wants to answer "what changed for this
  * package". An explicit `options.from` (anything but `"npm"`) is returned as-is, applying the same
- * way to every package. Otherwise, it's auto-detected from the package's currently-published npm
- * version: looked up via `npmViewVersion`, then mapped to a git tag using `.rmanrc
- * changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work - see
- * `tagPattern`) - and, if `catchUpFile` is given and exists, widened to also cover anything that
- * file hasn't caught up on yet (see its doc comment). Returns `undefined` when nothing can be
- * resolved at all (unpublished, no network, no matching tag, no catch-up file) - callers should
- * fall back to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed"
- * default when no hash is given).
+ * way to every package. Otherwise, it's auto-detected in order: (1) the package's
+ * currently-published npm version - looked up via `npmViewVersion`, then mapped to a git tag using
+ * `.rmanrc changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work -
+ * see `tagPattern`); (2) failing that (never published, private, no network, ...), this package's
+ * own most recent release tag directly - the same `findLatestTag` lookup `version` itself uses, so
+ * a package that's never been on npm (e.g. Docker-only) but has real tags from a previous `version`
+ * run still gets a correct boundary, not just "everything ever". Either way, if `catchUpFile` is
+ * given and exists, the result is widened to also cover anything that file hasn't caught up on yet
+ * (see its doc comment). Returns `undefined` when nothing can be resolved at all (never published
+ * *and* never tagged, no catch-up file - a genuinely first-ever release) - callers should fall back
+ * to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed" default when
+ * no hash is given).
  */
 export declare function detectChangeHash(git: GitHelper, pkg: Package, options?: DetectChangeHashOptions): Promise<string | undefined>;

package/utils/change-hash.js

@@ -47,14 +47,18 @@ export async function defaultNpmViewVersion(name, cwd) {
  * Resolves the commit/hash a package's changes should be measured "since" - the boundary
  * `changelog --from` uses, but reusable anywhere a command wants to answer "what changed for this
  * package". An explicit `options.from` (anything but `"npm"`) is returned as-is, applying the same
- * way to every package. Otherwise, it's auto-detected from the package's currently-published npm
- * version: looked up via `npmViewVersion`, then mapped to a git tag using `.rmanrc
- * changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work - see
- * `tagPattern`) - and, if `catchUpFile` is given and exists, widened to also cover anything that
- * file hasn't caught up on yet (see its doc comment). Returns `undefined` when nothing can be
- * resolved at all (unpublished, no network, no matching tag, no catch-up file) - callers should
- * fall back to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed"
- * default when no hash is given).
+ * way to every package. Otherwise, it's auto-detected in order: (1) the package's
+ * currently-published npm version - looked up via `npmViewVersion`, then mapped to a git tag using
+ * `.rmanrc changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work -
+ * see `tagPattern`); (2) failing that (never published, private, no network, ...), this package's
+ * own most recent release tag directly - the same `findLatestTag` lookup `version` itself uses, so
+ * a package that's never been on npm (e.g. Docker-only) but has real tags from a previous `version`
+ * run still gets a correct boundary, not just "everything ever". Either way, if `catchUpFile` is
+ * given and exists, the result is widened to also cover anything that file hasn't caught up on yet
+ * (see its doc comment). Returns `undefined` when nothing can be resolved at all (never published
+ * *and* never tagged, no catch-up file - a genuinely first-ever release) - callers should fall back
+ * to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed" default when
+ * no hash is given).
  */
 export async function detectChangeHash(git, pkg, options = {}) {
     if (options.from && options.from !== 'npm')
@@ -69,6 +73,8 @@ export async function detectChangeHash(git, pkg, options = {}) {
         const tag = starIdx === -1 ? expanded : expanded.slice(0, starIdx) + publishedVersion + expanded.slice(starIdx + 1);
         npmHash = (await git.tagExists(tag)) ? tag : undefined;
     }
+    if (!npmHash)
+        npmHash = await findLatestTag(git, pkg);
     const fileHash = options.catchUpFile ? await git.lastCommitTouching(options.catchUpFile) : undefined;
     if (!fileHash)
         return npmHash;