minepkg/minepkg

package provider

import (
    "context"
    "errors"
    "fmt"
    "io"
    "net/http"
    "strings"

    "github.com/minepkg/minepkg/internals/modrinth"
    "github.com/minepkg/minepkg/internals/ownhttp"
    "github.com/minepkg/minepkg/pkg/manifest"
    "golang.org/x/time/rate"
)

var (
    ErrVersionNotSupported       = errors.New("for modrinth version can only be '*', 'latest' a version id, sha1 or sha512")
    ErrCouldNotFindLatestVersion = errors.New("could not find latest version")
    ErrVersionHasNoFiles         = errors.New("version has no files")
)

type ModrinthProvider struct {
    Client *modrinth.Client
}

type modrinthResult struct {
    name    string
    version *modrinth.Version
    file    *modrinth.File
}

func (m *modrinthResult) Lock() *manifest.DependencyLock {
    lock := &manifest.DependencyLock{
        Name:        m.name,
        Version:     m.version.ID,
        VersionName: m.version.VersionNumber,
        Type:        "mod",
        URL:         m.file.URL,
        Provider:    "modrinth",
        Sha512:      m.file.Hashes.Sha512,
    }

    return lock
}

func (m *modrinthResult) Dependencies() []*manifest.InterpretedDependency {
    return nil
}

func NewModrinthProvider() *ModrinthProvider {
    // http client that is throttled
    client := http.Client{}
    // limit to 5 requests per second (https://github.com/modrinth/labrinth/blob/1e4d07a52c441030374d052a44dddaaaa25d1f87/src/main.rs#L254-L255)
    limiter := rate.NewLimiter(5, 120)
    client.Transport = ownhttp.NewThrottleTransport(client.Transport, limiter)
    client.Transport = ownhttp.NewAddHeaderTransport(client.Transport)

    return &ModrinthProvider{
        Client: modrinth.New(&client),
    }
}

func (m *ModrinthProvider) Name() string { return "modrinth" }

func (m *ModrinthProvider) Resolve(ctx context.Context, request *Request) (Result, error) {

    var wantedVersion *modrinth.Version

    var err error
    if request.Dependency.Version == "*" || request.Dependency.Version == "latest" {
        wantedVersion, err = m.resolveLatest(ctx, request)
    } else {
        wantedVersion, err = m.resolveById(ctx, request.Dependency.Version)
    }
    if err != nil {
        return nil, err
    }

    // this should never happen, we assume all versions have files
    if len(wantedVersion.Files) == 0 {
        return nil, ErrVersionHasNoFiles
    }

    return &modrinthResult{
        name:    request.Dependency.Name,
        version: wantedVersion,
        file:    fileFromVersion(wantedVersion),
    }, nil
}

func (m *ModrinthProvider) ResolveLatest(ctx context.Context, request *Request) (Result, error) {
    version, err := m.resolveLatest(ctx, request)
    if err != nil {
        return nil, err
    }

    if len(version.Files) == 0 {
        return nil, ErrVersionHasNoFiles
    }

    return &modrinthResult{
        name:    request.Dependency.Name,
        version: version,
        file:    fileFromVersion(version),
    }, nil
}

func (m *ModrinthProvider) resolveById(ctx context.Context, id string) (*modrinth.Version, error) {
    switch len(id) {
    case 8:
        // we fetch by version id
        return m.Client.GetVersion(ctx, id)
    case 40:
        fallthrough
    case 128:
        // we fetch the version by hash
        return m.Client.GetVersionFile(ctx, id)
    default:
        return nil, ErrVersionNotSupported
    }
}

func (m *ModrinthProvider) resolveLatest(ctx context.Context, request *Request) (*modrinth.Version, error) {
    query := &modrinth.ListProjectVersionQuery{
        Loaders:      []string{request.Requirements.PlatformName()},
        GameVersions: []string{request.Requirements.MinecraftVersion()},
    }

    versions, err := m.Client.ListProjectVersion(ctx, request.Dependency.Name, query)
    if err != nil {
        return nil, err
    }

    if len(versions) == 0 {
        return nil, ErrCouldNotFindLatestVersion
    }

    // grab the first version (not sure if this is good)
    return &versions[0], nil
}

func (m *ModrinthProvider) Fetch(ctx context.Context, toFetch Result) (io.Reader, int, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", toFetch.Lock().URL, nil)
    if err != nil {
        return nil, 0, err
    }

    fileRes, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, 0, err
    }

    return fileRes.Body, int(fileRes.ContentLength), nil
}

func (m *ModrinthProvider) CanConvertURL(url string) bool {
    return strings.HasPrefix(url, "https://cdn.modrinth.com/data/")
}

func (m *ModrinthProvider) ConvertURL(ctx context.Context, url string) (string, error) {
    if !m.CanConvertURL(url) {
        return "", fmt.Errorf("url %s is not a modrinth CDN url", url)
    }

    // url looks like https://cdn.modrinth.com/data/iFnEtHsI/versions/1.4.6/alaskanativecraft-1.4.6.jar
    // we need to extract the id (iFnEtHsI) and the version (1.4.6)

    // id is easy cause it is always the same length
    id := url[30:38]

    // version starts at the same position, but we need to find the end
    version := strings.SplitN(url[48:], "/", 2)[0]

    // now we can fetch the version
    versions, err := m.Client.ListProjectVersion(ctx, id, nil)
    if err != nil {
        return "", err
    }

    // now we need to find the version we want
    var wantedVersion *modrinth.Version

    for _, v := range versions {
        if v.VersionNumber == version || v.ID == version {
            wantedVersion = &v
            break
        }
    }

    if wantedVersion == nil {
        return "", fmt.Errorf("version %s not found", version)
    }

    // get the project slug
    project, err := m.Client.GetProject(ctx, id)
    if err != nil {
        return "", err
    }

    // now we can return install pkgid
    return fmt.Sprintf("modrinth:%s@%s", project.Slug, wantedVersion.ID), nil
}

func fileFromVersion(version *modrinth.Version) *modrinth.File {
    if len(version.Files) == 0 {
        return nil
    }

    // grab primary version, fallback to latest
    resolvedFile := version.Files[0]
    for _, f := range version.Files {
        if f.Primary {
            resolvedFile = f
            break
        }
    }

    return &resolvedFile
}