monkrb 0.17.0 → 0.19.0

data/lib/monk/live/client/protocol.js

@@ -8,6 +8,11 @@ export const MAX_DELAY = 30000;
 // Reconnect backoff: double, capped.
 export const nextDelay = (delay) => Math.min(delay * 2, MAX_DELAY);
 
+// The wait actually used: 50%..150% of the backoff delay. When the WS process
+// restarts, every open page loses its socket at once; without jitter they all
+// reconnect, and all refetch their page (resync), at the same instant.
+export const jittered = (delay, random = Math.random) => Math.floor(delay * (0.5 + random()));
+
 const MODES = ["morph", "replace", "append", "prepend", "remove"];
 
 // data-live-topic values ("a:1 b:2") -> a sorted, de-duplicated topic list.

data/lib/monk/live.rb

@@ -62,6 +62,16 @@ module Monk
         @max_topics = max_topics
       end
 
+      # Boot-time, main Ractor, in the WS process only (bin/websocket_server):
+      # starts the configured registry relaying other processes' updates
+      # to this process's sockets. A publish-only process (bin/server,
+      # bin/jobs) never calls it, so it opens no subscriber connection.
+      def listen!
+        registry || raise(NotConfiguredError,
+          "Monk::Live isn't configured -- call Monk::Live.configure(registry: ...) before listen!",)
+        registry.listen!
+      end
+
       # Boot-time, main Ractor. See Monk::Live::Policy for the semantics:
       # deny by default, first matching rule wins, anonymous subjects need
       # `anonymous: true`. The block must be Ractor-shareable.

data/lib/monk/mail/errors.rb

@@ -24,5 +24,12 @@ module Monk
     # refusing it. The transport's own exception is the #cause.
     class DeliveryError < StandardError
     end
+
+    # A DeliveryError the server made final: an SMTP 5xx (no such mailbox,
+    # relaying refused) or refused credentials. Raised by
+    # Monk::Mail::DeliveryJob (require "monk/mail/later") so the job isn't
+    # retried; still a DeliveryError, so a rescue of that catches it too.
+    class PermanentDeliveryError < DeliveryError
+    end
   end
 end

data/lib/monk/mail/later.rb

@@ -0,0 +1,53 @@
+require_relative "../mail"
+require_relative "../jobs"
+
+module Monk
+  module Mail
+    # Sends one message from a job process (docs/adr/0014-mail-from-jobs-and-login-links-created-in-the-job.md).
+    # Enqueued by Monk::Mail.deliver_later, never directly: its argument
+    # is the message's fields, already checked and with from: resolved.
+    class DeliveryJob < Monk::Job
+      queue "mailers"
+      never_retry PermanentDeliveryError
+
+      # The SMTP failures that are final, by class name so this file never
+      # loads net/smtp itself (the app's Gemfile decides that, ADR 0012):
+      # a 5xx reply, a malformed command, refused credentials. Everything
+      # else -- a 4xx "try later", a refused connection, TLS, a timeout --
+      # is worth retrying.
+      PERMANENT_SMTP_ERRORS = %w[Net::SMTPFatalError Net::SMTPSyntaxError Net::SMTPAuthenticationError].freeze
+
+      def self.perform(fields)
+        Monk::Mail.deliver(**fields.transform_keys(&:to_sym))
+      rescue DeliveryError => e
+        raise unless PERMANENT_SMTP_ERRORS.include?(e.cause&.class&.name)
+
+        raise PermanentDeliveryError, e.message
+      end
+    end
+
+    class << self
+      # deliver, later: the same arguments, plus enqueue's wait:, at: and
+      # conn: (the last one enqueues inside the caller's transaction, so the
+      # email commits or rolls back with the app's own writes). Returns the
+      # job's id. The message is built -- and so checked -- here, before
+      # anything is enqueued: bad input raises InvalidMessageError in the
+      # caller, exactly as deliver would, rather than failing later in the
+      # job process. Render HTML before calling (html: Monk::Mail.render(...)):
+      # the job stores the finished message and only sends it.
+      #
+      #   Monk::Mail.deliver_later(to: order[:email], subject: "Your receipt", text: receipt_text)
+      def deliver_later(to:, subject:, text: nil, html: nil, reply_to: nil, from: nil, wait: nil, at: nil, conn: nil)
+        raise NotConfiguredError, "call Monk::Mail.configure(url:, from:) before Monk::Mail.deliver_later" unless config
+
+        from ||= config[:from]
+        if from.nil?
+          raise InvalidMessageError, "no from: given, and Monk::Mail.configure has no default from: (MAIL_FROM)"
+        end
+
+        message = Message.new(from: from, to: to, subject: subject, text: text, html: html, reply_to: reply_to)
+        DeliveryJob.enqueue(message.to_h.transform_keys(&:to_s), wait: wait, at: at, conn: conn)
+      end
+    end
+  end
+end

data/lib/monk/persistence/pg.rb

@@ -1,3 +1,4 @@
+require "json"
 require "pg"
 
 require_relative "../persistence"
@@ -16,12 +17,31 @@ module Monk
     module Pg
       extend Monk::Persistence::Registry
 
+      # json/jsonb columns, decoded with plain JSON.parse. pg's own
+      # PG::TextDecoder::JSON (1.6.3) calls JSON.parse(string, quirks_mode:
+      # true), and json 3 removed that keyword, so with pg's default every
+      # json/jsonb read raised ArgumentError. json 3 parses a bare scalar
+      # ("7", "\"text\"") without it.
+      class JsonDecoder < PG::SimpleDecoder
+        def decode(string, _tuple = nil, _field = nil)
+          JSON.parse(string)
+        end
+      end
+
+      # pg's default result types, with JsonDecoder for json and jsonb.
+      # Built once and made shareable, so every Ractor's #connect can use
+      # it rather than building its own.
+      RESULT_TYPES = Ractor.make_shareable(
+        PG::BasicTypeRegistry.new.register_default_types
+          .tap { |types| %w[json jsonb].each { |name| types.register_type(0, name, nil, JsonDecoder) } },
+      )
+
       class << self
         private
 
         def connect(**opts)
           conn = PG.connect(**opts)
-          conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn)
+          conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn, registry: RESULT_TYPES)
           conn
         end