jason-rails 0.3.0

data/lib/jason/channel.rb

@@ -0,0 +1,37 @@
+class Jason::Channel < ActionCable::Channel::Base
+  attr_accessor :subscriptions
+
+  def receive(message)
+    subscriptions ||= []
+
+    begin # ActionCable swallows errors in this message - ensure they're output to logs.
+      if (config = message['createSubscription'])
+        subscription = Jason::Subscription.new(config: config)
+        subscriptions.push(subscription)
+        subscription.add_consumer(identifier)
+        config.keys.each do |model|
+          transmit(subscription.get(model.to_s.underscore))
+        end
+        stream_from subscription.channel
+      elsif (config = message['removeSubscription'])
+        subscription = Jason::Subscription.new(config: config)
+        subscriptions.reject! { |s| s.id == subscription.id }
+        subscription.remove_consumer(identifier)
+
+        # Rails for some reason removed stop_stream_from, so we need to stop all and then restart the other streams
+        # stop_all_streams
+        # subscriptions.each do |s|
+        #   stream_from s.channel
+        # end
+      elsif (data = message['getPayload'])
+        config = data.config
+        model = data.model
+        Jason::Subscription.new(config: config).get(model.to_s.underscore)
+      end
+    rescue => e
+      puts e.message
+      puts e.backtrace
+      raise e
+    end
+  end
+end

data/lib/jason/publisher.rb

@@ -0,0 +1,79 @@
+module Jason::Publisher
+  extend ActiveSupport::Concern
+
+  def cache_json
+    as_json_config = api_model.as_json_config
+    scope = api_model.scope
+
+    if self.persisted? && (scope.blank? || self.class.unscoped.send(scope).exists?(self.id))
+      payload = self.reload.as_json(as_json_config)
+      $redis.hset("jason:#{self.class.name.underscore}:cache", self.id, payload.to_json)
+    else
+      $redis.hdel("jason:#{self.class.name.underscore}:cache", self.id)
+    end
+  end
+
+  def publish_json
+    cache_json
+    return if skip_publish_json
+    subscriptions = $redis.hgetall("jason:#{self.class.name.underscore}:subscriptions")
+    subscriptions.each do |id, config_json|
+      config = JSON.parse(config_json)
+
+      if (config['conditions'] || {}).all? { |field, value| self.send(field) == value }
+        Jason::Subscription.new(id: id).update(self.class.name.underscore)
+      end
+    end
+  end
+
+  def publish_json_if_changed
+    subscribed_fields = api_model.subscribed_fields
+    publish_json if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present? || !self.persisted?
+  end
+
+  class_methods do
+    def subscriptions
+      $redis.hgetall("jason:#{self.name.underscore}:subscriptions")
+    end
+
+    def publish_all(instances)
+      instances.each(&:cache_json)
+
+      subscriptions.each do |id, config_json|
+        Jason::Subscription.new(id: id).update(self.name.underscore)
+      end
+    end
+
+    def flush_cache
+      $redis.del("jason:#{self.name.underscore}:cache")
+    end
+
+    def setup_json
+      self.after_initialize -> {
+        @api_model = Jason::ApiModel.new(self.class.name.underscore)
+      }
+      self.after_commit :publish_json_if_changed
+
+      include_models = Jason::ApiModel.new(self.name.underscore).include_models
+
+      include_models.map do |assoc|
+        puts assoc
+        reflection = self.reflect_on_association(assoc.to_sym)
+        reflection.klass.after_commit -> {
+          subscribed_fields = Jason::ApiModel.new(self.class.name.underscore).subscribed_fields
+          puts subscribed_fields.inspect
+
+          if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present?
+            self.send(reflection.inverse_of.name)&.publish_json
+          end
+        }
+      end
+    end
+  end
+
+  included do
+    attr_accessor :skip_publish_json, :api_model
+
+    setup_json
+  end
+end

data/lib/jason/subscription.rb

@@ -0,0 +1,172 @@
+class Jason::Subscription
+  attr_accessor :id, :config
+
+  def initialize(id: nil, config: nil)
+    if id
+      @id = id
+      raw_config = $redis.hgetall("jason:subscriptions:#{id}").map { |k,v| [k, JSON.parse(v)] }.to_h.with_indifferent_access
+      set_config(raw_config)
+    else
+      @id = Digest::MD5.hexdigest(config.to_json)
+      configure(config)
+    end
+  end
+
+  def set_config(raw_config)
+    @config =  raw_config.with_indifferent_access.map { |k,v| [k.underscore.to_s, v] }.to_h
+  end
+
+  def configure(raw_config)
+    set_config(raw_config)
+    $redis.hmset("jason:subscriptions:#{id}", *config.map { |k,v| [k, v.to_json]}.flatten)
+  end
+
+  def destroy
+    config.each do |model, value|
+      $redis.srem("jason:#{model.to_s.underscore}:subscriptions", id)
+    end
+    $redis.del("jason:subscriptions:#{id}")
+  end
+
+  def add_consumer(consumer_id)
+    before_consumer_count = consumer_count
+    $redis.sadd("jason:subscriptions:#{id}:consumers", consumer_id)
+    $redis.hset("jason:consumers", consumer_id, Time.now.utc)
+
+    if before_consumer_count == 0
+      add_subscriptions
+      publish_all
+    end
+  end
+
+  def remove_consumer(consumer_id)
+    $redis.srem("jason:subscriptions:#{id}:consumers", consumer_id)
+    $redis.hdel("jason:consumers", consumer_id)
+
+    if consumer_count == 0
+      remove_subscriptions
+    end
+  end
+
+  def consumer_count
+    $redis.scard("jason:subscriptions:#{id}:consumers")
+  end
+
+  def channel
+    "jason:#{id}"
+  end
+
+  def publish_all
+    config.each do |model, model_config|
+      klass = model.to_s.classify.constantize
+      conditions = model_config['conditions'] || {}
+      klass.where(conditions).find_each(&:cache_json)
+      update(model)
+    end
+  end
+
+  def add_subscriptions
+    config.each do |model, value|
+      $redis.hset("jason:#{model.to_s.underscore}:subscriptions", id, value.to_json)
+      update(model)
+    end
+  end
+
+  def remove_subscriptions
+    config.each do |model, _|
+      $redis.hdel("jason:#{model.to_s.underscore}:subscriptions", id)
+    end
+  end
+
+  def self.publish_all
+    JASON_API_MODEL.each do |model, _v|
+      klass = model.to_s.classify.constantize
+      klass.publish_all(klass.all) if klass.respond_to?(:publish_all)
+    end
+  end
+
+  def get(model)
+    value = JSON.parse($redis.get("#{channel}:#{model}:value") || '{}')
+    idx = $redis.get("#{channel}:#{model}:idx").to_i
+
+    {
+      type: 'payload',
+      md5Hash: id,
+      model: model,
+      value: value,
+      idx: idx
+    }
+  end
+
+  def get_diff(old_value, value)
+    JsonDiff.generate(old_value, value)
+  end
+
+  def deep_stringify(value)
+    if value.is_a?(Hash)
+      value.deep_stringify_keys
+    elsif value.is_a?(Array)
+      value.map { |x| x.deep_stringify_keys }
+    end
+  end
+
+  def get_throttle
+    if !$throttle_rate || !$throttle_timeout || Time.now.utc > $throttle_timeout
+      $throttle_timeout = Time.now.utc + 5.seconds
+      $throttle_rate = (Sidekiq.redis { |r| r.get 'global_throttle_rate' } || 0).to_i
+    else
+      $throttle_rate
+    end
+  end
+
+  # Atomically update and return patch
+  def update(model)
+    start_time = Time.now.utc
+    conditions = config[model]['conditions']
+
+    value = $redis.hgetall("jason:#{model}:cache")
+      .values.map { |v| JSON.parse(v) }
+      .select { |v| (conditions || {}).all? { |field, value| v[field] == value } }
+      .sort_by { |v| v['id'] }
+
+    # lfsa = last finished, started at
+    # If another job that started after this one, finished before this one, skip sending this state update
+    if Time.parse(Sidekiq.redis { |r| r.get("jason:#{channel}:lfsa") || '1970-01-01 00:00:00 UTC' } ) < start_time
+      Sidekiq.redis { |r| r.set("jason:#{channel}:lfsa", start_time) }
+    else
+      return
+    end
+
+    value = deep_stringify(value)
+
+    # If value has changed, return old value and new idx. Otherwise do nothing.
+    cmd = <<~LUA
+      local old_val=redis.call('get', ARGV[1] .. ':value')
+      if old_val ~= ARGV[2] then
+        redis.call('set', ARGV[1] .. ':value', ARGV[2])
+        local new_idx = redis.call('incr', ARGV[1] .. ':idx')
+        return { new_idx, old_val }
+      end
+    LUA
+
+    result = $redis.eval cmd, [], ["#{channel}:#{model}", value.to_json]
+    return if result.blank?
+
+    idx = result[0]
+    old_value = JSON.parse(result[1] || '{}')
+
+    diff = get_diff(old_value, value)
+
+    end_time = Time.now.utc
+
+    payload = {
+      model: model,
+      md5Hash: id,
+      diff: diff,
+      idx: idx.to_i,
+      latency: ((end_time - start_time)*1000).round
+    }
+
+    ActionCable.server.broadcast("jason:#{id}", payload)
+  end
+end

data/lib/jason/version.rb

@@ -0,0 +1,3 @@
+module Jason
+  VERSION = "0.3.0"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: jason-rails
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- James Rees
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-04 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- jarees@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- client/lib/JasonContext.d.ts
+- client/lib/JasonContext.js
+- client/lib/JasonProvider.d.ts
+- client/lib/JasonProvider.js
+- client/lib/actionFactory.d.ts
+- client/lib/actionFactory.js
+- client/lib/createActions.d.ts
+- client/lib/createActions.js
+- client/lib/createJasonReducers.d.ts
+- client/lib/createJasonReducers.js
+- client/lib/createPayloadHandler.d.ts
+- client/lib/createPayloadHandler.js
+- client/lib/index.d.ts
+- client/lib/index.js
+- client/lib/makeEager.d.ts
+- client/lib/makeEager.js
+- client/lib/useAct.d.ts
+- client/lib/useAct.js
+- client/lib/useSub.d.ts
+- client/lib/useSub.js
+- client/package.json
+- client/src/JasonContext.ts
+- client/src/JasonProvider.tsx
+- client/src/actionFactory.ts
+- client/src/createActions.ts
+- client/src/createJasonReducers.ts
+- client/src/createPayloadHandler.ts
+- client/src/index.ts
+- client/src/makeEager.ts
+- client/src/useAct.ts
+- client/src/useSub.ts
+- client/tsconfig.json
+- client/yarn.lock
+- jason-rails.gemspec
+- lib/jason.rb
+- lib/jason/api_model.rb
+- lib/jason/channel.rb
+- lib/jason/publisher.rb
+- lib/jason/subscription.rb
+- lib/jason/version.rb
+homepage: https://github.com/jamesr2323/jason
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jamesr2323/jason
+  source_code_uri: https://github.com/jamesr2323/jason
+  changelog_uri: https://github.com/jamesr2323/jason
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: Reactive user interfaces with minimal boilerplate, using Rails + Redux
+test_files: []