Merge branch '465-dev-share-url-fixes' into 'dev'

[BREAKING] refactoring of fc_url

Closes #465

See merge request !405

bin/gargantext-cli/CLI/Ini.hs

@@ -11,10 +11,7 @@ Import a corpus binary.
 
  -}
 
-{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE Strict            #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE TypeApplications #-}
 
 module CLI.Ini where
 
@@ -104,12 +101,12 @@ convertConfigs ini@(Ini.GargConfig { .. }) iniMail nlpConfig connInfo =
 
 mkFrontendConfig :: Ini.GargConfig -> CTypes.FrontendConfig
 mkFrontendConfig (Ini.GargConfig { .. }) =
-  CTypes.FrontendConfig { _fc_url = _gc_url
+  CTypes.FrontendConfig { _fc_external_url = _fc_url
+                        , _fc_internal_url = _fc_url
+                        , _fc_directory = "./purescript-gargantext/dist"
                         , _fc_backend_name = _gc_backend_name
-                        , _fc_url_backend_api = _gc_url_backend_api
                         , _fc_cors
                         , _fc_microservices
-                        , _fc_appPort = 3000
                         , _fc_cookie_settings = CTypes.defaultCookieSettings }
   where
     _fc_cors = CTypes.CORSSettings { _corsAllowedOrigins = [
@@ -138,6 +135,10 @@ mkFrontendConfig (Ini.GargConfig { .. }) =
       case parseBaseUrl (T.unpack url) of
         Nothing -> panicTrace $ "Cannot parse base url for: " <> url
         Just b -> CTypes.CORSOrigin b
+    _fc_url =
+      case parseBaseUrl (T.unpack _gc_url) of
+        Nothing -> panicTrace $ "Cannot parse base url for: " <> _gc_url
+        Just b -> b
 
 defaultNotificationsConfig :: CTypes.NotificationsConfig
 defaultNotificationsConfig =

bin/gargantext-cli/CLI/Server.hs

@@ -77,13 +77,11 @@ serverParser = hsubparser (
 start_p :: Parser CLIServer
 start_p = fmap CLIS_start $ ServerArgs
   <$> mode_p
-  <*> port_p
   <*> settings_p
 
 start_all_p :: Parser CLIServer
 start_all_p = fmap CLIS_startAll $ ServerArgs
   <$> mode_p
-  <*> port_p
   <*> settings_p
 
 mode_p :: Parser Mode
@@ -92,21 +90,13 @@ mode_p = option auto ( long "mode"
                     <> metavar "M"
                     <> help "Possible modes: Dev | Mock | Prod" )
 
-port_p :: Parser Int
-port_p = option auto ( long "port"
-                    <> short 'p'
-                    <> metavar "P"
-                    <> showDefault
-                    <> value 8008
-                    <> help "Port" )
-
 version_p :: Parser CLIServer
 version_p = pure CLIS_version
 
 
 startServerCLI :: Logger IO -> ServerArgs -> IO ()
 startServerCLI ioLogger (ServerArgs { .. }) = do
-  logMsg ioLogger INFO $ "starting server, mode: " <> show server_mode <> ", port: " <> show server_port <> ", config: " <> _SettingsFile server_toml
+  logMsg ioLogger INFO $ "starting server, mode: " <> show server_mode <> ", config: " <> _SettingsFile server_toml
   -- Sets the locale to avoid encoding issues like in #284.
   setLocaleEncoding utf8
 
@@ -114,4 +104,4 @@ startServerCLI ioLogger (ServerArgs { .. }) = do
     logMsg ioLogger ERROR "Mock mode not supported!"
     exitFailure
 
-  startGargantext server_mode server_port server_toml
+  startGargantext server_mode server_toml

bin/gargantext-cli/CLI/Types.hs

@@ -100,7 +100,6 @@ data CLIServer
 
 data ServerArgs = ServerArgs
   { server_mode :: !Mode
-  , server_port :: !Int
   , server_toml :: !SettingsFile }
   deriving (Show, Eq)
 

gargantext-settings.toml_toModify

 [frontend]
+# Main url serving the FrontEnd (public URL)
+external_url = "http://localhost:8008"
 
-# Main url serving the FrontEnd
-url = "http://localhost"
+# host/port where the GarganText server will bind to
+internal_url = "http://localhost:8008"
 
-backend_name = "localhost"
+# Location of the frontend code. This will be served at the root of
+# the path (e.g. index.html)
+directory = "./purescript-gargantext/dist"
 
-# Main API url serving the BackEnd
-url_backend_api = "http://localhost:8008/api/v1.0"
+backend_name = "localhost"
 
 jwt_settings = "TODO"
 

nix/pkgs.nix

+# https://nix.dev/tutorials/first-steps/towards-reproducibility-pinning-nixpkgs.html
 { pkgs ? import (if builtins.elem builtins.currentSystem ["x86_64-darwin" "aarch64-darwin"]
                  then ./pinned-25.05.darwin.nix
                  else ./pinned-25.05.nix) {} }:
 
 rec {
   inherit pkgs;
-  ghc966 = pkgs.haskell.compiler.ghc966;
-  cabal_install = pkgs.haskell.lib.compose.justStaticExecutables pkgs.haskell.packages.ghc966.cabal-install;
+  ghcVersion = "ghc966";
+  gargGhc = pkgs.haskell.compiler.${ghcVersion};
+  cabal_install = pkgs.haskell.lib.compose.justStaticExecutables pkgs.haskell.packages.${ghcVersion}.cabal-install;
   
   graphviz = pkgs.callPackage ./graphviz.nix {};
   igraph_0_10_4 = pkgs.callPackage ./igraph.nix {};
-  corenlp = pkgs.callPackage ./corenlp.nix { };  # 4.5.8
-  cabal2stack = pkgs.callPackage ./cabal2stack.nix { ghc = ghc966; };
+  corenlp = pkgs.callPackage ./corenlp.nix { };  # 4.5.9
+  cabal2stack = pkgs.callPackage ./cabal2stack.nix { ghc = gargGhc; };
   nng_notls = pkgs.nng.overrideAttrs (old: {
     cmakeFlags = (old.cmakeFlags or []) ++ [ "-DNNG_ENABLE_TLS=OFF" ];
   });
   
   hsBuildInputs = [
-    ghc966
+    gargGhc
     cabal_install
     pkgs.haskellPackages.alex
     pkgs.haskellPackages.ghcid

src/Gargantext/API.hs

@@ -49,7 +49,7 @@ import Gargantext.API.Routes.Named (API)
 import Gargantext.API.Routes.Named.EKG (EkgAPI)
 import Gargantext.API.Server.Named (server)
 import Gargantext.Core.Config
-import Gargantext.Core.Config.Types (CORSOrigin(..), CORSSettings, MicroServicesProxyStatus(..), NotificationsConfig(..), PortNumber, SettingsFile(..), corsAllowedOrigins, fc_appPort, fc_cors, fc_cookie_settings, microServicesProxyStatus)
+import Gargantext.Core.Config.Types (CORSOrigin(..), CORSSettings, MicroServicesProxyStatus(..), NotificationsConfig(..), PortNumber, SettingsFile(..), corsAllowedOrigins, fc_cors, fc_cookie_settings, fc_internal_url, microServicesProxyStatus)
 import Gargantext.Core.Config.Utils (readConfig)
 import Gargantext.Core.Notifications (withNotifications)
 import Gargantext.Database.Prelude qualified as DB
@@ -62,21 +62,20 @@ import Network.Wai.Handler.Warp hiding (defaultSettings)
 import Network.Wai.Middleware.Cors
 import Network.Wai.Middleware.RequestLogger (logStdout)
 import Servant hiding (Header)
-import Servant.Client.Core.BaseUrl (showBaseUrl)
+import Servant.Client.Core.BaseUrl (showBaseUrl, baseUrlPort)
 import System.Clock qualified as Clock
 import System.Cron.Schedule qualified as Cron
 
 -- | startGargantext takes as parameters port number and Toml file.
-startGargantext :: Mode -> PortNumber -> SettingsFile -> IO ()
-startGargantext mode port sf@(SettingsFile settingsFile) = do
-  config <- readConfig sf <&> (gc_frontend_config . fc_appPort) .~ port
+startGargantext :: Mode -> SettingsFile -> IO ()
+startGargantext mode sf@(SettingsFile settingsFile) = do
+  config <- readConfig sf
   withLoggerIO (config ^. gc_logging) $ \logger -> do
-    when (port /= config ^. gc_frontend_config . fc_appPort) $
-      panicTrace "TODO: conflicting settings of port"
     withNotifications config $ \dispatcher -> do
       env <- newEnv logger config dispatcher
       let fc = env ^. env_config . gc_frontend_config
       let proxyStatus = microServicesProxyStatus fc
+      let port = baseUrlPort (fc ^. fc_internal_url)
       runDbCheck env
       startupInfo config port proxyStatus
       app <- makeApp env

src/Gargantext/API/Admin/FrontEnd.hs

@@ -16,9 +16,10 @@ Loads all static file for the front-end.
 ---------------------------------------------------------------------
 module Gargantext.API.Admin.FrontEnd where
 
+import GHC.IO (FilePath)
 import Servant
 
 type FrontEndAPI = Raw
 
-frontEndServer :: Server FrontEndAPI
-frontEndServer = serveDirectoryFileServer "./purescript-gargantext/dist"
+frontEndServer :: FilePath -> Server FrontEndAPI
+frontEndServer path = serveDirectoryFileServer path

src/Gargantext/API/Node/ShareURL.hs

@@ -10,7 +10,7 @@ import Data.Validity qualified as V
 import Gargantext.API.Prelude (IsGargServer)
 import Gargantext.API.Routes.Named.Share qualified as Named
 import Gargantext.Core.Config (GargConfig, gc_frontend_config, HasConfig(hasConfig))
-import Gargantext.Core.Config.Types (fc_appPort, fc_url)
+import Gargantext.Core.Config.Types (getPublicUrl)
 import Gargantext.Core.Types (NodeType, NodeId, unNodeId, _ValidationError)
 import Gargantext.Database.Prelude (IsDBEnvExtra)
 import Gargantext.Prelude
@@ -37,18 +37,21 @@ get_url :: Maybe NodeType
         -> GargConfig
         -> Either String Named.ShareLink
 get_url nt id gc = do
-  let urlHost = T.unpack $ gc ^. gc_frontend_config . fc_url
-  let urlPort = gc ^. gc_frontend_config . fc_appPort
+  let fc = gc ^. gc_frontend_config
+  -- let urlHost = T.unpack $ gc ^. gc_frontend_config . fc_url
+  -- let urlPort = gc ^. gc_frontend_config . fc_appPort
   t <- maybe (Left "Invalid node Type") Right nt
   i <- maybe (Left "Invalid node ID")   Right id
 
+  let sharePart = "/#/share/" <> show t <> "/" <> show (unNodeId i)
+
   -- Include the port the server is running on if this is
   -- localhost, so that share URLs would work out of the box.
-  let !rawURL
-        | "localhost" `isInfixOf` urlHost
-        = urlHost <> ":" <> show urlPort <> "/#/share/" <> show t <> "/" <> show (unNodeId i)
-        | otherwise
-        = urlHost <> "/#/share/" <> show t <> "/" <> show (unNodeId i)
+  let !rawURL = T.unpack $ (getPublicUrl fc) <> sharePart
+        -- | "localhost" `isInfixOf` urlHost
+        -- = urlHost <> ":" <> show urlPort <> "/#/share/" <> show t <> "/" <> show (unNodeId i)
+        -- | otherwise
+        -- = urlHost <> "/#/share/" <> show t <> "/" <> show (unNodeId i)
   maybe (Left $ "Couldn't construct a valid share URL from '" <> rawURL <> "'")
         (Right . Named.ShareLink)
         (parseURI rawURL)

src/Gargantext/API/Server/Named.hs

@@ -16,7 +16,7 @@ import Gargantext.API.Admin.EnvTypes (Env)
 import Gargantext.API.Admin.FrontEnd (frontEndServer)
 import Gargantext.API.Auth.PolicyCheck ()
 import Gargantext.API.Errors
-import Gargantext.API.GraphQL as GraphQL
+import Gargantext.API.GraphQL as GraphQL ( GraphQLAPI, api )
 import Gargantext.API.Prelude (GargM)
 import Gargantext.API.Routes.Named
 import Gargantext.API.Server.Named.Public (serverPublicGargAPI)
@@ -24,7 +24,7 @@ import Gargantext.API.Swagger (openApiDoc)
 import Gargantext.API.ThrowAll (serverPrivateGargAPI)
 import Gargantext.Core.Notifications.Dispatcher.WebSocket qualified as Dispatcher
 import Gargantext.Core.Config (gc_frontend_config, hasConfig)
-import Gargantext.Core.Config.Types (fc_url_backend_api)
+import Gargantext.Core.Config.Types (fc_directory, fc_external_url)
 import Gargantext.Prelude hiding (Handler, catch)
 import Gargantext.System.Logging (logLocM, LogLevel(..))
 import Paths_gargantext qualified as PG -- cabal magic build module
@@ -40,7 +40,7 @@ serverGargAPI env
             , gargForgotPasswordAsyncAPI = forgotPasswordAsync
             , gargVersionAPI             = gargVersion
             , gargPrivateAPI             = serverPrivateGargAPI
-            , gargPublicAPI              = serverPublicGargAPI (env ^. hasConfig . gc_frontend_config . fc_url_backend_api)
+            , gargPublicAPI              = serverPublicGargAPI (env ^. hasConfig . gc_frontend_config . fc_external_url)
             }
   where
     gargVersion :: GargVersion (AsServerT (GargM Env BackendInternalError))
@@ -66,7 +66,7 @@ server env =
                        -- (Proxy :: Proxy AuthContext)
                        (transformJSON errScheme)
                        Dispatcher.wsServer
-     , frontendAPI = frontEndServer
+     , frontendAPI = frontEndServer (env ^. hasConfig . gc_frontend_config . fc_directory)
      }
   where
     transformJSON :: forall a. GargErrorScheme -> GargM Env BackendInternalError a -> Handler a

src/Gargantext/API/Server/Named/Private.hs

@@ -9,7 +9,7 @@ import Gargantext.API.Errors.Types (BackendInternalError)
 import Gargantext.API.Members (members)
 import Gargantext.API.Ngrams.List qualified as List
 import Gargantext.API.Node (annuaireNodeAPI, corpusNodeAPI, nodeAPI, nodeNodeAPI, nodesAPI, roots)
-import Gargantext.API.Node.Contact as Contact
+import Gargantext.API.Node.Contact as Contact ( contactAPI )
 import Gargantext.API.Node.Corpus.Export qualified as CorpusExport
 import Gargantext.API.Node.Corpus.Subcorpus qualified as Subcorpus
 import Gargantext.API.Node.Document.Export (documentExportAPI)
@@ -19,7 +19,7 @@ import Gargantext.API.Node.ShareURL ( shareURL )
 import Gargantext.API.Prelude (GargM)
 import Gargantext.API.Routes (addWithTempFileApi, addCorpusWithQuery)
 import Gargantext.API.Routes.Named.Private qualified as Named
-import Gargantext.API.Server.Named.Ngrams
+import Gargantext.API.Server.Named.Ngrams ( apiNgramsTableDoc )
 import Gargantext.API.Server.Named.Viz qualified as Viz
 import Gargantext.Core.Types.Individu (User(..))
 import Gargantext.Database.Admin.Types.Hyperdata (HyperdataAny)

src/Gargantext/API/Server/Named/Public.hs

@@ -4,9 +4,9 @@ module Gargantext.API.Server.Named.Public (
   ) where
 
 import Control.Lens ((^?), _Just)
-import Data.List qualified as List
 import Data.Map.Strict qualified as Map
 import Data.Set qualified as Set
+import Data.Text qualified as T
 import Gargantext.API.Node.File (fileApi)
 import Gargantext.API.Prelude (serverError, IsGargServer)
 import Gargantext.API.Public.Types (PublicData(..))
@@ -22,29 +22,30 @@ import Gargantext.Database.Query.Table.Node.Error (HasNodeError(..))
 import Gargantext.Database.Query.Table.NodeNode (selectPublicNodes)
 import Gargantext.Database.Schema.Node ( NodePoly(..), node_date, node_hyperdata ) -- (NodePoly(..))
 import Gargantext.Prelude
-import Servant
+import Servant ( ServerError(errBody), err405 )
+import Servant.Client.Core.BaseUrl (BaseUrl(..), showBaseUrl)
 import Servant.Server.Generic (AsServerT)
 
-serverPublicGargAPI :: IsGargServer env err m => Text -> Named.GargPublicAPI (AsServerT m)
+serverPublicGargAPI :: IsGargServer env err m => BaseUrl -> Named.GargPublicAPI (AsServerT m)
 serverPublicGargAPI baseUrl = Named.GargPublicAPI $
   Named.GargPublicAPI'
-    { publicHomeAPI = api_home baseUrl
-    , publicNodeAPI = Named.NodeAPI api_node
+    { publicHomeAPI = apiHome baseUrl
+    , publicNodeAPI = Named.NodeAPI apiNode
     }
 
-api_home :: IsGargServer env err m => Text -> Named.HomeAPI (AsServerT m)
-api_home baseUrl = Named.HomeAPI $ runDBQuery $ catMaybes
+apiHome :: IsGargServer env err m => BaseUrl -> Named.HomeAPI (AsServerT m)
+apiHome baseUrl = Named.HomeAPI $ runDBQuery $ catMaybes
    <$> map (toPublicData baseUrl)
    <$> filterPublicDatas
    <$> selectPublic
 
-api_node :: IsGargServer env err m => NodeId -> Named.FileAPI (AsServerT m)
-api_node nId = Named.FileAPI $ do
+apiNode :: IsGargServer env err m => NodeId -> Named.FileAPI (AsServerT m)
+apiNode nId = Named.FileAPI $ do
   pubNodes <- runDBQuery publicNodes
   -- TODO optimize with SQL
-  case Set.member nId pubNodes of
-    False -> serverError $ err405 { errBody = "Not allowed" }
-    True  -> fileApi nId
+  (if Set.member nId pubNodes
+   then fileApi nId
+   else serverError $ err405 { errBody = "Not allowed" })
 
 -------------------------------------------------------------------------
 
@@ -61,7 +62,7 @@ filterPublicDatas :: [(Node HyperdataFolder, Maybe Int)]
 filterPublicDatas datas =
   map (\(n,mi) ->
           let mi' = UnsafeMkNodeId <$> mi in
-                  ( _node_id n, (n, maybe [] (:[]) mi' ))
+                  ( _node_id n, (n, maybeToList mi' ))
       ) datas
       & Map.fromListWith (\(n1,i1) (_n2,i2) -> (n1, i1 <> i2))
       & Map.filter (not . null . snd)
@@ -72,28 +73,29 @@ publicNodes :: HasNodeError err
 publicNodes = do
   candidates <- filterPublicDatas <$> selectPublicNodes
   pure $ Set.fromList
-       $ List.concat
-       $ map (\(n, ns) -> (_node_id n) : ns) candidates
+       $ concatMap (\(n, ns) -> _node_id n : ns) candidates
 
 
 -- http://localhost:8008/api/v1.0/node/23543/file/download<Paste>
 -- http://localhost:8000/images/Gargantextuel-212x300.jpg
-toPublicData :: Text -> (Node HyperdataFolder, [NodeId]) -> Maybe PublicData
-toPublicData base (n , mn) = do
-  title <- (hd ^? (_Just . hf_data . cf_title))
-  abstract <- (hd ^? (_Just . hf_data . cf_desc ))
-  img <- (Just $ url' mn) -- "images/Gargantextuel-212x300.jpg"
-  url <- (Just $ url' mn)
+toPublicData :: BaseUrl -> (Node HyperdataFolder, [NodeId]) -> Maybe PublicData
+toPublicData baseUrl (n , mn) = do
+  title <- hd ^? (_Just . hf_data . cf_title)
+  abstract <- hd ^? (_Just . hf_data . cf_desc )
+  img <- Just $ url' mn -- "images/Gargantextuel-212x300.jpg"
+  url <- Just $ url' mn
   date <- Just (show $ utc2year (n^.node_date))
-  database <- (hd ^? (_Just . hf_data . cf_query))
-  author <- (hd ^? (_Just . hf_data . cf_authors))
+  database <- hd ^? (_Just . hf_data . cf_query)
+  author <- hd ^? (_Just . hf_data . cf_authors)
   pure $ PublicData { .. }
   where
     hd = head
        $ filter (\(HyperdataField cd _ _) -> cd == JSON)
        $ n^. (node_hyperdata . hc_fields)
-    url' :: [NodeId] -> Text
-    url' mn' = base
+    path :: [NodeId] -> Text
+    path mn' = "/api/v1.0"
            <>   "/public/"
-           <> (show $ (maybe 0 unNodeId $ head mn'))
+           <> show (maybe 0 unNodeId (head mn'))
            <> "/file/download"
+    url' :: [NodeId] -> Text
+    url' mn' = T.pack $ showBaseUrl $ baseUrl { baseUrlPath = T.unpack $ path mn' }

src/Gargantext/API/Server/Named/Remote.hs

@@ -38,7 +38,7 @@ import Gargantext.API.Errors.Types
 import Gargantext.API.Ngrams.Prelude (getNgramsList)
 import Gargantext.API.Ngrams.Types (NgramsList)
 import Gargantext.API.Node.Document.Export (get_document_json)
-import Gargantext.API.Node.Document.Export.Types
+import Gargantext.API.Node.Document.Export.Types ( DocumentExport(_de_documents) )
 import Gargantext.API.Prelude (IsGargServer)
 import Gargantext.API.Routes.Client (remoteImportClient)
 import Gargantext.API.Routes.Named.Remote qualified as Named

src/Gargantext/Core/Config.hs

@@ -53,7 +53,7 @@ import Gargantext.Core.Config.Worker (WorkerSettings)
 import Gargantext.Prelude
 import Network.HTTP.Client qualified as HTTP
 import Servant.Auth.Server (JWTSettings)
-import Servant.Client (BaseUrl(..), Scheme(Http), parseBaseUrl)
+import Servant.Client (BaseUrl(..))
 import Toml.Schema
 import Toml.Schema.FromValue (typeError)
 
@@ -142,10 +142,8 @@ instance ToTable GargConfig where
 
 
 mkProxyUrl :: GargConfig -> BaseUrl
-mkProxyUrl GargConfig{..} =
-  case parseBaseUrl (T.unpack $ _fc_url _gc_frontend_config) of
-    Nothing -> BaseUrl Http "localhost" 80 ""
-    Just bh -> bh { baseUrlPort = _msProxyPort $ _fc_microservices _gc_frontend_config }
+mkProxyUrl GargConfig{ _gc_frontend_config = cfg } =
+  (_fc_external_url cfg) { baseUrlPort = _msProxyPort $ _fc_microservices cfg }
 
 
 class HasConfig env where

src/Gargantext/Core/Config/Types.hs

@@ -27,13 +27,14 @@ module Gargantext.Core.Config.Types
   , f_istex_url
   , PortNumber
   , FrontendConfig(..)
-  , fc_url
+  , fc_external_url
+  , fc_internal_url
   , fc_backend_name
-  , fc_url_backend_api
+  , fc_directory
   , fc_cors
   , fc_microservices
-  , fc_appPort
   , fc_cookie_settings
+  , getPublicUrl
   , defaultCookieSettings
   , MicroServicesProxyStatus(..)
   , microServicesProxyStatus
@@ -63,7 +64,7 @@ import Database.PostgreSQL.Simple qualified as PGS
 import Gargantext.Prelude
 import Servant.Auth.Server (CookieSettings(..), JWTSettings, XsrfCookieSettings(..), defaultJWTSettings, readKey, writeKey)
 import Servant.Auth.Server qualified as SAuth
-import Servant.Client.Core (BaseUrl, parseBaseUrl, showBaseUrl)
+import Servant.Client.Core (BaseUrl(..), parseBaseUrl, showBaseUrl)
 import System.Directory (doesFileExist)
 import Toml
 import Toml.Schema
@@ -199,35 +200,49 @@ defaultCookieSettings = SAuth.defaultCookieSettings { cookieXsrfSetting = Just x
 
 -- TODO jwtSettings = defaultJWTSettings
 data FrontendConfig =
-  FrontendConfig { _fc_url             :: !Text
+  FrontendConfig { _fc_external_url    :: !BaseUrl
+                 , _fc_internal_url    :: !BaseUrl
+                 , _fc_directory       :: !FilePath
                  , _fc_backend_name    :: !Text
-                 , _fc_url_backend_api :: !Text
                  , _fc_cors            :: !CORSSettings
                  , _fc_microservices   :: !MicroServicesSettings
-                 , _fc_appPort         :: !PortNumber
                  , _fc_cookie_settings :: !CookieSettings
                }
   deriving (Generic, Show)
 instance FromValue FrontendConfig where
   fromValue = parseTableFromValue $ do
-    _fc_url <- reqKey "url"
+    _fc_external_url_txt <- reqKey "external_url"
+    _fc_external_url <-
+      case parseBaseUrl (T.unpack _fc_external_url_txt) of
+        Nothing -> fail "cannot parse fc_external_url"
+        Just b -> pure b
+    _fc_internal_url_txt <- reqKey "internal_url"
+    _fc_internal_url <-
+      case parseBaseUrl (T.unpack _fc_internal_url_txt) of
+        Nothing -> fail "cannot parse fc_internal_url"
+        Just b -> pure b
+    _fc_directory <- reqKey "directory"
     _fc_backend_name <- reqKey "backend_name"
-    _fc_url_backend_api <- reqKey "url_backend_api"
     _fc_cors <- reqKey "cors"
     _fc_microservices <- reqKey "microservices"
-    let _fc_appPort = 3000
+    
     return $ FrontendConfig { _fc_cookie_settings = defaultCookieSettings, .. }
 instance ToValue FrontendConfig where
   toValue = defaultTableToValue
 instance ToTable FrontendConfig where
-  toTable (FrontendConfig { .. }) = table [ "url" .= _fc_url
+  toTable (FrontendConfig { .. }) = table
+      [ "external_url" .= (T.pack $ showBaseUrl _fc_external_url)
+      , "internal_url" .= (T.pack $ showBaseUrl _fc_internal_url)
+      , "directory"    .= _fc_directory
       , "backend_name" .= _fc_backend_name
-                                          , "url_backend_api" .= _fc_url_backend_api
       , "cors" .= _fc_cors
       , "microservices" .= _fc_microservices ]
 
 makeLenses ''FrontendConfig
 
+getPublicUrl :: FrontendConfig -> Text
+getPublicUrl (FrontendConfig { .. }) = T.pack $ showBaseUrl _fc_external_url
+
 data MicroServicesProxyStatus
   = PXY_enabled PortNumber
   | PXY_disabled

src/Gargantext/Core/Mail.hs

@@ -16,7 +16,7 @@ import Control.Monad.Trans.Control (MonadBaseControl)
 import Data.List qualified as List
 import Data.Text (splitOn)
 import Gargantext.Core.Config (gc_frontend_config, HasConfig(..))
-import Gargantext.Core.Config.Types (fc_url, fc_backend_name)
+import Gargantext.Core.Config.Types (fc_backend_name, getPublicUrl)
 import Gargantext.Core.Config.Mail (gargMail, GargMail(..), MailConfig)
 import Gargantext.Core.Types.Individu
 import Gargantext.Database.Schema.User (UserLight(..))
@@ -75,7 +75,7 @@ mail mailCfg model = do
     (m,u)   = email_to         model
     subject = email_subject    model
     body    = emailWith (ServerAddress (view (gc_frontend_config . fc_backend_name) cfg)
-                                       (view (gc_frontend_config . fc_url) cfg)) model
+                                       (getPublicUrl $ view gc_frontend_config cfg)) model
   liftBase $ gargMail mailCfg (GargMail { gm_to = m
                                         , gm_name = Just u
                                         , gm_subject = subject

test-data/test_config.toml

 [frontend]
-url = "http://localhost"
+external_url = "http://localhost"
+internal_url = "http://localhost"
+directory = "./purescript-gargantext/dist"
 backend_name = "localhost"
-url_backend_api = "http://localhost:8008/api/v1.0"
 jwt_settings = "TODO"
 
 [frontend.cors]

test/Test/API/Setup.hs

@@ -24,7 +24,7 @@ import Gargantext.API.Admin.EnvTypes (Env (..), env_dispatcher)
 import Gargantext.API.Errors.Types
 import Gargantext.API.Prelude
 import Gargantext.Core.Config hiding (jwtSettings)
-import Gargantext.Core.Config.Types (fc_appPort, jwtSettings)
+import Gargantext.Core.Config.Types (jwtSettings, fc_external_url, fc_internal_url)
 import Gargantext.Core.Notifications (withNotifications)
 import Gargantext.Core.Types.Individu
 import Gargantext.Database.Action.Flow
@@ -37,7 +37,7 @@ import Gargantext.Database.Prelude
 import Gargantext.Database.Query.Table.Node (getOrMkList)
 import Gargantext.Database.Query.Tree.Root (MkCorpusUser(..))
 import Gargantext.MicroServices.ReverseProxy (microServicesProxyApp)
-import Gargantext.Prelude hiding (catches, Handler)
+import Gargantext.Prelude hiding (catches, to, Handler)
 import Gargantext.System.Logging
 import Network.HTTP.Client.TLS (newTlsManager)
 import Network.HTTP.Types
@@ -48,6 +48,7 @@ import Network.Wai.Handler.Warp.Internal
 import Network.WebSockets qualified as WS
 import Prelude hiding (show)
 import Servant.Auth.Client ()
+import Servant.Client.Core (baseUrlPort)
 import Test.Database.Setup (withTestDB)
 import Test.Database.Types
 import UnliftIO qualified
@@ -72,7 +73,9 @@ newTestEnv :: TestEnv -> Logger (GargM Env BackendInternalError) -> Warp.Port ->
 newTestEnv testEnv logger port = do
   !manager_env  <- newTlsManager
 
-  let config_env    = test_config testEnv & (gc_frontend_config . fc_appPort) .~ port
+  let config_env    = test_config testEnv
+                        & (gc_frontend_config . fc_external_url) %~ (\b -> b { baseUrlPort = port })
+                        & (gc_frontend_config . fc_internal_url) %~ (\b -> b { baseUrlPort = port })
   -- dbParam        <- pure $ testEnvToPgConnectionInfo testEnv
   -- !pool          <- newPool dbParam