@fynpo/base 1.1.22 → 2.0.0

package/README.md

@@ -1,3 +1,64 @@
+[![NPM version][npm-image]][npm-url] [![Build Status][build-image]][build-url]
+
 # @fynpo/base
 
-A zero setup monorepo manager for node.js - <https://jchip.github.io/fynpo/>
+The package-graph and config layer under [fynpo] and [fyn].
+
+It answers the questions a monorepo tool keeps asking: which directories in this repo are packages, how do they depend on each other, what order can they be built in, and what does the repo's `fynpo` config say. Nothing here drives a command - it's the shared model that fynpo's commands and fyn's local-package resolution are both built on.
+
+## Install
+
+```bash
+npm install @fynpo/base
+```
+
+## Usage
+
+```js
+import { FynpoDepGraph, FynpoConfigManager, readFynpoPackages } from "@fynpo/base";
+
+const graph = new FynpoDepGraph({ cwd: process.cwd() });
+await graph.resolve();
+
+// packages found, and how they relate
+console.log(Object.keys(graph.packages.byName));
+```
+
+## What's in it
+
+### `FynpoDepGraph`
+
+Reads the repo's packages and builds the dependency graph between them - direct and indirect, across `dependencies`, `devDependencies`, `optionalDependencies` and `peerDependencies`. Gives you topological ordering for running tasks in dependency order, and resolves a `name@<semver>` reference to the local `name@version` that satisfies it.
+
+Its `autoSearched` flag records whether packages had to be discovered by searching every directory (because the config declared no `packages` patterns) - worth surfacing, since a repo that keeps packages outside the default location behaves differently in commands that don't auto-search.
+
+### `FynpoConfigManager`
+
+Loads and normalizes the repo's `fynpo.json` / `fynpo.config.js`.
+
+### `readFynpoPackages(options)` and `makePkgDeps(packages, opts)`
+
+The lower-level pieces if you want the package list or the dep relations without the graph object.
+
+### `PackageRef`, `pkgId`, `getDepSection`, `makeDepStep`
+
+Helpers for parsing and formatting package references and dependency sections.
+
+### `caching`
+
+Exported as a namespace (`import { caching } from "@fynpo/base"`) - input/output hashing used for fynpo's task caching: `processInput`, `processOutput`, `processLifecycleInput`, `readHashDigest`.
+
+### `gitignore` helpers and `posixify`
+
+Small utilities shared by the tools.
+
+## License
+
+Licensed under the [Apache License, Version 2.0](./LICENSE).
+
+[fynpo]: https://github.com/jchip/fynjs/tree/main/packages/fynpo
+[fyn]: https://github.com/jchip/fynjs/tree/main/packages/fyn
+[npm-image]: https://badge.fury.io/js/%40fynpo%2Fbase.svg
+[npm-url]: https://npmjs.org/package/@fynpo/base
+[build-image]: https://github.com/jchip/fynjs/actions/workflows/ci.yml/badge.svg
+[build-url]: https://github.com/jchip/fynjs/actions/workflows/ci.yml

package/dist/caching.d.ts

@@ -60,9 +60,9 @@ export declare function processInput({ cwd, input, packageJson, extra, }?: {
 }): Promise<{
     files: string[];
     data: {
-        env: any;
-        versions: any;
-        npmScripts: any;
+        env: Pick<NodeJS.ProcessEnv, string>;
+        versions: Pick<NodeJS.ProcessVersions, string>;
+        npmScripts: Pick<any, string>;
         fileHashes: Record<string, string>;
         extra: any;
     };
@@ -97,7 +97,7 @@ export declare function processOutput({ cwd, inputHash, calcHash, output, preFil
     /** list of pre-determined files, will be filtered with output.exclude */
     preFiles?: string[];
 }): Promise<{
-    files: any;
+    files: string[];
     data: {
         inputHash: string;
         fileHashes: {};

package/dist/caching.js

@@ -1,17 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readHashDigest = void 0;
-exports.processInput = processInput;
-exports.processLifecycleInput = processLifecycleInput;
-exports.processOutput = processOutput;
-const tslib_1 = require("tslib");
-const filter_scan_dir_1 = require("filter-scan-dir");
-const minimatch_1 = tslib_1.__importDefault(require("minimatch"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const crypto_1 = tslib_1.__importDefault(require("crypto"));
-const minimatch_group_1 = require("./minimatch-group");
+import { filterScanDir } from "filter-scan-dir";
+import { Minimatch } from "minimatch";
+import _ from "lodash";
+import Fs from "fs";
+import Path from "path";
+import Crypto from "crypto";
+import { checkMmMatch, deconstructMM, unrollMmMatch } from "./minimatch-group.js";
 /**
  * create a sha256 hash for some data
  *
@@ -19,7 +12,7 @@ const minimatch_group_1 = require("./minimatch-group");
  * @returns
  */
 function hashData1(data, encoding = "base64url") {
-    return crypto_1.default.createHash("sha256").update(data).digest(encoding);
+    return Crypto.createHash("sha256").update(data).digest(encoding);
 }
 function makeBase64Url(hash) {
     return hash.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
@@ -30,9 +23,9 @@ function hashData2(data, encoding = "base64url") {
     }
     return hashData1(data, encoding);
 }
-const hasBase64Url = typeof crypto_1.default.createHash("sha256").digest("base64url") === "string";
+const hasBase64Url = typeof Crypto.createHash("sha256").digest("base64url") === "string";
 const hashData = hasBase64Url ? hashData1 : hashData2;
-exports.readHashDigest = hasBase64Url
+export const readHashDigest = hasBase64Url
     ? (hash, encoding = "base64url") => {
         hash.setEncoding(encoding);
         hash.end();
@@ -55,7 +48,7 @@ exports.readHashDigest = hasBase64Url
  * @returns
  */
 async function hashFile(filename, encoding = "base64url") {
-    const data = await fs_1.default.promises.readFile(filename);
+    const data = await Fs.promises.readFile(filename);
     const hash = hashData(data, encoding);
     return hash;
 }
@@ -69,7 +62,7 @@ async function hashFiles(cwd, files, encoding = "base64url") {
     const hashes = {};
     const promises = [];
     for (const file of files) {
-        promises.push(hashFile(path_1.default.join(cwd, file), encoding).then((h) => (hashes[file] = h)));
+        promises.push(hashFile(Path.join(cwd, file), encoding).then((h) => (hashes[file] = h)));
     }
     await Promise.all(promises);
     const result = {};
@@ -84,7 +77,7 @@ async function hashFiles(cwd, files, encoding = "base64url") {
  * @returns
  */
 async function readPackageJson(cwd) {
-    return JSON.parse(await fs_1.default.promises.readFile(path_1.default.join(cwd, "package.json"), "utf-8"));
+    return JSON.parse(await Fs.promises.readFile(Path.join(cwd, "package.json"), "utf-8"));
 }
 /**
  * Convert minimatch string patterns to Minimatch instances
@@ -95,7 +88,7 @@ async function readPackageJson(cwd) {
 function makeMmPatterns(patterns, options = { dot: true }) {
     return []
         .concat(patterns)
-        .map((x) => x && new minimatch_1.default.Minimatch(x, options))
+        .map((x) => x && new Minimatch(x, options))
         .filter((x) => x);
 }
 /**
@@ -108,24 +101,24 @@ function makeMmPatterns(patterns, options = { dot: true }) {
 async function scanFiles(cwd, includes, excludes) {
     const filter = (_file, _path, extras) => {
         // filter-scan-dir now handles filtering symlinks when includeDir: false and includeSymlink is not set
-        if (!(0, minimatch_group_1.checkMmMatch)(extras.dirFile, includes) || (0, minimatch_group_1.checkMmMatch)(extras.dirFile, excludes)) {
+        if (!checkMmMatch(extras.dirFile, includes) || checkMmMatch(extras.dirFile, excludes)) {
             return false;
         }
         return true;
     };
-    const dirIncludes = includes.map((mx) => (0, minimatch_group_1.deconstructMM)(mx));
+    const dirIncludes = includes.map((mx) => deconstructMM(mx));
     const filterDir = (_file, _path, extras) => {
         const dir = `${extras.dirFile}/`; // add extra / to force matching directory
-        const inc = dirIncludes.find((di) => (0, minimatch_group_1.checkMmMatch)(dir, di.mms));
+        const inc = dirIncludes.find((di) => checkMmMatch(dir, di.mms));
         if (inc) {
-            const exc = (0, minimatch_group_1.checkMmMatch)(dir, excludes);
+            const exc = checkMmMatch(dir, excludes);
             if (!exc) {
                 return true;
             }
         }
         return false;
     };
-    return (await (0, filter_scan_dir_1.filterScanDir)({
+    return (await filterScanDir({
         cwd,
         filter,
         filterDir,
@@ -140,13 +133,13 @@ async function scanFiles(cwd, includes, excludes) {
  * @param param0
  * @returns result from processing input rules
  */
-async function processInput({ cwd, input, packageJson, extra, } = { input: {} }) {
+export async function processInput({ cwd, input, packageJson, extra, } = { input: {} }) {
     const files = await scanFiles(cwd, makeMmPatterns(input.include, input.minimatchOptions), makeMmPatterns(input.exclude, input.minimatchOptions));
     const fileHashes = await hashFiles(cwd, files);
     const data = {
-        env: lodash_1.default.pick(process.env, input.includeEnv),
-        versions: lodash_1.default.pick(process.versions, input.includeVersions),
-        npmScripts: lodash_1.default.pick(lodash_1.default.get(packageJson || (await readPackageJson(cwd)), "scripts"), input.npmScripts),
+        env: _.pick(process.env, input.includeEnv),
+        versions: _.pick(process.versions, input.includeVersions),
+        npmScripts: _.pick(_.get(packageJson || (await readPackageJson(cwd)), "scripts"), input.npmScripts),
         fileHashes,
         extra: extra || {}, // additional data
     };
@@ -159,10 +152,10 @@ async function processInput({ cwd, input, packageJson, extra, } = { input: {} })
  * @param param0
  * @returns
  */
-async function processLifecycleInput({ cwd, input, packageJson, } = { input: {} }) {
+export async function processLifecycleInput({ cwd, input, packageJson, } = { input: {} }) {
     packageJson = packageJson || (await readPackageJson(cwd));
-    const npmScripts = lodash_1.default.pick(lodash_1.default.get(packageJson, "scripts"), input.npmScripts);
-    if (lodash_1.default.isEmpty(npmScripts)) {
+    const npmScripts = _.pick(_.get(packageJson, "scripts"), input.npmScripts);
+    if (_.isEmpty(npmScripts)) {
         return {};
     }
     return await processInput({ cwd, input, packageJson });
@@ -173,22 +166,22 @@ async function processLifecycleInput({ cwd, input, packageJson, } = { input: {}
  * @param param0
  * @returns
  */
-async function processOutput({ cwd, inputHash, calcHash, output, preFiles, } = { output: {} }) {
+export async function processOutput({ cwd, inputHash, calcHash, output, preFiles, } = { output: {} }) {
     const mmIncludes = makeMmPatterns(output.include, output.minimatchOptions);
     const mmExcludes = makeMmPatterns(output.exclude, output.minimatchOptions);
     const files = await scanFiles(cwd, mmIncludes, mmExcludes);
     preFiles = []
         .concat(preFiles)
         .filter((x) => {
-        if (!x || (0, minimatch_group_1.unrollMmMatch)(x, mmExcludes)) {
+        if (!x || unrollMmMatch(x, mmExcludes)) {
             return false;
         }
         return true;
     })
-        .map((x) => x.replace(`${cwd}${path_1.default.sep}`, ""));
+        .map((x) => x.replace(`${cwd}${Path.sep}`, ""));
     let hash = "";
     let fileHashes = {};
-    const allFiles = lodash_1.default.uniq(files.concat(preFiles)).sort();
+    const allFiles = _.uniq(files.concat(preFiles)).sort();
     let data = { inputHash, fileHashes };
     //
     if (calcHash) {
@@ -200,4 +193,3 @@ async function processOutput({ cwd, inputHash, calcHash, output, preFiles, } = {
     const now = Date.now();
     return { files: allFiles, data, hash, access: now, create: now };
 }
-//# sourceMappingURL=caching.js.map

package/dist/fynpo-config.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FynpoConfigManager = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const optional_require_1 = require("optional-require");
+import Fs from "fs";
+import Path from "path";
+import { makeOptionalImport } from "optional-import";
+const optionalImport = makeOptionalImport(import.meta);
 /**
  * manage fynpo config
  */
-class FynpoConfigManager {
+export class FynpoConfigManager {
     constructor(opts = {}) {
         this.options = { cwd: process.cwd(), ...opts };
         this._topDir = undefined;
@@ -49,7 +46,7 @@ class FynpoConfigManager {
     }
     async readJson(file) {
         try {
-            const data = await fs_1.default.promises.readFile(file, "utf8");
+            const data = await Fs.promises.readFile(file, "utf8");
             return JSON.parse(data);
         }
         catch (err) {
@@ -61,23 +58,44 @@ class FynpoConfigManager {
         }
     }
     async search() {
+        var _a;
         let dir = this.options.cwd;
         let prevDir = dir;
         let count = 0;
         do {
             // allow manually disable fynpo with a file
-            if (fs_1.default.existsSync(path_1.default.join(dir, ".no-fynpo"))) {
+            if (Fs.existsSync(Path.join(dir, ".no-fynpo"))) {
                 break;
             }
-            [".js", ".json"].find((ext) => {
-                return (this._config = (0, optional_require_1.optionalRequire)(path_1.default.join(dir, `fynpo.config${ext}`)));
+            //
+            // `fynpo.config.js` loads as a module: an absent file falls back, while one that exists
+            // but throws still surfaces as an error rather than being mistaken for absent.
+            //
+            // `fynpo.config.json` is NOT loaded as a module - `import()` of JSON needs an import
+            // attribute (`ERR_IMPORT_ATTRIBUTE_MISSING` without one), and reading it as JSON is what
+            // it is anyway. `readJson` already reports a malformed file and swallows only ENOENT.
+            //
+            const configMod = await optionalImport(Path.join(dir, "fynpo.config.js"), {
+                default: undefined,
             });
+            if (configMod) {
+                // a CJS config's `module.exports`, or an ESM config's `export default`, is on `.default`
+                this._config = (_a = configMod.default) !== null && _a !== void 0 ? _a : configMod;
+            }
+            else {
+                try {
+                    this._config = await this.readJson(Path.join(dir, "fynpo.config.json"));
+                }
+                catch (_e) {
+                    //
+                }
+            }
             if (this._config) {
                 this._type = "fynpo monorepo";
                 break;
             }
             try {
-                this._config = await this.readJson(path_1.default.join(dir, "fynpo.json"));
+                this._config = await this.readJson(Path.join(dir, "fynpo.json"));
                 this._type = "fynpo monorepo";
                 break;
             }
@@ -85,7 +103,7 @@ class FynpoConfigManager {
                 //
             }
             try {
-                const lerna = await this.readJson(path_1.default.join(dir, "lerna.json"));
+                const lerna = await this.readJson(Path.join(dir, "lerna.json"));
                 if (lerna.fynpo) {
                     this._type = "lerna monorepo with fynpo";
                     this._config = lerna;
@@ -96,14 +114,13 @@ class FynpoConfigManager {
                 //
             }
             prevDir = dir;
-            dir = path_1.default.dirname(dir);
+            dir = Path.dirname(dir);
         } while (++count < 50 && dir !== prevDir);
-        // add alias patterns for packages config
-        if (this._config && this._config.hasOwnProperty("packages")) {
-            this._config.patterns = this._config.packages;
-        }
+        //
+        // No `patterns` alias any more - see the matching note in fynpo/src/utils.ts loadConfig.
+        // `patterns` bypasses auto-search, while `include` is meant to filter what auto-search
+        // found. The raw `packages` config is carried through and resolved downstream. FPO-17.
+        //
         this._topDir = dir;
     }
 }
-exports.FynpoConfigManager = FynpoConfigManager;
-//# sourceMappingURL=fynpo-config.js.map

package/dist/fynpo-dep-graph.d.ts

@@ -1,4 +1,4 @@
-import mm from "minimatch";
+import { Minimatch } from "minimatch";
 /**
  * Basic information about a package: name, version, and its path in the monorepo
  */
@@ -61,7 +61,7 @@ export declare class PackageRef {
      * create a RegExp from it.
      */
     regex?: RegExp;
-    mm?: mm.IMinimatch;
+    mm?: Minimatch;
     constructor(ref: string);
     /**
      * Parse a package ref in string form
@@ -174,6 +174,13 @@ export type ReadFynpoOptions = {
     patterns?: string[];
     /** top dir of the monorepo to start searching */
     cwd?: string;
+    /**
+     * List of package names to NOT resolve as local packages.
+     * These packages will always be fetched from registry instead of using local versions.
+     */
+    noFynLocal?: string[];
+    /** raw `packages` config from fynpo.json - drives discovery and the publish sets */
+    packages?: unknown;
 };
 /**
  * Create a package ID by joining name and version into a single string with `@`
@@ -198,6 +205,13 @@ export declare class FynpoDepGraph {
     depMapByPath: Record<string, PackageDepData>;
     /** Remember resolved package for a `name@<semver>` ID to its `name@version` ID */
     resolvedCache: Record<string, string>;
+    /**
+     * True when no `packages` patterns were configured and every directory had to be
+     * searched for a package.json. Callers can surface this - discovery is then
+     * implicit, and a repo that keeps packages outside the default location gets
+     * different results from the commands that don't auto-search.
+     */
+    autoSearched: boolean;
     _options: ReadFynpoOptions;
     constructor(options?: ReadFynpoOptions);
     /**
@@ -278,6 +292,18 @@ export declare class FynpoDepGraph {
      * @returns fynpo package info
      */
     resolvePackage(name: string, semver: string, fallbackToFirst?: boolean): FynpoPackageInfo;
+    /**
+     * Check if a dependency should NOT be resolved as a local package.
+     *
+     * Checks both:
+     * 1. Monorepo-wide `noFynLocal` option
+     * 2. Per-package `fyn.dependencies[name]` setting (false or "no-fyn-local")
+     *
+     * @param pkgInfo - the package that has the dependency
+     * @param depName - name of the dependency to check
+     * @returns true if the dependency should NOT be resolved locally
+     */
+    checkNoFynLocal(pkgInfo: FynpoPackageInfo, depName: string): boolean;
     /**
      * Figure out all the packages' direct dependencies on other local packages
      *