aberlaas-helper 2.18.1 → 2.20.1

package/lib/helper.js

@@ -0,0 +1,195 @@
+import path from 'node:path';
+import { _ } from 'golgoth';
+import {
+  env,
+  exists,
+  firostError,
+  firostImport,
+  run as firostRun,
+  gitRoot,
+  glob,
+  packageRoot,
+  wrap,
+} from 'firost';
+
+// Exported wrapper object so we can mock indidividual methods in tests by
+// spying on __ like this:
+// import { __, methodName } from
+// vi.spyOn(__, 'methodName').mockReturnValue()
+export const __ = {
+  /**
+   * Absolute path of where the user was when running the initial "yarn run"
+   * command that triggered aberlaas
+   * @returns {string} Absolute path to working directory
+   */
+  hostWorkingDirectory() {
+    // INIT_CWD is set by yarn as the directory where the yarn command is being
+    // called
+    return env('INIT_CWD') || process.cwd();
+  },
+
+  /**
+   * Absolute path to the closest package root
+   * @returns {string} Absolute path to closest package root
+   */
+  hostPackageRoot() {
+    return packageRoot(__.hostWorkingDirectory());
+  },
+
+  /**
+   * Return an absolute path to a file in the host package folder
+   * @param {string} relativePath Relative path from the host package root
+   * @returns {string} Absolute path to the host file
+   */
+  hostPackagePath(relativePath = '') {
+    return path.resolve(__.hostPackageRoot(), relativePath);
+  },
+
+  /**
+   * Find files in host package directory following glob patterns.
+   * Will exclude some directories by default, and allow specifying only
+   * specific file extensions
+   * @param {Array} userPattern Patterns to match
+   * @param {Array} safeExtensions Optional array of extensions to safelist. If
+   * set, only files of this extensions will be returned
+   * @returns {Array} Array of files matching the patterns
+   */
+  async findHostPackageFiles(userPattern, safeExtensions = []) {
+    const patterns = [
+      ..._.castArray(userPattern),
+      // Exclude folders that shouldn't be included
+      '!**/build/**',
+      '!**/dist/**',
+      '!**/fixtures/**',
+      '!**/node_modules/**',
+      '!**/tmp/**',
+      '!**/vendors/**',
+      '!**/.claude/**',
+      '!**/.git/**',
+      '!**/.next/**',
+      '!**/.turbo/**',
+      '!**/.yarn/**',
+    ];
+
+    // Expanding globs
+    let allFiles = await glob(patterns, {
+      directories: false,
+      cwd: __.hostPackageRoot(),
+    });
+
+    if (_.isEmpty(safeExtensions)) {
+      return allFiles;
+    }
+
+    // Keep only files of specified extensions
+    allFiles = _.filter(allFiles, (filepath) => {
+      const extension = path.extname(filepath);
+      const extensionWithoutDot = _.replace(extension, '.', '');
+      return (
+        _.includes(safeExtensions, extension) ||
+        _.includes(safeExtensions, extensionWithoutDot)
+      );
+    });
+
+    return allFiles;
+  },
+
+  /**
+   * Return absolute path to the host dir
+   * @returns {string} Absolute path to host dir
+   */
+  hostGitRoot() {
+    return gitRoot(__.hostWorkingDirectory());
+  },
+
+  /**
+   * Return an absolute path to a file in the host
+   * @param {string} relativePath Relative path from the host root
+   * @returns {string} Absolute path to the host file
+   */
+  hostGitPath(relativePath = '') {
+    return path.resolve(__.hostGitRoot(), relativePath);
+  },
+
+  /**
+   * Return a config object for a specific tool.
+   * Will first check for the user supplied path to the config file, then
+   * fallback to the default config file in the host, and finally fallback to
+   * the default base config in the aberlaas module.
+   * @param {string} userConfigPath User specified config file, relative to the host root
+   * @param {string} hostConfigPath Default host config path, relative to the host root
+   * @param {object} baseConfig Base aberlaas config, final fallback
+   * @returns {object} Config object
+   */
+  async getConfig(userConfigPath, hostConfigPath, baseConfig = {}) {
+    // Taking value from --config in CLI in priority
+    if (userConfigPath) {
+      const configPath = __.hostGitPath(userConfigPath);
+      if (!(await exists(configPath))) {
+        throw firostError(
+          'ABERLAAS_HELPER_GET_CONFIG_USER_PROVIDED_NOT_FOUND',
+          `Provided config file (${userConfigPath}) not found`,
+        );
+      }
+      // TODO: Add a test for that
+
+      return await firostImport(configPath, { forceReload: true });
+    }
+
+    // Checking for custom config in the host
+    if (hostConfigPath) {
+      const hostConfigFullPath = __.hostGitPath(hostConfigPath);
+      if (await exists(hostConfigFullPath)) {
+        return await firostImport(hostConfigFullPath, { forceReload: true });
+      }
+    }
+
+    // Fallback on default config in aberlaas
+    return baseConfig;
+  },
+
+  /**
+   * Debug command, prints useful info about the host environment
+   * Used in tests, to double check in real conditions, what the various paths
+   * refer to
+   */
+  /**
+   * Run a yarn command from the host git root
+   * @param {string} command Command to run (e.g., 'test', 'lint', 'test --failFast')
+   * @returns {Promise} Result of the command execution
+   */
+  async yarnRun(command) {
+    const cwd = __.hostGitRoot();
+    return await firostRun(`yarn run ${command}`, {
+      cwd,
+      env: { FORCE_COLOR: '1' },
+    });
+  },
+
+  async run() {
+    console.log(
+      JSON.stringify(
+        {
+          hostWorkingDirectory: __.hostWorkingDirectory(),
+          hostPackageRoot: __.hostPackageRoot(),
+          hostGitRoot: __.hostGitRoot(),
+        },
+        null,
+        2,
+      ),
+    );
+  },
+};
+
+// Named exports of each method, but they wrap a call to __.{methodName}.
+// This allow us to mock __.{methodName} in tests, and still having the named
+// export use the mocked versions of the inner methods.
+export const hostWorkingDirectory = wrap(__, 'hostWorkingDirectory');
+export const hostPackageRoot = wrap(__, 'hostPackageRoot');
+export const hostPackagePath = wrap(__, 'hostPackagePath');
+export const findHostPackageFiles = wrap(__, 'findHostPackageFiles');
+export const hostGitRoot = wrap(__, 'hostGitRoot');
+export const hostGitPath = wrap(__, 'hostGitPath');
+export const getConfig = wrap(__, 'getConfig');
+export const yarnRun = wrap(__, 'yarnRun');
+export const run = wrap(__, 'run');

package/lib/main.js

@@ -1,100 +1,14 @@
-import path from 'node:path';
-import { _ } from 'golgoth';
-import { exists, firostImport, glob } from 'firost';
-
-export default {
-  /**
-   * Return absolute path to the host dir
-   * @returns {string} Absolute path to host dir
-   */
-  hostRoot() {
-    return process.cwd();
-  },
-  /**
-   * Return an absolute path to a file in the host
-   * @param {string} relativePath Relative path from the host root
-   * @returns {string} Absolute path to the host file
-   */
-  hostPath(relativePath = '') {
-    return path.resolve(this.hostRoot(), relativePath);
-  },
-  /**
-   * Find files in host directory following glob patterns. Will exclude some
-   * directories by default, and allow specifying only specific file extensions
-   * @param {Array} userPattern Patterns to match
-   * @param {Array} safeExtensions Optional array of extensions to safelist. If
-   * set, only files of this extensions will be returned
-   * @returns {Array} Array of files matching the patterns
-   */
-  async findHostFiles(userPattern, safeExtensions = []) {
-    const patterns = _.castArray(userPattern);
-    // Making all path relative to the host
-    const globs = _.map(patterns, (pattern) => {
-      return this.hostPath(pattern);
-    });
-
-    // Exclude folders that shouldn't be included
-    const blockedFolders = [
-      'build',
-      'dist',
-      'fixtures',
-      'node_modules',
-      'tmp',
-      'vendors',
-      '.git',
-      '.yarn',
-      '.claude',
-      '.next',
-    ];
-    _.each(blockedFolders, (blockedFolder) => {
-      const deepFolder = `**/${blockedFolder}/**`;
-      globs.push(`!${this.hostPath(deepFolder)}`);
-    });
-
-    // Expanding globs
-    let allFiles = await glob(globs, { directories: false });
-
-    if (_.isEmpty(safeExtensions)) {
-      return allFiles;
-    }
-
-    // Keep only files of specified extensions
-    allFiles = _.filter(allFiles, (filepath) => {
-      const extension = path.extname(filepath);
-      const extensionWithoutDot = _.replace(extension, '.', '');
-      return (
-        _.includes(safeExtensions, extension) ||
-        _.includes(safeExtensions, extensionWithoutDot)
-      );
-    });
-
-    return allFiles;
-  },
-  /**
-   * Return a config object for a specific tool.
-   * Will first check for the user supplied path to the config file, then
-   * fallback to the default config file in the host, and finally fallback to
-   * the default base config in the aberlaas module.
-   * @param {string} userConfigPath User specified config file, relative to the host root
-   * @param {string} hostConfigPath Default host config path, relative to the host root
-   * @param {object} baseConfig Base aberlaas config, final fallback
-   * @returns {object} Config object
-   */
-  async getConfig(userConfigPath, hostConfigPath, baseConfig = {}) {
-    // Taking value from --config in CLI in priority
-    if (userConfigPath) {
-      return await firostImport(this.hostPath(userConfigPath));
-    }
-
-    // Checking for custom config in the host
-    if (hostConfigPath) {
-      const hostConfigFullPath = this.hostPath(hostConfigPath);
-      if (await exists(hostConfigFullPath)) {
-        return await firostImport(hostConfigFullPath);
-      }
-    }
-
-    // Fallback on default config in aberlaas
-    return baseConfig;
-  },
-};
+// Helper
+export { findHostPackageFiles } from './helper.js';
+export { getConfig } from './helper.js';
+export { hostGitPath } from './helper.js';
+export { hostGitRoot } from './helper.js';
+export { hostPackagePath } from './helper.js';
+export { hostPackageRoot } from './helper.js';
+export { hostWorkingDirectory } from './helper.js';
+export { run } from './helper.js';
+export { yarnRun } from './helper.js';
+export { __ } from './helper.js';
+
+// Test helper
+export { mockHelperPaths } from './test-helper.js';

package/lib/test-helper.js

@@ -0,0 +1,18 @@
+import { __ as helper } from './helper.js';
+/**
+ * Safely mock aberlaas helper functions to point to a test directory.
+ * This prevents tests from accidentally modifying the real aberlaas repository.
+ * All helper path functions (hostGitRoot, hostPackageRoot, hostWorkingDirectory)
+ * will point to the same test directory as a safety measure.
+ * You can override specific paths afterwards if needed.
+ * @param {string} testDirectory - Absolute path to test directory
+ */
+export function mockHelperPaths(testDirectory) {
+  /* eslint-disable no-undef */
+  vi.spyOn(helper, 'hostGitRoot').mockReturnValue(testDirectory);
+  vi.spyOn(helper, 'hostPackageRoot').mockReturnValue(`${testDirectory}/lib`);
+  vi.spyOn(helper, 'hostWorkingDirectory').mockReturnValue(
+    `${testDirectory}/lib/src`,
+  );
+  /* eslint-enable no-undef */
+}

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "aberlaas-helper",
   "type": "module",
+  "sideEffects": false,
   "description": "aberlaas shared helper: Common methods used by all commands",
-  "version": "2.18.1",
+  "version": "2.20.1",
   "repository": "pixelastic/aberlaas",
   "homepage": "https://projects.pixelastic.com/aberlaas/",
   "author": "Tim Carry (@pixelastic)",
   "license": "MIT",
   "files": [
-    "lib/*.js"
+    "lib/main.js",
+    "lib/helper.js",
+    "lib/test-helper.js"
   ],
   "exports": {
     ".": "./lib/main.js"
@@ -17,25 +20,22 @@
   "engines": {
     "node": ">=18.18.0"
   },
-  "scripts": {
-    "build": "../../scripts/local/build",
-    "build:prod": "../../scripts/local/build-prod",
-    "cms": "../../scripts/local/cms",
-    "serve": "../../scripts/local/serve",
-    "ci": "../../scripts/local/ci",
-    "release": "../../scripts/local/release",
-    "update-dependencies": "node ../../scripts/meta/update-dependencies.js",
-    "test:meta": "../../scripts/local/test-meta",
-    "test": "../../scripts/local/test",
-    "test:watch": "../../scripts/local/test-watch",
-    "compress": "../../scripts/local/compress",
-    "lint": "../../scripts/local/lint",
-    "lint:fix": "../../scripts/local/lint-fix"
-  },
   "dependencies": {
-    "find-up": "7.0.0",
-    "firost": "5.2.1",
+    "aberlaas-versions": "workspace:*",
+    "firost": "5.5.1",
     "golgoth": "3.0.0"
   },
-  "gitHead": "00b60dcf9aebab442a809ccc81942005d87d1b5c"
+  "scripts": {
+    "build": "cd ../docs && yarn run build",
+    "build:prod": "cd ../docs && yarn run build:prod",
+    "cms": "cd ../docs && yarn run cms",
+    "serve": "cd ../docs && yarn run serve",
+    "release": "cd ../.. && ./scripts/release",
+    "test:meta": "cd ../.. && ./scripts/test-meta",
+    "test": "cd ../.. && ./scripts/test",
+    "test:watch": "cd ../.. && ./scripts/test-watch",
+    "compress": "cd ../.. && ./scripts/compress",
+    "lint": "cd ../.. && ./scripts/lint",
+    "lint:fix": "cd ../.. && ./scripts/lint-fix"
+  }
 }