`init` doesn't run on page reload

[bahalperin]

Short version: is there a way to get a Msg to fire when the page loads?

This might just be me misunderstanding how things are meant to work rather than a real issue.

I expected that if I refreshed the page, init would run again and I'd get my app into a fresh state. Here's a specific example of something I'm running to that feels odd to me. I'm exploring the language and building a simple slack clone. While developing, I'm logged in as two different users in two different tabs. User 1 creates a new channel but I forgot to add a pubsub message so it never appears in the UI of user 2. I'd expect to be able to reload the page for user 2 to get the new channel, but it seems like there's no message to hook into to do that.

I can think of some hacky ways to get this to work but wondering if there's something built in that I'm missing. Thanks!

Also, is there a better place to ask questions like this rather than creating an issue?

[anzellai]

First of all, thanks for the thoughtful question, this is a gap clearly I haven't covered in the docs.

Working as intended: Sky.Live keeps Model alive across page reload via the sky_sid cookie. init runs on first session, then the runtime restores Model on subsequent reloads until TTL expiry. So for your slack-clone case, the pub/sub publish you noticed missing is the right fix -- reload-as-resync isn't a feature gap, it's a missing broadcast.

If you genuinely want fresh state on reload, easiest path is to clear the sky_sid cookie before navigating; next request gets a fresh session and init fires again.

Q on forum: GitHub Discussions is the right place for usage questions if it's on, otherwise issues are fine for now, and I'll surface this pattern in the Sky.Live docs since you're not the first to hit it.

In near future, perhaps we should use Sky.Live to create a sky-chat or sky-discussion... will properly look at this in a few weeks time.

[bahalperin]

Working as intended: Sky.Live keeps Model alive across page reload via the sky_sid cookie. init runs on first session, then the runtime restores Model on subsequent reloads until TTL expiry. So for your slack-clone case, the pub/sub publish you noticed missing is the right fix -- reload-as-resync isn't a feature gap, it's a missing broadcast.

Thanks for the reply! 100% agree in this case. Maybe a better example would be similar, but in production. The pubsub exists and fires but (for whatever reason) fails. User 2 never sees the new channel, until they trigger some action that reloads the list of channels. For most websites, I think most people would expect that they'll see it on a page reload. Could make sense to have a hook into this that users can handle with a Msg if they want to?

Live.app {
  ...
  onPageLoad : Maybe Msg
}

or an event on url change similar to Elm?

Live.app {
  ...
  onUrlChange : String -> Msg
}

and that could also trigger on the first page load. Just some thoughts off the top of my head that are not super well formed yet. It's also possible this is just a me problem and doesn't need to be addressed at all.

[anzellai]

Working as intended on the init side. Reload isn't the right fix here; pub/sub is. When User 1 creates a channel, broadcast it on a topic and User 2's session picks it up the moment its update runs. No reload, no onPageLoad needed.

A small sketch of the shape:

module Channels exposing (main)

import Sky.Core.Prelude exposing (..)
import Sky.Core.Task as Task
import Std.Live as Live
import Std.Live exposing (route)
import Std.Cmd as Cmd
import Std.Sub as Sub
import Std.Ui as Ui
import Std.Ui exposing (Element)
import Std.Db as Db


channelsTopic : String
channelsTopic = "channels"


type Msg
    = CreateChannelClicked String
    | ChannelCreated String
    | ChannelsReloaded (Result Error (List String))


type alias Model = { channels : List String, draft : String }


init _ =
    ( { channels = [], draft = "" }
    , Cmd.perform fetchChannels ChannelsReloaded )


update msg model =
    case msg of
        CreateChannelClicked name ->
            ( { model | channels = name :: model.channels }
            , Cmd.batch
                [ Cmd.perform (insertChannel name) (always (ChannelCreated name))
                , Cmd.publish channelsTopic name
                ]
            )

        ChannelCreated name ->
            if List.member name model.channels then
                ( model, Cmd.none )
            else
                ( { model | channels = name :: model.channels }, Cmd.none )

        ChannelsReloaded (Ok xs) ->
            ( { model | channels = xs }, Cmd.none )

        ChannelsReloaded (Err _) ->
            ( model, Cmd.none )


subscriptions _ =
    Sub.subscribeTopic channelsTopic ChannelCreated


fetchChannels : Task Error (List String)
fetchChannels = Db.queryDecode "SELECT name FROM channels" ...

insertChannel : String -> Task Error ()
insertChannel name = Db.exec "INSERT INTO channels(name) VALUES(?)" [name] |> Task.map (always ())


view model = ...   -- list + form, dispatches CreateChannelClicked on submit


main =
    Live.app
        { init = init, update = update, view = view, subscriptions = subscriptions
        , routes = [ route "/" () ]
        , notFound = ()
        }

How this closes your case:

1. User 1's update inserts the row, then Cmd.publish channelsTopic name broadcasts.
2. User 2's subscription on channelsTopic delivers ChannelCreated name. Its update appends without reloading.
3. Cmd.publish echoes to the publisher too. The List.member guard de-dups so the publisher's optimistic update doesn't double-add. Use Cmd.publishNoEcho if you'd rather opt out.

For the "session was offline when the broadcast fired" case, init runs fetchChannels at session start (first connect, or after TTL expiry). The DB handles cold-start hydration; pub/sub handles the steady state.

If you want a belt-and-braces periodic resync, Sub.every works too, but for sessions on the same instance pub/sub is the canonical move.

Refs: docs/skylive/pubsub.md, examples/29-pubsub-counter.