NixOSConfig/lib/modules/rclone.nix

{ config, lib, pkgs, ... }:
let
  mkProvider =
    { secretLoader ? ({ ... }: ""), envLoader ? ({ ... }: { }), options ? {}, ... }: {
      inherit
        secretLoader
        envLoader
        options
      ;
    };

  syncProviders = {
    nextcloud = mkProvider {};
    proton = mkProvider {};
  };

  syncType = lib.types.submodule (
    { config, name, ... }: {
      options = {
        type = lib.mkOption {
          description = "The type of the sync";
          type = lib.types.enum (builtins.attrNames syncProviders);
        };

        autoStart = lib.mkOption {
          type = lib.types.bool;
          description = "Whether to start this sync automatically.";
          default = true;
        };

        systemdDependencies = lib.mkOption {
          type = lib.types.attrsOf lib.types.str;
          description = "The systemd services this sync depends on.";
          example = {
            secrets = "sops-nix.service";
          };
        };

        environment = lib.mkOption {
          type = lib.types.attrsOf lib.types.envVar;
          description = "The environment variables to pass to the service.";
          default = {};
        };

        secretsScript = lib.mkOption {
          type = lib.types.lines;
          description = "A script for loading secrets before launching the sync.";
          default = [];
        };
      };

      config = {
        environment = syncProviders.${config.type}.envLoader config;
        secretsScript = syncProviders.${config.type}.secretLoader config;
      };
    });
in {
  options = {
    programs.rclone = {
      enable = lib.mkEnableOption "rclone";

      configs = lib.mkOption {
        type = lib.types.attrsOf syncType;
        description = "The synchronizations to set up.";
        default = {};
      };
    };
  };

  config =
    let
      cfg = config.programs.rclone;
    in {
      home.packages = lib.optional cfg.enable pkgs.rclone;

      systemd.user = lib.optionalAttrs cfg.enable {
        enable = true;

        services = {
          rclone = {
            Unit = {
              Description = "rclone Starter";
              Documentation = "man:rclone(1)";
            };

            Service = {
              Type = "simple";

              ExecStartPre =
                let
                  script = pkgs.writeShellScriptBin "rclone-pre" ''
                    sleep 10
                  '';
                in
                  (lib.getExe script);

              ExecStart =
                let
                  script = pkgs.writeShellScriptBin "rclone" ''
                    systemctl --user start rclone.target
                  '';
                in
                  (lib.getExe script);
            };
          };
        } // (
          lib.attrsets.concatMapAttrs
          (name: sync:
            let
              serviceName = "rclone-sync-${name}";
            in {
              ${serviceName} = {
                Unit = {
                  Description = "${sync.type}";
                };

                Service = {
                  Environment = lib.mapAttrsToList
                    (key: val: (lib.escapeShellArg "${key}=${val}"))
                    sync.environment;

                  ExecStart =
                    let
                      script = pkgs.writeShellScriptBin serviceName ''
                        ${sync.secretsScript}
                        bash -c echo hello world
                      '';
                    in
                      (lib.getExe script);
                };
              };
            })
          cfg.configs);

        targets.rclone = {
          Unit = {
            Description = "rclone Mounts";
            Documentation = "man:rclone(1)";
          };
        };
      };
    };
}