surikat 0.2.2

data/lib/surikat/templates/application.yml.tmpl

@@ -0,0 +1,14 @@
+# Application Configuration
+development:
+  session:
+    storage: file
+
+test:
+  session:
+    storage: file
+    file: tmp/test_session_store
+
+production:
+  session:
+    storage: redis
+    url: localhost

data/lib/surikat/templates/base_aaa_model.rb.tmpl

@@ -0,0 +1,28 @@
+# This Surikat model class was generated automatically.
+
+class User < Surikat::BaseModel
+
+   # Add your own validation rules, instance methods, relationships etc.
+
+  validates :email, uniqueness: true, presence: true
+  validates :hashed_password, presence: true
+
+  def password=(cleartext)
+    self.hashed_password = Digest::SHA256.hexdigest(cleartext)
+  end
+
+  def self.authenticate(args)
+    User.where(email: args['email'], hashed_password: Digest::SHA256.hexdigest(args['password'])).first
+  end
+
+  # We want to use +password+ instead of +hashed_password+ when we create the user
+  # This method is only used for in tests (+spec/user_spec.rb+).
+  def self.random_params
+    {
+        'email' => "some_#{SecureRandom.hex(5)}@email.com",
+        'password' => 'some password',
+        'roleids' => 'user,admin,superadmin'
+    }
+  end
+
+end

data/lib/surikat/templates/base_model.rb.tmpl

@@ -0,0 +1,6 @@
+# This Surikat model class was generated automatically.
+class %{class_name} < Surikat::BaseModel
+
+  # Add your own validation rules, instance methods, relationships etc.
+
+end

data/lib/surikat/templates/base_spec.rb.tmpl

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+describe % {class_name}Queries do
+  context "When testing the %{class_name} queries" do
+
+    before(:all) do
+      %{class_name}.destroy_all
+      @%{model_name} = %{class_name}.create_random
+      @more_%{model_name_plural} = (1..10).to_a.map {%{class_name}.create_random}
+
+      @expected_fields = [ %{columns_space} ]
+    end
+
+    describe "#queries" do
+
+      it "should retrieve an instance of %{class_name}" do
+        query    = "
+        { %{class_name}(id: #{@%{model_name}.id}) {
+           #{@expected_fields.join("\n")}
+          }
+        }"
+        response = Surikat::run query, {}
+
+        expected = {
+            "%{class_name}" => dates2string(@%{model_name}.attributes.slice(*@expected_fields))
+        }
+
+        expect(response).to eq expected
+      end
+
+      [ %{columns_space} ].each do |col|
+        it "should retrieve the #{col} of an instance of %{class_name}" do
+          query    = "
+        { %{class_name}(id: #{@%{model_name}.id}) {
+           #{col}
+          }
+        }"
+          response = Surikat::run query, {}
+
+          expected = {
+              "%{class_name}" => dates2string({
+                  col => @%{model_name}.send(col)
+              })
+          }
+
+          expect(response).to eq expected
+        end
+      end
+
+      it "should retrieve all instances of %{class_name}" do
+        query    = "
+        { %{class_name_plural}(q: \"id_lt=10000\") {
+            #{@expected_fields.join("\n")}
+          }
+        }"
+        response = Surikat::run query, {}
+
+        expected = {
+            "%{class_name_plural}" => ([ @%{model_name}] + @more_%{model_name_plural}).map {|r| dates2string(r.attributes.slice(*@expected_fields))}
+        }
+
+        expect(response).to eq expected
+      end
+
+    end
+
+  end
+
+  context "When testing the %{class_name} mutations" do
+
+    before(:all) do
+      Author.destroy_all
+
+      @expected_fields = [ %{columns_space} ]
+    end
+
+    describe "#mutations" do
+
+      it "should create an instance of %{class_name}" do
+        query = "
+          mutation %{class_name}($%{model_name}: %{class_name}Input) {
+            %{class_name}(%{model_name}: $%{model_name}) {
+               #{@expected_fields.join("\n")}
+            }
+          }
+         "
+
+        variables = {'%{model_name}' => %{class_name}.random_params}
+
+        response = Surikat::run query, variables
+
+        expect(response).to be_instance_of Hash
+        expect(response['%{class_name}']).to include variables['%{model_name}'].slice(*@expected_fields)
+      end
+
+      it "should update an instance of %{class_name}" do
+        %{model_name}_params = %{class_name}.random_params
+        %{model_name} = %{class_name}.create %{model_name}_params
+
+        new_%{model_name}_params = %{class_name}.random_params
+
+        # Step 1: Test that the update operation returns true
+        query = "
+          mutation Update%{class_name}($%{model_name}: %{class_name}Input) {
+            Update%{class_name}(%{model_name}: $%{model_name}) {
+              #{@expected_fields.join("\n")}
+            }
+          }
+        "
+
+        params_plus = new_%{model_name}_params.merge({'id' => %{model_name}.id, 'created_at' => %{model_name}.created_at.to_s, 'updated_at' => %{model_name}.updated_at.to_s})
+
+        variables = {'%{model_name}' => params_plus}
+
+        response = Surikat::run query, variables
+
+        expect(response).to be_instance_of Hash
+        expect(response['Update%{class_name}']).to eq true
+
+        # Step 2: Test that the record has been updated
+        %{model_name}.reload
+        expect(%{model_name}.attributes.slice(*@expected_fields)).to eq params_plus.slice(*@expected_fields)
+      end
+
+      it "should destroy an instance of %{class_name}" do
+        %{model_name} = %{class_name}.create_random
+
+        # Step 1: Test that the destroy operation returns true
+        query = "
+          mutation Delete%{class_name}($id: ID) {
+            Delete%{class_name}(id: $id)
+          }
+        "
+
+        variables = {'id' => %{model_name}.id}
+
+        response = Surikat::run query, variables
+
+        expect(response).to be_instance_of Hash
+        expect(response['Delete%{class_name}']).to eq true
+
+        # Step 2: Test that the object actually doesn't exist
+        expect {%{model_name}.reload}.to raise_error ActiveRecord::RecordNotFound
+      end
+
+    end
+  end
+end

data/lib/surikat/templates/config.ru.tmpl

@@ -0,0 +1,61 @@
+require 'rack/app'
+require 'oj'
+require 'surikat'
+
+Dir.glob('./config/initializers/*.rb').sort.each do |file|
+  require file
+end
+
+class %{app_name_capitalized} < Rack::App
+
+  get '/' do
+    app
+  end
+
+  post '/' do
+    app
+  end
+
+  def app
+    ActiveRecord::Base.logger = Logger.new(STDOUT) unless ENV['RACK_ENV'] == 'production'
+
+    session_key = request.env['HTTP_SURIKAT']
+
+    # first, try to parse it as JSON
+    json_payload = Oj.load(payload) rescue nil
+
+    if json_payload
+      query, variables = json_payload['query'], json_payload['variables']
+    else # then, as parameters, either GET
+      if query = params['query']
+        variables = params['variables']
+      else # or POST
+        split_payload, query, variables = payload.split('&'), nil, nil
+        split_payload.to_a.each do |line|
+          split_line  = line.split('=')
+          name, value = split_line.to_a[0], split_line.to_a[1, 1000].join('=')
+
+          query       = CGI::unescape(value) if name == 'query'
+          variables   = CGI::unescape(value) if name == 'variables'
+        end
+
+        variables = Oj.load(variables) if !variables.to_s.empty?
+      end
+    end
+
+    if query.to_s.strip.empty?
+      result = {'error' => 'Empty query'}
+    else
+      result = begin
+        Surikat::run query, variables, debug: false, session_key: session_key
+      rescue Exception => e
+        puts "Error running query #{query.inspect}: #{e.message}\n#{e.backtrace.join("\n")}"
+        {'error': e.message}
+      end
+    end
+
+    Oj.dump result, mode: :compat
+  end
+end
+
+run %{app_name_capitalized}

data/lib/surikat/templates/console.tmpl

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+ENV['RACK_ENV'] ||= 'development'
+
+require "bundler/setup"
+require "surikat"
+
+Dir.glob('./config/initializers/*.rb').sort.each do |file|
+  require file
+end
+
+puts "Welcome to the Surikat console. You are in the #{ENV['RACK_ENV']} environment."
+
+require "irb"
+IRB.start(__FILE__)

data/lib/surikat/templates/crud_queries.rb.tmpl

@@ -0,0 +1,105 @@
+=begin
+This class was generated by the scaffold generator.
+It contains methods to get, list, create, update and delete instances of %{class_name}.
+Default routes are created for each of this method (use 'surikat list routes' or look inside config/routes.yml to see them).
+Example queries/mutations can be found in the comments for each method.
+Generated at:: %{time}
+=end
+class %{class_name}Queries < Surikat::BaseQueries
+
+=begin
+Description: Retrieve one %{class_name} instance by its id
+Query Name: %{class_name}
+
+Input: { 'id' => ID }
+
+Output Type: %{class_name}
+
+Query Example:
+%{examples_get}
+=end
+  def get
+    %{class_name}.where(id: arguments['id'])
+  end
+
+=begin
+Description: Retrieve all %{class_name} instances
+Query Name: %{class_name_plural}
+
+Input: { 'q' => String }
+A Ransack selector (https://github.com/activerecord-hackery/ransack)
+
+Output Type: [%{class_name}]
+
+Query Example:
+%{examples_list}
+=end
+  def all
+    ransack = {}
+    CGI::parse(arguments['q']).each { |k, v| ransack[k] = v.first}
+
+    %{class_name}.ransack(ransack).result
+  end
+
+=begin
+Description: Create an instance of %{class_name} and return it; this is a mutation.
+Mutation Name: %{class_name}
+
+Input: { '%{class_name}' => {
+%{input_type_detailed_no_id}
+  }
+}
+
+Output Type: %{class_name}
+
+Query Example:
+%{examples_create}
+
+Example Variables:
+%{pretty_create_vars}
+=end
+  def create
+    %{class_name}.create arguments['%{class_name_downcase}']
+  end
+
+=begin
+Description: Update an instance of %{class_name}; this is a mutation.
+Query Name: Update%{class_name}
+
+Input: { '%{class_name}' => {
+%{input_type_detailed}
+  }
+}
+
+Output Type: Boolean
+
+Query Example:
+%{examples_update}
+
+Example Variables:
+%{pretty_update_vars}
+=end
+  def update
+    %{class_name}.find(arguments['%{class_name_downcase}']['id']).update(arguments['%{class_name_downcase}'].without('id'))
+  end
+
+=begin
+Description: Delete an instance of %{class_name}.
+Query Name: Delete%{class_name}
+
+Input: { 'id' => ID }
+
+OutputType: Boolean
+
+Query Example:
+%{examples_delete}
+
+Example Variables:
+%{pretty_random_id}
+=end
+  def delete
+    %{class_name}.where(id: arguments['id']).destroy_all
+    true
+  end
+
+end

data/lib/surikat/templates/database.yml.tmpl

@@ -0,0 +1,26 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+#
+default: &default
+  adapter: sqlite3
+  pool: 5
+  timeout: 5000
+
+development:
+  <<: *default
+  database: db/development.sqlite3
+
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run tests.
+# Do not set this db to the same as development or production!
+test:
+  <<: *default
+  database: db/test.sqlite3
+
+production:
+  <<: *default
+  database: db/production.sqlite3

data/lib/surikat/templates/hello_queries.rb.tmpl

@@ -0,0 +1,19 @@
+# This is a generated file.
+# To test these queries, run 'rspec -f d spec/hello_spec.rb'
+# To see example queries for them, use 'surikat exemplify HelloQueries hello'
+# If you want to throw away this file, please remember to also delete the relevant routes and tests.
+class HelloQueries < Surikat::BaseQueries
+  def hello
+    'world'
+  end
+
+  def show_session
+    session.to_h.inspect
+  end
+
+  def add_session
+    key, val = "key_#{SecureRandom.hex(3)}", SecureRandom.hex(5)
+    session[key] = val
+    "#{key},#{val}"
+  end
+end

data/lib/surikat/templates/hello_spec.rb.tmpl

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+describe HelloQueries do
+  context "When greeting" do
+    describe "Surikat" do
+      it "should respond nicely" do
+        response = Surikat.run '{Hello}', {}
+        expect(response['Hello']).to eq 'world'
+      end
+    end
+  end
+
+  context "When testing session management" do
+    describe "Surikat" do
+      it "should persist data in session between requests" do
+        query = "{AddSession}"
+        response = Surikat::run(query, {}, {session_key: 'abc'})
+        expect(response['AddSession']).to include ','
+
+        key, val = response['AddSession'].split(',')
+        query = '{ShowSession}'
+        response = Surikat::run(query, {}, {session_key: 'abc'})
+        expect(response['ShowSession']).to include val
+        expect(response['ShowSession']).to include key
+      end
+
+      it "should not persist data across different sessions" do
+        query = "{AddSession}"
+        response = Surikat::run(query, {}, {session_key: 'abc'})
+        expect(response['AddSession']).to include ','
+
+        _, val = response['AddSession'].split(',')
+        query = '{ShowSession}'
+        response = Surikat::run(query, {}, {session_key: 'def'})
+        expect(response['ShowSession']).to_not include val
+      end
+    end
+  end
+end