wasmify-rails 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ba6a11376e388d3ded351a2c72bfed1bab2063c2b4eb98d8c63f1a5d50214e4
-  data.tar.gz: 8444b60b24fbfac498cf489c09ad0d4787552cee1e921cb3c9f5dece19643666
+  metadata.gz: 4888ee4d3efedd0bd93074f7856cf0be0789bad2ab092c460af84e79603bd0cf
+  data.tar.gz: 163b3dbd14d60250ab04f5e6c1d2b2e601b65e79f51b827bcd50e19cf0bb614a
 SHA512:
-  metadata.gz: 653e2e65cbeb368db2da8b6c357e25d6b017750d906b08a2e60bd71e24c9b5f6410970223a5c13cb806a99b495eb3256b3e1c5964181f0ad0e51a0d85e2190d3
-  data.tar.gz: 105c28242943f9055901e116fb4bac929028b225751d49f5745a3304683a8fb8cb7f8a917119aa63fa0bab1d127b7d96bd1ac2ff12dff3b31e053507549f7d28
+  metadata.gz: '00814ba133827f4b932fe3ee8bce0ff3096fe10ff7b41c28d10ac64353888d9aa0b4078b2c6572b082acf83c693abc7071dfd48eece93fd6d6f8e8e8942bb9b2'
+  data.tar.gz: 2ebed2d0efa0f87e3a8685be5799382ef20dc8b93c7817777c3eb8387e88617197a24a36a7931b8e5790fa6771706c4d689c9382ba12e50e1b9adefae08c2191

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.4.0
+
+- Backport various patches from Rails tutorial.
+
+## 0.3.2
+
+- Add `Rack::WASI::IncomingHandler` mimicking `wasi/http:proxy` interface.
+
 ## 0.3.1
 
 - Use latest patch versions for Ruby 3.3 and 3.4.

data/lib/active_record/connection_adapters/nulldb_adapter/core.rb

@@ -325,7 +325,7 @@ class ActiveRecord::ConnectionAdapters::NullDBAdapter < ActiveRecord::Connection
 
   def new_table_definition(adapter = nil, table_name = nil, is_temporary = nil, options = {})
     case ::ActiveRecord::VERSION::MAJOR
-    when 6, 7
+    when 6, 7, 8
       TableDefinition.new(self, table_name, temporary: is_temporary, options: options.except(:id))
     when 5
       TableDefinition.new(table_name, is_temporary, options.except(:id), nil)

data/lib/active_record/connection_adapters/pglite_adapter.rb

@@ -107,11 +107,19 @@ module ActiveRecord
         private attr_reader :js_interface
 
         def initialize(config)
-          @js_interface = config.fetch(:js_interface, "pglite4rails").to_sym
+          @js_interface =
+            if config[:js_interface]
+              config[:js_interface]
+            else
+              # Set up the database in JS and get the idenfier back
+              JS.global[:pglite].create_interface(config[:database]).await.to_s
+            end.to_sym
           @last_result = nil
           @prepared_statements_map = {}
         end
 
+        def finished? = true
+
         def set_client_encoding(encoding)
         end
 

data/lib/active_record/connection_adapters/sqlite3_wasm_adapter.rb

@@ -52,6 +52,10 @@ module ActiveRecord
 
         def busy_timeout(...) = nil
 
+        def busy_handler_timeout=(...)
+          nil
+        end
+
         def execute(sql)
           @last_statement = Statement.new(self, sql)
           @last_statement.result

data/lib/active_record/tasks/pglite_database_tasks.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class PGliteDatabaseTasks # :nodoc:
+      def self.using_database_configurations?
+        true
+      end
+
+      attr_reader :db_config, :configuration_hash
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
+      end
+
+      def create(connection_already_established = false)
+        JS.global[:pglite].create_interface(db_config.database).await
+      end
+
+      def purge(...)
+        # skip for now
+      end
+    end
+  end
+end

data/lib/rack/data_uri_uploads.rb

@@ -19,7 +19,9 @@ module Rack
 
       request = Rack::Request.new(env)
 
-      if request.post? || request.put? || request.patch?
+      if (
+        request.post? || request.put? || request.patch?
+      ) && request.get_header("HTTP_CONTENT_TYPE").match?(%r{multipart/form-data})
         transform_params(request.params)
         env["action_dispatch.request.request_parameters"] = request.params
       end

data/lib/rack/wasi/incoming_handler.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "uri"
+require "base64"
+require "rack"
+require "rack/test"
+
+require "rack/data_uri_uploads"
+
+module Rack
+  module WASI
+    class Result < Data.define(:value, :error)
+      def tag = error ? "error" : "ok"
+    end
+
+    #  resource incoming-request {
+    #    method: func() -> method;
+    #    path-with-query: func() -> option<string>;
+    #    scheme: func() -> option<scheme>;
+    #    authority: func() -> option<string>;
+    #    headers: func() -> headers;
+    #    consume: func() -> result<incoming-body>;
+    # }
+    # https://github.com/WebAssembly/wasi-http/blob/d163277b8684483a2334363ca1492ca298ea526d/wit/types.wit#L274
+    class IncomingRequest
+      # We use a reference to the global JS object to access the incoming request data.
+      def initialize(js_object_id)
+        @js_object = ::JS.global[js_object_id]
+      end
+
+      def method = @js_object.call(:method).to_s
+
+      def path_with_query
+        path = @js_object.call(:pathWithQuery)
+        if path.typeof == "string"
+          path.to_s
+        end
+      end
+
+      def scheme
+        sch = @js_object.call(:scheme)
+        if sch.typeof == "string"
+          sch.to_s
+        end
+      end
+
+      def authority
+        auth = @js_object.call(:authority)
+        if auth.typeof == "string"
+          auth.to_s
+        end
+      end
+
+      def headers
+        entries = ::JS.global[:Object].entries(@js_object.call(:headers))
+        entries.to_a.each.with_object({}) do |entry_val, acc|
+          key, val = entry_val.to_a
+          acc[key.to_s] = val.to_s
+          acc
+        end
+      end
+
+      # NOTE: Currently, we only support text bodies
+      def consume
+        body = @js_object.call(:consume)
+        if body.typeof == "string"
+          body.to_s
+        end
+      end
+    end
+
+    #  resource response-outparam {
+    #    set: static func(
+    #      param: response-outparam,
+    #      response: result<outgoing-response, error-code>,
+    #    );
+    #  }
+    #
+    # https://github.com/WebAssembly/wasi-http/blob/d163277b8684483a2334363ca1492ca298ea526d/wit/types.wit#L437
+    class ResponseOutparam
+      # We use a reference to the global JS object to access the incoming request data
+      def initialize(js_object_id)
+        @js_object = ::JS.global[js_object_id]
+      end
+
+      def set(result)
+        @js_object.call(:set, ::JS::Object.wrap(result))
+      end
+    end
+
+    #  resource outgoing-response {
+    #    constructor(headers: headers);
+    #    status-code: func() -> status-code;
+    #    set-status-code: func(status-code: status-code) -> result;
+    #    headers: func() -> headers;
+    #    body: func() -> result<outgoing-body>;
+    #  }
+    #
+    #  resource outgoing-body {
+    #    write: func() -> result<output-stream>;
+    #    finish: static func(
+    #        this: outgoing-body,
+    #        trailers: option<trailers>
+    #      ) -> result<_, error-code>;
+    #    }
+    #  }
+    #
+    # https://github.com/WebAssembly/wasi-http/blob/d163277b8684483a2334363ca1492ca298ea526d/wit/types.wit#L572
+    class OutgoingResponse
+      attr_reader :status_code, :headers, :body
+
+      def initialize(headers:, status_code: 200)
+        @headers = headers
+        @status_code = status_code
+        @body = nil
+      end
+
+      def write(response_body)
+        @body = response_body
+      end
+    end
+
+    # wasi:http/proxy-like handler implementation for Rack apps
+    class IncomingHandler
+      private attr_reader :base_url
+
+      def initialize(app, base_url: "http://localhost:3000", skip_data_uri_uploads: false)
+        @app = app
+
+        @app = Rack::DataUriUploads.new(@app) unless skip_data_uri_uploads
+
+        @base_url = base_url
+      end
+
+      # Takes Wasi request, converts it to Rack request,
+      # calls the Rack app, and write Rack response back to the Wasi response.
+      #
+      # @param [Rack::WASI::HTTP::IncomingRequest] req
+      # @param [Rack::WASI::HTTP::ResponseOutparam] res
+      def handle(req, res)
+        uri = URI.join(base_url, req.path_with_query || "")
+        headers = req.headers.each.with_object({}) do |(key, value), headers|
+          headers["HTTP_#{key.upcase.gsub("-", "_")}"] = value
+          headers
+        end
+
+        http_method = req.method.upcase
+        headers[:method] = http_method
+
+        body = req.consume
+        headers[:input] = StringIO.new(body) if body
+
+        request = Rack::MockRequest.env_for(uri.to_s, headers)
+        begin
+          response = Rack::Response[*@app.call(request)]
+          response_status, response_headers, bodyiter = *response.finish
+
+          out_response = OutgoingResponse.new(headers: response_headers, status_code: response_status)
+
+          body = ""
+          body_is_set = false
+
+          bodyiter.each do |part|
+            body += part
+            body_is_set = true
+          end
+
+          # Serve images as base64 from Ruby and decode back in JS
+          # FIXME: extract into a separate middleware and add a header to indicate the transformation
+          if response_headers["Content-Type"]&.start_with?("image/")
+            body = Base64.strict_encode64(body)
+          end
+
+          out_response.write(body) if body_is_set
+          res.set(Result.new(out_response, nil))
+        rescue Exception => e
+          res.set(Result.new(e.message, 503))
+        end
+      end
+    end
+  end
+end

data/lib/rackup/handler/wasi.rb

@@ -0,0 +1,16 @@
+module Rackup
+  module Handler
+    class WASIServer
+      def self.run(app, **options)
+        require "rack/wasi/incoming_handler"
+        port = options[:Port]
+
+        $incoming_handler = ::Rack::WASI::IncomingHandler.new(app)
+
+        ::Wasmify::ExternalCommands.server(port)
+      end
+    end
+
+    register :wasi, WASIServer
+  end
+end

data/lib/wasmify/external_commands.rb

@@ -0,0 +1,23 @@
+module Wasmify
+  module ExternalCommands
+    class << self
+      attr_reader :command
+
+      def register(*names)
+        names.each do |name|
+          module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(...)
+              raise ArgumentError, "Command has been already defined: #{command}" if command
+
+              ::JS.global[:externalCommands].#{name}(...)
+
+              @command = :#{name}
+            end
+          RUBY
+        end
+      end
+
+      def any? = !!command
+    end
+  end
+end

data/lib/wasmify/patcha.rb

@@ -0,0 +1,40 @@
+# Use TracePoint to wait for a particular class to load,
+# so we can apply a patch right away
+module Wasmify
+  module Patcha
+    class << self
+      def on_load(name, &callback)
+        callbacks[name] = callback
+      end
+
+      def on_class(event)
+        # Ignore singletons
+        return if event.self.singleton_class?
+
+        class_name = name_method.bind_call(event.self)
+
+        return unless callbacks[class_name]
+
+        clbk = callbacks.delete(class_name)
+        tracer.disable if callbacks.empty?
+
+        clbk.call
+      end
+
+      def setup!
+        return if callbacks.empty?
+
+        @tracer = TracePoint.new(:end, &method(:on_class))
+        tracer.enable
+        # Use `Module#name` instead of `self.name` to handle overwritten `name` method
+        @name_method = Module.instance_method(:name)
+      end
+
+      private
+
+      attr_reader :tracer, :name_method
+
+      def callbacks = @callbacks ||= {}
+    end
+  end
+end

data/lib/wasmify/rails/patches/action_text.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Wasmify::Patcha.on_load("ActionText::PlainTextConversion") do
+  module ActionText::PlainTextConversion
+    def plain_text_for_node(node)
+      html = node.to_html
+      # FIXME: use external interface?
+      html.gsub(/<[^>]*>/, " ").strip
+    end
+  end
+end

data/lib/wasmify/rails/patches/rails.rb

@@ -0,0 +1,35 @@
+Wasmify::Patcha.on_load("Rails::Server") do
+  Rails::Server.prepend(Module.new do
+    def initialize(options)
+      # disable pid files
+      options.delete(:pid)
+      super
+    end
+
+    # Change the after_stop_callback logic
+    def start(after_stop_callback = nil)
+      Kernel.at_exit(&after_stop_callback) if after_stop_callback
+      super()
+    end
+  end)
+end
+
+Wasmify::Patcha.on_load("Rails::Generators::Actions") do
+  Rails::Generators::Actions.prepend(Module.new do
+    # Always run Rails commands inline (we cannot spawn new processes)
+    def rails_command(command, options = {})
+      super(command, options.merge(inline: true))
+    end
+  end)
+end
+
+Wasmify::Patcha.on_load("Rails::Console::IRBConsole") do
+  Rails::Console::IRBConsole.prepend(Module.new do
+    def start
+      # Disable default IRB behaviour but keep the configuration around
+      ::IRB::Irb.prepend(Module.new { def run(*); end })
+      super
+      ::Wasmify::ExternalCommands.console
+    end
+  end)
+end

data/lib/wasmify/rails/patches.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "wasmify/patcha"
+
+require "wasmify/rails/patches/rails"
+require "wasmify/rails/patches/action_text"
+
+Wasmify::Patcha.setup!

data/lib/wasmify/rails/railtie.rb

@@ -16,7 +16,6 @@ module Wasmify
   end
 end
 
-
 require "action_mailer/null_delivery"
 
 # NullDB for Active Record
@@ -27,3 +26,6 @@ ActiveRecord::ConnectionAdapters.register("sqlite3_wasm", "ActiveRecord::Connect
 
 # PGlite adapter
 ActiveRecord::ConnectionAdapters.register("pglite", "ActiveRecord::ConnectionAdapters::PGliteAdapter", "active_record/connection_adapters/pglite_adapter")
+
+require "active_record/tasks/pglite_database_tasks"
+ActiveRecord::Tasks::DatabaseTasks.register_task(/pglite/, "ActiveRecord::Tasks::PGliteDatabaseTasks")

data/lib/wasmify/rails/shim.rb

@@ -19,11 +19,40 @@ require "bundler"
 # Load core classes and deps patches
 $LOAD_PATH.unshift File.expand_path("shims", __dir__)
 
+# Prevent features:
+#   - `bundler/setup` — we do that manually via `/bundle/setup`#
+%w[
+  bundler/setup
+].each do |feature|
+  $LOAD_PATH.resolve_feature_path(feature)&.then { $LOADED_FEATURES << _1[1] }
+end
+
 # Misc patches
 
+# Stub drb/unix for test parallelization
+$LOADED_FEATURES << $LOAD_PATH.resolve_feature_path("drb/unix")[1]
+
 # Make gem no-op
 define_singleton_method(:gem) { |*| nil }
 
+module FileUtils
+  # Touch doesn't work for some reason
+  def self.touch(path) = File.write(path, "")
+end
+
+# Support Kernel.at_exit
+module Kernel
+  @@at_exit_hooks = []
+
+  def at_exit(&block)
+    @@at_exit_hooks << block
+  end
+
+  def execute_at_exit_hooks
+    @@at_exit_hooks.reverse_each { _1.call }
+  end
+end
+
 # Patch Bundler.require to simply require files without looking at specs
 def Bundler.require(*groups)
   Bundler.definition.dependencies_for([:wasm]).each do |dep|
@@ -60,6 +89,7 @@ class Thread
   def self.new(...)
     f = Fiber.new(...)
     def f.value = resume
+    def f.join = value
     f
   end
 end

data/lib/wasmify/rails/shims/nokogiri.rb

@@ -0,0 +1,165 @@
+# This is a minimal Nokogiri stub to make Action Text basic features work (no embeddings)
+module Nokogiri
+  module XML
+    class DocumentFragment
+    end
+
+    module Node
+      module SaveOptions
+        AS_HTML = 1
+      end
+    end
+  end
+
+  module HTML5
+    class Document
+      def initialize
+        # TODO
+      end
+
+      def encoding=(enc)
+      end
+
+      def fragment(html)
+        DocumentFragment.new(html)
+      end
+
+      def create_element(tag_name, attributes = {})
+        # Create an element with given tag name and attributes
+      end
+    end
+
+    class DocumentFragment < XML::DocumentFragment
+      attr_reader :elements, :name
+
+      def initialize(html_string)
+        @html_string = html_string
+        @elements = []
+        @name = html_string.match(/<(\w+)/).then { next unless _1; _1[1] }
+      end
+
+      def css(selector)
+        # Return array of matching nodes
+        # Must support selectors like:
+        # - "a[href]" - anchor tags with href attribute
+        # - "action-text-attachment" - elements by tag name
+        # - Complex selectors for attachment galleries
+        []
+      end
+
+      def children
+        []
+      end
+
+      def dup
+        self.class.new(@html_string)
+      end
+
+      def to_html(options = {})
+        # Must respect options[:save_with] if provided
+        @html_string
+      end
+
+      def elements
+        self
+      end
+
+      def deconstruct
+        children
+      end
+    end
+
+    class Node
+      attr_accessor :parent
+
+      def initialize(name, attributes = {})
+        @name = name
+        @attributes = attributes
+        @children = []
+        @text = ""
+      end
+
+      # Node type and content
+      def name
+        @name # e.g., "p", "div", "text", etc.
+      end
+
+      def text
+        # Return text content (for text nodes) or aggregate text of children
+      end
+
+      def text?
+        # Return true if this is a text node
+        name == "text" || name == "#text"
+      end
+
+      # Attribute access
+      def [](attribute_name)
+        # Get attribute value
+        @attributes[attribute_name]
+      end
+
+      def []=(attribute_name, value)
+        # Set attribute value
+        @attributes[attribute_name] = value
+      end
+
+      def key?(attribute_name)
+        # Check if attribute exists
+        @attributes.key?(attribute_name)
+      end
+
+      def remove_attribute(attribute_name)
+        # Remove attribute and return its value
+        @attributes.delete(attribute_name)
+      end
+
+      # DOM traversal
+      def children
+        # Return array of child nodes
+        @children
+      end
+
+      def ancestors
+        # Return array of ancestor nodes (parent, grandparent, etc.)
+        result = []
+        node = parent
+        while node
+          result << node
+          node = node.parent
+        end
+        result
+      end
+
+      # DOM manipulation
+      def replace(replacement)
+        # Replace this node with the replacement (string or node)
+        # If replacement is a string, parse it as HTML
+      end
+
+      # CSS matching
+      def matches?(selector)
+        # Check if this node matches the given CSS selector
+      end
+
+      # HTML output
+      def to_html(options = {})
+        # Convert to HTML string
+      end
+
+      def to_s
+        to_html
+      end
+
+      def inspect
+        # For debugging
+        "#<Node:#{name} #{@attributes.inspect}>"
+      end
+    end
+  end
+
+  module HTML4
+    Document = HTML5::Document
+    DocumentFragment = HTML5::DocumentFragment
+  end
+end

data/lib/wasmify/rails/shims/rails-html-sanitizer.rb

@@ -138,6 +138,9 @@ module Rails
         def full_sanitizer = self
         def link_sanitizer = self
         def safe_list_sanitizer = self
+        def allowed_tags = []
+        def allowed_attributes = []
+        def allowed_styles = []
       end
 
       def sanitize(html, ...) = html

data/lib/wasmify/rails/shims/socket.rb

@@ -9,6 +9,10 @@ end
 class Socket < BasicSocket
   AF_UNSPEC = 0
   AF_INET = 1
+
+  def self.gethostname
+    "localhost"
+  end
 end
 
 class IPSocket < Socket

data/lib/wasmify/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Wasmify
   module Rails # :nodoc:
-    VERSION = "0.3.1"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wasmify-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-07 00:00:00.000000000 Z
+date: 2025-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -137,6 +137,7 @@ files:
 - lib/active_record/connection_adapters/pglite_adapter.rb
 - lib/active_record/connection_adapters/pglite_shims/pg.rb
 - lib/active_record/connection_adapters/sqlite3_wasm_adapter.rb
+- lib/active_record/tasks/pglite_database_tasks.rb
 - lib/generators/wasmify/install/USAGE
 - lib/generators/wasmify/install/install_generator.rb
 - lib/generators/wasmify/install/templates/config/environments/wasm.rb
@@ -153,10 +154,17 @@ files:
 - lib/generators/wasmify/pwa/templates/pwa/vite.config.js
 - lib/image_processing/null.rb
 - lib/rack/data_uri_uploads.rb
+- lib/rack/wasi/incoming_handler.rb
+- lib/rackup/handler/wasi.rb
 - lib/wasmify-rails.rb
+- lib/wasmify/external_commands.rb
+- lib/wasmify/patcha.rb
 - lib/wasmify/rails/builder.rb
 - lib/wasmify/rails/configuration.rb
 - lib/wasmify/rails/packer.rb
+- lib/wasmify/rails/patches.rb
+- lib/wasmify/rails/patches/action_text.rb
+- lib/wasmify/rails/patches/rails.rb
 - lib/wasmify/rails/railtie.rb
 - lib/wasmify/rails/shim.rb
 - lib/wasmify/rails/shims/io/console.rb