flake.nix

{
  description = "
    `VS Code Marketplace` (~40K) and `Open VSX` (~3K) extensions as `Nix` expressions.
    Learn more in the flake [repo](https://github.com/nix-community/nix-vscode-extensions).
  ";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/3a05eebede89661660945da1f151959900903b6a";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs =
    inputs@{
      self,
      nixpkgs,
      flake-utils,
      ...
    }:
    let
      nix-dev = import ./nix-dev;
      inputsCombined = nix-dev.inputs // inputs;
    in
    nix-dev.inputs.flake-parts.lib.mkFlake { inputs = inputsCombined; } {
      systems = import flake-utils.inputs.systems;

      imports = [
        nix-dev.inputs.devshell.flakeModule
        nix-dev.inputs.treefmt-nix.flakeModule
        nix-dev.inputs.nix-unit.modules.flake.default
      ];

      flake =
        let
          vscode-marketplace = "vscode-marketplace";
          open-vsx = "open-vsx";
          universal = "universal";

          systemPlatform = {
            "aarch64-darwin" = "darwin-arm64";
            "x86_64-linux" = "linux-x64";
            "aarch64-linux" = "linux-arm64";
            "x86_64-darwin" = "darwin-x64";
          };

          overlays = {
            default =
              final: prev:
              let
                pkgs = prev;
                inherit (pkgs) lib;
                currentPlatform = systemPlatform.${final.system};
                isCompatibleVersion =
                  vscodeVersion: engineVersion:
                  if lib.strings.hasPrefix "^" engineVersion then
                    lib.versionAtLeast vscodeVersion (lib.strings.removePrefix "^" engineVersion)
                  else
                    vscodeVersion == engineVersion;
                filterByPlatform =
                  {
                    checkVSCodeVersion,
                    # version of VSCode or VSCodium
                    vscodeVersion,
                  }:
                  (builtins.filter (
                    x:
                    (x.platform == universal || x.platform == currentPlatform)
                    && (if checkVSCodeVersion then (isCompatibleVersion vscodeVersion x.engineVersion) else true)
                  ));
                loadGenerated =
                  {
                    needLatest ? true,
                    checkVSCodeVersion ? false,
                    vscodeVersion ? "*",
                    site,
                  }:
                  lib.pipe site [
                    (x: ./data/cache/${site}${if needLatest then "-latest" else "-release"}.json)
                    builtins.readFile
                    builtins.fromJSON
                    (filterByPlatform { inherit checkVSCodeVersion vscodeVersion; })
                    (map (
                      extension@{
                        name,
                        publisher,
                        version,
                        platform,
                        ...
                      }:
                      extension
                      // {
                        url =
                          if site == vscode-marketplace then
                            let
                              platformSuffix = if platform == universal then "" else "targetPlatform=${platform}";
                            in
                            "https://${publisher}.gallery.vsassets.io/_apis/public/gallery/publisher/${publisher}/extension/${name}/${version}/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage?${platformSuffix}"
                          else
                            let
                              platformSuffix = if platform == universal then "" else "@${platform}";
                              platformInfix = if platform == universal then "" else "/${platform}";
                            in
                            "https://open-vsx.org/api/${publisher}/${name}${platformInfix}/${version}/file/${publisher}.${name}-${version}${platformSuffix}.vsix";
                      }
                    ))
                    (
                      x:
                      builtins.map (ext: ext // { hash = ext.sha256; }) x
                      ++ filterByPlatform { inherit checkVSCodeVersion vscodeVersion; } (
                        pkgs.lib.attrsets.mapAttrsToList
                          (name: value: {
                            url = value.src.url;
                            hash = value.src.outputHash;
                            inherit (value)
                              publisher
                              name
                              version
                              platform
                              engineVersion
                              ;
                          })
                          (
                            # append extra extensions fetched from elsewhere to overwrite site extensions
                            import ./data/extra-extensions/generated.nix {
                              inherit (pkgs)
                                fetchgit
                                fetchurl
                                fetchFromGitHub
                                dockerTools
                                ;
                            }
                          )
                      )
                    )
                    # lowercase all names and publishers
                    (map (
                      extension@{ name, publisher, ... }:
                      extension
                      // {
                        name = lib.toLower name;
                        publisher = lib.toLower publisher;
                      }
                    ))
                    (
                      let
                        # keep outside of map to improve performance
                        # TODO pass user's nixpkgs
                        mkExtension = import ./mkExtension.nix { inherit pkgs; };
                      in
                      map (
                        {
                          name,
                          publisher,
                          version,
                          hash,
                          url,
                          ...
                        }:
                        let
                          extensionConfig = {
                            mktplcRef = {
                              inherit
                                name
                                publisher
                                version
                                hash
                                ;
                            };

                            # We use not only VSCode Markeplace but also Open VSX
                            # so we need to provide the URL for the extension
                            vsix = prev.fetchurl {
                              inherit url hash;
                              name = "${name}-${version}.zip";
                            };
                          };
                        in
                        {
                          inherit name;
                          value = mkExtension extensionConfig;
                        }
                      )
                    )
                    # group by publisher
                    (builtins.groupBy ({ value, ... }: value.vscodeExtPublisher))
                    # platform-specific extensions will overwrite universal extensions
                    # due to the sorting order of platforms in the Haskell script
                    (builtins.mapAttrs (
                      _:
                      builtins.foldl' (
                        k:
                        { name, value }:
                        k
                        // {
                          ${name} =
                            if !(lib.attrsets.isDerivation value) then
                              builtins.throw ''
                                The extension '${value.vscodeExtPublisher}.${name}' has been removed on ${pkgs.system}.
                                See '${./removed.nix}' for details.
                              ''
                            else
                              value;
                        }
                      ) { }
                    ))
                  ];
                mkSet =
                  attrs@{
                    checkVSCodeVersion ? false,
                    vscodeVersion ? "*",
                  }:
                  {
                    vscode-marketplace = loadGenerated (attrs // { site = vscode-marketplace; });
                    open-vsx = loadGenerated (attrs // { site = open-vsx; });
                    vscode-marketplace-release = loadGenerated (
                      attrs
                      // {
                        needLatest = false;
                        site = vscode-marketplace;
                      }
                    );
                    open-vsx-release = loadGenerated (
                      attrs
                      // {
                        needLatest = false;
                        site = open-vsx;
                      }
                    );
                  };
                res = (mkSet { }) // {
                  forVSCodeVersion =
                    vscodeVersion:
                    mkSet {
                      checkVSCodeVersion = true;
                      inherit vscodeVersion;
                    };
                };
              in
              res;
          };

          templates = {
            default = {
              path = ./template;
              description = "VSCodium with extensions";
            };
          };
        in
        {
          inherit overlays templates;
        }
        // flake-utils.lib.eachDefaultSystem (
          system:
          let
            pkgs = import nixpkgs {
              inherit system;
              # Uncomment to allow unfree extensions
              # config.allowUnfree = true;
              overlays = [ self.overlays.default ];
            };

            extensions = {
              inherit (pkgs)
                vscode-marketplace
                open-vsx
                vscode-marketplace-release
                open-vsx-release
                forVSCodeVersion
                ;
            };
          in
          {
            inherit extensions;
          }
        );

      perSystem =
        {
          self',
          system,
          lib,
          pkgs,
          inputs',
          ...
        }:
        let
          devshells.default = {
            commands = {
              tools = [
                {
                  expose = true;
                  packages = {
                    inherit (pkgs) nvfetcher;
                  };
                }
                {
                  prefix = "nix run .#";
                  packages = {
                    inherit (self'.packages) updateExtensions updateExtraExtensions;
                  };
                }
              ];
            };
          };

          mkShellApps = lib.mapAttrs (
            name: value:
            if !(lib.isDerivation value) && lib.isAttrs value then
              pkgs.writeShellApplication (value // { inherit name; })
            else
              value
          );

          haskell = import ./haskell;

          packages =
            {
              default = lib.trivial.pipe pkgs.vscode-with-extensions [
                (
                  x:
                  x.override {
                    vscode = pkgs.vscodium;
                    vscodeExtensions =
                      with self.extensions.${system}.vscode-marketplace;
                      [
                        golang.go
                        vlanguage.vscode-vlang
                        rust-lang.rust-analyzer
                        vadimcn.vscode-lldb
                      ]
                      ++ (lib.lists.optionals (builtins.elem system lib.platforms.linux) [
                        # Exclusively for testing purpose
                        (ms-vscode.cpptools.override { meta.license = [ ]; })
                        # Local build hangs
                        # yzane.markdown-pdf
                      ]);
                  }
                )
                (
                  x:
                  x.overrideAttrs (prev: {
                    meta = prev.meta // {
                      description = "VSCodium with a few extensions.";
                      longDescription = ''
                        This is a sample overridden VSCodium (a FOSS fork of VS Code) with a few extensions.
                        You can override this package and set `vscodeExtensions` to a list of extension
                        derivations, specifically those provided by this flake.
                        The [repository] offers approximately 40,000 extensions from the [Visual Studio Marketplace]
                        and an additional 4,500 from the [Open VSX Registry].
                        [repository]: https://github.com/nix-community/nix-vscode-extensions
                        [Visual Studio Marketplace]: https://marketplace.visualstudio.com/vscode
                        [Open VSX Registry]: https://open-vsx.org/
                      '';
                    };
                  })
                )
              ];
            }
            // mkShellApps {
              updateExtensions = {
                text = ''${lib.meta.getExe haskell.outputs.packages.${system}.default} "$@"'';
                meta.description = "Update extensions";
              };
              updateExtraExtensions = {
                text = "${lib.meta.getExe pkgs.nvfetcher} -c extra-extensions.toml -o data/extra-extensions";
                meta.description = "Update extra extensions";
              };
            };

          legacyPackages.saveFromGC.ci.jobs =
            let
              mkSaveFromGC =
                attrs: import "${nix-dev.inputs.cache-nix-action}/saveFromGC.nix" ({ inherit pkgs; } // attrs);
              template = (import nix-dev.inputs.flake-compat { src = ./template; }).defaultNix;
            in
            {
              test =
                (mkSaveFromGC {
                  inputs = {
                    self.inputs = inputsCombined;
                  };
                  derivations = [ self'.packages.default ];
                }).saveFromGC;

              update =
                (mkSaveFromGC {
                  inputs = {
                    self.inputs = inputsCombined;
                    inherit haskell;
                  };
                  derivations = [
                    self'.packages.updateExtensions
                    self'.packages.updateExtraExtensions
                    self'.formatter
                  ];
                }).saveFromGC;

              test-template =
                (mkSaveFromGC {
                  inputs = {
                    self = template;
                    inherit template;
                  };
                  derivations = [ template.devShells.${system}.default ];
                }).saveFromGC;
            };

          nix-unit = {
            allowNetwork = true;

            inputs = {
              inherit (inputsCombined)
                nixpkgs
                flake-parts
                nix-unit
                flake-compat
                ;
            };

            tests =
              let
                inherit (self.extensions.${system}) vscode-marketplace;
              in
              {
                "test: ms-python.vscode-pylance fails if unfree" = {
                  expr =
                    # https://discourse.nixos.org/t/evaluating-possibly-nonfree-derivations/24835/2
                    (builtins.tryEval (builtins.unsafeDiscardStringContext vscode-marketplace.ms-python.vscode-pylance))
                    .success;
                  expected = false;
                };
                "test: ms-vscode.cpptools passes only on " = {
                  expr = (builtins.tryEval vscode-marketplace.ms-vscode.cpptools).success;
                  expected = builtins.elem system lib.platforms.linux;
                };
                "test: ms-python.vscode-pylance passes if not unfree" = {
                  expr =
                    (builtins.tryEval (vscode-marketplace.ms-python.vscode-pylance.override { meta.license = [ ]; }))
                    .success;
                  expected = true;
                };
                "test: rust-lang.rust-analyzer passes" = {
                  expr = (builtins.tryEval vscode-marketplace.rust-lang.rust-analyzer).success;
                  expected = true;
                };
              };
          };

          treefmt = {
            flakeCheck = false;

            programs = {
              nixfmt.enable = true;
              prettier.enable = true;
            };

            settings.global.excludes = [
              "haskell/**"
              "data/**"
              # ".github/**"
              ".envrc"
              ".env"
              "LICENSE"
              # "README.md"
              "cabal.project"
              "extra-extensions.toml"
              ".markdownlint.jsonc"
            ];
          };
        in
        {
          inherit
            devshells
            packages
            legacyPackages
            nix-unit
            treefmt
            ;
        };
    };

  nixConfig = {
    extra-trusted-substituters = [
      "https://nix-community.cachix.org"
      "https://hydra.iohk.io"
    ];
    extra-trusted-public-keys = [
      "nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs="
      "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="
    ];
  };
}