monkrb 0.20.0 → 0.21.0

data/lib/monk/templates/base/bin/websocket_server

@@ -1,77 +0,0 @@
-#!/usr/bin/env ruby
-require "bundler/setup"
-require_relative "../config/settings"
-
-# config/auth.rb only exists if this app was scaffolded with --auth -- a
-# missing file is a harmless no-op, the same way config/settings.rb treats
-# a missing dotenv gem. Present or not, it's what decides whether this
-# process authenticates connections below.
-begin
-  require_relative "../config/auth"
-rescue LoadError
-end
-
-require "monk/websocket"
-
-# A single broadcast chat channel: every connection subscribes to :chat,
-# and whatever one connection sends is broadcast to everyone on it
-# (including itself), prefixed with the authenticated subject when there
-# is one.
-#
-# Defined inside a module, not at this script's own top level -- self at a
-# script's top level is the main object, which is *not* Ractor-shareable,
-# so a proc built there fails Server#run's Ractor.make_shareable check.
-# Module bodies are always shareable, same as StateRactor#update's block
-# requirement.
-module ChatServer
-  # REDIS_URL set (by an app scaffolded with --redis, or by hand) wraps the
-  # registry so :chat also fans out to every other Monk::WebSocket::Server
-  # process sharing that Redis -- unset, it's in-process only. Either way
-  # the app code above never has to know which: RedisFanout has the exact
-  # same #register/#unregister/#count/#broadcast interface as Registry.
-  REGISTRY =
-    if (redis_url = ENV["REDIS_URL"])
-      require "monk/websocket/redis_fanout"
-      Monk::WebSocket::RedisFanout.new(Monk::WebSocket::Registry.new, redis_url: redis_url)
-    else
-      Monk::WebSocket::Registry.new
-    end
-
-  HANDLER = proc do |connection|
-    connection.subscribe(REGISTRY, :chat)
-    loop do
-      message = connection.read
-      break unless message
-
-      REGISTRY.broadcast(:chat, "#{connection.subject || "guest"}: #{message}")
-    end
-  end
-end
-
-# This process holds the sockets, so it's the one that listens for other
-# processes' broadcasts: with REDIS_URL, a subscriber connection, opened
-# here at boot (an unreachable Redis fails right here). A plain Registry
-# has nothing to listen to, and listen! does nothing.
-ChatServer::REGISTRY.listen!
-
-# false, not nil, without --auth: Server.new refuses nil.
-authenticate = !!(defined?(Monk::Auth) && Monk::Auth.config)
-# Sessions are checked through config/auth.rb's :auth pool rather than in
-# each socket's own Ractor, which would hold a Postgres connection per
-# open page. This is the only process that uses the pool, so it starts it.
-db_pool = (:auth if authenticate)
-Monk::Persistence::Pg.start_pools!(db_pool) if db_pool
-
-port = ENV.fetch("WS_PORT", "9293").to_i
-# Defaults to public_url (config/settings.rb) so one PUBLIC_URL env var
-# keeps this in sync with the app's actual origin instead of two vars
-# drifting apart; set WS_ALLOWED_ORIGINS directly for anything more, e.g.
-# more than one origin (comma-separated).
-allowed_origins = ENV.fetch("WS_ALLOWED_ORIGINS", Monk::Settings[:public_url]).split(",")
-
-server = Monk::WebSocket::Server.new(
-  port: port, authenticate: authenticate, allowed_origins: allowed_origins, db_pool: db_pool,
-)
-puts "Monk::WebSocket::Server listening on ws://0.0.0.0:#{port} " \
-  "(authenticate: #{authenticate}, redis fan-out: #{ENV["REDIS_URL"] ? "on" : "off"})"
-server.run(&ChatServer::HANDLER)

data/lib/monk/templates/jobs/app/jobs/send_login_link.rb

@@ -1,28 +0,0 @@
-# Sends a magic link from bin/jobs instead of the login request. The token
-# is created here, right before it's sent, so the raw token is never
-# stored anywhere -- not even in the job queue, which a plain
-# Monk::Mail.deliver_later of the link would do (Monk's
-# docs/adr/0014-mail-from-jobs-and-login-links-created-in-the-job.md).
-# Enqueue it from your login route, after your own per-email rate limit
-# and with a redirect_to already checked against redirect_allowlist:
-#
-#   post("/auth/request") do
-#     SendLoginLink.enqueue(params[:email])
-#     json(sent: true)
-#   end
-class SendLoginLink < Monk::Job
-  queue "mailers"
-  # About 50 seconds of retries: a login email minutes late, after the
-  # user has likely asked for another, is worse than none.
-  max_attempts 3
-  never_retry Monk::InvalidRedirectError
-
-  def self.perform(email, redirect_to = nil)
-    token = Monk::Auth.request_login(email, redirect_to: redirect_to)
-    # Your callback route; config/settings.rb's public_url is the origin.
-    link = "#{Monk::Settings[:public_url]}/auth/callback/#{token}"
-    # Calls config/auth.rb's deliver: (AppMailer::MAGIC_LINK) -- a
-    # synchronous send, here in the job.
-    Monk::Auth.deliver_link(email: email, link: link, token: token)
-  end
-end

data/lib/monk/templates/live/app/app.rb

@@ -1,22 +0,0 @@
-class App < Monk::Base
-  views "app/views"
-  layout "layouts/app"
-  assets "public"
-
-  # State shared across requests lives in a StateRactor; the update block is
-  # built here, where self is shareable, not inline in the route.
-  hits = Monk::StateRactor.new(0)
-  increment = Ractor.make_shareable(proc { |n| n + 1 })
-
-  get("/") { @title = "App"; render "index", hits: hits.value }
-
-  # Change state, then tell every open page that shows it. Monk::Live.patch
-  # renders the partial once and pushes it to the "hits" topic's subscribers.
-  post("/hit") do
-    Monk::Live.patch("hits", to: "#hits", partial: "live/_hits", hits: hits.update(&increment))
-    redirect "/"
-  end
-
-  get("/hello") { "hello from monk" }
-  get("/api/hello") { json(message: "hello from monk") }
-end

data/lib/monk/templates/live/app/views/index.erb

@@ -1,18 +0,0 @@
-<h1>Monk::Live</h1>
-<p>
-  Open this page in two tabs and press the button in one: the counter in the
-  other updates by itself. The server pushes the new HTML over a WebSocket;
-  there is no polling and no page JavaScript of your own.
-</p>
-
-<%# live_topic makes this element's page subscribe to the "hits" topic. %>
-<p <%= live_topic "hits" %>>Hits so far: <%= render "live/_hits", hits: locals[:hits], layout: false %></p>
-
-<form method="post" action="/hit"><button>+1</button></form>
-
-<p>
-  The pieces: <code>live_topic</code> in this view, the partial
-  <code>app/views/live/_hits.erb</code>, <code>Monk::Live.patch</code> in
-  <code>POST /hit</code> (<code>app/app.rb</code>), and the rules and Redis
-  wiring in <code>config/live.rb</code>.
-</p>

data/lib/monk/templates/live/bin/websocket_server

@@ -1,50 +0,0 @@
-#!/usr/bin/env ruby
-require "bundler/setup"
-require_relative "../config/settings"
-
-# config/auth.rb only exists if this app was scaffolded with --auth -- a
-# missing file is a harmless no-op, the same way config/settings.rb treats
-# a missing dotenv gem. Present or not, it's what decides whether this
-# process authenticates connections below.
-begin
-  require_relative "../config/auth"
-rescue LoadError
-end
-
-# Monk::Live: the browsers' sockets end here. The handler takes their
-# subscribe/unsubscribe messages, checks each topic against the rules in
-# config/live.rb, and relays whatever bin/server's process publishes over
-# Redis.
-require_relative "../config/live"
-
-# This process holds the browsers' sockets, so it's the only one that
-# listens for updates published elsewhere (bin/server, bin/jobs): the
-# fanout's subscriber connection is opened here, at boot, and an
-# unreachable Redis/Postgres fails right here.
-Monk::Live.listen!
-
-# With Monk::Auth (--auth), a socket with a valid session gets its user,
-# and one without -- a visitor, or a session since revoked -- comes in
-# anonymous instead of refused. The rules in config/live.rb decide what
-# each may subscribe to: a topic is open to visitors only if its rule says
-# `anonymous: true`, like the demo's "hits". Without Monk::Auth every
-# socket is anonymous.
-authenticate = defined?(Monk::Auth) && Monk::Auth.config ? :optional : false
-# Sessions are checked through config/auth.rb's :auth pool rather than in
-# each socket's own Ractor, which would hold a Postgres connection per
-# open page. This is the only process that uses the pool, so it starts it.
-db_pool = (:auth if authenticate)
-Monk::Persistence::Pg.start_pools!(db_pool) if db_pool
-
-port = ENV.fetch("WS_PORT", "9293").to_i
-# Defaults to public_url (config/settings.rb) so one PUBLIC_URL env var
-# keeps this in sync with the app's actual origin instead of two vars
-# drifting apart; set WS_ALLOWED_ORIGINS directly for anything more, e.g.
-# more than one origin (comma-separated).
-allowed_origins = ENV.fetch("WS_ALLOWED_ORIGINS", Monk::Settings[:public_url]).split(",")
-
-server = Monk::WebSocket::Server.new(
-  port: port, authenticate: authenticate, allowed_origins: allowed_origins, db_pool: db_pool,
-)
-puts "Monk::Live WebSocket server listening on ws://0.0.0.0:#{port} (authenticate: #{authenticate})"
-server.run(&Monk::Live::HANDLER)

data/lib/monk/templates/live/config/live_pg.rb

@@ -1,60 +0,0 @@
-# Monk::Live wiring, required by both processes: config/load.rb (this app
-# publishes updates, e.g. from a route) and bin/websocket_server (the browsers'
-# sockets terminate there and are handed the updates).
-#
-# They are separate processes, so *something* has to carry a publish from
-# one to the other. `monk new --live --postgres` (and not --redis) wired
-# this file instead of the Redis-based default -- Postgres LISTEN/NOTIFY
-# carries the publish instead, reusing the exact DB_* env vars
-# config/persistence.rb already reads, so there's no Redis to run. The
-# tradeoff: a single broadcast is capped at just under 8000 bytes
-# (Monk::WebSocket::PgFanout::MAX_NOTIFY_PAYLOAD_BYTES, Postgres's own
-# NOTIFY limit) -- regenerate with --redis instead if that becomes a real
-# constraint. Full design in the monk gem's own docs/design/live-pg-fanout.md.
-require_relative "settings"
-require "monk/live"
-require "monk/websocket/pg_fanout"
-
-# Where the browser opens its WebSocket (read by the layout). In
-# development there's no reverse proxy in front, so this is the direct WS
-# port; outside development it defaults to a /ws path under public_url
-# (config/settings.rb) -- matching the path-based proxy routing
-# docs/guides/deploying.md's "Adding Monk::WebSocket" section sets up, so
-# setting PUBLIC_URL alone keeps this in sync instead of two env vars
-# drifting apart. Override with LIVE_WS_URL directly if your setup doesn't
-# fit that shape.
-default_live_ws_url =
-  if Monk.env.development?
-    "ws://localhost:9293"
-  else
-    Monk::Settings[:public_url].sub(/\Ahttps:\/\//, "wss://").sub(/\Ahttp:\/\//, "ws://") + "/ws"
-  end
-
-Monk::Settings.configure do
-  optional :live_ws_url, default: default_live_ws_url
-end
-
-Monk::Live.configure(
-  registry: Monk::WebSocket::PgFanout.new(
-    Monk::WebSocket::Registry.new,
-    pg_opts: {
-      host: ENV.fetch("DB_HOST", "127.0.0.1"),
-      port: ENV.fetch("DB_PORT", "5432").to_i,
-      user: ENV.fetch("DB_USER", "postgres"),
-      password: ENV.fetch("DB_PASSWORD", "postgres"),
-      dbname: ENV.fetch("DB_NAME", "app_development"),
-    },
-  ),
-)
-
-# Who may subscribe to what. Nothing is allowed unless a rule says so, and an
-# anonymous connection is denied unless the rule opts in with `anonymous: true`.
-# The rule blocks live in a module because they have to be Ractor-shareable
-# (self at the top of this file is not).
-module AppLive
-  # The demo counter is public. A real rule looks at who is asking:
-  #   proc { |subject, topic| topic == "contacts:#{subject}" }
-  PUBLIC = proc { |_subject, _topic| true }
-end
-
-Monk::Live.authorize("hits", anonymous: true, &AppLive::PUBLIC)

data/lib/monk/templates/mail/Gemfile.extra

@@ -1 +0,0 @@
-gem "net-smtp" # Monk::Mail's smtp:// transport (config/mail.rb)

data/lib/monk/templates/postgres/Dockerfile

@@ -1,32 +0,0 @@
-# Same shape as the base Dockerfile, plus libpq: the pg gem's native
-# extension needs libpq-dev (headers) to compile in the builder stage and
-# libpq5 (the runtime lib alone, no headers) in the final image.
-FROM ruby:4.0-slim AS builder
-WORKDIR /app
-
-RUN apt-get update -qq \
-    && apt-get install -y --no-install-recommends build-essential libpq-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY Gemfile Gemfile.lock* ./
-RUN bundle install
-
-FROM ruby:4.0-slim
-WORKDIR /app
-
-RUN apt-get update -qq \
-    && apt-get install -y --no-install-recommends libpq5 \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY --from=builder /usr/local/bundle /usr/local/bundle
-COPY . .
-
-# Matches bin/server's own default (PORT overrides both, e.g. on a
-# platform that assigns its own). bin/websocket_server (WS_PORT default
-# 9293) is a separate process/deploy unit -- run this same image with
-# `bin/websocket_server` as the command instead of publishing another
-# port from this Dockerfile -- see docs/guides/deploying.md. With --jobs,
-# bin/jobs is another one, the same way: this image, `bin/jobs` as the
-# command, no port at all.
-EXPOSE 9292
-CMD ["bin/server", "--bind", "0.0.0.0"]

data/lib/monk/templates/postgres/Gemfile.extra

@@ -1,2 +0,0 @@
-gem "pg"
-gem "irb"

data/lib/monk/templates/redis/Gemfile.extra

@@ -1 +0,0 @@
-gem "redis"