commit d3ba34c9e44f9ec1a7c379af15cf5e7662c0781e · pyrox.dev/nixpkgs

-9

nixos/modules/services/web-apps/plausible.md

···

       15
       15
        
       {

     

       16
       16
        
         services.plausible = {

     

       17
       17
        
           enable = true;

     

       18
       18
       -
           adminUser = {

     

       19
       19
       -
             # activate is used to skip the email verification of the admin-user that's

     

       20
       20
       -
             # automatically created by plausible. This is only supported if

     

       21
       21
       -
             # postgresql is configured by the module. This is done by default, but

     

       22
       22
       -
             # can be turned off with services.plausible.database.postgres.setup.

     

       23
       23
       -
             activate = true;

     

       24
       24
       -
             email = "admin@localhost";

     

       25
       25
       -
             passwordFile = "/run/secrets/plausible-admin-pwd";

     

       26
       26
       -
           };

     

       27
       18
        
           server = {

     

       28
       19
        
             baseUrl = "http://analytics.example.org";

     

       29
       20
        
             # secretKeybaseFile is a path to the file which contains the secret generated

+5 -47

nixos/modules/services/web-apps/plausible.nix

···

       11
       11
        
       

     

       12
       12
        
           package = mkPackageOption pkgs "plausible" { };

     

       13
       13
        
       

     

       14
       14
       -
           adminUser = {

     

       15
       15
       -
             name = mkOption {

     

       16
       16
       -
               default = "admin";

     

       17
       17
       -
               type = types.str;

     

       18
       18
       -
               description = ''

     

       19
       19
       -
                 Name of the admin user that plausible will created on initial startup.

     

       20
       20
       -
               '';

     

       21
       21
       -
             };

     

       22
       22
       -
       

     

       23
       23
       -
             email = mkOption {

     

       24
       24
       -
               type = types.str;

     

       25
       25
       -
               example = "admin@localhost";

     

       26
       26
       -
               description = ''

     

       27
       27
       -
                 Email-address of the admin-user.

     

       28
       28
       -
               '';

     

       29
       29
       -
             };

     

       30
       30
       -
       

     

       31
       31
       -
             passwordFile = mkOption {

     

       32
       32
       -
               type = types.either types.str types.path;

     

       33
       33
       -
               description = ''

     

       34
       34
       -
                 Path to the file which contains the password of the admin user.

     

       35
       35
       -
               '';

     

       36
       36
       -
             };

     

       37
       37
       -
       

     

       38
       38
       -
             activate = mkEnableOption "activating the freshly created admin-user";

     

       39
       39
       -
           };

     

       40
       40
       -
       

     

       41
       14
        
           database = {

     

       42
       15
        
             clickhouse = {

     

       43
       16
        
               setup = mkEnableOption "creating a clickhouse instance" // { default = true; };

     
···

       164
       137
        
       

     

       165
       138
        
         imports = [

     

       166
       139
        
           (mkRemovedOptionModule [ "services" "plausible" "releaseCookiePath" ] "Plausible uses no distributed Erlang features, so this option is no longer necessary and was removed")

     

       140
       140
       +
           (mkRemovedOptionModule [ "services" "plausible" "adminUser" "name" ] "Admin user is now created using first start wizard")

     

       141
       141
       +
           (mkRemovedOptionModule [ "services" "plausible" "adminUser" "email" ] "Admin user is now created using first start wizard")

     

       142
       142
       +
           (mkRemovedOptionModule [ "services" "plausible" "adminUser" "passwordFile" ] "Admin user is now created using first start wizard")

     

       143
       143
       +
           (mkRemovedOptionModule [ "services" "plausible" "adminUser" "activate" ] "Admin user is now created using first start wizard")

     

       167
       144
        
         ];

     

       168
       145
        
       

     

       169
       146
        
         config = mkIf cfg.enable {

     

       170
       170
       -
           assertions = [

     

       171
       171
       -
             { assertion = cfg.adminUser.activate -> cfg.database.postgres.setup;

     

       172
       172
       -
               message = ''

     

       173
       173
       -
                 Unable to automatically activate the admin-user if no locally managed DB for

     

       174
       174
       -
                 postgres (`services.plausible.database.postgres.setup') is enabled!

     

       175
       175
       -
               '';

     

       176
       176
       -
             }

     

       177
       177
       -
           ];

     

       178
       178
       -
       

     

       179
       147
        
           services.postgresql = mkIf cfg.database.postgres.setup {

     

       180
       148
        
             enable = true;

     

       181
       149
        
           };

     
···

       243
       211
        
                   # Home is needed to connect to the node with iex

     

       244
       212
        
                   HOME = "/var/lib/plausible";

     

       245
       213
        
       

     

       246
       246
       -
                   ADMIN_USER_NAME = cfg.adminUser.name;

     

       247
       247
       -
                   ADMIN_USER_EMAIL = cfg.adminUser.email;

     

       248
       248
       -
       

     

       249
       249
       -
                   DATABASE_SOCKET_DIR = cfg.database.postgres.socket;

     

       250
       250
       -
                   DATABASE_NAME = cfg.database.postgres.dbname;

     

       214
       214
       +
                   DATABASE_URL = "postgresql:///${cfg.database.postgres.dbname}?host=${cfg.database.postgres.socket}";

     

       251
       215
        
                   CLICKHOUSE_DATABASE_URL = cfg.database.clickhouse.url;

     

       252
       216
        
       

     

       253
       217
        
                   BASE_URL = cfg.server.baseUrl;

     
···

       270
       234
        
                   # even though we set `RELEASE_DISTRIBUTION=none` so the cookie should be unused.

     

       271
       235
        
                   # Thus, make a random one, which should then be ignored.

     

       272
       236
        
                   export RELEASE_COOKIE=$(tr -dc A-Za-z0-9 < /dev/urandom | head -c 20)

     

       273
       273
       -
                   export ADMIN_USER_PWD="$(< $CREDENTIALS_DIRECTORY/ADMIN_USER_PWD )"

     

       274
       237
        
                   export SECRET_KEY_BASE="$(< $CREDENTIALS_DIRECTORY/SECRET_KEY_BASE )"

     

       275
       238
        
       

     

       276
       239
        
                   ${lib.optionalString (cfg.mail.smtp.passwordFile != null)

     
···

       283
       246
        
       

     

       284
       247
        
                   ${cfg.package}/migrate.sh

     

       285
       248
        
                   export IP_GEOLOCATION_DB=${pkgs.dbip-country-lite}/share/dbip/dbip-country-lite.mmdb

     

       286
       286
       -
                   ${cfg.package}/bin/plausible eval "(Plausible.Release.prepare() ; Plausible.Auth.create_user(\"$ADMIN_USER_NAME\", \"$ADMIN_USER_EMAIL\", \"$ADMIN_USER_PWD\"))"

     

       287
       287
       -
                   ${optionalString cfg.adminUser.activate ''

     

       288
       288
       -
                     psql -d plausible <<< "UPDATE users SET email_verified=true where email = '$ADMIN_USER_EMAIL';"

     

       289
       289
       -
                   ''}

     

       290
       249
        
       

     

       291
       250
        
                   exec plausible start

     

       292
       251
        
                 '';

     
···

       297
       256
        
                   WorkingDirectory = "/var/lib/plausible";

     

       298
       257
        
                   StateDirectory = "plausible";

     

       299
       258
        
                   LoadCredential = [

     

       300
       300
       -
                     "ADMIN_USER_PWD:${cfg.adminUser.passwordFile}"

     

       301
       259
        
                     "SECRET_KEY_BASE:${cfg.server.secretKeybaseFile}"

     

       302
       260
        
                   ] ++ lib.optionals (cfg.mail.smtp.passwordFile != null) [ "SMTP_USER_PWD:${cfg.mail.smtp.passwordFile}"];

     

       303
       261
        
                 };

+3 -24

nixos/tests/plausible.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ pkgs, lib, ... }: {

     

       1
       1
       +
       import ./make-test-python.nix ({ lib, ... }: {

     

       2
       2
        
         name = "plausible";

     

       3
       3
       -
         meta = with lib.maintainers; {

     

       4
       4
       -
           maintainers = [ ];

     

       3
       3
       +
         meta = {

     

       4
       4
       +
           maintainers = lib.teams.cyberus.members;

     

       5
       5
        
         };

     

       6
       6
        
       

     

       7
       7
        
         nodes.machine = { pkgs, ... }: {

     

       8
       8
        
           virtualisation.memorySize = 4096;

     

       9
       9
        
           services.plausible = {

     

       10
       10
        
             enable = true;

     

       11
       11
       -
             adminUser = {

     

       12
       12
       -
               email = "admin@example.org";

     

       13
       13
       -
               passwordFile = "${pkgs.writeText "pwd" "foobar"}";

     

       14
       14
       -
               activate = true;

     

       15
       15
       -
             };

     

       16
       11
        
             server = {

     

       17
       12
        
               baseUrl = "http://localhost:8000";

     

       18
       13
        
               secretKeybaseFile = "${pkgs.writeText "dont-try-this-at-home" "nannannannannannannannannannannannannannannannannannannan_batman!"}";

     
···

       32
       27
        
           machine.succeed("curl -f localhost:8000 >&2")

     

       33
       28
        
       

     

       34
       29
        
           machine.succeed("curl -f localhost:8000/js/script.js >&2")

     

       35
       35
       -
       

     

       36
       36
       -
           csrf_token = machine.succeed(

     

       37
       37
       -
               "curl -c /tmp/cookies localhost:8000/login | grep '_csrf_token' | sed -E 's,.*value=\"(.*)\".*,\\1,g'"

     

       38
       38
       -
           )

     

       39
       39
       -
       

     

       40
       40
       -
           machine.succeed(

     

       41
       41
       -
               f"curl -b /tmp/cookies -f -X POST localhost:8000/login -F email=admin@example.org -F password=foobar -F _csrf_token={csrf_token.strip()} -D headers"

     

       42
       42
       -
           )

     

       43
       43
       -
       

     

       44
       44
       -
           # By ensuring that the user is redirected to the dashboard after login, we

     

       45
       45
       -
           # also make sure that the automatic verification of the module works.

     

       46
       46
       -
           machine.succeed(

     

       47
       47
       -
               "[[ $(grep 'location: ' headers | cut -d: -f2- | xargs echo) == /sites* ]]"

     

       48
       48
       -
           )

     

       49
       49
       -
       

     

       50
       50
       -
           machine.shutdown()

     

       51
       30
        
         '';

     

       52
       31
        
       })

+99 -28

pkgs/servers/web-apps/plausible/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , beamPackages

     

       3
       3
       -
       , buildNpmPackage

     

       4
       4
       -
       , fetchFromGitHub

     

       5
       5
       -
       , nodejs

     

       6
       6
       -
       , nixosTests

     

       7
       7
       -
       , ...

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         beamPackages,

     

       4
       4
       +
         buildNpmPackage,

     

       5
       5
       +
         rustPlatform,

     

       6
       6
       +
         fetchFromGitHub,

     

       7
       7
       +
         nodejs,

     

       8
       8
       +
         runCommand,

     

       9
       9
       +
         nixosTests,

     

       10
       10
       +
         npm-lockfile-fix,

     

       11
       11
       +
         brotli,

     

       12
       12
       +
         tailwindcss,

     

       13
       13
       +
         esbuild,

     

       14
       14
       +
         ...

     

       8
       15
        
       }:

     

       9
       16
        
       

     

       10
       17
        
       let

     

       11
       18
        
         pname = "plausible";

     

       12
       12
       -
         version = "2.0.0";

     

       19
       19
       +
         version = "2.1.4";

     

       20
       20
       +
         mixEnv = "ce";

     

       13
       21
        
       

     

       14
       22
        
         src = fetchFromGitHub {

     

       15
       23
        
           owner = "plausible";

     

       16
       24
        
           repo = "analytics";

     

       17
       25
        
           rev = "v${version}";

     

       18
       18
       -
           hash = "sha256-yrTwxBguAZbfEKucUL+w49Hr6D7v9/2OjY1h27+w5WI=";

     

       19
       19
       -
         };

     

       20
       20
       -
       

     

       21
       21
       -
         # TODO consider using `mix2nix` as soon as it supports git dependencies.

     

       22
       22
       -
         mixFodDeps = beamPackages.fetchMixDeps {

     

       23
       23
       -
           pname = "${pname}-deps";

     

       24
       24
       -
           inherit src version;

     

       25
       25
       -
           hash = "sha256-CAyZLpjmw1JreK3MopqI0XsWhP+fJEMpXlww7CibSaM=";

     

       26
       26
       +
           hash = "sha256-wV2zzRKJM5pQ06pF8vt1ieFqv6s3HvCzNT5Hed29Owk=";

     

       27
       27
       +
           postFetch = ''

     

       28
       28
       +
             ${lib.getExe npm-lockfile-fix} $out/assets/package-lock.json

     

       29
       29
       +
             sed -ie '

     

       30
       30
       +
               /defp deps do/ {

     

       31
       31
       +
                 n

     

       32
       32
       +
                 /\[/ a\

     

       33
       33
       +
                   \{:rustler, ">= 0.0.0", optional: true \},

     

       34
       34
       +
                 }

     

       35
       35
       +
             ' $out/mix.exs

     

       36
       36
       +
             cat >> $out/config/config.exs <<EOF

     

       37
       37
       +
             config :mjml, Mjml.Native,

     

       38
       38
       +
               crate: :mjml_nif,

     

       39
       39
       +
               skip_compilation?: true

     

       40
       40
       +
             EOF

     

       41
       41
       +
           '';

     

       26
       42
        
         };

     

       27
       43
        
       

     

       28
       44
        
         assets = buildNpmPackage {

     

       29
       45
        
           pname = "${pname}-assets";

     

       30
       46
        
           inherit version;

     

       31
       47
        
           src = "${src}/assets";

     

       32
       32
       -
           npmDepsHash = "sha256-2t1M6RQhBjZxx36qawVUVC+ob9SvQIq5dy4HgVeY2Eo=";

     

       48
       48
       +
           npmDepsHash = "sha256-Rf1+G9F/CMK09KEh022vHe02FADJtARKX4QEVbmvSqk=";

     

       33
       49
        
           dontNpmBuild = true;

     

       34
       50
        
           installPhase = ''

     

       35
       51
        
             runHook preInstall

     
···

       42
       58
        
           pname = "${pname}-tracker";

     

       43
       59
        
           inherit version;

     

       44
       60
        
           src = "${src}/tracker";

     

       45
       45
       -
           npmDepsHash = "sha256-y09jVSwUrxF0nLpLqS1yQweYL+iMF6jVx0sUdQtvrpc=";

     

       61
       61
       +
           npmDepsHash = "sha256-ng0YpBZc0vcg5Bsr1LmgXtzNCtNV6hJIgLt3m3yRdh4=";

     

       46
       62
        
           dontNpmBuild = true;

     

       47
       63
        
           installPhase = ''

     

       48
       64
        
             runHook preInstall

     
···

       50
       66
        
             runHook postInstall

     

       51
       67
        
           '';

     

       52
       68
        
         };

     

       69
       69
       +
       

     

       70
       70
       +
         mixFodDeps = beamPackages.fetchMixDeps {

     

       71
       71
       +
           inherit

     

       72
       72
       +
             pname

     

       73
       73
       +
             version

     

       74
       74
       +
             src

     

       75
       75
       +
             mixEnv

     

       76
       76
       +
             ;

     

       77
       77
       +
           hash = "sha256-N6cYlYwNss2FPYcljANJYbXobmLFauZ64F7Sf/+7Ctg=";

     

       78
       78
       +
         };

     

       79
       79
       +
       

     

       80
       80
       +
         mjmlNif = rustPlatform.buildRustPackage {

     

       81
       81
       +
           pname = "mjml-native";

     

       82
       82
       +
           version = "";

     

       83
       83
       +
           src = "${mixFodDeps}/mjml/native/mjml_nif";

     

       84
       84
       +
           cargoHash = "sha256-W4r8W+JGTE6j4gDogL5Yulr0mbaXjDbwDTwhzMbbDcQ=";

     

       85
       85
       +
           doCheck = false;

     

       86
       86
       +
       

     

       87
       87
       +
           env = {

     

       88
       88
       +
             RUSTLER_PRECOMPILED_FORCE_BUILD_ALL = "true";

     

       89
       89
       +
             RUSTLER_PRECOMPILED_GLOBAL_CACHE_PATH = "unused-but-required";

     

       90
       90
       +
           };

     

       91
       91
       +
         };

     

       92
       92
       +
       

     

       93
       93
       +
         patchedMixFodDeps = runCommand mixFodDeps.name { } ''

     

       94
       94
       +
           mkdir $out

     

       95
       95
       +
           cp -r --no-preserve=mode ${mixFodDeps}/. $out

     

       96
       96
       +
       

     

       97
       97
       +
           mkdir -p $out/mjml/priv/native

     

       98
       98
       +
           for lib in ${mjmlNif}/lib/*

     

       99
       99
       +
           do

     

       100
       100
       +
             # normalies suffix to .so, otherswise build would fail on darwin

     

       101
       101
       +
             file=''${lib##*/}

     

       102
       102
       +
             base=''${file%.*}

     

       103
       103
       +
             ln -s "$lib" $out/mjml/priv/native/$base.so

     

       104
       104
       +
           done

     

       105
       105
       +
         '';

     

       106
       106
       +
       

     

       53
       107
        
       in

     

       54
       54
       -
       beamPackages.mixRelease {

     

       55
       55
       -
         inherit pname version src mixFodDeps;

     

       108
       108
       +
       beamPackages.mixRelease rec {

     

       109
       109
       +
         inherit

     

       110
       110
       +
           pname

     

       111
       111
       +
           version

     

       112
       112
       +
           src

     

       113
       113
       +
           mixEnv

     

       114
       114
       +
           ;

     

       56
       115
        
       

     

       57
       116
        
         nativeBuildInputs = [

     

       58
       117
        
           nodejs

     

       118
       118
       +
           brotli

     

       59
       119
        
         ];

     

       60
       120
        
       

     

       121
       121
       +
         mixFodDeps = patchedMixFodDeps;

     

       122
       122
       +
       

     

       61
       123
        
         passthru = {

     

       62
       62
       -
           tests = { inherit (nixosTests) plausible; };

     

       124
       124
       +
           tests = {

     

       125
       125
       +
             inherit (nixosTests) plausible;

     

       126
       126
       +
           };

     

       63
       127
        
           updateScript = ./update.sh;

     

       128
       128
       +
           inherit assets tracker;

     

       64
       129
        
         };

     

       65
       130
        
       

     

       66
       66
       -
         postPatch = ''

     

       67
       67
       -
           substituteInPlace lib/plausible_release.ex --replace 'defp prepare do' 'def prepare do'

     

       68
       68
       -
         '';

     

       131
       131
       +
         env = {

     

       132
       132
       +
           APP_VERSION = version;

     

       133
       133
       +
           RUSTLER_PRECOMPILED_FORCE_BUILD_ALL = "true";

     

       134
       134
       +
           RUSTLER_PRECOMPILED_GLOBAL_CACHE_PATH = "unused-but-required";

     

       135
       135
       +
         };

     

       69
       136
        
       

     

       70
       137
        
         preBuild = ''

     

       71
       138
        
           rm -r assets tracker

     

       72
       72
       -
           cp -r ${assets} assets

     

       139
       139
       +
           cp --no-preserve=mode -r ${assets} assets

     

       73
       140
        
           cp -r ${tracker} tracker

     

       141
       141
       +
       

     

       142
       142
       +
           cat >> config/config.exs <<EOF

     

       143
       143
       +
           config :tailwind, path: "${lib.getExe tailwindcss}"

     

       144
       144
       +
           config :esbuild, path: "${lib.getExe esbuild}"

     

       145
       145
       +
           EOF

     

       74
       146
        
         '';

     

       75
       147
        
       

     

       76
       148
        
         postBuild = ''

     

       77
       77
       -
           export NODE_OPTIONS=--openssl-legacy-provider # required for webpack compatibility with OpenSSL 3 (https://github.com/webpack/webpack/issues/14532)

     

       78
       78
       -
           npm run deploy --prefix ./assets

     

       79
       149
        
           npm run deploy --prefix ./tracker

     

       80
       150
        
       

     

       81
       151
        
           # for external task you need a workaround for the no deps check flag

     

       82
       152
        
           # https://github.com/phoenixframework/phoenix/issues/2690

     

       83
       83
       -
           mix do deps.loadpaths --no-deps-check, phx.digest

     

       153
       153
       +
           mix do deps.loadpaths --no-deps-check, assets.deploy

     

       154
       154
       +
           mix do deps.loadpaths --no-deps-check, phx.digest priv/static

     

       84
       155
        
         '';

     

       85
       156
        
       

     

       86
       157
        
         meta = with lib; {

+6 -54

pkgs/servers/web-apps/plausible/update.sh

···

       1
       1
        
       #!/usr/bin/env nix-shell

     

       2
       2
       -
       #!nix-shell -i bash -p jq nix-prefetch-github yarn yarn2nix-moretea.yarn2nix moreutils

     

       3
       3
       -
       

     

       4
       4
       -
       # NOTE: please check on new releases which steps aren't necessary anymore!

     

       5
       5
       -
       # Currently the following things are done:

     

       6
       6
       -
       #

     

       7
       7
       -
       # * Add correct `name`/`version` field to `package.json`, otherwise `yarn2nix` fails to

     

       8
       8
       -
       #   find required dependencies.

     

       9
       9
       -
       # * Adjust `file:`-dependencies a bit for the structure inside a Nix build.

     

       10
       10
       -
       # * Update hashes for the tarball & the fixed-output drv with all `mix`-dependencies.

     

       11
       11
       -
       # * Generate `yarn.lock` & `yarn.nix` in a temporary directory.

     

       2
       2
       +
       #!nix-shell -i bash -p nix-update jq elixir npm-lockfile-fix nixfmt-rfc-style

     

       12
       3
        
       

     

       13
       4
        
       set -euxo pipefail

     

       14
       5
        
       

     

       15
       15
       -
       dir="$(realpath $(dirname "$0"))"

     

       16
       16
       -
       export latest="$(curl -q https://api.github.com/repos/plausible/analytics/releases/latest \

     

       17
       17
       -
         | jq -r '.tag_name')"

     

       18
       18
       -
       nix_version="$(cut -c2- <<< "$latest")"

     

       19
       19
       -
       

     

       20
       20
       -
       if [[ "$(nix-instantiate -A plausible.version --eval --json | jq -r)" = "$nix_version" ]];

     

       21
       21
       -
       then

     

       22
       22
       -
         echo "Already using version $latest, skipping"

     

       23
       23
       -
         exit 0

     

       24
       24
       -
       fi

     

       25
       25
       -
       

     

       26
       26
       -
       SRC="https://raw.githubusercontent.com/plausible/analytics/${latest}"

     

       27
       27
       -
       

     

       28
       28
       -
       package_json="$(curl -qf "$SRC/assets/package.json")"

     

       29
       29
       -
       

     

       30
       30
       -
       echo "$package_json" \

     

       31
       31
       -
         | jq '. + {"name":"plausible","version": $ENV.latest}' \

     

       32
       32
       -
         | sed -e 's,../deps/,../../tmp/deps/,g' \

     

       33
       33
       -
         > $dir/package.json

     

       34
       34
       -
       

     

       35
       35
       -
       tarball_meta="$(nix-prefetch-github plausible analytics --rev "$latest")"

     

       36
       36
       -
       tarball_hash="$(jq -r '.hash' <<< "$tarball_meta")"

     

       37
       37
       -
       tarball_path="$(nix-build -E 'with import ./. {}; { p }: fetchFromGitHub (builtins.fromJSON p)' --argstr p "$tarball_meta")"

     

       38
       38
       -
       fake_hash="$(nix-instantiate --eval -A lib.fakeHash | xargs echo)"

     

       39
       39
       -
       

     

       40
       40
       -
       sed -i "$dir/default.nix" \

     

       41
       41
       -
         -e 's,version = ".*",version = "'"$nix_version"'",' \

     

       42
       42
       -
         -e '/^  src = fetchFromGitHub/,+4{;s#hash = "\(.*\)"#hash = "'"$tarball_hash"'"#}' \

     

       43
       43
       -
         -e '/^  mixFodDeps =/,+3{;s#hash = "\(.*\)"#hash = "'"$fake_hash"'"#}'

     

       44
       44
       -
       

     

       45
       45
       -
       mix_hash="$(nix-build -A plausible.mixFodDeps 2>&1 | tail -n3 | grep 'got:' | cut -d: -f2- | xargs echo || true)"

     

       46
       46
       -
       

     

       47
       47
       -
       sed -i "$dir/default.nix" -e '/^  mixFodDeps =/,+3{;s#hash = "\(.*\)"#hash = "'"$mix_hash"'"#}'

     

       6
       6
       +
       nix-update plausible

     

       48
       7
        
       

     

       49
       49
       -
       tmp_setup_dir="$(mktemp -d)"

     

       50
       50
       -
       trap "rm -rf $tmp_setup_dir" EXIT

     

       8
       8
       +
       version="$(nix-instantiate -A plausible.version --eval --json | jq -r)"

     

       9
       9
       +
       source_url="$(nix-instantiate -A plausible.src.url --eval --json | jq -r)"

     

       51
       10
        
       

     

       52
       52
       -
       cp -r $tarball_path/* $tmp_setup_dir/

     

       53
       53
       -
       cp -r "$(nix-build -A plausible.mixFodDeps)" "$tmp_setup_dir/deps"

     

       54
       54
       -
       chmod -R u+rwx "$tmp_setup_dir"

     

       11
       11
       +
       nix-update --url "$source_url" --version "$version" plausible.tracker

     

       12
       12
       +
       nix-update --url "$source_url" --version "$version" plausible.assets

     

       55
       13
        
       

     

       56
       56
       -
       pushd $tmp_setup_dir/assets

     

       57
       57
       -
       yarn

     

       58
       58
       -
       yarn2nix > "$dir/yarn.nix"

     

       59
       59
       -
       cp yarn.lock "$dir/yarn.lock"

     

       60
       60
       -
       popd

     

       61
       14
        
       

     

       62
       62
       -
       nix-build -A plausible

+2 -2

pkgs/top-level/all-packages.nix

···

       1926
       1926
        
         lukesmithxyz-bible-kjv = callPackage ../applications/misc/kjv/lukesmithxyz-kjv.nix { };

     

       1927
       1927
        
       

     

       1928
       1928
        
         plausible = callPackage ../servers/web-apps/plausible {

     

       1929
       1929
       -
           elixir = elixir_1_14;

     

       1930
       1930
       -
           beamPackages = beamPackages.extend (self: super: { elixir = elixir_1_14; });

     

       1929
       1929
       +
           elixir = elixir_1_17;

     

       1930
       1930
       +
           beamPackages = beamPackages.extend (self: super: { elixir = elixir_1_17; });

     

       1931
       1931
        
         };

     

       1932
       1932
        
       

     

       1933
       1933
        
         reattach-to-user-namespace = callPackage ../os-specific/darwin/reattach-to-user-namespace { };