action.yml

name: "Has installed dependencies"
description: "Action to check if dependencies have been installed according to the package manager used."
author: hoverkraft
branding:
  icon: settings
  color: blue

inputs:
  dependencies:
    description: "The dependencies to check."
    required: true
  working-directory:
    description: |
      Working directory where the dependencies are installed.
      Can be absolute or relative to the repository root.
    required: false
    default: "."

outputs:
  installed-dependencies:
    description: "A map of dependencies and the status weither they have been installed or not."
    value: ${{ steps.has-dependencies.outputs.installed-dependencies }}

runs:
  using: "composite"
  steps:
    - shell: bash
      # FIXME: workaround until will be merged: https://github.com/actions/runner/pull/1684
      run: mkdir -p ./self-actions/ && cp -r $GITHUB_ACTION_PATH/../* ./self-actions/

    - id: working-directory
      uses: hoverkraft-tech/ci-github-common/actions/working-directory@f5847cb398fe65d53794e6aba98ebdfa0801f691 # 0.32.0
      with:
        working-directory: ${{ inputs.working-directory }}
        enforce-path-in-workspace: "false"

    - id: get-package-manager
      if: inputs.package-manager == ''
      uses: ./self-actions/get-package-manager
      with:
        working-directory: ${{ steps.working-directory.outputs.absolute-path }}

    - shell: bash
      # FIXME: workaround until will be merged: https://github.com/actions/runner/pull/1684
      run: |
        rm -fr ./self-actions
    - id: has-dependencies
      uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
      env:
        WORKING_DIRECTORY: ${{ steps.working-directory.outputs.absolute-path }}
        DEPENDENCIES: ${{ inputs.dependencies }}
        PACKAGE_MANAGER: ${{ steps.get-package-manager.outputs.package-manager }}
      with:
        # jscpd:ignore-start
        script: |
          const workingDirectory = process.env.WORKING_DIRECTORY;
          core.debug(`Running in working directory: ${workingDirectory}`);
          process.chdir(workingDirectory);

          const dependenciesPatterns = {
            storybook: /@storybook\/[a-z0-9\-]+/,
            nx: /@nx\/[a-z0-9\-]+/,
            docusaurus: /@docusaurus\/[a-z0-9\-]+/,
          };

          const dependencies = process.env.DEPENDENCIES.split('\n').map(x => x.trim()).filter(x => x !== '');

          const hasDependencies = Object.fromEntries(dependencies.map(dependency => [dependency, false]));

          const setHasDependencies = (dependency) => {
            for (const dependencyName of Object.keys(hasDependencies)) {
              if (hasDependencies[dependencyName]) {
                continue;
              }

              if (dependencyName === dependency) {
                hasDependencies[dependencyName] = true;
                continue;
              }

              if (dependenciesPatterns[dependencyName] && dependenciesPatterns[dependencyName].test(dependency)) {
                hasDependencies[dependencyName] = true;
                continue;
              }
            }
          };

          const parseNpmDependencies = (dependencies) => {
            for (const dependencyName of Object.keys(dependencies)) {
              const dependency = dependencies[dependencyName];
              setHasDependencies(dependencyName);

              if (Object.values(hasDependencies).every(Boolean)) {
                break;
              }

              if (dependency.dependencies) {
                parseNpmDependencies(dependency.dependencies);
              }
            }
          };

          const parseYarnDependencies = (dependencies) => {
            for (const dependency of dependencies.data.trees) {

              const dependencyName = dependency.name.split('@').slice(0, -1).join('@');
              setHasDependencies(dependencyName);

              if (Object.values(hasDependencies).every(Boolean)) {
                break;
              }
            }
          };

          const parseDependencies = async (command) => {
            const { exitCode, stdout, stderr } = await exec.getExecOutput(command, undefined, {
              cwd: workingDirectory,
              silent: true,
              ignoreReturnCode: true,
            });

            if (exitCode !== 0) {
              throw new Error(
                `Failed to list dependencies with command "${command}" (exit code: ${exitCode}).\n${stderr || 'No stderr output.'}`
              );
            }

            if (stdout === '') {
              return;
            }

            let allInstalledDependencies;
            try {
              allInstalledDependencies = JSON.parse(stdout);
            } catch (error) {
              throw new Error(
                `Dependency listing command "${command}" did not return valid JSON: ${error.message}`
              );
            }

            return allInstalledDependencies;
          }

          let allInstalledDependencies, parser;
          switch (process.env.PACKAGE_MANAGER) {
            case 'npm':
              allInstalledDependencies = await parseDependencies(
                `${process.env.PACKAGE_MANAGER} list --depth=1 --json --no-progress --pattern="${dependencies.join('|')}" --non-interactive`
              );
              allInstalledDependencies = allInstalledDependencies?.dependencies;
              parser = parseNpmDependencies;
              break;

            case 'pnpm':
              allInstalledDependencies = await parseDependencies(
                `${process.env.PACKAGE_MANAGER} list --depth=1 --json --no-color`
              );
              (allInstalledDependencies || []).reduce((accumulator, currentValue) => {
                return { ...accumulator, ...(currentValue?.dependencies || {}) };
              }, []);
              parser = parseNpmDependencies;
              break;

            case 'yarn':
              allInstalledDependencies = await parseDependencies(
                `${process.env.PACKAGE_MANAGER} list --depth=1 --json --no-progress --pattern="${dependencies.join('|')}" --non-interactive`
              );
              parser = parseYarnDependencies;
              break;

            default:
              throw new Error(`Unsupported package manager: ${process.env.PACKAGE_MANAGER}`);
          }

          if (allInstalledDependencies) {
            await parser(allInstalledDependencies);
          }

          core.setOutput('installed-dependencies', hasDependencies);
        # jscpd:ignore-end