Dream2Nix

https://dream2nix.dev/
Admin
Dream2Nix is a modular framework for automated and reproducible packaging solutions across various...
Tokens:18,504
Snippets:130
Trust Score:6.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### PHP Composer Package Management with Dream2Nix

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Build PHP projects with Composer-based dependency resolution using Dream2Nix. This example demonstrates how to define project dependencies, build phases, and installation steps for a PHP application.

```nix
{
  dream2nix,
  pkgs,
  ...
}: {
  imports = [
    dream2nix.modules.dream2nix.php-composer-lock
  ];

  name = "my-php-app";
  version = "3.1.0";

  paths = {
    projectRoot = ./.;
    lockFile = ./composer.lock;
  };

  deps.stdenv = pkgs.stdenv;

  mkDerivation = {
    src = ./.;
    buildInputs = [
      pkgs.php82
      pkgs.php82Packages.composer
    ];

    buildPhase = ''
      composer install --no-dev --optimize-autoloader
    '';

    installPhase = ''
      mkdir -p $out/share/php/my-app
      cp -r * $out/share/php/my-app/
    '';

    checkPhase = ''
      php vendor/bin/phpunit tests/
    '';

    doCheck = true;
  };

  env.PHP_VERSION = "8.2";
}
```

--------------------------------

### Nix mkDerivation Build Phase Hooks

Source: https://dream2nix.dev/options_option=overrides.%3Cname%3E.buildPythonPackage

Allows execution of custom commands during specific phases of the Nix build lifecycle. This includes phases like unpacking, configuring, building, and installing. Examples include `preConfigurePhases`, `postPatch`, and `preInstallPhases`.

```nix
overrides.myPackage.mkDerivation.preConfigurePhases = [ "myCustomConfigurePhase" ];
myCustomConfigurePhase = ''
  echo "Running custom configure phase"
'';
```

```nix
overrides.myPackage.mkDerivation.postPatch = ''
  echo "Patching complete"
'';
```

```nix
overrides.myPackage.mkDerivation.preInstallPhases = [ "myCustomInstallPhase" ];
myCustomInstallPhase = ''
  echo "Running custom install phase"
'';
```

--------------------------------

### Environment Variables and Build Flags in Nix Derivations

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Configure environment variables and build flags across all derivations using Dream2Nix. This example demonstrates how to set compiler flags, dependency paths, and other environment settings for a Nix build.

```nix
{
  dream2nix,
  pkgs,
  ...
}: {
  name = "native-app";

  env = {
    CC = "${pkgs.gcc}/bin/gcc";
    CXX = "${pkgs.gcc}/bin/g++";
    PKG_CONFIG_PATH = "${pkgs.openssl.dev}/lib/pkgconfig";
    RUST_BACKTRACE = "1";
    DATABASE_URL = "postgresql://localhost/devdb";
  };

  mkDerivation = {
    cmakeFlags = [
      "-DCMAKE_BUILD_TYPE=Release"
      "-DENABLE_TESTS=ON"
    ];

    configureFlags = [
      "--enable-optimizations"
      "--with-openssl=${pkgs.openssl.dev}"
    ];

    makeFlags = [
      "PREFIX=$(out)"
      "VERBOSE=1"
    ];

    hardeningEnable = ["fortify" "pie"];
    hardeningDisable = ["strictoverflow"];

    enableParallelBuilding = true;
    enableParallelChecking = true;

    buildInputs = [pkgs.openssl pkgs.postgresql];
    nativeBuildInputs = [pkgs.cmake pkgs.pkg-config];

    strictDeps = true;
  };
}
```

--------------------------------

### Node.js Granular Package Installation and Overrides

Source: https://dream2nix.dev/options_option=nodejs-devshell.nodeModules.nodejs-granular.overrideAll

Defines methods for installing Node.js packages granularly and provides options to override all aspects of the installation process. This includes managing dependency resolution, lock file content, and external script execution.

```nix
nodejs-devshell.nodeModules.nodejs-granular.installMethod
nodejs-devshell.nodeModules.nodejs-granular.overrideAll
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.deps
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.deps.stdenv
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.env
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.content
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.extraScripts
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.fields
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.fields.<name>.default
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.fields.<name>.script
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.invalidationData
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.isValid
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.lib.computeFODHash
nodejs-devshell.nodeModules.nodejs-granular.overrideAll.lock.refresh
```

--------------------------------

### Nix: Customizing Build Phases with Hooks

Source: https://context7.com/context7/dream2nix_dev/llms.txt

This Nix snippet demonstrates overriding standard build phases (preUnpack, patchPhase, preConfigure, configurePhase, preBuild, buildPhase, checkPhase, preInstall, postInstall, preFixup, postFixup) within a `mkDerivation` context. It includes examples of shell commands for file manipulation, configuration, downloading resources, compilation, testing, and managing runtime dependencies. These hooks allow for fine-grained control over the build process, essential for complex projects.

```nix
{
  dream2nix,
  pkgs,
  ...:
}: {
  name = "complex-build";

  mkDerivation = {
    src = ./.;

    preUnpack = ''
      echo "Preparing to unpack source..."
      export SOURCE_DATE_EPOCH=0
    '';

    patchPhase = ''
      substituteInPlace Makefile \
        --replace "/usr/bin" "${pkgs.coreutils}/bin"

      patchShebangs scripts/
    '';

    preConfigure = ''
      # Generate build configuration
      python3 scripts/configure.py --prefix=$out
    '';

    configurePhase = ''
      ./configure \
        --prefix=$out \
        --sysconfdir=$out/etc \
        --enable-feature-x
    '';

    preBuild = ''
      # Download build-time resources
      curl -o data.json https://example.com/build-data.json
    '';

    buildPhase = ''
      make -j$NIX_BUILD_CORES all
    '';

    doCheck = true;
    checkPhase = ''
      make test
      ./integration-tests.sh
    '';

    preInstall = ''
      mkdir -p $out/share/data
    '';

    postInstall = ''
      # Install additional files
      cp -r configs $out/etc/
      ln -s $out/bin/app $out/bin/app-cli
    '';

    preFixup = ''
      # Wrap binaries with runtime dependencies
      for prog in $out/bin/*; do
        wrapProgram $prog \
          --prefix PATH : ${pkgs.lib.makeBinPath [pkgs.git]}
      done
    '';

    postFixup = ''
      # Remove unnecessary files
      find $out -name "*.pyc" -delete
    '';
  };
}

```

--------------------------------

### Dream2nix mkDerivation Configuration Options

Source: https://dream2nix.dev/options_option=overrides&option_scope=40&scope=WIP-nodejs-builder-v3

This section lists and describes various configuration options for the `mkDerivation` function in dream2nix. These options control aspects like build dependencies, build phases, installation, and source handling. They are essential for customizing how packages are built and managed.

```nix
mkDerivation.depsBuildBuildPropagated
mkDerivation.depsBuildTarget
mkDerivation.depsBuildTargetPropagated
mkDerivation.depsHostHost
mkDerivation.depsHostHostPropagated
mkDerivation.depsTargetTarget
mkDerivation.depsTargetTargetPropagated
mkDerivation.disallowedReferences
mkDerivation.disallowedRequisites
mkDerivation.distFlags
mkDerivation.distPhase
mkDerivation.distTarget
mkDerivation.doCheck
mkDerivation.doDist
mkDerivation.doInstallCheck
mkDerivation.dontAddDisableDepTrack
mkDerivation.dontAddPrefix
mkDerivation.dontAddStaticConfigureFlags
mkDerivation.dontBuild
mkDerivation.dontConfigure
mkDerivation.dontCopyDist
mkDerivation.dontDisableStatic
mkDerivation.dontFixLibtool
mkDerivation.dontFixup
mkDerivation.dontInstall
mkDerivation.dontMakeSourcesWritable
mkDerivation.dontMoveBin
mkDerivation.dontPatch
mkDerivation.dontPatchELF
mkDerivation.dontPatchShebangs
mkDerivation.dontPruneLibtoolFiles
mkDerivation.dontStrip
mkDerivation.dontStripHost
mkDerivation.dontStripTarget
mkDerivation.dontUnpack
mkDerivation.enableParallelBuilding
mkDerivation.enableParallelChecking
mkDerivation.exportReferenceGraph
mkDerivation.fixupPhase
mkDerivation.forceShare
mkDerivation.hardeningDisable
mkDerivation.hardeningEnable
mkDerivation.impureEnvVars
mkDerivation.installCheckFlags
mkDerivation.installCheckInputs
mkDerivation.installCheckPhase
mkDerivation.installCheckTarget
mkDerivation.installFlags
mkDerivation.installPhase
mkDerivation.installTargets
mkDerivation.makeFlags
mkDerivation.makefile
mkDerivation.mesonFlags
mkDerivation.meta
mkDerivation.nativeBuildInputs
mkDerivation.nativeCheckInputs
mkDerivation.outputHash
mkDerivation.outputHashAlgo
mkDerivation.outputHashMode
mkDerivation.outputs
mkDerivation.passAsFile
mkDerivation.passthru
mkDerivation.patchFlags
mkDerivation.patchPhase
mkDerivation.patches
mkDerivation.phases
mkDerivation.pos
mkDerivation.postBuild
mkDerivation.postCheck
mkDerivation.postConfigure
mkDerivation.postDist
mkDerivation.postFixup
mkDerivation.postInstalCheck
mkDerivation.postInstall
mkDerivation.postPatch
mkDerivation.postPhases
mkDerivation.postUnpack
mkDerivation.preBuild
mkDerivation.preBuildPhases
mkDerivation.preCheck
mkDerivation.preConfigure
mkDerivation.preConfigurePhases
mkDerivation.preDist
mkDerivation.preDistPhases
mkDerivation.preFixup
mkDerivation.preFixupPhases
mkDerivation.preInstall
mkDerivation.preInstallCheck
mkDerivation.preInstallPhases
mkDerivation.prePatch
mkDerivation.prePhases
mkDerivation.preUnpack
mkDerivation.preferLocalBuild
mkDerivation.prefix
mkDerivation.prefixKey
mkDerivation.propagatedBuildInputs
mkDerivation.propagatedNativeBuildInputs
mkDerivation.propagatedSandboxProfile
mkDerivation.realBuilder
mkDerivation.requiredSystemFeatures
mkDerivation.sandboxProfile
mkDerivation.separateDebugInfo
mkDerivation.setSourceRoot
mkDerivation.setupHook
mkDerivation.shellHook
mkDerivation.sourceRoot
mkDerivation.src
mkDerivation.srcs
mkDerivation.strictDeps
mkDerivation.stripAllFlags
mkDerivation.stripAllList
mkDerivation.stripDebugFlags
mkDerivation.stripDebugList
mkDerivation.tarballs
mkDerivation.unpackCmd
mkDerivation.unpackPhase
```

--------------------------------

### Nix mkDerivation Override Hooks

Source: https://dream2nix.dev/options_option=overrides.%3Cname%3E.buildPythonPackage

Defines actions to be executed at various stages of the Nix build process for a derivation. These hooks allow for customization before or after unpacking, patching, building, or installing. Examples include `postInstall`, `preBuild`, and `shellHook`.

```nix
overrides.myPackage.mkDerivation.postInstall = ''
  echo "Installation complete"
'';
```

```nix
overrides.myPackage.mkDerivation.preBuild = ''
  echo "Starting build..."
'';
```

```nix
overrides.myPackage.mkDerivation.shellHook = ''
  export MY_VAR="some_value"
'';
```

--------------------------------

### Example of Defining Node.js Dependencies

Source: https://dream2nix.dev/options_option=nodejs-devshell.nodeModules.nodejs-granular.overrideAll

An example Nix configuration demonstrating how to define dependencies for Node.js packages within a devshell. It shows inheriting attributes like `stdenv` and `pandoc` from `nixpkgs.haskellPackages`, illustrating the concept of overridable dependency injection.

```nix
{nixpkgs, ...}:
{
  inherit (nixpkgs) stdenv;
  inherit (nixpkgs.haskellPackages) pandoc;
}
```

--------------------------------

### Handle Python Dependencies with pip

Source: https://dream2nix.dev/options_option=preBuild&option_scope=1&scope=buildPythonPackage-mixin

The `pip` module is specifically designed for managing Python package installations using `pip`. It integrates with Nix to ensure that Python packages installed via `pip` are properly managed and reproducible. Options like `permitUserSite` control the installation scope.

```nix
pip { ... }

```

--------------------------------

### Create Node.js Dev Shell w/ Granular Dependencies in dream2nix

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Create isolated Node.js development environments with granular dependencies using `nodejs-devshell-v3` within dream2nix. This setup defines project paths, lock file locations, and dependency overrides. It needs nixpkgs for Node.js.

```nix
{
  dream2nix,
  pkgs,
  ...
}: {
  imports = [
    dream2nix.modules.dream2nix.nodejs-devshell-v3
  ];

  name = "my-webapp-devshell";

  paths = {
    projectRoot = ./.;
    lockFile = ./package-lock.json;
  };

  nodejs-devshell-v3.nodeModules = {
    nodejs-granular-v3 = {
      overrideAll = {
        mkDerivation.doCheck = false;
        env.NODE_ENV = "development";
      };

      overrides."react" = {
        mkDerivation.buildPhase = ''
          npm run build
        '';
      };
    };

    lock.fields = {
      npmrc.default = ''
        registry=https://registry.npmjs.org/
        //registry.npmjs.org/:_authToken=\${NPM_TOKEN}
      '';
    };
  };

  mkDerivation = {
    shellHook = ''
      export PATH="$PWD/node_modules/.bin:$PATH"
      echo "Development shell ready"
    '';
    buildInputs = [pkgs.nodejs-18_x];
  };
}

```

--------------------------------

### Python PDM Project Configuration with Dream2Nix

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Use PDM (Python Development Master) for modern Python project management with Dream2Nix. This example shows how to configure a Python project with PDM, including dependency management, build phases, and testing.

```nix
{
  dream2nix,
  pkgs,
  ...
}: {
  imports = [
    dream2nix.modules.dream2nix.python-pdm
  ];

  name = "ml-project";
  version = "0.5.0";

  deps.python = pkgs.python311;

  buildPythonPackage = {
    format = "pyproject";
    build-system = ["pdm-backend"];
    dependencies = [
      "pandas"
      "scikit-learn"
      "torch"
    ];
    optional-dependencies = {
      gpu = ["cupy"];
    };
  };

  mkDerivation = {
    src = ./.;
    buildInputs = [pkgs.pdm];
    nativeBuildInputs = [pkgs.python311Packages.setuptools];

    buildPhase = ''
      pdm install --prod
      pdm build
    '';

    checkPhase = ''
      pdm run pytest
    '';
  };

  paths.lockFile = ./pdm.lock;
}
```

--------------------------------

### Nix: Example Usage of overrideAll

Source: https://dream2nix.dev/options_option=overrideAll&option_scope=38&scope=WIP-groups

An example demonstrating how to use the `overrideAll` module in dream2nix to modify build settings. This specific example disables the 'doCheck' option for `mkDerivation`, which is a common way to alter build behavior for all dependencies managed by dream2nix.

```nix
{
  mkDerivation = {
    doCheck = false;
  };
}

```

--------------------------------

### Python Package Building: permitUserSite Option

Source: https://dream2nix.dev/options_option=permitUserSite&option_scope=1&scope=buildPythonPackage-mixin

The `permitUserSite` option for `buildPythonPackage-mixin` controls whether the `PYTHONNOUSERSITE` environment variable is set in wrapped Python programs. This allows or disallows Python packages to be installed in the user's site-packages directory.

```nix
{
  # Skip setting the PYTHONNOUSERSITE environment variable in wrapped programs
  permitUserSite =...
}

```

--------------------------------

### Nixpkgs Path Package Configuration

Source: https://dream2nix.dev/options_option=nodejs-granular.overrideAll.mkDerivation

Specifies the directory where Node.js packages are installed or managed by dream2nix.

```nix
nodejs-granular.overrideAll.paths.package = "string";
```

--------------------------------

### Nix: Configure mkDerivation overrides for php-granular dependencies

Source: https://dream2nix.dev/options_option=php-granular

This Nix configuration allows defining custom build phases and actions for individual dependencies. It provides extensive control over steps like patching, building, checking, and installing packages by specifying attributes within the `mkDerivation` set. These overrides are applied only to dependencies that match a specific name.

```nix
php-granular.overrides.<name>.mkDerivation.patches
php-granular.overrides.<name>.mkDerivation.phases
php-granular.overrides.<name>.mkDerivation.pos
php-granular.overrides.<name>.mkDerivation.postBuild
php-granular.overrides.<name>.mkDerivation.postCheck
php-granular.overrides.<name>.mkDerivation.postConfigure
php-granular.overrides.<name>.mkDerivation.postDist
php-granular.overrides.<name>.mkDerivation.postFixup
php-granular.overrides.<name>.mkDerivation.postInstalCheck
php-granular.overrides.<name>.mkDerivation.postInstall
php-granular.overrides.<name>.mkDerivation.postPatch
php-granular.overrides.<name>.mkDerivation.postPhases
php-granular.overrides.<name>.mkDerivation.postUnpack
php-granular.overrides.<name>.mkDerivation.preBuild
php-granular.overrides.<name>.mkDerivation.preBuildPhases
php-granular.overrides.<name>.mkDerivation.preCheck
php-granular.overrides.<name>.mkDerivation.preConfigure
php-granular.overrides.<name>.mkDerivation.preConfigurePhases
php-granular.overrides.<name>.mkDerivation.preDist
php-granular.overrides.<name>.mkDerivation.preDistPhases
php-granular.overrides.<name>.mkDerivation.preFixup
php-granular.overrides.<name>.mkDerivation.preFixupPhases
php-granular.overrides.<name>.mkDerivation.preInstall
php-granular.overrides.<name>.mkDerivation.preInstallCheck
php-granular.overrides.<name>.mkDerivation.preInstallPhases
php-granular.overrides.<name>.mkDerivation.prePatch
php-granular.overrides.<name>.mkDerivation.prePhases
php-granular.overrides.<name>.mkDerivation.preUnpack
php-granular.overrides.<name>.mkDerivation.preferLocalBuild
php-granular.overrides.<name>.mkDerivation.prefix
php-granular.overrides.<name>.mkDerivation.prefixKey
php-granular.overrides.<name>.mkDerivation.propagatedBuildInputs
php-granular.overrides.<name>.mkDerivation.propagatedNativeBuildInputs
php-granular.overrides.<name>.mkDerivation.propagatedSandboxProfile
php-granular.overrides.<name>.mkDerivation.realBuilder
php-granular.overrides.<name>.mkDerivation.requiredSystemFeatures
php-granular.overrides.<name>.mkDerivation.sandboxProfile
php-granular.overrides.<name>.mkDerivation.separateDebugInfo
php-granular.overrides.<name>.mkDerivation.setSourceRoot
php-granular.overrides.<name>.mkDerivation.setupHook
php-granular.overrides.<name>.mkDerivation.shellHook
php-granular.overrides.<name>.mkDerivation.sourceRoot
php-granular.overrides.<name>.mkDerivation.src
php-granular.overrides.<name>.mkDerivation.srcs
php-granular.overrides.<name>.mkDerivation.strictDeps
php-granular.overrides.<name>.mkDerivation.stripAllFlags
php-granular.overrides.<name>.mkDerivation.stripAllList
php-granular.overrides.<name>.mkDerivation.stripDebugFlags
php-granular.overrides.<name>.mkDerivation.stripDebugList
php-granular.overrides.<name>.mkDerivation.tarballs
php-granular.overrides.<name>.mkDerivation.unpackCmd
php-granular.overrides.<name>.mkDerivation.unpackPhase
```

```nix
{
  hello = {
    mkDerivation = {
      postPatch = ''
        substituteInPlace Makefile --replace /usr/local /usr
      '';
    };
  };
}
```

--------------------------------

### Nix Override: mkDerivation Phases

Source: https://dream2nix.dev/options_option=overrideAll&option_scope=33&scope=python-pdm

These Nix override attributes allow you to hook into specific phases of the mkDerivation build process. They enable custom actions before or after standard build steps like unpacking, patching, configuring, building, or installing. Usage typically involves defining shell scripts or commands to be executed within the Nix build environment.

```nix
overrides.<name>.mkDerivation.postInstall
overrides.<name>.mkDerivation.postPatch
overrides.<name>.mkDerivation.postPhases
overrides.<name>.mkDerivation.postUnpack
overrides.<name>.mkDerivation.preBuild
overrides.<name>.mkDerivation.preBuildPhases
overrides.<name>.mkDerivation.preCheck
overrides.<name>.mkDerivation.preConfigure
overrides.<name>.mkDerivation.preConfigurePhases
overrides.<name>.mkDerivation.preDist
overrides.<name>.mkDerivation.preDistPhases
overrides.<name>.mkDerivation.preFixup
overrides.<name>.mkDerivation.preFixupPhases
overrides.<name>.mkDerivation.preInstall
overrides.<name>.mkDerivation.preInstallCheck
overrides.<name>.mkDerivation.preInstallPhases
overrides.<name>.mkDerivation.prePatch
overrides.<name>.mkDerivation.prePhases
overrides.<name>.mkDerivation.preUnpack
```

--------------------------------

### Nix: shellHook Declaration in mkDerivation-mixin

Source: https://dream2nix.dev/options_option=shellHook&option_scope=12&scope=mkDerivation-mixin

The `shellHook` option in dream2nix's `mkDerivation-mixin` allows for custom shell commands to be executed during the build process. It accepts either a null value or a string containing the shell commands. This is useful for environment setup or custom build steps within the Nix derivation.

```nix
null
```

--------------------------------

### Dream2nix Modules and Options

Source: https://dream2nix.dev/options_option=postInstall&option_scope=1&scope=buildPythonPackage-mixin

This section provides details on the various modules and configuration options available within dream2nix, including build system integrations and package management features.

```APIDOC
## POST /websites/dream2nix_dev/modules

### Description
This endpoint provides access to the dream2nix modules and their associated configuration options.

### Method
GET

### Endpoint
/websites/dream2nix_dev/modules

### Parameters

#### Query Parameters
- **module_name** (string) - Optional - Filter modules by name.
- **option_name** (string) - Optional - Filter options by name.

### Request Example
```json
{
  "query": {
    "module_name": "buildPythonPackage-mixin",
    "option_name": "postInstall"
  }
}
```

### Response
#### Success Response (200)
- **modules** (array) - List of available modules and their options.
  - **name** (string) - The name of the module.
  - **options** (array) - List of configuration options for the module.
    - **name** (string) - The name of the option.
    - **description** (string) - A description of the option.
    - **type** (string) - The data type of the option.
    - **default** (any) - The default value of the option.
    - **declarations** (string) - Links to declarations for the option.

#### Response Example
```json
{
  "modules": [
    {
      "name": "buildPythonPackage-mixin",
      "options": [
        {
          "name": "postInstall",
          "description": "This option has no description.",
          "type": "null or string",
          "default": null,
          "declarations": "https://github.com/nix-community/dream2nix/blob/main/modules/dream2nix/mkDerivation-mixin/interface.nix"
        }
      ]
    }
  ]
}
```
```

--------------------------------

### mkDerivation Mixin Options

Source: https://dream2nix.dev/options_option=postBuild&option_scope=12&scope=mkDerivation-mixin

Details on options available within the mkDerivation-mixin scope, including postBuild.

```APIDOC
## POST /api/mkDerivation-mixin/postBuild

### Description
This option has no description.

### Method
POST

### Endpoint
/api/mkDerivation-mixin/postBuild

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **postBuild** (null or string) - Optional - The value for the postBuild option.

### Request Example
```json
{
  "postBuild": null
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the successful update of the postBuild option.

#### Response Example
```json
{
  "message": "postBuild option updated successfully."
}
```
```

--------------------------------

### Set Up Development Environments with nodejs-devshell

Source: https://dream2nix.dev/options_option=preBuild&option_scope=1&scope=buildPythonPackage-mixin

The `nodejs-devshell` module helps create reproducible development shells for Node.js projects. It leverages `package.json` and lock files to ensure consistent environments for development and testing. Different versions like `nodejs-devshell-v3` are available.

```nix
nodejs-devshell { ... }

```

--------------------------------

### mkDerivation-mixin Module Options

Source: https://dream2nix.dev/options_option=preCheck&option_scope=12&scope=mkDerivation-mixin

Documentation for the options within the mkDerivation-mixin module, which influences how derivations are constructed.

```APIDOC
## mkDerivation-mixin Module

### Description
This module provides a set of options for customizing the `mkDerivation` function within dream2nix.

### Options

#### `preCheck`

*   **Description**: This option has no description.
*   **Type**: `null or string`
*   **Default**: `null`
*   **Scope**: `mkDerivation-mixin`
*   **Declarations**: [https://github.com/nix-community/dream2nix/blob/main/modules/dream2nix/mkDerivation-mixin/interface.nix](https://github.com/nix-community/dream2nix/blob/main/modules/dream2nix/mkDerivation-mixin/interface.nix)

#### `__contentAddressed`

*   **Description**: Whether to make the output content-addressed.
*   **Type**: `boolean`
*   **Default**: `true`

#### `__darwinAllowLocalNetworking`

*   **Description**: Whether to allow local networking on Darwin.
*   **Type**: `boolean`
*   **Default**: `false`

#### `__impureHostDeps`

*   **Description**: Whether to allow impure host dependencies.
*   **Type**: `boolean`
*   **Default**: `false`

#### `__propagatedImpureHostDeps`

*   **Description**: Whether to allow propagated impure host dependencies.
*   **Type**: `boolean`
*   **Default**: `false`

#### `__structuredAttrs`

*   **Description**: Whether to use structured attributes.
*   **Type**: `boolean`
*   **Default**: `false`

#### `allowSubstitutes`

*   **Description**: Whether to allow substitutes for dependencies.
*   **Type**: `boolean`
*   **Default**: `true`

#### `allowedReferences`

*   **Description**: List of allowed references.
*   **Type**: `list`
*   **Default**: `[]`

#### `allowedRequisites`

*   **Description**: List of allowed requisites.
*   **Type**: `list`
*   **Default**: `[]`

#### `args`

*   **Description**: Additional arguments to pass to the builder.
*   **Type**: `list`
*   **Default**: `[]`

#### `buildFlags`

*   **Description**: Flags to pass to the build system.
*   **Type**: `list`
*   **Default**: `[]`

#### `buildInputs`

*   **Description**: Build-time dependencies.
*   **Type**: `list`
*   **Default**: `[]`

#### `buildPhase`

*   **Description**: Custom build phase script.
*   **Type**: `string`
*   **Default**: `null`

#### `builder`

*   **Description**: The builder to use (e.g., `/nix/store/...-stdenv/setup`).
*   **Type**: `string`
*   **Default**: `"/nix/store/89z2m71j8z759x0f0d6wz51r01y46362-bash-interactive-5.2.021/bin/bash"

```

--------------------------------

### Public Interface Documentation

Source: https://dream2nix.dev/options_option=public&option_scope=12&scope=mkDerivation-mixin

Documentation for the `public` interface in dream2nix, which represents the final package derivation.

```APIDOC
## GET /websites/dream2nix_dev/modules/public

### Description
Documentation for the `public` interface in dream2nix, which represents the final package derivation. This interface contains all fields that Nix expects from a derivation, such as name, outputs, drvPath, and outPath. It can be built using `nix-build` or `nix build`.

### Method
GET

### Endpoint
/websites/dream2nix_dev/modules/public

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **name** (string) - The name of the package.
- **outputs** (attribute set) - A set of outputs for the derivation.
- **drvPath** (path) - The path to the derivation file.
- **outPath** (path) - The path to the output of the derivation.

#### Response Example
```json
{
  "name": "example-package",
  "outputs": {
    "out": {
      "path": "/nix/store/abcdef...-example-package"
    }
  },
  "drvPath": "/nix/store/abcdef...-example-package.drv",
  "outPath": "/nix/store/abcdef...-example-package"
}
```
```

--------------------------------

### Nix mkDerivation Mixin for Pre-Distribution Phases

Source: https://dream2nix.dev/options_option=preDistPhases&option_scope=12&scope=mkDerivation-mixin

This snippet documents the `preDistPhases` option within the `mkDerivation-mixin` module of dream2nix. It specifies that this option is intended for actions to be performed before the distribution phase of a Nix derivation. The option accepts a list of anything and defaults to null.

```nix
{
  preDistPhases = null; # or a list of phases
}
```

--------------------------------

### outputHash Configuration

Source: https://dream2nix.dev/options_option=outputHash&option_scope=1&scope=buildPythonPackage-mixin

Details the configuration options for the `outputHash` setting within dream2nix modules, including its scope, description, type, and default value.

```APIDOC
## `outputHash`

### Description
This option has no description.

### Method
N/A (Configuration Option)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```json
{
  "outputHash": "sha256:1234abcd..."
}
```

### Response
#### Success Response (200)
N/A (This is a configuration option, not an endpoint)

#### Response Example
```json
{
  "outputHash": "sha256:1234abcd..."
}
```

### Additional Information
- **Scope**: `buildPythonPackage-mixin`
- **Type**: `null or string`
- **Default**: `null`
- **Documentation Link**: https://github.com/nix-community/dream2nix/blob/main/modules/dream2nix/mkDerivation-mixin/interface.nix
```

--------------------------------

### Configure Python Package Bytecode Removal (Dream2Nix)

Source: https://dream2nix.dev/options_option=overrides.%3Cname%3E.buildPythonPackage

Controls whether bytecode is removed from the bin folder for Python packages. This is relevant for packages that generate bytecode for executables with extensions, ensuring a cleaner installation. Configured via the `removeBinBytecode` option within `buildPythonPackage` overrides.

```nix
overrides.myPythonPackage.buildPythonPackage.removeBinBytecode = true;
```

--------------------------------

### Multi-Derivation Package with Multiple Outputs in Nix

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Create packages with multiple outputs (bins, libs, docs) using the multi-derivation pattern in Nix.  This enables separation of concerns and organization of different types of build products.

```nix
{
  dream2nix,
  pkgs,
  lib,
  ...
}: {
  imports = [
    dream2nix.modules.dream2nix.multi-derivation-package
  ];

  name = "full-stack-app";
  version = "1.5.2";

  mkDerivation = {
    outputs = ["out" "dev" "doc"];

    buildPhase = ''
      # Build main application
      cargo build --release

      # Build documentation
      cargo doc --no-deps

      # Build development tools
      cargo build --bin devtools
    '';

    installPhase = ''
      mkdir -p $out/bin $dev/bin $doc/share/doc

      install -Dm755 target/release/app $out/bin/
      install -Dm755 target/release/devtools $dev/bin/
      cp -r target/doc $doc/share/doc/app/
    '';

    postInstall = ''
      wrapProgram $out/bin/app \
        --prefix PATH : ${lib.makeBinPath [pkgs.git pkgs.curl]}
    '';
  };

  public.docs = "$doc/share/doc/app/index.html";
}
```

--------------------------------

### Manage Node.js Dependencies with nodejs-package-json

Source: https://dream2nix.dev/options_option=preBuild&option_scope=1&scope=buildPythonPackage-mixin

The `nodejs-package-json` module facilitates building Node.js projects by integrating with `package.json`. It handles dependencies specified in `package.json` and `package-lock.json`. Options like `nodejs-granularity` control how dependencies are bundled.

```nix
nodejs-package-json { ... }

```

--------------------------------

### Configure Rust Package Build with buildRustPackage

Source: https://dream2nix.dev/options_option=preBuild&option_scope=1&scope=buildPythonPackage-mixin

The `buildRustPackage` module is used to build Rust packages within the Nix ecosystem. It allows for customization of build inputs, phases, and Rust-specific configurations such as `cargoFlags` and `rustDependencies`. The `outputHash` option is crucial for reproducible builds.

```nix
buildRustPackage { ... }

```

--------------------------------

### Configure Nix Derivations with prePhases in mkDerivation-mixin

Source: https://dream2nix.dev/options_option=prePhases&option_scope=12&scope=mkDerivation-mixin

The `prePhases` option in `mkDerivation-mixin` allows for custom actions to be executed before the standard build phases. It accepts a list of arbitrary expressions. This is useful for setting up specific build environments or performing pre-build tasks.

```nix
{
  options = {
    prePhases = {
      type = "null or (list of anything)";
      default = null;
      description = "This option has no description.";
    };
  };
  ...
}
```

--------------------------------

### Nix: Configure mkDerivation Build Options

Source: https://dream2nix.dev/options_option=overrides&option_scope=33&scope=python-pdm

These Nix attributes provide various options for customizing the mkDerivation build process, including local build preferences, build prefixes, dependency handling, and stripping flags.

```nix
overrides.<name>.mkDerivation.preferLocalBuild
overrides.<name>.mkDerivation.prefix
overrides.<name>.mkDerivation.prefixKey
overrides.<name>.mkDerivation.strictDeps
overrides.<name>.mkDerivation.stripAllFlags
overrides.<name>.mkDerivation.stripAllList
overrides.<name>.mkDerivation.stripDebugFlags
overrides.<name>.mkDerivation.stripDebugList
overrides.<name>.mkDerivation.tarballs
```

--------------------------------

### Define Nix Derivations with mkDerivation

Source: https://dream2nix.dev/options_option=preBuild&option_scope=1&scope=buildPythonPackage-mixin

The `mkDerivation` function is a core Nix primitive for defining derivations (packages). The `mkDerivation-mixin` module extends this by providing additional options like `preBuild`, `postInstall`, and various `dont*` flags to control build behavior, dependency handling, and phase execution. It supports multiple output types and complex build configurations.

```nix
mkDerivation {
  name = "my-package";
  version = "1.0";
  src = ./.;
  
  # Example of a mixin option
  preBuild = "echo 'About to build';";
  
  buildInputs = [ pkgs.zlib ];
  # ... other mkDerivation options
}

```

--------------------------------

### Nix mkDerivation Source Configuration

Source: https://dream2nix.dev/options_option=overrides.%3Cname%3E.buildPythonPackage

Specifies the source code for a Nix derivation. The `src` attribute is fundamental, and options like `setSourceRoot` and `unpackCmd` offer fine-grained control over how the source is handled and where the build should occur.

```nix
overrides.myPackage.mkDerivation.src = fetchurl { url = "http://example.com/source.tar.gz"; sha256 = "..."; };
```

```nix
overrides.myPackage.mkDerivation.setSourceRoot = "source";
```

```nix
overrides.myPackage.mkDerivation.unpackCmd = "tar -xzf $src";
```

--------------------------------

### Configure Python Package Build with buildPythonPackage

Source: https://dream2nix.dev/options_option=preBuild&option_scope=1&scope=buildPythonPackage-mixin

The `buildPythonPackage` module provides a Nix function to build Python packages. It accepts various arguments to customize the build process, including build inputs, phases, and Python-specific settings like `permitUserSite` and `ensurePip`. Dependencies are managed through `buildInputs` and `propagatedBuildInputs`.

```nix
buildPythonPackage { ... }

```

--------------------------------

### Build Rust Project with Crane in dream2nix

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Build Rust packages using the crane-based `rust-crane` module in dream2nix, enabling incremental compilation. This configuration specifies the project root, lock file, build profile, test commands, and dependencies. It requires nixpkgs for Rust and OpenSSL.

```nix
{
  dream2nix,
  config,
  ...
}: {
  imports = [
    dream2nix.modules.dream2nix.rust-crane
  ];

  name = "my-rust-cli";
  version = "0.2.1";

  paths = {
    projectRoot = ./.;
    projectRootFile = "Cargo.toml";
    lockFile = ./Cargo.lock;
  };

  rust-crane = {
    buildProfile = "release";
    buildFlags = ["--features" "advanced"];
    runTests = true;
    testCommand = "cargo test --all-features";
    testFlags = ["--" "--nocapture"];

    depsDrv = {
      mkDerivation.buildInputs = [pkgs.openssl];
      env.OPENSSL_DIR = "${pkgs.openssl.dev}";
    };
  };

  mkDerivation = {
    buildInputs = [pkgs.openssl pkgs.pkg-config];
    nativeBuildInputs = [pkgs.rustc pkgs.cargo];
    CARGO_BUILD_INCREMENTAL = "false";
    postInstall = ''
      installShellCompletion --bash completions/my-rust-cli.bash
    '';
  };

  deps.craneSource = sources.crane;
}

```

--------------------------------

### Build Python Package with dream2nix

Source: https://context7.com/context7/dream2nix_dev/llms.txt

Configure and build Python packages using the `buildPythonPackage` module within dream2nix, utilizing pip-based dependency management. This snippet defines package metadata, dependencies, and test configurations. It relies on nixpkgs for Python and build tools.

```nix
{
  dream2nix,
  config,
  lib,
  ...
}: {
  imports = [
    dream2nix.modules.dream2nix.pip
  ];

  name = "my-python-app";
  version = "1.0.0";

  deps.python = pkgs.python311;

  buildPythonPackage = {
    format = "pyproject";
    pyproject = true;
    dependencies = ["requests" "numpy"];
    optional-dependencies = {
      dev = ["pytest" "black"];
    };
    pythonImportsCheck = ["my_app"];
    pytestFlagsArray = ["-v" "tests/"];
    disabledTests = ["test_network_dependency"];
  };

  mkDerivation = {
    src = ./.;
    nativeBuildInputs = [pkgs.setuptools];
    doCheck = true;
  };

  pip = {
    buildDependencies = ["setuptools" "wheel"];
    flattenDependencies = true;
    ignoredDependencies = ["optional-lib"];
  };
}

```

--------------------------------

### Nixpkgs Override Name mkDerivation Allow Substitutes Configuration

Source: https://dream2nix.dev/options_option=nodejs-granular.overrideAll.mkDerivation

Determines whether to allow binary substitutes (pre-built binaries) for a specific override's mkDerivation in dream2nix.

```nix
nodejs-granular.overrides.<name>.mkDerivation.allowSubstitutes = true or false;
```

--------------------------------

### Nix Override: mkDerivation Build Inputs and Source

Source: https://dream2nix.dev/options_option=overrideAll&option_scope=33&scope=python-pdm

These Nix override attributes control the build inputs and source handling for mkDerivation. They allow specifying propagated build and native build inputs, defining preferred local builds, setting the source root, and customizing how source archives are unpacked. The `src` attribute is fundamental for defining the input source code.

```nix
overrides.<name>.mkDerivation.preferLocalBuild
overrides.<name>.mkDerivation.propagatedBuildInputs
overrides.<name>.mkDerivation.propagatedNativeBuildInputs
overrides.<name>.mkDerivation.setSourceRoot
overrides.<name>.mkDerivation.sourceRoot
overrides.<name>.mkDerivation.src
overrides.<name>.mkDerivation.srcs
unpackCmd
```

--------------------------------

### Nixpkgs mkDerivation Sources Configuration

Source: https://dream2nix.dev/options_option=nodejs-granular.overrideAll.mkDerivation

Specifies additional sources for Nixpkgs mkDerivation. This can be a list of files or directories to include.

```nix
nodejs-granular.overrideAll.mkDerivation.srcs = ["string or path"];
```

--------------------------------

### Node.js Module Public Information and Version

Source: https://dream2nix.dev/options_option=nodejs-devshell-v3.nodeModules.mkDerivation

Specifies public-facing information and version details for Node.js modules managed by Dream2nix. This includes general public attributes and documentation paths.

```nix
nodejs-devshell-v3.nodeModules.nodejs-granular-v3.overrideAll.public
nodejs-devshell-v3.nodeModules.nodejs-granular-v3.overrideAll.public.docs
nodejs-devshell-v3.nodeModules.nodejs-granular-v3.overrideAll.version
```

--------------------------------

### Nixpkgs mkDerivation Source Configuration

Source: https://dream2nix.dev/options_option=nodejs-granular.overrideAll.mkDerivation

Configures the source for Nixpkgs mkDerivation. This typically points to the main source archive or directory.

```nix
nodejs-granular.overrideAll.mkDerivation.src = "string or path";
```

--------------------------------

### Nix: Configure mkDerivation Pre-Build Hooks

Source: https://dream2nix.dev/options_option=overrides&option_scope=33&scope=python-pdm

These Nix attributes enable you to run custom commands before various stages of the mkDerivation build process. They are essential for setting up the build environment, applying initial patches, or configuring the build system.

```nix
overrides.<name>.mkDerivation.preBuild
overrides.<name>.mkDerivation.preBuildPhases
overrides.<name>.mkDerivation.preCheck
overrides.<name>.mkDerivation.preConfigure
overrides.<name>.mkDerivation.preConfigurePhases
overrides.<name>.mkDerivation.preDist
overrides.<name>.mkDerivation.preDistPhases
overrides.<name>.mkDerivation.preFixup
overrides.<name>.mkDerivation.preFixupPhases
overrides.<name>.mkDerivation.preInstall
overrides.<name>.mkDerivation.preInstallCheck
overrides.<name>.mkDerivation.preInstallPhases
overrides.<name>.mkDerivation.prePatch
overrides.<name>.mkDerivation.prePhases
overrides.<name>.mkDerivation.preUnpack
```

--------------------------------

### Define Project Root File in Nix

Source: https://dream2nix.dev/options_option=paths

Specifies the file name used to determine the project's root directory. This is essential for locating package definitions, especially for lock and update scripts. Ensure that the `paths.projectRoot` variable correctly points to a directory containing this file.

```nix
paths.projectRootFile = ".git";
```

--------------------------------

### Nix mkDerivation Build Behavior Configuration

Source: https://dream2nix.dev/options_option=overrides.%3Cname%3E.buildPythonPackage

Controls various aspects of the build process, including build directory, stripping debug information, and builder selection. Options like `sourceRoot`, `stripAllFlags`, and `realBuilder` allow for detailed customization.

```nix
overrides.myPackage.mkDerivation.sourceRoot = "src";
```

```nix
overrides.myPackage.mkDerivation.stripAllFlags = true;
```

```nix
overrides.myPackage.mkDerivation.realBuilder = pkgs.gcc.bin.gcc;
```

--------------------------------

### separateDebugInfo Module

Source: https://dream2nix.dev/options_option=separateDebugInfo&option_scope=1&scope=buildPythonPackage-mixin

Documentation for the `separateDebugInfo` option within the dream2nix modules, specifying its scope, type, and default value.

```APIDOC
## separateDebugInfo

### Description
This option has no description.

### Method
N/A (Configuration Option)

### Endpoint
N/A (Configuration Option)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A

### Additional Information
- **Scope**: `buildPythonPackage-mixin`
- **Declarations**: https://github.com/nix-community/dream2nix/blob/main/modules/dream2nix/mkDerivation-mixin/interface.nix
- **Type**: `null or boolean`
- **Default**: `null`
```
Tokens:
Raw