jsonSchemaCatalogs: init (#412279)

{

  callPackage,

  fetchFromGitHub,

  jsonSchemaCatalogs,

  lib,

  nix-update-script,

  rustPlatform,

  passthru = {

    tests = {

      run = callPackage ./test-run.nix { json-schema-catalog-rs = finalAttrs.finalPackage; };

      jsonSchemaCatalogs = jsonSchemaCatalogs.tests.override {

        json-schema-catalog-rs = finalAttrs.finalPackage;

      };

    };

    updateScript = nix-update-script { };

{

  fetchurl,

  lib,

  newCatalog,

}:

newCatalog {

  name = "json-patch-schemastore";

  displayName = "JSON Patch as maintained by the https://www.schemastore.org community";

  version = "2024-11-26";

  groups = {

    "JSON Patch" = {

      "https://json.schemastore.org/json-patch.json" = fetchurl {

        name = "json-patch-schema";

        # Note that we don't use the json.schemastore.org URLs directly, as those are mutable resources.

        # Make sure to update the version above!

        url = "https://github.com/schemastore/schemastore/raw/138439cd4f9d7bf57d6747b674ce5bbcffbfafdc/src/schemas/json/json-patch.json";

        hash = "sha256-vrqlgvlU61aEO6jd1SLLEqJDZG1k+eTBozcyPmhUp2U=";

      };

    };

  };

  extraDescription = ''

    A JSON Patch is a sequence of editing and checking operations to perform against another JSON document.

    It is specified in IETF RFC 6902: https://datatracker.ietf.org/doc/html/rfc6902/

    The schema is maintained by the community at https://www.schemastore.org, which is a collection of JSON Schemas for various purposes.

  '';

  meta = {

    maintainers = with lib.maintainers; [ roberth ];

    license = lib.licenses.asl20;

    changelog = "https://github.com/schemastore/schemastore/commits/master/src/schemas/json/json-patch.json";

  };

}

{

  fetchurl,

  lib,

  newCatalog,

}:

newCatalog {

  name = "json-schema";

  displayName = "JSON Schema Metaschemas";

  groups = {

    "JSON Schema" = {

      "http://json-schema.org/draft-04/schema#" = fetchurl {

        name = "json-schema-draft-04";

        url = "https://json-schema.org/draft-04/schema";

        hash = "sha256-4UidC0dV8CeTMCWR0/y48Htok6gqlPJIlfjk7fEbguI=";

      };

      "http://json-schema.org/draft-06/schema#" = fetchurl {

        name = "json-schema-draft-06";

        url = "https://json-schema.org/draft-06/schema";

        hash = "sha256-AGTogLohS/8c7lEeZ4++SMmCbdNZ6R4kI/w23mey6+E=";

      };

      "http://json-schema.org/draft-07/schema#" = fetchurl {

        name = "json-schema-draft-07";

        url = "https://json-schema.org/draft-07/schema";

        hash = "sha256-aS4dFl5Hr8tfEbLOHGOWNf+oNANdbstrzzCHSB2uhAQ=";

      };

      # Unclear how newer metaschemas should be handled, so leaving them out for now.

      # https://github.com/roberth/json-schema-catalog-rs/issues/8

    };

  };

  meta = {

    maintainers = with lib.maintainers; [ roberth ];

    # https://github.com/json-schema-org/json-schema-spec/blob/main/LICENSE

    license = [

      lib.licenses.bsd3

      lib.licenses.afl3

    ];

  };

}

{

  lib,

  newScope,

  json-schema-catalog-rs,

  jsonschema-cli,

}:

let

  inherit (lib) concatMapAttrs optionalAttrs;

  inherit (lib.strings) hasSuffix removeSuffix;

  jsonSchemaCatalogs = lib.makeScope newScope (

    self:

    {

      inherit ((self.callPackage ./lib.nix { }).lib) newCatalog;

      tests = self.callPackage ./tests.nix { };

    }

    // concatMapAttrs (

      k: v:

      optionalAttrs (v == "regular" && hasSuffix ".nix" k) {

        ${removeSuffix ".nix" k} = self.callPackage (./catalogs + "/${k}") { };

      }

    ) (builtins.readDir ./catalogs)

  );

in

{

  # Exported to `pkgs`

  inherit jsonSchemaCatalogs;

}

{

  lib,

  json-schema-catalog-rs,

  runCommand,

  jq,

}:

let

  /**

    A somewhat opinionated method for constructing a JSON Schema Catalog from files in a Nix store.

    The input is a slightly simpler format:

    ```nix

    {

      name = "my-catalog"; # derivation name, default displayName

      displayName = "My Catalog"; # optional

      groups = {

        "Group One" = {

          "https://example.com/schemas/one-v1.json" = pkgs.fetchurl { ... };

          "https://example.com/schemas/one-v2.json" = pkgs.fetchurl { ... };

          "https://example.com/schemas/one-common.json" = pkgs.fetchurl { ... };

        };

        "Group Two" = {

          "https://example.com/schemas/two-v1.json" = ./two-v1.json; # Files can be local

        };

      };

    }

    ```

  */

  newCatalog =

    {

      name,

      displayName ? name,

      groups,

      version ? null,

      extraDescription ? null,

      meta ? { },

    }:

    let

      # lazyDerivation tidies up the package attributes

      package = lib.lazyDerivation {

        derivation = drv;

        passthru = {

          name = "catalog-${name}";

          internals = drv;

        }

        // lib.optionalAttrs (version != null) {

          inherit version;

        };

        meta = {

          description = "JSON Schema Catalog for ${displayName}";

          longDescription =

            let

              licenses = lib.toList meta.license;

              show = license: license.fullName or license;

              theLicensesApply =

                if lib.length licenses == 1 then

                  "The package license, ${show (lib.head licenses)}, applies"

                else

                  "The package licenses, ${lib.concatMapStringsSep " / " show licenses}, apply";

            in

            ''

              A JSON Schema Catalog is a mapping from URIs to JSON Schema documents.

              It enables offline use, e.g. in build processes, and therefore it improves performance, robustness and safety.

              ${lib.optionalString (extraDescription != null) "\n${extraDescription}\n"}

              ${theLicensesApply} to the schemas in this catalog. The catalog file itself is licensed under the terms of the Nix expression that governs it, e.g. MIT in the case of Nixpkgs.

            '';

        }

        // meta;

      };

      drvArgs = {

        pname = name;

        catalogJson = builtins.toJSON {

          name = displayName;

          groups = lib.mapAttrsToList (name: group: {

            inherit name;

            # TODO dedup the longest common prefix by putting it in baseLocation

            baseLocation = "/";

            schemas = lib.mapAttrsToList (id: location: {

              inherit id;

              inherit location;

            }) group;

          }) groups;

        };

        passAsFile = [ "catalogJson" ];

        passthru = {

          inherit groups;

        };

        nativeBuildInputs = [

          jq

          json-schema-catalog-rs

        ];

      }

      // lib.optionalAttrs (version != null) {

        inherit version;

      };

      drv = runCommand "${package.name}${lib.optionalString (version != null) "-${version}"}" drvArgs ''

        out_dir="$out/share/json-schema-catalogs"

        out_file="$out_dir/$name.json"

        mkdir -p "$out_dir"

        # Write the catalog JSON. `jq` formats it nicely.

        jq . <"$catalogJsonPath" >"$out_file"

        json-schema-catalog check "$out_file"

      '';

    in

    package;

in

{

  lib =

    # Exported as part of `pkgs.jsonSchemaCatalogs`

    {

      inherit newCatalog;

    };

}