wasmify-rails 0.1.0

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

@@ -0,0 +1,15 @@
+class ActiveRecord::ConnectionAdapters::NullDBAdapter
+
+  class Statement
+    attr_reader :entry_point, :content
+
+    def initialize(entry_point, content = "")
+      @entry_point, @content = entry_point, content
+    end
+
+    def ==(other)
+      self.entry_point == other.entry_point
+    end
+  end
+
+end

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

@@ -0,0 +1,23 @@
+class ActiveRecord::ConnectionAdapters::NullDBAdapter
+
+  class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+    attr_accessor :name
+    alias_method :enum, :string
+    alias_method :uuid, :string
+    alias_method :citext, :text
+    alias_method :interval, :text
+    alias_method :geometry, :text
+    alias_method :serial, :integer
+    alias_method :bigserial, :integer
+    alias_method :inet, :string
+    alias_method :jsonb, :json if method_defined? :json
+    alias_method :hstore, :json
+
+    if ::ActiveRecord::VERSION::MAJOR == 7 && ::ActiveRecord::VERSION::MINOR >= 1
+      # Avoid check for option validity
+      def create_column_definition(name, type, options)
+        ActiveRecord::ConnectionAdapters::ColumnDefinition.new(name, type, options)
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/nulldb_adapter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'stringio'
+require 'singleton'
+require 'pathname'
+
+require 'active_support'
+require 'active_support/deprecation'
+require 'active_record/connection_adapters/nulldb_adapter'
+
+module NullDB
+  class Configuration < Struct.new(:project_root); end
+
+  class << self
+    def configure
+      @configuration = Configuration.new.tap {|c| yield c}
+    end
+
+    def configuration
+      if @configuration.nil?
+        raise "NullDB not configured. Require a framework, ex 'nulldb/rails'"
+      end
+
+      @configuration
+    end
+
+    def nullify(options={})
+      begin
+        @prev_connection = ActiveRecord::Base.connection_pool.try(:spec)
+      rescue ActiveRecord::ConnectionNotEstablished
+      end
+      ActiveRecord::Base.establish_connection(options.merge(:adapter => :nulldb))
+    end
+
+    def restore
+      if @prev_connection
+        ActiveRecord::Base.establish_connection(@prev_connection.config)
+      end
+    end
+
+    def checkpoint
+      ActiveRecord::Base.connection.checkpoint!
+    end
+  end
+end
+
+# Need to defer calling Rails.root because when bundler loads, Rails.root is nil
+NullDB.configure {|ndb| def ndb.project_root;Rails.root;end}
+
+class ActiveRecord::Base
+  # Instantiate a new NullDB connection.  Used by ActiveRecord internally.
+  def self.nulldb_connection(config)
+    ActiveRecord::ConnectionAdapters::NullDBAdapter.new(config)
+  end
+end
+
+require 'active_record/connection_adapters/nulldb_adapter/core'
+require 'active_record/connection_adapters/nulldb_adapter/statement'
+require 'active_record/connection_adapters/nulldb_adapter/checkpoint'
+require 'active_record/connection_adapters/nulldb_adapter/column'
+require 'active_record/connection_adapters/nulldb_adapter/configuration'
+require 'active_record/connection_adapters/nulldb_adapter/empty_result'
+require 'active_record/connection_adapters/nulldb_adapter/index_definition'
+require 'active_record/connection_adapters/nulldb_adapter/null_object'
+require 'active_record/connection_adapters/nulldb_adapter/table_definition'
+require 'active_record/connection_adapters/nulldb_adapter/quoting'

data/lib/active_record/connection_adapters/sqlite3_wasm_adapter.rb

@@ -0,0 +1,163 @@
+require "active_record/connection_adapters/sqlite3_adapter"
+
+module SQLite3
+  module Database
+    def self.quote(s) = s.gsub("'", "''")
+  end
+
+  module Pragmas
+  end
+end
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    def sqlite3_wasm_adapter_class
+      ConnectionAdapters::SQLite3WasmAdapter
+    end
+
+    def sqlite3_wasm_connection(config)
+      sqlite3_wasm_adapter_class.new(config)
+    end
+  end
+
+  module ConnectionAdapters
+    class SQLite3WasmAdapter < SQLite3Adapter
+      class ExternalInterface
+        private attr_reader :js_interface
+
+        def initialize(config)
+          @js_interface = config.fetch(:js_interface, "sqlite4rails").to_sym
+        end
+
+        def exec(...)
+          JS.global[js_interface].exec(...)
+        end
+
+        def busy_timeout(...) = nil
+
+        def execute(sql)
+          @last_statement = Statement.new(self, sql)
+          @last_statement.result
+        end
+
+        def prepare(sql) = Statement.new(self, sql)
+
+        def closed? = false
+
+        def transaction(mode = nil)
+          # deferred doesn't work 🤷‍♂️
+          mode = nil if mode.nil?
+          execute "begin #{mode} transaction"
+
+          if block_given?
+            abort = false
+            begin
+              yield self
+            rescue
+              abort = true
+              raise
+            ensure
+              abort and rollback or commit
+            end
+          else
+            true
+          end
+        end
+
+        def commit
+          execute "commit transaction"
+          true
+        end
+
+        def rollback
+          execute "rollback transaction"
+          true
+        end
+
+        def changes
+          JS.global[js_interface].changes.to_i
+        end
+      end
+
+      class Statement
+        attr_reader :interface, :sql
+
+        def initialize(interface, sql)
+          @interface = interface
+          @sql = sql
+          @columns = nil
+          @rows = nil
+        end
+
+        def close = nil
+
+        def columns
+          execute
+          @columns
+        end
+
+        def result
+          execute
+          @rows.map { @columns.zip(_1).to_h }.freeze
+        end
+
+        def to_a
+          execute
+          @rows
+        end
+
+        def execute
+          return if @rows
+
+          res = interface.exec(sql)
+          # unwrap column names
+          cols = res[:cols].to_a.map(&:to_s)
+          # unwrap row values
+          rows = res[:rows].to_a.map do |row|
+            row.to_a.map do |val|
+              str_val = val.to_s
+              next str_val if val.typeof == "string"
+              next str_val == "true" if val.typeof == "boolean"
+
+              # handle integers and floats
+              next str_val.include?(".") ? val.to_f : val.to_i if val.typeof == "number"
+
+              str_val
+            end
+          end
+
+          @columns = cols
+          @rows = rows
+        end
+
+        def reset!
+          @rows = nil
+          @columns = nil
+        end
+      end
+
+      class << self
+        def database_exists?(config)
+          true
+        end
+
+        def new_client(config) = ExternalInterface.new(config)
+      end
+
+      attr_reader :external_interface
+
+      def initialize(...)
+        AbstractAdapter.instance_method(:initialize).bind_call(self, ...)
+
+        @prepared_statements = false
+        @memory_database = false
+        @connection_parameters = @config.merge(database: @config[:database].to_s, results_as_hash: true)
+        @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
+      end
+
+      def database_exists? = true
+
+      def database_version = SQLite3Adapter::Version.new("3.45.1")
+    end
+  end
+end

data/lib/active_storage/null_delivery.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  class NullDeliveryMethod
+    def initialize(*)
+    end
+
+    def deliver!(_)
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_mailer) do
+  ActionMailer::Base.add_delivery_method :null
+end

data/lib/generators/wasmify/install/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Configures the application for Wasm-ification
+
+Example:
+    bin/rails generate wasmify:install

data/lib/generators/wasmify/install/install_generator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class Wasmify::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path("templates", __dir__)
+
+  def copy_files
+    template "config/wasmify.yml"
+    template "config/environments/wasm.rb"
+  end
+
+  def configure_database
+     append_to_file "config/database.yml", <<~EOF
+        wasm:
+          adapter: <%= ENV.fetch("ACTIVE_RECORD_ADAPTER") { "nulldb" } %>
+     EOF
+  end
+
+  def configure_action_cable
+    in_root do
+      next unless File.file?("config/cable.yml")
+
+      append_to_file "config/cable.yml", <<~EOF
+
+        wasm:
+          adapter: <%= ENV.fetch("ACTION_CABLE_ADAPTER") { "inline" } %>
+      EOF
+    end
+  end
+
+  def configure_gitignore
+    append_to_file ".gitignore", <<~EOF
+      # Ignore the compiled WebAssembly modules
+      *.wasm
+      # Ignore ruby.wasm build artefacts
+      build/
+      rubies/
+      dist/
+    EOF
+  end
+
+  def inject_wasmify_shim_into_environment
+    inject_into_file "config/application.rb", after: /require_relative\s+['"]boot['"]\n/ do
+      <<~RUBY
+
+        require "wasmify/rails/shim"
+      RUBY
+    end
+  end
+
+  def skip_bundler_setup_in_boot
+    inject_into_file "config/boot.rb", after: /require ['"]bundler\/setup['"]/ do
+      " unless RUBY_PLATFORM =~ /wasm/"
+    end
+  end
+
+  def add_tzinfo_data_to_gemfile
+    append_to_file "Gemfile", <<~RUBY
+
+      group :wasm do
+        gem "tzinfo-data"
+      end
+    RUBY
+
+    run "bundle install"
+  end
+
+  def finish
+    say_status :info, "✅ The application is prepared for Wasm-ificaiton!\n\n" \
+                      "Next steps are:\n" \
+                      " - Gemfile: Add `group: [:default, :wasm]` to the dependencies required in Wasm runtime" \
+                      " - Run `bin/rails wasmify:build:core:verify` to see if the bundle compiles"
+  end
+end

data/lib/generators/wasmify/install/templates/config/environments/wasm.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "production"
+
+Rails.application.configure do
+  config.enable_reloading = false
+
+  config.assume_ssl = false
+  config.force_ssl  = false
+
+  # FIXME: Tags are not being reset right now
+  config.log_tags = []
+
+  if ENV["DEBUG"] == "1"
+    config.consider_all_requests_local = true
+    config.action_dispatch.show_exceptions = :none
+    config.log_level = :debug
+    config.logger = Logger.new($stdout)
+  end
+
+  config.cache_store = :memory_store
+  config.active_job.queue_adapter = :inline
+  config.action_mailer.delivery_method = :null
+
+  if config.respond_to?(:active_storage)
+    config.active_storage.variant_processor = :null
+  end
+
+  config.secret_key_base = "<change-me>"
+end

data/lib/generators/wasmify/install/templates/config/wasmify.yml

@@ -0,0 +1,17 @@
+# Specify the list of directories to be included into the final
+# app.wasm file.
+pack_directories:
+  - app
+  - lib
+  - config
+  - db
+  - public
+
+# Specify the list of gems to skip during the base module compiliation.
+# Usually, you want to specify the gems with native extensions that are
+# not currently Wasm-compatible.
+exclude_gems:
+  - bigdecimal
+  - nio4r
+  - io-console
+  - psych

data/lib/generators/wasmify/pwa/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Creates a new PWA JS application to server the Wasm version of the app.
+
+Example:
+    bin/rails generate wasmify:pwa

data/lib/generators/wasmify/pwa/pwa_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Wasmify::PwaGenerator < Rails::Generators::Base
+  source_root File.expand_path("templates", __dir__)
+
+  def copy_files
+    directory "pwa", "pwa"
+  end
+
+  private
+
+  def wasmify_rails_version = Wasmify::Rails::VERSION
+end

data/lib/generators/wasmify/pwa/templates/pwa/README.md

@@ -0,0 +1,40 @@
+# PWA app to run a Rails Wasm app
+
+The app provides a Service Worker to serve requests through the Rails/Wasm app.
+
+## Running locallly
+
+```sh
+yarn install
+
+yarn dev
+```
+
+Then go to [http://localhost:5173](http://localhost:5173).
+
+> [!NOTE]
+> Use Chrome or another browser supporting [CookieStore API](https://caniuse.com/?search=cookiestore).
+
+## Serving via HTTPS
+
+Although `localhost` should work fine for development, you can also run the app over `https://` for a more production-like experience (and to attach a worker to a custom domain).
+
+For that, we recommend using [puma-dev](https://github.com/puma/puma-dev).
+
+Install `puma-dev` and add the port 5173 to its configuration:
+
+```sh
+echo "5173" > ~/.puma-dev/rails-wasm
+```
+
+Then, run the server as follows:
+
+```sh
+yarn dev --host 0.0.0.0
+```
+
+Go to [https://rails-wasm.test](https://rails-wasm.test) to open the app.
+
+## Credits
+
+The launcher HTML/JS is based on the [Yuta Saito](https://github.com/kateinoigakukun)'s work on [Mastodon in the browser](https://github.com/kateinoigakukun/mastodon/tree/katei/wasmify).

data/lib/generators/wasmify/pwa/templates/pwa/boot.html

@@ -0,0 +1,102 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <meta name="og:title" content="Rails on Wasm" />
+        <meta name="og:description" content="Rails on Wasm launcher" />
+        <title>Rails on Wasm | Launch</title>
+        <script type="module" src="/boot.js"></script>
+        <style>
+            #boot-console-output {
+                background-color: #0c0c0c;
+                color: #f8f8f2;
+                font-family: monospace;
+                font-size: 0.8em;
+                padding: 1em;
+                white-space: pre-wrap;
+                min-height: 200px;
+                overflow-y: scroll;
+            }
+            #launch-button {
+                background-color: #007bff;
+                color: #fff;
+                border: none;
+                padding: 0.5em 1em;
+                font-size: 1em;
+                cursor: pointer;
+                border: 1px solid #ccc;
+            }
+            #launch-button:disabled {
+                background-color: #ccc;
+                color: #666;
+            }
+            #reboot-button {
+                background-color: #dc3545;
+                color: #fff;
+                border: none;
+                padding: 0.5em 1em;
+                font-size: 1em;
+                cursor: pointer;
+                border: 1px solid #ccc;
+            }
+            #reboot-button:disabled {
+                background-color: #ccc;
+                color: #666;
+            }
+            #reload-button {
+                background-color: #eeeeee;
+                color: #333;
+                border: none;
+                padding: 0.5em 1em;
+                font-size: 1em;
+                cursor: pointer;
+                border: 1px solid #333;
+            }
+            #reload-button:disabled {
+                background-color: #ccc;
+                color: #666;
+            }
+            #reload-debug-button {
+                background-color: rgb(159, 166, 40);
+                color: #000;
+                border: none;
+                padding: 0.5em 1em;
+                font-size: 1em;
+                cursor: pointer;
+                border: 1px solid #000;
+            }
+            #reload-debug-button:disabled {
+                background-color: #ccc;
+                color: #666;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>Rails on Wasm 🚀</h1>
+        <p>
+            Wait for the Service Worker to install and boot the app. This may
+            take a while.
+        </p>
+
+        <p>
+            <button id="launch-button" disabled>Launch</button>
+            <button id="reload-button" disabled>Reload Rails</button>
+            <button id="reload-debug-button" disabled>
+                Reload Rails (debug mode)
+            </button>
+            <button id="reboot-button" disabled>Hard Reset*</button>
+        </p>
+
+        <div id="boot-message"></div>
+        <progress id="boot-progress" max="100" value="0"></progress>
+        <pre id="boot-console-output"></pre>
+        <hr />
+        <p>
+            <small>
+                * Please ensure you close all tabs of this app before rebooting
+                to unregister the old Service Worker.
+            </small>
+        </p>
+    </body>
+</html>

data/lib/generators/wasmify/pwa/templates/pwa/boot.js

@@ -0,0 +1,96 @@
+async function registerServiceWorker() {
+  const oldRegistrations = await navigator.serviceWorker.getRegistrations();
+  for (const registration of oldRegistrations) {
+    if (registration.installing.state === "installing") {
+      return;
+    }
+  }
+
+  const workerUrl =
+    import.meta.env.MODE === "production"
+      ? "/rails.sw.js"
+      : "/dev-sw.js?dev-sw";
+
+  await navigator.serviceWorker.register(workerUrl, {
+    scope: "/",
+    type: "module",
+  });
+}
+
+async function boot({ bootMessage, bootProgress, bootConsoleOutput }) {
+  if (!("serviceWorker" in navigator)) {
+    console.error("Service Worker is not supported in this browser.");
+    return;
+  }
+
+  if (!navigator.serviceWorker.controller) {
+    await registerServiceWorker();
+
+    bootMessage.textContent = "Waiting for Service Worker to activate...";
+  } else {
+    console.log("Service Worker already active.");
+  }
+
+  navigator.serviceWorker.addEventListener("message", function (event) {
+    switch (event.data.type) {
+      case "progress": {
+        bootMessage.textContent = event.data.step;
+        bootProgress.value = event.data.value;
+        break;
+      }
+      case "console": {
+        bootConsoleOutput.textContent += event.data.message + "\n";
+        break;
+      }
+      default: {
+        console.log("Unknown message type:", event.data.type);
+      }
+    }
+  });
+
+  return await navigator.serviceWorker.ready;
+}
+
+async function init() {
+  const bootMessage = document.getElementById("boot-message");
+  const bootProgress = document.getElementById("boot-progress");
+  const bootConsoleOutput = document.getElementById("boot-console-output");
+  const registration = await boot({
+    bootMessage,
+    bootProgress,
+    bootConsoleOutput,
+  });
+  if (!registration) {
+    return;
+  }
+  bootMessage.textContent = "Service Worker Ready";
+  bootProgress.value = 100;
+
+  const launchButton = document.getElementById("launch-button");
+  launchButton.disabled = false;
+  launchButton.addEventListener("click", async function () {
+    // Open in a new window
+    window.open("/", "_blank");
+  });
+
+  const rebootButton = document.getElementById("reboot-button");
+  rebootButton.disabled = false;
+  rebootButton.addEventListener("click", async function () {
+    await registration.unregister();
+    window.location.reload();
+  });
+
+  const reloadButton = document.getElementById("reload-button");
+  reloadButton.disabled = false;
+  reloadButton.addEventListener("click", async function () {
+    registration.active.postMessage({ type: "reload-rails" });
+  });
+
+  const reloadDebugButton = document.getElementById("reload-debug-button");
+  reloadDebugButton.disabled = false;
+  reloadDebugButton.addEventListener("click", async function () {
+    registration.active.postMessage({ type: "reload-rails", debug: true });
+  });
+}
+
+init();

data/lib/generators/wasmify/pwa/templates/pwa/database.js

@@ -0,0 +1,18 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+
+export const setupSQLiteDatabase = async () => {
+  const sqlite3 = await sqlite3InitModule();
+
+  console.log("Running SQLite3 version", sqlite3.version.libVersion);
+  const db =
+    "opfs" in sqlite3
+      ? new sqlite3.oo1.OpfsDb("/railsdb.sqlite3")
+      : new sqlite3.oo1.DB("/railsdb.sqlite3", "ct");
+  console.log(
+    "opfs" in sqlite3
+      ? `OPFS is available, created persisted database at ${db.filename}`
+      : `OPFS is not available, created transient database ${db.filename}`,
+  );
+
+  return db;
+};