hyper-resource 1.0.0.lap86 → 1.0.0.lap87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aea164bac45355bd1005264f1a9ce5f273454b2c97ddd63db204fc17542d374d
-  data.tar.gz: 7f67b54de3ff4f449c93a59904a33f6889323a0d907acc329a01d0fee2622efd
+  metadata.gz: 4d276e459e66303c270a3fd19ad817000f7591604673852f2084c1b591b1bf4a
+  data.tar.gz: 14cfa291e0a603badf2f8e4cb9484e3996e5708a2cc059ad1dc5b8ef111784f3
 SHA512:
-  metadata.gz: 6f304149b7ed89dd3a1963e75a1fda39ec562b8d7c1c1e7b7fb112815cdae463defbf138f66a9500bee056cd054369f3a57a945c259c5ab9557a68c7fc7f4243
-  data.tar.gz: c27ff1a053421ee0450a133e07e1d45e02faba561d31a328e095d2adf3221d62109ba2916fef25a15bd8b856089e1c6fcd667042d6f1dd85a3ff8fb6ade48964
+  metadata.gz: d4d5e94abd9001519c6455257887eec88937c9dadfa1f41527fc5e1516e1d18432e9c6ea87497d041ed2d599985a80d47ae6fc9b4b20ced7d5613c75fb7aebd8
+  data.tar.gz: 72a52d2bc6dce43d4c1c2d2c6827494629786782b58dcb5e9ee7d6bffb822a83830bbd957a15ed9e2d4a56fad9459e69b63f9b107f77822a98a18aaabe40c8af

data/README.md

@@ -112,4 +112,209 @@ EXAMPLE
 
 ## Implementation
 
-How to install....
+## Implementation
+
+Hyperloop needs to be installed and working before you install HyperResource. These instructions are likely to change/be simplified as this Gem matures.
+
++ Add the gems (make sure its the latest version)
+
+`gem 'hyper-resource', '1.0.0.lap86'`
+`gem 'opal-jquery', github: 'janbiedermann/opal-jquery', branch: 'why_to_n'`
+`gem 'opal-activesupport', github: 'opal/opal-activesupport', branch: 'master'`
+
++ Require HyperResource in your `hyperloop_webpack_loader.rb` file
+
+`require 'hyper-resource'`
+`require 'opal-jquery'`
+
+ + Update your `application_record.rb` file and move it to the `hyperloop/models` folder
+
+ ```
+# application_record.rb
+if RUBY_ENGINE == 'opal'
+  class ApplicationRecord
+    def self.inherited(base)
+      base.include(HyperRecord)
+    end
+  end
+else
+  class ApplicationRecord < ActiveRecord::Base
+    # when updating this part, also update the ApplicationRecord in app/models/application_record.rb
+    # for rails eager loading in production, so production doesn't fail
+    self.abstract_class = true
+    extend HyperRecord::ServerClassMethods
+    include HyperRecord::PubSub
+  end
+end
+ ```
+
++ Move the models you want on the client to the `hyperloop/models` folder
+
++ Make sure you guard anything in your model which you do not want on the client:
+
+```
+unless RUBY_ENGINE == 'opal'
+  # herein stuff that you do not want on the client (Devise, etc)
+end
+```
+
++ Add Pusher to your gemfile
+
+`gem pusher`
+
++ Add it with Yarn
+
+`yarn add pusher-js`
+
++ Then import in your `app.js`
+
+`import Pusher from 'pusher-js';`
+`global.Pusher = Pusher;`
+
++ Add your api endpoint to `hyperloop.rb`
+
+`config.resource_api_base_path = '/api'`
+
++ Create you API controllers as normal - ensure they return JSON in this format
+
+```
+{
+  "members":[
+    {"member":{"id":1,"email":"a@b.com","first_name":"John","last_name":"Smith"}},
+    {"member":{"id":2,"email":"b@c.com","first_name":null,"last_name":null}}
+  ]
+}
+```
+
+Rabl gem example view:
+
+```
+collection @members, root: :members
+attributes :id,
+  :email,
+  :first_name,
+  :last_name
+```
+
++ Create your API controller and make sure to implement `show` as this is called by HyperResource. Please see the example controller below for details on pub_sub
+
+```ruby
+module Api
+  class PersonasController < ApplicationController
+    # GET /api/personas.json
+    def index
+      authorize(Persona)
+
+      @personas = Persona.all
+      subscribe_scope(@personas, Persona, :all)
+      respond_to do |format|
+        format.json {}
+      end
+    end
+
+    # GET /api/personas/123.json
+    def show
+      @persona = Persona.find(params[:id])
+
+      authorize(@persona)
+
+      subscribe_record(@persona)
+      respond_to do |format|
+        format.json {}
+      end
+    end
+
+    # POST /api/plans/1/personas.json
+    def create
+      authorize(Persona)
+
+      @persona = Persona.new(persona_params)
+
+      subscribe_record(@persona)
+      respond_to do |format|
+        if @persona.save
+          subscribe_record(@persona)
+          publish_scope(Persona, :all)
+          format.json { render :show, status: :created }
+        else
+          format.json { render json: @persona.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /api/personas/1.json
+    def update
+      @persona = Persona.find(params[:id])
+      @persona.assign_attributes(persona_params)
+
+      authorize(@persona)
+
+      respond_to do |format|
+        if @persona.update(persona_params)
+          pub_sub_record(@persona)
+          format.json { render :show, status: :ok }
+        else
+          format.json { render json: @persona.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /personas/1.json
+    def destroy
+      @persona = Persona.find(params[:id])
+      # authorize @persona
+
+      @persona.destroy
+      publish_record(@persona)
+      respond_to do |format|
+        format.json { head :no_content }
+      end
+    end
+
+    private
+
+    def persona_params
+      permitted_keys = Persona.attribute_names.map(&:to_sym)
+      %i[id created_at updated_at].each do |key|
+        permitted_keys.delete(key)
+      end
+      params.require(:data).permit(permitted_keys)
+    end
+  end
+end
+```
+
++ Install Redis and add the following to your `hyperloop.rb`
+
+```ruby
+config.redis_instance = if ENV['REDIS_URL']
+                            Redis.new(url: ENV['REDIS_URL'])
+                          else
+                            Redis.new
+                          end
+```
+
++ Add the following to your `ApplicationController`
+
+```
+include Hyperloop::Resource::PubSub
+```
+
++ Add these routes:
+
+```
+namespace :api, defaults: { format: :json } do
+
+    # introspection
+    # get '/:model_klass/relations', to: 'relations#index'
+    # get '/:model_klass/methods', to: 'methods#index'
+    # get '/:model_klass/methods/:id', to: 'methods#show'
+    # patch '/:model_klass/methods/:id', to: 'methods#update'
+    # get '/:model_klass/properties', to: 'properties#index'
+    get '/:model_klass/scopes', to: 'scopes#index'
+    get '/:model_klass/scopes/:id', to: 'scopes#show'
+    patch '/:model_klass/scopes/:id', to: 'scopes#update'
+
+```
+
++ Add the `ScopesController` as per the example in this Gem

data/lib/hyper_record/class_methods.rb

@@ -122,6 +122,58 @@ module HyperRecord
       # end
     end
 
+    # macro define collection_query_method, RPC on instance level of a record of current HyperRecord class
+    # The supplied block must return a Array of Records!
+    #
+    # @param name [Symbol] name of method
+    # @param options [Hash] with known keys:
+    #   default_result: result to present during render during method call in progress, is a Array by default, should be a Enumerable in any case
+    #
+    # This macro defines additional methods:
+    def collection_query_method(name, options = { default_result: []})
+      # @!method promise_[name]
+      # @return [Promise] on success the .then block will receive the result of the RPC call as arg
+      #    on failure the .fail block will receive the HTTP response object as arg
+      define_method("promise_#{name}") do
+        @fetch_states[name] = 'i'
+        unless @rest_methods.has_key?(name)
+          @rest_methods[name] = options
+          @rest_methods[name] = { result: options[:default_result] }
+        end
+        raise "#{self.class.to_s}[_no_id_].#{name}, can't execute instance collection_query_method without id!" unless self.id
+        self.class._promise_get_or_patch("#{resource_base_uri}/#{self.id}/methods/#{name}.json?timestamp=#{`Date.now() + Math.random()`}").then do |response_json|
+          collection = self.class._convert_array_to_collection(response_json[:result], self)
+          @rest_methods[name][:result] = collection
+          @fetch_states[name] = 'f'
+          _notify_observers
+          @rest_methods[name][:result]
+        end.fail do |response|
+          error_message = "#{self.class.to_s}[#{self.id}].#{name}, a collection_query_method, failed to execute!"
+          `console.error(error_message)`
+          response
+        end
+      end
+      # @!method [name]
+      # @return result either the default_result ass specified in the options or the real result if the RPC call already finished
+      define_method(name) do
+        _register_observer
+        unless @rest_methods.has_key?(name)
+          @rest_methods[name] = options
+          @rest_methods[name] = { result: options[:default_result] }
+        end
+        unless @fetch_states.has_key?(name) && 'fi'.include?(@fetch_states[name])
+          self.send("promise_#{name}")
+        end
+        @rest_methods[name][:result]
+      end
+      # @!method update_[name] mark internal structures so that the method is called again once it is requested again
+      # @return nil
+      define_method("update_#{name}") do
+        @fetch_states[name] = 'u'
+        nil
+      end
+    end
+
     # create a new instance of current HyperRecord class and save it to the db
     #
     # @param record_hash [Hash] optional data for the record
@@ -507,7 +559,7 @@ module HyperRecord
       end
     end
 
-    # macro define rest_class_methods, RPC on instance level of a record of current HyperRecord class
+    # macro define rest_methods, RPC on instance level of a record of current HyperRecord class
     #
     # @param name [Symbol] name of method
     # @param options [Hash] with known keys:

data/lib/hyper_record/server_class_methods.rb

@@ -1,5 +1,26 @@
 module HyperRecord
   module ServerClassMethods
+    # DSL for defining collection_query_methods
+    # @param name [Symbol] name of the method
+    # @param options [Hash] known key: default_result, used client side
+    def collection_query_method(name, options = { default_result: [] }, &block)
+      rest_methods[name] = options
+      rest_methods[name][:params] = block.arity
+      define_method(name) do
+        array_of_records = instance_exec(&block)
+        array_of_records.map do |record|
+          subscribe_record(record)
+          record_json = record.as_json
+          record_model = record.class.to_s.underscore
+          if record_json.has_key?(record_model)
+            record_json
+          else
+            { record_model => record_json }
+          end
+        end
+      end
+    end
+
     # DSL for defining rest_class_methods
     # @param name [Symbol] name of the method
     # @param options [Hash] known key: default_result, used client side

data/lib/hyperloop/resource/version.rb

@@ -1,5 +1,5 @@
 module Hyperloop
   module Resource
-    VERSION = '1.0.0.lap86'
+    VERSION = '1.0.0.lap87'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyper-resource
 version: !ruby/object:Gem::Version
-  version: 1.0.0.lap86
+  version: 1.0.0.lap87
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-18 00:00:00.000000000 Z
+date: 2018-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal