wasmify-rails 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d34168c0b9ab6af658deb9e91559fc45ff5d17bb7d015ef8859c216ab9736b41
-  data.tar.gz: 7049aa93891ea2fde7f911ed87d5f0356f01f99769b77a430aae69dd9db2b8c4
+  metadata.gz: 55efaa8fa8cd15d3eb906efe9342baa453af8e53d363f12bc72fb4c3f2afc1a8
+  data.tar.gz: a20c26e0a6525f9f0bb183a4d59620895864c6f450739677d39e39a95c471a49
 SHA512:
-  metadata.gz: 43003eafb292715b34a9360426a2f8cd4bc572f8ce9f0494a19999abe48487fa766656bfa6da57bfa3a9e1ab74bb2b1e41db9191208015a85699364e1a9eda29
-  data.tar.gz: 8879ab43592abc34a0675d7e80763e9030b86cd2145535ec26fe0446465379d0c10f3a7c685d47b4a8165abe6e94714987ad8774ff3e16ce781abaea21699a35
+  metadata.gz: 78329c56067b9bf41c72bd46fb02686ceea78b12f9785f6f2623bf12558476d36d45db1e6ac0402be16f070fc83e2ce4490ef816d55626c1ea847762059d5fff
+  data.tar.gz: 3e783be0989c85ba28841078b7f2ea7626f7b682d9c807fa411307a08988d73046c8f56aa8eecc1ad4a5c0c41d757c1003e0499378465616a46d04242002c22c

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master
 
+## 0.2.0
+
+- Add pglite support.
+
+## 0.1.5
+
+- Added async mode to rack.js.
+
+- Added ability to pass env vars to Ruby VM.
+
+- Rails 8 support for `sqlite3_wasm` adapter.
+
 ## 0.1.4
 
 - Improve `wasmify:install`.

data/README.md

@@ -4,6 +4,9 @@
 
 This gem provides tools and extensions to compile Rails applications to WebAssembly.
 
+> [!NOTE]
+> Read more in our handbook: [Rails on Wasm](https://writebook-on-wasm.fly.dev/5/ruby-on-rails-on-webassembly)
+
 ## Installation
 
 Adding to your Gemfile:
@@ -169,7 +172,8 @@ This gem provides a variety of _adapters_ and plugins to make your Rails applica
 
 - Active Record
 
-  - `sqlite3_wasm` adapter: work with `sqlite3` Wasm just like with a regular SQLite database.
+  - `sqlite3_wasm` adapter: works with `sqlite3` Wasm just like with a regular SQLite database.
+  - `pglite` adapter: uses [pglite](https://pglite.dev) as a database.
   - `nulldb` adapter for testing purposes.
 
 - Active Storage

data/lib/active_record/connection_adapters/pglite_adapter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+# Update the $LOAD_PATH to include the pg stub
+$LOAD_PATH.unshift(File.expand_path(File.join(__dir__, "pglite_shims")))
+
+module PGlite
+  class << self
+    attr_accessor :logger
+
+    def log(message)
+      logger&.debug "[pglite] #{message}"
+    end
+  end
+
+  class Result
+    def initialize(res)
+      @res = res
+    end
+
+    def map_types!(map)
+      self
+    end
+
+    def values
+      results = []
+      columns = self.fields
+      @res[:rows].to_a.each do |raw_row|
+        row = []
+        columns.each do |col|
+          value = raw_row[col]
+          row << translate_value(value)
+        end
+        results << row
+      end
+      results
+    end
+
+    def fields
+      @res[:fields].to_a.map { |col| col[:name].to_s }
+    end
+
+    def ftype(index)
+      @res[:fields][index][:dataTypeID]
+    end
+
+    def fmod(index)
+      0
+    end
+
+    def cmd_tuples
+      @res[:affectedRows].to_i
+    end
+
+    def clear
+    end
+
+    include Enumerable
+
+    def each
+      columns = self.fields
+      @res[:rows].to_a.each do |raw_row|
+        row = {}
+        columns.each do |col|
+          value = raw_row[col]
+          row[col.to_s] = translate_value(value)
+        end
+        yield row
+      end
+    end
+
+    private
+      def translate_value(value)
+        case value.typeof
+        when "number"
+          value.to_i
+        when "boolean"
+          value == JS::True
+        when "undefined"
+          nil
+        else
+          if value == JS::Null
+            nil
+          else
+            value.to_s
+          end
+        end
+      end
+  end
+end
+
+require "active_record/connection_adapters/postgresql_adapter"
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    def pglite_adapter_class
+      ConnectionAdapters::PGliteAdapter
+    end
+
+    def pglite_connection(config)
+      pglite_adapter_class.new(config)
+    end
+  end
+
+  module ConnectionAdapters
+    class PGliteAdapter < PostgreSQLAdapter
+      class ExternalInterface
+        private attr_reader :js_interface
+
+        def initialize(config)
+          @js_interface = config.fetch(:js_interface, "pglite4rails").to_sym
+          @last_result = nil
+          @prepared_statements_map = {}
+        end
+
+        def set_client_encoding(encoding)
+        end
+
+        def transaction_status
+          PG::PQTRANS_IDLE
+        end
+
+        def escape(str)
+          str
+        end
+
+        def raw_query(sql, params)
+          PGlite.log "[pglite] query: #{sql} with params: #{params}"
+          params = params.map { |param| param.to_js }
+          raw_res = JS.global[js_interface].query(sql, params.to_js).await
+          result = PGlite::Result.new(raw_res)
+          PGlite.log "[pglite] result: #{result.values}"
+          @last_result = result
+          result
+        rescue => e
+          raise PG::Error, e.message
+        end
+
+        def exec(sql)
+          raw_query(sql, [])
+        end
+
+        alias query exec
+        alias async_exec exec
+        alias async_query exec
+
+        def exec_params(sql, params)
+          if params.empty?
+            return exec(sql)
+          end
+          raw_query(sql, params)
+        end
+
+        def exec_prepared(name, params)
+          sql = @prepared_statements_map[name]
+          exec_params(sql, params)
+        end
+
+        def prepare(name, sql, param_types = nil)
+          @prepared_statements_map[name] = sql
+        end
+
+        def get_last_result
+          @last_result
+        end
+
+        def reset
+          @prepared_statements_map = {}
+        end
+      end
+
+      class << self
+        def database_exists?(config)
+          true
+        end
+
+        def new_client(...) = ExternalInterface.new(...)
+      end
+
+      def initialize(...)
+        AbstractAdapter.instance_method(:initialize).bind_call(self, ...)
+        @connection_parameters = @config.compact
+
+        @max_identifier_length = nil
+        @type_map = ActiveRecord::Type::HashLookupTypeMap.new
+        @raw_connection = nil
+        @notice_receiver_sql_warnings = []
+
+        @use_insert_returning = true
+      end
+
+      def get_database_version = 150000 # 15devel
+
+      def configure_connection
+      end
+
+      module Type
+        class BigintArray < ActiveRecord::Type::Value
+          def deserialize(value)
+            return nil if value.nil? || value == ""
+            value[1..-2].split(",").map(&:to_i)
+          end
+
+          def serialize(value)
+            return nil if value.nil? || value == ""
+            "{" + value.map(&:to_s).join(", ") + "}"
+          end
+
+          def cast(value)
+            value
+          end
+        end
+      end
+
+      def get_oid_type(oid, fmod, column_name, sql_type = "")
+        # https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_type.dat
+        oid = oid.to_i
+        ty = case oid
+        when 16
+          ActiveRecord::Type::Boolean.new
+        when 20
+          ActiveRecord::Type::Integer.new(limit: 8)
+        when 21
+          ActiveRecord::Type::Integer.new
+        when 23
+          ActiveRecord::Type::Integer.new
+        when 25
+          ActiveRecord::Type::String.new
+        when 114
+          ActiveRecord::Type::String.new
+        when 700, 701
+          ActiveRecord::Type::Float.new
+        when 1015
+          ActiveRecord::Type::String.new
+        when 1016 # bigint[]
+          Type::BigintArray.new
+        when 1043
+          ActiveRecord::Type::String.new
+        when 1082
+          ActiveRecord::Type::Date.new
+        when 1083
+          ActiveRecord::Type::Time.new
+        when 1114
+          ActiveRecord::Type::DateTime.new
+        when 1184
+          ActiveRecord::Type::DateTime.new
+        when 1700
+          ActiveRecord::Type::Decimal.new
+        when 3802
+          ActiveRecord::Type::Json.new
+        else
+          ActiveRecord::Type.default_value
+        end
+        @type_map.register_type(oid, ty)
+        ty
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/pglite_shims/pg.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# pg gem stub
+module PG
+  PQTRANS_IDLE = 0 # (connection idle)
+  PQTRANS_ACTIVE = 1 # (command in progress)
+  PQTRANS_INTRANS = 2 # (idle, within transaction block)
+  PQTRANS_INERROR = 3 # (idle, within failed transaction)
+  PQTRANS_UNKNOWN = 4 # (cannot determine status)
+
+  class Error < StandardError; end
+  class ConnectionBad < Error; end
+
+  class Connection
+    class << self
+      def quote_ident(str)
+        str = str.to_s
+        return '""' if str.empty?
+        if str =~ /[^a-zA-Z_0-9]/ || str =~ /^[0-9]/
+          '"' + str.gsub('"', '""') + '"'
+        else
+          str
+        end
+      end
+    end
+  end
+
+  # Just a stub for now
+  class SimpleDecoder
+  end
+end

data/lib/active_record/connection_adapters/sqlite3_wasm_adapter.rb

@@ -1,12 +1,12 @@
-# Stub: SQLite3::ForkSafety.suppress_warnings!
+# Rails 8 compatibility
 module SQLite3
-  class BusyException < StandardError
-  end
-
   module ForkSafety
     def self.suppress_warnings!
     end
   end
+
+  class BusyException < StandardError
+  end
 end
 
 require "active_record/connection_adapters/sqlite3_adapter"
@@ -44,6 +44,12 @@ module ActiveRecord
           JS.global[js_interface].exec(...)
         end
 
+        def execute_batch2(...)
+          # TODO: it's used by fixtures and truncate_all, so
+          # we don't need it right now
+          raise NotImplementedError, "sqlite3_wasm#execute_batch2 is not implemented yet"
+        end
+
         def busy_timeout(...) = nil
 
         def execute(sql)
@@ -195,6 +201,29 @@ module ActiveRecord
       def database_exists? = true
 
       def database_version = SQLite3Adapter::Version.new("3.45.1")
+
+      # Rails 8 interface
+      def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch: false)
+        if batch
+          raw_connection.execute_batch2(sql)
+        elsif prepare
+          raise NotImplementedError, "sqlite3_wasm prepared statements are not implemented yet"
+        else
+          stmt = raw_connection.prepare(sql)
+          result =
+            if stmt.column_count.zero?
+              ActiveRecord::Result.empty
+            else
+              ActiveRecord::Result.new(stmt.columns, stmt.to_a)
+            end
+        end
+
+        @last_affected_rows = raw_connection.changes
+        verified!
+
+        notification_payload[:row_count] = result&.length || 0
+        result
+      end
     end
   end
 end

data/lib/wasmify/rails/builder.rb

@@ -11,13 +11,14 @@ module Wasmify
     class Builder
       ORIGINAL_EXCLUDED_GEMS = RubyWasm::Packager::EXCLUDED_GEMS.dup.freeze
 
-      attr_reader :output_dir
+      attr_reader :output_dir, :target
 
-      def initialize(output_dir: Wasmify::Rails.config.tmp_dir)
+      def initialize(output_dir: Wasmify::Rails.config.tmp_dir, target: Wasmify::Rails.config.wasm_target)
         @output_dir = output_dir
+        @target = target
       end
 
-      def run(name:, exclude_gems: [])
+      def run(name:, exclude_gems: [], opts: "")
         # Reset excluded gems
         RubyWasm::Packager::EXCLUDED_GEMS.replace(ORIGINAL_EXCLUDED_GEMS)
 
@@ -31,11 +32,22 @@ module Wasmify
           RubyWasm::Packager::EXCLUDED_GEMS << gem_name
         end
 
+        opts = opts&.split(" ") || []
+
         args = %W(
           build
           --ruby-version #{Wasmify::Rails.config.short_ruby_version}
+          --target #{target}
           -o #{File.join(output_dir, name)}
-        )
+        ) + opts
+
+        patches_dir = ::Rails.root.join("ruby_wasm_patches").to_s
+
+        if File.directory?(patches_dir)
+          Dir.children(patches_dir).each do |patch|
+            args << "--patch=#{File.join(patches_dir, patch)}"
+          end
+        end
 
         FileUtils.mkdir_p(output_dir)
         RubyWasm::CLI.new(stdout: $stdout, stderr: $stderr).run(args)

data/lib/wasmify/rails/configuration.rb

@@ -9,7 +9,7 @@ module Wasmify
 
     class Configuration
       attr_reader :pack_directories, :exclude_gems, :ruby_version,
-                  :tmp_dir, :output_dir,
+                  :tmp_dir, :output_dir, :wasm_target,
                   :skip_assets_precompile
 
       def initialize
@@ -24,6 +24,7 @@ module Wasmify
         @tmp_dir = config["tmp_dir"] || ::Rails.root.join("tmp", "wasmify")
         @output_dir = config["output_dir"] || ::Rails.root.join("dist")
         @skip_assets_precompile = config["skip_assets_precompile"] || false
+        @wasm_target = config["wasm_target"] || "wasm32-unknown-wasip1"
       end
 
       def short_ruby_version

data/lib/wasmify/rails/tasks.rake

@@ -12,28 +12,38 @@ namespace :wasmify do
   end
 
   desc "Build ruby.wasm with all dependencies"
-  task :build do
+  task :build, [:args] do |_, args|
+    opts = args.args
     unless ENV["BUNDLE_ONLY"] == "wasm"
-      next spawn("RAILS_ENV=wasm BUNDLE_ONLY=wasm bundle exec rails wasmify:build").then { Process.wait(_1) }
+      next spawn(%Q(RAILS_ENV=wasm BUNDLE_ONLY=wasm bundle exec rails 'wasmify:build[#{opts}]')).then do
+        Process.wait2(_1)
+      end.then do |(_, status)|
+        status.success? or exit(status.exitstatus)
+      end
     end
 
     require "wasmify/rails/builder"
 
     builder = Wasmify::Rails::Builder.new
-    builder.run(name: "ruby.wasm")
+    builder.run(name: "ruby.wasm", opts:)
   end
 
   namespace :build do
     desc "Build ruby.wasm with all dependencies but JS shim (to use with wasmtime)"
-    task :core do
+    task :core, [:args] do |_, args|
+      opts = args.args
       unless ENV["BUNDLE_ONLY"] == "wasm"
-        next spawn("RAILS_ENV=wasm BUNDLE_ONLY=wasm bundle exec rails wasmify:build:core").then { Process.wait(_1) }
+        next spawn(%Q(RAILS_ENV=wasm BUNDLE_ONLY=wasm bundle exec rails 'wasmify:build:core[#{opts}]')).then do
+          Process.wait2(_1)
+        end.then do |(_, status)|
+          status.success? or exit(status.exitstatus)
+        end
       end
 
       require "wasmify/rails/builder"
 
       builder = Wasmify::Rails::Builder.new
-      builder.run(name: "ruby-core.wasm", exclude_gems: ["js"])
+      builder.run(name: "ruby-core.wasm", exclude_gems: ["js"], opts:)
     end
 
     namespace :core do
@@ -55,11 +65,18 @@ namespace :wasmify do
   end
 
   desc "Pack the application into to a single module"
-  task pack: :build do
+  task :pack, [:args] do |_, args|
+    opts = args.args
+    Rails::Command.invoke "wasmify:build[#{opts}]"
+
     # First, precompile assets
     unless Wasmify::Rails.config.skip_assets_precompile
       Bundler.with_unbundled_env do
-        spawn("SECRET_KEY_BASE_DUMMY=1 RAILS_ENV=production bundle exec rails assets:precompile").then { Process.wait(_1) }
+        spawn("SECRET_KEY_BASE_DUMMY=1 RAILS_ENV=production bundle exec rails assets:precompile").then do
+          Process.wait2(_1)
+        end.then do |(_, status)|
+          status.success? or exit(status.exitstatus)
+        end
       end
     end
 
@@ -68,15 +85,27 @@ namespace :wasmify do
     packer = Wasmify::Rails::Packer.new
 
     packer.run(name: "app.wasm", ruby_wasm_path: File.join(Wasmify::Rails.config.tmp_dir, "ruby.wasm"))
+  ensure
+    # Clean up precompiled assets
+    unless Wasmify::Rails.config.skip_assets_precompile
+      FileUtils.rm_rf(Rails.root.join("public/assets")) if File.directory?(Rails.root.join("public/assets"))
+    end
   end
 
   namespace :pack do
     desc "Pack the application into to a single module without JS shim"
-    task :core do
+    task :core, [:args] do |_, args|
+      opts = args.args
+      Rails::Command.invoke "wasmify:build:core[#{opts}]"
+
       # First, precompile assets
       unless Wasmify::Rails.config.skip_assets_precompile
         Bundler.with_unbundled_env do
-          spawn("SECRET_KEY_BASE_DUMMY=1 RAILS_ENV=production bundle exec rails assets:precompile").then { Process.wait(_1) }
+          spawn("SECRET_KEY_BASE_DUMMY=1 RAILS_ENV=production bundle exec rails assets:precompile").then do
+            Process.wait2(_1)
+          end.then do |(_, status)|
+            status.success? or exit(status.exitstatus)
+          end
         end
       end
 
@@ -91,6 +120,11 @@ namespace :wasmify do
         ruby_wasm_path: File.join(Wasmify::Rails.config.tmp_dir, "ruby-core.wasm"),
         storage_dir: "storage"
       )
+    ensure
+      # Clean up precompiled assets
+      unless Wasmify::Rails.config.skip_assets_precompile
+        FileUtils.rm_rf(Rails.root.join("public/assets")) if File.directory?(Rails.root.join("public/assets"))
+      end
     end
 
     namespace :core do

data/lib/wasmify/rails/version.rb

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

data/lib/wasmify-rails.rb

@@ -25,3 +25,6 @@ ActiveRecord::ConnectionAdapters.register("nulldb", "ActiveRecord::ConnectionAda
 
 # SQLite3 Wasm adapter
 ActiveRecord::ConnectionAdapters.register("sqlite3_wasm", "ActiveRecord::ConnectionAdapters::SQLite3WasmAdapter", "active_record/connection_adapters/sqlite3_wasm_adapter")
+
+# PGlite adapter
+ActiveRecord::ConnectionAdapters.register("pglite", "ActiveRecord::ConnectionAdapters::PGliteAdapter", "active_record/connection_adapters/pglite_adapter")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wasmify-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-27 00:00:00.000000000 Z
+date: 2024-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -134,6 +134,8 @@ files:
 - lib/active_record/connection_adapters/nulldb_adapter/quoting.rb
 - lib/active_record/connection_adapters/nulldb_adapter/statement.rb
 - lib/active_record/connection_adapters/nulldb_adapter/table_definition.rb
+- 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/generators/wasmify/install/USAGE
 - lib/generators/wasmify/install/install_generator.rb
@@ -194,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key: 
 specification_version: 4
 summary: Tools and extensions to package Rails apps as Wasm modules