devos/lib/mkFlake/evalArgs.nix
Pacman99 eab0bf074c lib: one line for arguments, drop userFlake*
Also format all files and add a flake.lock for lib
for a folder thats meant to work on other flakes theres never a reason
it should need to refer to itself, only other flakes. So "self" and
"inputs" are better namings for these variables. The userFlake* is
redundant and confusing, when trying to call the functions its hard to
figure out how to use them when there are now two lines of arguments to
figure out.
2021-04-23 23:46:56 -07:00

230 lines
6.8 KiB
Nix

{ lib }:
{ nixos, args }:
let
argOpts = with lib; { config, ... }:
let
inherit (lib) os;
inherit (config) self;
maybeImport = obj:
if (builtins.typeOf obj == "path") || (builtins.typeOf obj == "string") then
import obj
else
obj;
/* Custom types needed for arguments */
moduleType = with types; pathTo (anything // {
inherit (submodule { }) check;
description = "valid module";
});
overlayType = pathTo (types.anything // {
check = builtins.isFunction;
description = "valid Nixpkgs overlay";
});
systemType = types.enum config.supportedSystems;
flakeType = with types; (addCheck attrs lib.isStorePath) // {
description = "nix flake";
};
# Apply maybeImport during merge and before check
# To simplify apply keys and improve type checking
pathTo = elemType: with types; coercedTo path maybeImport elemType;
# Accepts single item or a list
# apply keys end up with a list
# This should not be used if expecting a nested list
# all lists will get flattened by this
coercedListOf = elemType:
let coerceToList = x: flatten (singleton x); in
with types; coercedTo elemType coerceToList (listOf elemType);
pathToListOf = x: pathTo (coercedListOf x);
/* Submodules needed for API containers */
channelsModule = {
options = with types; {
input = mkOption {
type = flakeType;
default = nixos;
description = ''
nixpkgs flake input to use for this channel
'';
};
overlays = mkOption {
type = pathToListOf overlayType;
default = [ ];
description = ''
overlays to apply to this channel
these will get exported under the 'overlays' flake output as <channel>/<name>
'';
};
externalOverlays = mkOption {
type = pathToListOf overlayType;
default = [ ];
description = ''
overlays to apply to the channel that don't get exported to the flake output
useful to include overlays from inputs
'';
};
config = mkOption {
type = pathTo attrs;
default = { };
description = ''
nixpkgs config for this channel
'';
};
};
};
hostModule = {
options = with types; {
system = mkOption {
type = systemType;
default = "x86_64-linux";
description = ''
system for this host
'';
};
channelName = mkOption {
type = types.enum (builtins.attrValues config.channels);
default = "nixpkgs";
description = ''
Channel this host should follow
'';
};
};
};
# This is only needed for hostDefaults
# modules in each host don't get exported
externalModulesModule = {
options = {
externalModules = mkOption {
type = pathToListOf moduleType;
default = [ ];
description = ''
The configuration for this host
'';
};
};
};
modulesModule = {
options = {
modules = mkOption {
type = pathToListOf moduleType;
default = [ ];
description = ''
modules to include
'';
};
};
};
# Home-manager's configs get exported automatically from nixos.hosts
# So there is no need for a host options in the home namespace
# This is only needed for nixos
includeHostsModule = { name, ... }: {
options = with types; {
hostDefaults = mkOption {
type = submodule [ hostModule externalModulesModule modulesModule ];
default = { };
description = ''
Defaults for all hosts.
the modules passed under hostDefaults will be exported
to the '${name}Modules' flake output.
They will also be added to all hosts.
'';
};
hosts = mkOption {
type = attrsOf (submodule [ hostModule modulesModule ]);
default = { };
description = ''
configurations to include in the ${name}Configurations output
'';
};
};
};
# profiles and suites - which are profile collections
profilesModule = { name, ... }: {
options = with types; {
profiles = mkOption {
type = coercedListOf path;
default = [ ];
apply = list:
# Merge a list of profiles to one set
let profileList = map (x: os.mkProfileAttrs (toString x)) list; in
foldl (a: b: a // b) { } profileList;
description = "path to profiles folder that can be collected into suites";
};
suites = mkOption {
type = pathTo (functionTo attrs);
default = _: { };
apply = suites: os.mkSuites {
inherit suites;
inherit (config) profiles;
};
description = ''
Function with the input of 'profiles' that returns an attribute set
with the suites for this config system.
These can be accessed through the 'suites' special argument.
'';
};
};
};
in
{
options = with types; {
self = mkOption {
type = flakeType;
description = "The flake to create the devos outputs for";
};
supportedSystems = mkOption {
type = listOf str;
default = lib.defaultSystems;
description = ''
The systems supported by this flake
'';
};
channels =
let
default = {
nixpkgs = {
input = nixos;
};
};
in
mkOption {
type = attrsOf (submodule channelsModule);
inherit default;
apply = x: default // x;
description = ''
nixpkgs channels to create
'';
};
os = mkOption {
type = submodule [ includeHostsModule profilesModule ];
default = { };
description = ''
hosts, modules, suites, and profiles for nixos
'';
};
home = mkOption {
type = submodule [ profilesModule modulesModule ];
default = { };
description = ''
hosts, modules, suites, and profiles for home-manager
'';
};
};
};
in
lib.evalModules {
modules = [ argOpts args ];
}