justfile

export NIXPKGS_ALLOW_UNFREE := "1"
export NOTHANKS := "1"

default:
  @just --list

# --------------------------------------------------
# Section: Nix Development Environment
# --------------------------------------------------
# This section contains recipes for setting up and managing
# the Nix development environment, including entering the environment,
# cleaning caches, and initializing the project.
# --------------------------------------------------

# Recipe to enter the Nix development environment 🧰
dev:
  @echo "Entering Nix development environment 🧰 ..."
  @nix develop

# Recipe to clean Go cache, Go modules cache, and Nix/DevEnv/DirEnv cache 🧹
clean-all:
  @echo "Cleaning Go cache 🧹 ..."
  @go clean -cache
  @echo "Cleaning Go modules cache 🧹 ..."
  @go clean -modcache
  @echo "Cleaning Nix/DevEnv/DirEnv cache 🧹 ..."
  @nix-collect-garbage -d

fmt:
    @echo "Formatting code 🔍 ..."
    @nix develop --command treefmt

# Recipe to run pre-commit hooks 🔍
run-hooks:
  @echo "Running pre-commit hooks 🔍 ..."
  @pre-commit autoupdate
  @pre-commit run --all-files
  @echo "Pre-commit hooks passed ✅"

# Recipe to bump version of a module 🔄
bump-version mod bump='minor':
    #!/usr/bin/env bash
    set -euo pipefail

    echo "🔄 Bumping version for {{mod}} module"

    # Verify that the module directory exists and contains a dagger.json file
    if [ ! -d "{{mod}}" ] || [ ! -f "{{mod}}/dagger.json" ]; then
        echo "❌ Module {{mod}} not found or dagger.json missing"
        exit 1
    fi

    # Get the latest tag for this module
    latest_tag=$(git describe --tags --abbrev=0 --match "{{mod}}/*" 2>/dev/null || echo "{{mod}}/v0.0.0")
    current_version=$(echo $latest_tag | sed 's/{{mod}}\/v//')

    # Calculate the new version
    new_version="v$(semver bump {{bump}} "v$current_version")"

    echo "🔢 Current version: v$current_version"
    echo "🆕 New version: $new_version"

    read -p "Proceed with version bump? (y/N) " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        echo "❌ Aborting"
        exit 1
    fi

    # Create and push the new tag
    new_tag="{{mod}}/$new_version"
    git tag -a "$new_tag" -m "Bump {{mod}} to $new_version"
    git push origin "$new_tag"

    echo "✅ Version bumped to $new_version and tag $new_tag created"
    echo "🚀 Tag has been pushed to the remote repository"

# --------------------------------------------------
# Section: Recipes for running tests, examples, and linting
# ------------------------------------------------------------------------------
# This section contains recipes for running tests, examples, and linting in a certain module.
# cleaning caches, and initializing the project.
# --------------------------------------------------

# Recipe to run all the tests in the target module 🧪
test mod *args: (reloadmod mod) (reloadtest mod)
  @echo "🚀 Running Dagger module tests in module [{{mod}}]..."
  @echo "📦 Currently in {{mod}} module 🧪, path=`pwd`/{{mod}}/tests"
  @cd {{mod}}/tests && dagger functions
  @cd {{mod}}/tests && dagger call test-all {{args}}

# Recipe to run all the examples in the target module 📄
examplesgo mod *args: (reloadmod mod) (reloadexamples mod)
  @echo "🚀 Running Dagger module examples (Go SDK)..."
  @echo "📦 Currently in {{mod}} module examples/go 📄, path=`pwd`/{{mod}}/examples/go"
  @cd {{mod}}/examples/go && dagger call all-recipes {{args}}

# Recipe to run GolangCI Lint in top-level module🧹
lintmod mod *args: (reloadmod mod)
  @echo "Running Go (GolangCI)... 🧹 in module [{{mod}}] 📦"
  @nix develop .# --command bash -c "cd {{mod}} && golangci-lint run --config ../.golangci.yml --verbose {{args}}"

# Recipe to run GolangCI Lint in tests module 🧹
linttests mod *args: (reloadtest mod)
  @echo "Running Go (GolangCI)... 🧹 in module [{{mod}}/tests] 🧪"
  @nix develop .# --command bash -c "cd {{mod}}/tests && golangci-lint run --config ../../.golangci.yml --verbose {{args}}"

# Recipe to run GolangCI Lint in examples/go module 🧹
lintexamples mod *args: (reloadexamples mod)
  @echo "Running Go (GolangCI)... 🧹 in module [{{mod}}/examples/go] 📄"
  @nix develop .# --command bash -c "cd {{mod}}/examples/go && golangci-lint run --config ../../../.golangci.yml --verbose {{args}}"

# Recipe to run GolangCI Lint in all modules 🧹
lintall mod: (lintmod mod) (linttests mod) (lintexamples mod)
  @echo "✅ All Go (GolangCI) lint checks passed ✅"

# Recipe to run the whole CI locally 🚀
ci mod: (reloadall mod) (lintall mod) (test mod) (examplesgo mod) (ci-mod-docs mod)
  @echo "🎉 All checks passed! 🎉"

# Recipe to validate if the dagger module has the README.md file and the LICENSE file 📄
ci-mod-docs mod:
  @echo "🔍 Validating the module documentation..."
  @test -f {{mod}}/README.md || (echo "❌ README.md file not found" && exit 1)
  @test -f {{mod}}/LICENSE || (echo "❌ LICENSE file not found" && exit 1)
  @echo "✅ Module documentation is valid"

# --------------------------------------------------
# Section: Dagger Functions
# --------------------------------------------------
# This section contains recipes for calling functions
# in a certain module.
# --------------------------------------------------

# Recipe to call an specific function from the examples/go project in a certain module 📞
callfnexample mod *args: (check-dagger-pre-requisites mod) (reloadexamples mod)
  @echo "🔧 Calling a function in the 📄 examples/go module [{{mod}}/examples/go]..."
  @echo "📦 Currently in [{{mod}}/examples/go] module, path=`pwd`"
  @cd {{mod}}/examples/go && dagger call {{args}}

# Recipe for dagger call tests in a certain module 🧪
callfntest mod *args: (check-dagger-pre-requisites mod) (reloadtest mod)
  @echo "🔨 Calling a function {{args}} in the 🧪 test module [{{mod}}/tests]..."
  @echo "📦 Currently in [{{mod}}/tests] module, path=`pwd`/{{mod}}/tests"
  @cd {{mod}}/tests && dagger functions
  @cd {{mod}}/tests && dagger call {{args}}

# Recipe to call a certain function by a module's name, passing extra arguments optionally 📞
callfn mod *args: (check-dagger-pre-requisites mod) (reloadmod mod)
  @echo "🔨 Calling a function {{args}} in the module [{{mod}}]..."
  @echo "📂 Currently in [{{mod}}] module, path=`pwd`/{{mod}}"
  @cd {{mod}} && dagger functions
  @cd {{mod}} && dagger call {{args}}

# Recipe to list functions in a certain module 📄
listfns mod *args: (check-dagger-pre-requisites mod) (reloadmod mod)
  @echo "📄 Retrieving available functions for the module..."
  @echo "📦 Currently in [{{mod}}] module, path=`pwd`/{{mod}}"
  @cd {{mod}} && dagger functions

# Recipe to list functions in a test 🧪 module
listfnstest mod *args: (check-dagger-pre-requisites mod) (reloadtest mod)
  @echo "📄 Retrieving available functions for the module..."
  @echo "📦 Currently in [{{mod}}/tests] module, path=`pwd`/{{mod}}/tests"
  @cd {{mod}}/tests && dagger functions {{args}}

# Recipe to list functions in a examples/go 📄 module
listfnsexamples mod *args: (check-dagger-pre-requisites mod) (reloadexamples mod)
  @echo "📄 Retrieving available functions for the module..."
  @echo "📦 Currently in [{{mod}}/examples/go] module, path=`pwd`"
  @cd {{mod}}/examples/go && dagger functions {{args}}

# --------------------------------------------------
# Section: Dagger Maintenance
# --------------------------------------------------
# This section contains recipes for various maintenance
# operations related to Dagger modules.
# --------------------------------------------------

# Recipe that wraps the dagger CLI in a certain module 📦
dagcli mod *args: (check-dagger-pre-requisites mod)
  @echo "🚀 Running Dagger CLI in a certain module..."
  @echo "📦 Currently in [{{mod}}] module, path=`pwd`/{{mod}}"
  @cd {{mod}} && dagger {{args}}

# Recipe to run dagger develop and if the engine gots updated, update the modules 🔄
update-all: (daggy-compile) (check-docker-or-podman)
  @echo "🚀 Developing (or upgrading) all Dagger modules..."
  @.daggerx/daggy/target/release/daggy --task=develop

# --------------------------------------------------
# Section: Creating new modules
# --------------------------------------------------
# This section contains recipes for various operations
# related to Dagger modules, such as calling functions,
# listing functions, and running tests.
# --------------------------------------------------

# Recipe to create a new module using Daggy (a rust CLI tool) 🛠️
create mod with-ci='false' type='full': (daggy-compile) (check-docker-or-podman)
  @echo "🚀 Creating a new {{type}} module of type {{type}}..."
  @.daggerx/daggy/target/release/daggy --task=create --module={{mod}} --module-type={{type}}
  @if [ "{{with-ci}}" = "true" ]; then just cilocal {{mod}}; fi

# Recipe to create a new light module using Daggy 🛠️
createlight mod with-ci='false' type='light': (daggy-compile) (check-docker-or-podman)
  @echo "🚀 Creating a new {{type}} module of type {{type}}..."
  @./.daggerx/daggy/target/release/daggy --task=create --module={{mod}} --module-type={{type}}
  @if [ "{{with-ci}}" = "true" ]; then just cilocal {{mod}}; fi

# --------------------------------------------------
# Section: Daggy Operations
# --------------------------------------------------
# This section contains recipes for compiling and testing
# the Daggy tool.
# --------------------------------------------------

# Recipe to run Daggy tests 🧪
daggy-tests: (daggy-compile)
  @echo "Running Daggy tests 🧪 ..."
  @cd .daggerx/daggy && cargo test

# Recipe to compile Daggy 🔄
daggy-compile:
  @echo "Compiling Daggy 🔄 ..."
  @cd .daggerx/daggy && cargo build --release
  @echo "Daggy compiled successfully 🔄"

# --------------------------------------------------
# Section: Reloading Dagger Modules
# --------------------------------------------------
# This section contains recipes for reloading Dagger
# modules and their tests.
# --------------------------------------------------

# Recipe to reload Dagger module (Dagger Develop) 🔄
reloadmod mod *args: (check-dagger-pre-requisites mod)
  @echo "🚀 Running Dagger development in a given module..."
  @echo "📦 Currently in [{{mod}}] module, path=`pwd`/{{mod}}"
  @cd {{mod}} && dagger develop {{args}}
  @echo "✅ Module reloaded successfully"

# Recipe to reload a Dagger module's tests (Dagger Develop) 🔄
reloadtest mod *args: (check-dagger-pre-requisites mod)
  @echo "🚀 Running Dagger development in a given module's tests..."
  @echo "📦 Currently in [{{mod}}/tests] module, path=`pwd`/{{mod}}/tests"
  @cd {{mod}}/tests && dagger develop {{args}}
  @echo "✅ Module Tests reloaded successfully"

# Recipe to reload the Dagger module's examples (examples/go) 🔄
reloadexamples mod *args: (check-dagger-pre-requisites mod)
  @echo "🚀 Reloading the module's examples..."
  @echo "📦 Currently in {{mod}}/examples/go module, path=`pwd`"
  @test -d {{mod}}/examples/go || (echo "❌ Module examples not found" && exit 1)
  @cd {{mod}}/examples/go && dagger develop {{args}}
  @echo "🚀 Module's examples reloaded successfully"

# Recipe to reload Dagger module and its underlying tests (Dagger Develop & Dagger Call/Functions) 🔄
reloadall mod *args: (reloadmod mod) (reloadtest mod) (reloadexamples mod)
  @echo "🔄 Reloading all the module, tests and examples... [{{mod}}]"
  @echo "🚀 Module reloaded successfully"


# --------------------------------------------------
# Section: Utilities
# --------------------------------------------------
# This section contains recipes for utilities that
# are used to validate if Docker or Podman is running
# and to validate if a given directory is a Dagger module.
# --------------------------------------------------

# Recipe to check if Docker or Podman is running 🔄
check-docker-or-podman:
  #!/usr/bin/env sh
  set -e

  if command -v docker > /dev/null 2>&1; then
    if ! docker info > /dev/null 2>&1; then
      echo "❌ Docker is installed but not running. Please start Docker and try again."
      exit 1
    else
      echo "✅ Docker is running."
    fi
  elif command -v podman > /dev/null 2>&1; then
    if ! podman info > /dev/null 2>&1; then
      echo "❌ Podman is installed but not running. Please start Podman and try again."
      exit 1
    else
      echo "✅ Podman is running."
    fi
  else
    echo "❌ Neither Docker nor Podman is installed. Please install one of them and try again."
    exit 1
  fi

# Recipe that validate if it's an actual Dagger module
is-dagger-module mod:
  @echo "🔍 Validating if [{{mod}}] is a Dagger module..."
  @test -d {{mod}} || (echo "❌ Module not found at path=`pwd`/{{mod}}" && exit 1)
  @test -f {{mod}}/dagger.json || (echo "❌ dagger.json not found in module at path=`pwd`/{{mod}}. Not a Dagger module." && exit 1)
  @echo "✅ [{{mod}}] is a Dagger module"


# Recipe that check Dagger pre-requisites
check-dagger-pre-requisites mod: (check-docker-or-podman) (is-dagger-module mod)

# Recipe to sync module-template (light) changes that require sync in the Go templates. 🔍
syncmodlight: (daggy-compile)
  @echo "🔍 Syncing the module..."
  @./.daggerx/daggy/target/release/daggy --task=sync --inspect-type=light --detailed=false

# Recipe to sync module-template (full) changes that require sync in the Go templates. 🔍
syncmodfull: (daggy-compile)
  @echo "🔍 Syncing the module..."
  @./.daggerx/daggy/target/release/daggy --task=sync --inspect-type=full --detailed=false