midb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6a12da2fe9657a3beacfe2a00aed774bede4101
+  data.tar.gz: 7af6d67d1a748311d665af0b1330d7ac4ba69dcb
+SHA512:
+  metadata.gz: 7eaee7eccb98dbf4001039eea0f2d11a012b305bff7fb822597137b631689cfbae555188f1f5384e2a035067ad836a85920864086c65e1ec03b7f98f35cb3dea
+  data.tar.gz: 1deda596c389b6804abe4cd55202165f4a3897a6169899e5aa4e2f3f3af4cf7101f66a5a474ed5c91bceb8f0b42c09a8163be42de5ca5935d1168a51b4997cd7

data/bin/midb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+## midb: middleware for databases! ##
+# 08/31/15, unrar
+require 'midb'
+
+# Pass the arguments to the controler, we don't want the action here ;-)
+MIDB::ServerController.args = ARGV
+
+# And start the server
+MIDB::ServerController.init()
+
+# Save data in case we didn't actually start the server but change the configuration
+MIDB::ServerController.save()

data/lib/midb/dbengine_model.rb

@@ -0,0 +1,50 @@
+require 'midb/server_controller'
+require 'sqlite3'
+require 'mysql2'
+
+module MIDB
+  class DbengineModel
+    attr_accessor :engine, :host, :uname, :pwd, :port, :db
+    def initialize()
+      @engine = MIDB::ServerController.config["dbengine"]
+      @host = MIDB::ServerController.config["dbhost"]
+      @port = MIDB::ServerController.config["dbport"]
+      @uname = MIDB::ServerController.config["dbuser"]
+      @pwd = MIDB::ServerController.config["dbpassword"]
+      @db = MIDB::ServerController.db
+    end
+    # Method: connect
+    # Connect to the specified database
+    def connect()
+      if @engine == :sqlite3
+        sq = SQLite3::Database.open("./db/#{@db}.db")
+        sq.results_as_hash = true
+        return sq
+      elsif @engine == :mysql
+        return Mysql2::Client.new(:host => @host, :username => @uname, :password => @pwd, :database => @db)
+      end
+    end
+
+    # Method: query
+    # Perform a query, return a hash
+    def query(res, query)
+      if @engine == :sqlite3
+        return res.execute(query)
+      elsif @engine == :mysql
+        return res.query(query)
+      end
+    end
+
+    # Method: extract
+    # Extract a field from a query
+    def extract(result, field)
+      if @engine == :sqlite3
+        return result[0][field] || result[field]
+      elsif @engine == :mysql
+        result.each do |row|
+          return row[field]
+        end
+      end
+    end
+  end
+end

data/lib/midb/errors_view.rb

@@ -0,0 +1,31 @@
+require 'midb/server_controller'
+
+# This controller handles errors.
+module MIDB
+  class ErrorsView
+    # Method: die
+    # Handles arguments that cause program termination.
+    # Errors: :noargs, :server_already_started
+    def self.die(err)
+      errmsg =  case err
+                when :noargs then "No command supplied. See `midb help`."
+                when :server_already_started then "The server has already been started and is running."
+                when :server_not_running then "The server isn't running."
+                when :server_error then "Error while starting server."
+                when :no_serves then "No files are being served. Try running `midb serve file.json`"
+                when :syntax then "Syntax error. See `midb help`"
+                when :file_404 then "File not found."
+                when :not_json then "Specified file isn't JSON!"
+                when :json_exists then "Specified file is already being served."
+                when :json_not_exists then "The JSON file isn't being served."
+                when :unsupported_engine then "The specified database engine isn't supported by midb."
+                when :already_project then "This directory already contains a midb project."
+                when :bootstrap then "midb hasn't been bootstraped in this folder. Run `midb bootstrap`."
+                when :no_help then "No help available for this command. See a list of commands with `midb help`."
+                else "Unknown error: #{err.to_s}"
+                end
+      abort("Fatal error: #{errmsg}")
+
+    end
+  end
+end

data/lib/midb/security_controller.rb

@@ -0,0 +1,31 @@
+require 'hmac-sha1'
+require 'base64'
+require 'cgi'
+
+# midb security controller - handles API authentication 
+# this will probably become another different project soon!
+module MIDB
+  class SecurityController
+
+    # Method: is_auth?
+    # Checks if an HTTP header is the authorization one
+    def self.is_auth?(header)
+       return header.split(":")[0].downcase == "authentication"
+    end
+
+    # Method: parse_auth
+    # Parses an authentication header
+    def self.parse_auth(header)
+      return header.split(" ")[1]
+    end
+
+    # Method: check?
+    # Checks if an HMAC digest is properly authenticated
+    def self.check?(header, params, key)
+      signature = params
+      hmac = HMAC::SHA1.new(key)
+      hmac.update(signature)
+      return self.parse_auth(header) == CGI.escape(Base64.encode64("#{hmac.digest}"))
+    end
+  end
+end

data/lib/midb/server_controller.rb

@@ -0,0 +1,337 @@
+require 'midb/server_model'
+require 'midb/server_view'
+require 'midb/errors_view'
+require 'midb/security_controller'
+
+require 'yaml'
+require 'socket'
+require 'uri'
+require 'json'
+require 'sqlite3'
+
+module MIDB
+  # This controller controls the behavior of the midb server.
+  class ServerController
+    # Variable declaration
+    class << self
+      # args[] => passed by the binary
+      # config => configuration array saved and loaded from .midb.yaml
+      # db => the database we're using
+      # http_status => the HTTP status, sent by the model
+      attr_accessor :args, :config, :db, :http_status, :port
+    end
+    # status => server status
+    # serves[] => JSON files served by the API
+    @http_status = "200 OK"
+    @args = []
+    @config = Hash.new()
+    @port = 8081
+
+    # Method: init
+    # Decide what to do according to the supplied command!
+    def self.init()
+      # We should have at least one argument, which can be `run` or `serve`
+      MIDB::ErrorsView.die(:noargs) if @args.length < 1
+
+      # Load the config
+      if File.file?(".midb.yaml")
+        @config = YAML.load_file(".midb.yaml")
+      else
+        # If the file doesn't exist, we need to bootstrap
+        MIDB::ErrorsView.die(:bootstrap) if @args[0] != "help" && args[0] != "bootstrap"
+      end
+
+      case @args[0]
+
+      # Command: help
+      # Shows the help
+      when "help"
+        if @args.length > 1
+          case @args[1]
+          when "bootstrap"
+            MIDB::ServerView.help(:bootstrap)
+          when "set"
+            MIDB::ServerView.help(:set)
+          when "start"
+            MIDB::ServerView.help(:start)
+          when "serve"
+            MIDB::ServerView.help(:serve)
+          when "unserve"
+            MIDB::ServerView.help(:unserve)
+          else
+            MIDB::ErrorsView.die(:no_help)
+          end
+        else
+          MIDB::ServerView.help(:list)
+        end
+
+      # Command: bootstrap
+      # Create config file and initial directories
+      when "bootstrap"
+        if File.file?(".midb.yaml")
+          MIDB::ErrorsView.die(:already_project)
+        else
+          # If the file doesn't exist it, create it with the default stuff
+          @config["serves"] = []
+          @config["status"] = :asleep    # The server is initially asleep
+          @config["apikey"] = "midb-api" # This should be changed, it's the private API key
+          @config["dbengine"] = :sqlite3  # SQLite is the default engine
+          # Default DB configuration for MySQL and other engines
+          @config["dbhost"] = "localhost"
+          @config["dbport"] = 3306
+          @config["dbuser"] = "nobody"
+          @config["dbpassword"] = "openaccess" 
+          File.open(".midb.yaml", 'w') do |l|
+            l.write @config.to_yaml
+          end
+          # Create json/ and db/ directory if it doesn't exist 
+          Dir.mkdir("json") unless File.exists?("json")
+          Dir.mkdir("db") unless File.exists?("db")
+          MIDB::ServerView.info(:bootstrap)
+        end
+    
+      # Command: set
+      # Sets configuration factors.
+      when "set"
+        # Check syntax
+        MIDB::ErrorsView.die(:syntax) if @args.length < 2
+        subset = @args[1].split(":")[0]
+        subcmd = @args[1].split(":")[1]
+        set = @args.length < 3 ? false : true
+        setter = @args[2] if set
+        case subset
+        when "db"
+          # DB Config
+          case subcmd
+          when "engine"
+            if set
+              @config["dbengine"] = case setter.downcase
+                                    when "sqlite3" then :sqlite3
+                                    when "mysql" then :mysql
+                                    else :undef
+                                    end
+              if @config["dbengine"] == :undef
+                MIDB::ErrorsView.die(:unsupported_engine)
+                @config["dbengine"] = :sqlite3
+              end
+            end
+            MIDB::ServerView.out_config(:dbengine)
+          when "host"
+            @config["dbhost"] = setter if set
+            MIDB::ServerView.out_config(:dbhost)
+          when "port"
+            @config["dbport"] = setter if set
+            MIDB::ServerView.out_config(:dbport)
+          when "user"
+            @config["dbuser"] = setter if set
+            MIDB::ServerView.out_config(:dbuser)
+          when "password"
+            @config["dbpassword"] = setter if set
+            MIDB::ServerView.out_config(:dbpassword)
+          else
+            MIDB::ErrorsView.die(:synax)
+          end
+        when "api"
+          case subcmd
+          when "key"
+            @config["apikey"] = setter if set
+            MIDB::ServerView.out_config(:apikey)
+          end
+        else
+          MIDB::ErrorsView.die(:syntax)
+        end
+
+
+      # Command: start
+      # Starts the server
+      when "start"
+        # Check syntax
+        MIDB::ErrorsView.die(:syntax) if @args.length < 2
+        MIDB::ErrorsView.die(:syntax) if @args[1].split(":")[0] != "db"
+        # Is the server already started?
+        MIDB::ErrorsView.die(:server_already_started) if @config["status"] == :running
+        # Are any files being served?
+        MIDB::ErrorsView.die(:no_serves) if @config["serves"].length == 0
+        # If it successfully starts, change our status and notify thru view
+        @args.each do |arg|
+          if arg.split(":")[0] == "db"
+            @db = arg.split(":")[1]
+          elsif arg.split(":")[0] == "port"
+            @port = arg.split(":")[1]
+          end
+        end
+
+        if self.start(@port)
+          @config["status"] = :running
+          MIDB::ServerView.success()
+        else
+          MIDB::ErrorsView.die(:server_error)
+        end
+
+      # Command: serve
+      # Serves a JSON file
+      when "serve"
+        # Check if there's a second argument
+        MIDB::ErrorsView.die(:syntax) if @args.length < 2
+        # Is the server running? It shouldn't
+        MIDB::ErrorsView.die(:server_already_started) if @config["status"] == :running
+        # Is there such file as @args[1]?
+        MIDB::ErrorsView.die(:file_404) unless File.file?("./json/" + @args[1])
+        # Is the file a JSON file?
+        MIDB::ErrorsView.die(:not_json) unless File.extname(@args[1]) == ".json"
+        # Is the file already loaded?
+        MIDB::ErrorsView.die(:json_exists) if @config["serves"].include? @args[1]
+
+        # Tests passed, so let's add the file to the served list!
+        @config["serves"].push @args[1]
+        MIDB::ServerView.show_serving()
+
+      # Command: unserve
+      # Stop serving a JSON file.
+      when "unserve"
+        # Check if there's a second argument
+        MIDB::ErrorsView.die(:syntax) if @args.length < 2
+        # Is the server running? It shouldn't
+        MIDB::ErrorsView.die(:server_already_started) if @config["status"] == :running
+        # Is the file already loaded?
+        MIDB::ErrorsView.die(:json_not_exists) unless @config["serves"].include? @args[1]
+
+        # Delete it!
+        @config["serves"].delete @args[1]
+        MIDB::ServerView.show_serving()
+
+      # Command: stop
+      # Stops the server.
+      when "stop"
+        # Is the server running?
+        MIDB::ErrorsView.die(:server_not_running) unless @config["status"] == :running
+
+        @config["status"] = :asleep
+        MIDB::ServerView.server_stopped()
+      end
+    end
+
+    # Method: start
+    # Starts the server on the given port (default: 8080)
+    def self.start(port=8081)
+      serv = TCPServer.new("localhost", port)
+      MIDB::ServerView.info(:start, port)
+
+      # Manage the requests
+      loop do
+        socket = serv.accept
+        MIDB::ServerView.info(:incoming_request, socket.addr[3])
+
+        request = self.parse_request(socket.gets)
+
+        # Get a hash with the headers
+        headers = {}
+        while line = socket.gets.split(' ', 2)
+          break if line[0] == "" 
+          headers[line[0].chop] = line[1].strip
+        end
+        data = socket.read(headers["Content-Length"].to_i)
+
+
+        MIDB::ServerView.info(:request, request)
+        response_json = Hash.new()
+
+        # Endpoint syntax: ["", FILE, ID, (ACTION)]
+        endpoint = request[1].split("/")
+        ep_file = endpoint[1]
+
+        method = request[0]
+        endpoints = [] # Valid endpoints
+
+        # Load the JSON served files
+        @config["serves"].each do |js|
+          # The filename is a valid endpoint
+          endpoints.push File.basename(js, ".*")
+        end
+
+        # Load the endpoints
+        found = false
+        endpoints.each do |ep|
+          if ep_file == ep
+            found = true
+            MIDB::ServerView.info(:match_json, ep)
+            # Analyze the request and pass it to the model
+            if method == "GET"
+              case endpoint.length
+              when 2
+                # No ID has been specified. Return all the entries
+                # Pass it to the model and get the JSON
+                response_json = MIDB::ServerModel.get_all_entries(@db, ep).to_json
+              when 3
+                # An ID has been specified. Should it exist, return all of its entries.
+                response_json = MIDB::ServerModel.get_entries(@db, ep, endpoint[2]).to_json
+              end
+            else
+              # An action has been specified. We're going to need HTTP authentification here.
+              MIDB::ServerView.info(:auth_required)
+
+              if (not headers.has_key? "Authentication") ||
+                 (not MIDB::SecurityController.check?(headers["Authentication"], data, @config["apikey"]))
+                @http_status = "401 Unauthorized"
+                response_json = MIDB::ServerView.json_error(401, "Unauthorized").to_json
+                MIDB::ServerView.info(:no_auth)
+
+              else
+                MIDB::ServerView.info(:auth_success)
+                if method == "POST"
+                  response_json = MIDB::ServerModel.post(@db, ep, data).to_json
+                else
+                  if endpoint.length >= 3
+                    if method == "DELETE"
+                      response_json = MIDB::ServerModel.delete(@db, ep, endpoint[2]).to_json 
+                    elsif method == "PUT"
+                      response_json = MIDB::ServerModel.put(@db, ep, endpoint[2], data).to_json
+                    end
+                  else
+                    @http_status = "404 Not Found"
+                    response_json = MIDB::ServerView.json_error(404, "Must specify an ID.").to_json
+                  end
+                end
+              end
+            end
+            MIDB::ServerView.info(:response, response_json)
+            # Return the results via HTTP
+            socket.print "HTTP/1.1 #{@http_status}\r\n" +
+                        "Content-Type: text/json\r\n" +
+                        "Content-Length: #{response_json.size}\r\n" +
+                        "Connection: close\r\n"
+            socket.print "\r\n"
+            socket.print response_json
+            socket.print "\r\n"
+            MIDB::ServerView.info(:success)
+          end
+        end
+        unless found
+          MIDB::ServerView.info(:not_found)
+          response = MIDB::ServerView.json_error(404, "Invalid API endpoint.").to_json
+
+          socket.print "HTTP/1.1 404 Not Found\r\n" +
+                       "Content-Type: text/json\r\n" +
+                       "Content-Length: #{response.size}\r\n" +
+                       "Connection: close\r\n"
+          socket.print "\r\n"
+          socket.print response
+        end
+      end
+    end
+
+    # Method: parse_request
+    # Parses an HTTP requests and returns an array [method, uri]
+    def self.parse_request(req)
+      [req.split(" ")[0], req.split(" ")[1]]
+    end
+
+    # Method: save
+    # Saves config to .midb.yaml
+    def self.save()
+      File.open(".midb.yaml", 'w') do |l|
+        l.write @config.to_yaml
+      end
+    end
+  end
+end

data/lib/midb/server_model.rb

@@ -0,0 +1,293 @@
+require 'midb/server_controller'
+require 'midb/dbengine_model'
+require 'midb/server_view'
+
+require 'sqlite3'
+require 'json'
+require 'cgi'
+module MIDB
+  class ServerModel
+    attr_accessor :jsf
+
+    # Method: get_structure
+    # Safely get the structure
+    def self.get_structure()
+      JSON.parse(IO.read("./json/#{@jsf}.json"))["id"]
+    end
+
+    # Method: query_to_hash
+    # Convert a HTTP query string to a JSONable hash
+    def self.query_to_hash(query)
+      Hash[CGI.parse(query).map {|key,values| [key, values[0]||true]}]
+    end
+
+    # Method: post
+    # Act on POST requests - create a new resource
+    def self.post(db, jsf, data)
+      @jsf = jsf
+      jss = self.get_structure() # For referencing purposes
+
+      input = self.query_to_hash(data)
+      bad_request = false
+      resp = nil
+      jss.each do |key, value|
+        # Check if we have it on the query too
+        unless input.has_key? key
+          resp = MIDB::ServerView.json_error(400, "Bad Request - Not enough data for a new resource")
+          MIDB::ServerController.http_status = 400
+          bad_request = true
+        end
+      end
+      input.each do |key, value|
+        # Check if we have it on the structure too
+        unless jss.has_key? key
+          resp = MIDB::ServerView.json_error(400, "Bad Request - Wrong argument #{key}")
+          MIDB::ServerController.http_status = 400
+          bad_request = true
+        end
+      end
+      
+
+      # Insert the values if we have a good request
+      unless bad_request
+        fields = Hash.new
+        inserts = Hash.new
+        main_table = self.get_structure.values[0].split('/')[0]
+        input.each do |key, value|
+          struct = jss[key]
+          table = struct.split("/")[0]
+          inserts[table] ||= []
+          fields[table] ||= []
+          inserts[table].push "\"" + value + "\""
+          fields[table].push struct.split("/")[1]
+          if struct.split("/").length > 2
+            match = struct.split("/")[2]
+            matching_field = match.split("->")[0]
+            row_field = match.split("->")[1]
+            fields[table].push matching_field
+            if MIDB::ServerController.config["dbengine"] == "mysql"
+              inserts[table].push "(SELECT #{row_field} FROM #{main_table} WHERE id=(SELECT LAST_INSERT_ID()))"
+            else
+              inserts[table].push "(SELECT #{row_field} FROM #{main_table} WHERE id=(last_insert_rowid()))"
+            end
+          end
+        end
+        queries = []      
+        inserts.each do |table, values|
+          queries.push "INSERT INTO #{table}(#{fields[table].join(',')}) VALUES (#{inserts[table].join(',')});"
+        end
+        # Connect to the database
+        dbe = MIDB::DbengineModel.new
+        dblink = dbe.connect()
+        results = []
+        rid = nil
+        # Find the ID to return in the response (only for the first query)
+        queries.each do |q|
+          results.push dbe.query(dblink, q)
+          if MIDB::ServerController.config["dbengine"] == "mysql"
+            rid ||= dbe.extract(dbe.query(dblink, "SELECT id FROM #{main_table} WHERE id=(SELECT LAST_INSERT_ID());"), "id")
+          else
+            rid ||= dbe.extract(dbe.query(dblink, "SELECT id FROM #{main_table} WHERE id=(last_insert_rowid());"), "id")
+          end
+        end
+        MIDB::ServerController.http_status = "201 Created"
+        resp = {"status": "201 created", "id": rid}
+      end
+      return resp
+    end
+
+    # Method: put
+    # Update an already existing resource
+    def self.put(db, jsf, id, data)
+      @jsf = jsf
+      jss = self.get_structure() # For referencing purposes
+
+      input = self.query_to_hash(data)
+      bad_request = false
+      resp = nil
+      input.each do |key, value|
+        # Check if we have it on the structure too
+        unless jss.has_key? key
+          resp = MIDB::ServerView.json_error(400, "Bad Request - Wrong argument #{key}")
+          MIDB::ServerController.http_status = 400
+          bad_request = true
+        end
+      end
+
+      # Check if the ID exists
+      db = MIDB::DbengineModel.new
+      dbc = db.connect()
+      dbq = db.query(dbc, "SELECT * FROM #{self.get_structure.values[0].split('/')[0]} WHERE id=#{id};")
+      unless dbq.length > 0
+        resp = MIDB::ServerView.json_error(404, "ID not found")
+        MIDB::ServerController.http_status = 404
+        bad_request = true
+      end
+      
+      # Update the values if we have a good request
+      unless bad_request
+        fields = Hash.new
+        inserts = Hash.new
+        where_clause = Hash.new
+        main_table = self.get_structure.values[0].split('/')[0]
+        where_clause[main_table] = "id=#{id}"
+        input.each do |key, value|
+          struct = jss[key]
+          table = struct.split("/")[0]
+          inserts[table] ||= []
+          fields[table] ||= []
+          inserts[table].push "\"" + value + "\""
+          fields[table].push struct.split("/")[1]
+          if struct.split("/").length > 2
+            match = struct.split("/")[2]
+            matching_field = match.split("->")[0]
+            row_field = match.split("->")[1]
+            where_clause[table] = "#{matching_field}=(SELECT #{row_field} FROM #{main_table} WHERE #{where_clause[main_table]});"
+          end
+        end
+        queries = []
+        updates = Hash.new
+        # Turn it into a hash
+        inserts.each do |table, values|
+          updates[table] ||= Hash.new
+          updates[table] = Hash[fields[table].zip(inserts[table])]
+          query = "UPDATE #{table} SET "
+          updates[table].each do |f, v|
+            query = query + "#{f}=#{v} "
+          end
+          queries.push query + "WHERE #{where_clause[table]};"
+        end
+        # Run the queries
+        results = []
+        queries.each do |q|
+          results.push db.query(dbc, q)
+        end
+        MIDB::ServerController.http_status = "200 OK"
+        resp = {"status": "200 OK"}
+      end
+      return resp
+    end
+
+
+    def self.delete(db, jsf, id)
+      # Check if the ID exists
+      db = MIDB::DbengineModel.new
+      dbc = db.connect()
+      dbq = db.query(dbc, "SELECT * FROM #{self.get_structure.values[0].split('/')[0]} WHERE id=#{id};")
+      if not dbq.length > 0
+        resp = MIDB::ServerView.json_error(404, "ID not found").to_json
+        MIDB::ServerController.http_status = 404
+        bad_request = true
+      else
+        # ID Found, so let's delete it. (including linked resources!)
+        @jsf = jsf
+        jss = self.get_structure() # Referencing
+
+        where_clause = {}
+        tables = []
+        main_table = jss.values[0].split('/')[0]
+        where_clause[main_table] = "id=#{id}"
+
+        jss.each do |k, v|
+          table = v.split("/")[0]
+          tables.push table unless tables.include? table
+          # Check if it's a linked resource, generate WHERE clause accordingly
+          if v.split("/").length > 2
+            match = v.split("/")[2]
+            matching_field = match.split("->")[0]
+            row_field = match.split("->")[1]
+            # We have to run the subquery now because it'll be deleted later!
+            subq = "SELECT #{row_field} FROM #{main_table} WHERE #{where_clause[main_table]};"
+            res = db.query(dbc, subq)
+            subqres = db.extract(res, row_field)
+            where_clause[table] ||= "#{matching_field}=#{subqres}"
+          else
+            # Normal WHERE clause
+            where_clause[table] ||= "id=#{id}"
+          end
+        end
+
+        # Generate and run queries
+        results = []
+        tables.each do |tb|
+          query = "DELETE FROM #{tb} WHERE #{where_clause[tb]};"
+          results.push db.query(dbc, query)
+        end
+        MIDB::ServerController.http_status = "200 OK"
+        resp = {"status": "200 OK"}
+      end
+      return resp
+    end
+
+    # Method: get_entries
+    # Get the entries from a given ID.
+    def self.get_entries(db, jsf, id)
+      @jsf = jsf
+      jso = Hash.new()
+
+      dbe = MIDB::DbengineModel.new()
+      dblink = dbe.connect()
+      rows = dbe.query(dblink, "SELECT * FROM #{self.get_structure.values[0].split('/')[0]} WHERE id=#{id};")
+      if rows.length > 0
+        rows.each do |row|
+          jso[row["id"]] = self.get_structure
+
+          self.get_structure.each do |name, dbi|
+            table = dbi.split("/")[0]
+            field = dbi.split("/")[1]
+            # Must-match relations ("table2/field/table2-field->row-field")
+            if dbi.split("/").length > 2
+              match = dbi.split("/")[2]
+              matching_field = match.split("->")[0]
+              row_field = match.split("->")[1]
+              query = dbe.query(dblink, "SELECT #{field} FROM #{table} WHERE #{matching_field}=#{row[row_field]};")
+            else
+              query = dbe.query(dblink, "SELECT #{field} from #{table} WHERE id=#{row['id']};")
+            end
+            jso[row["id"]][name] = query.length > 0 ? dbe.extract(query,field) : "unknown"
+          end
+        end
+        MIDB::ServerController.http_status = "200 OK"
+      else
+        MIDB::ServerController.http_status = "404 Not Found"
+        jso = MIDB::ServerView.json_error(404, "Not Found")
+      end
+      return jso
+
+    end
+
+    # Method: get_all_entries
+    # Get all the entries from the fields specified in a JSON-parsed hash
+    def self.get_all_entries(db, jsf)
+      @jsf = jsf
+      jso = Hash.new()
+   
+      # Connect to database
+      dbe = MIDB::DbengineModel.new()
+      dblink = dbe.connect()
+      rows = dbe.query(dblink, "SELECT * FROM #{self.get_structure.values[0].split('/')[0]};")
+
+      # Iterate over all rows of this table
+      rows.each do |row|
+        # Replace the "id" in the given JSON with the actual ID and expand it with the fields
+        jso[row["id"]] = self.get_structure
+
+        self.get_structure.each do |name, dbi|
+          table = dbi.split("/")[0]
+          field = dbi.split("/")[1]
+          # Must-match relations ("table2/field/table2-field->row-field")
+          if dbi.split("/").length > 2
+            match = dbi.split("/")[2]
+            matching_field = match.split("->")[0]
+            row_field = match.split("->")[1]
+            query = dbe.query(dblink, "SELECT #{field} FROM #{table} WHERE #{matching_field}=#{row[row_field]};")
+          else
+            query = dbe.query(dblink, "SELECT #{field} from #{table} WHERE id=#{row['id']};")
+          end
+          jso[row["id"]][name] = query.length > 0 ? dbe.extract(query,field) : "unknown"
+        end
+      end
+      return jso
+    end
+  end
+end

data/lib/midb/server_view.rb

@@ -0,0 +1,99 @@
+require 'midb/server_controller'
+module MIDB
+  class ServerView
+    def self.success()
+      puts "Ayyy great"
+    end
+
+    # Method: json_error
+    # Return a JSON error response
+    def self.json_error(errno, msg)
+      return {"error" => {"errno" => errno, "msg" => msg}}
+    end
+
+    # Method: show_serving
+    # Shows the files being served
+    def self.show_serving()
+      puts "The follow JSON files are being served as APIs:"
+      MIDB::ServerController.config["serves"].each do |serv|
+        puts "- #{serv}"
+      end
+    end
+
+    # Method: server_stopped
+    # Notice that the server has been stopped.
+    def self.server_stopped()
+      puts "The server has been successfully stopped!"
+    end
+
+    # Method: info
+    # Send some info
+    def self.info(what, info=nil)
+      msg = case what
+            when :start then "Server started on port #{info}. Listening for connections..."
+            when :incoming_request then "> Incoming request from #{info}."
+            when :request then ">> Request method: #{info[0]}\n>>> Endpoint: #{info[1]}"
+            when :match_json then ">> The request matched a JSON file: #{info}.json\n>> Creating response..."
+            when :response then ">> Sending JSON response (RAW):\n#{info}"
+            when :success then "> Successfully managed this request!"
+            when :not_found then "> Invalid endpoint - sending a 404 error."
+            when :auth_required then ">> Authentication required. Checking for the HTTP header..."
+            when :no_auth then ">> No authentication header - sending a 401 error."
+            when :auth_success then ">> Successfully authenticated the request."
+            when :bootstrap then "> Successfully bootstraped!"
+            end
+      puts msg
+    end
+
+    # Method: out_config
+    # Output some config
+    def self.out_config(what)
+      msg = case what
+            when :dbengine then "Database engine: #{MIDB::ServerController.config['dbengine']}."
+            when :dbhost then "Database server host: #{MIDB::ServerController.config['dbhost']}."
+            when :dbport then "Database server port: #{MIDB::ServerController.config['dbport']}."
+            when :dbuser then "Database server user: #{MIDB::ServerController.config['dbuser']}."
+            when :dbpassword then "Database server password: #{MIDB::ServerController.config['dbpassword']}."
+            when :apikey then "Private API key: #{MIDB::ServerController.config['apikey']}"
+            else "Error??"
+            end
+      puts msg
+    end
+
+    # Method: help
+    # Shows the help
+    def self.help(what)
+      case what
+      when :list
+        puts "midb has several commands that you can use. For detailed information, see `midb help command`."
+        puts " "
+        puts "bootstrap\tCreate the basic files and directories that midb needs to be ran in a folder."
+        puts "set\tModify this project's settings. See the detailed help for a list of options."
+        puts "serve\tServes a JSON file - creates an API endpoint."
+        puts "unserve\tStops serving a JSON file - the endpoint is no longer valid."
+        puts "start\tStarts an API server. See detailed help for more."
+      when :bootstrap
+        puts "This command creates the `.midb.yaml` config file, and the `db` and `json` directories if they don't exist."
+        puts "You must bootstrap before running any other commands."
+      when :set
+        puts "Sets config options. If no value is given, it shows the current value."
+        puts "db:host\tHost name of the database (for MySQL)"
+        puts "db:user\tUsername for the database (for MySQL)"
+        puts "db:password\tPassword for the database (for MySQL)"
+        puts "db:engine\t(sqlite3, mysql) Changes the database engine."
+        puts "api:key\tChanges the private API key, used for authentication over HTTP."
+      when :serve
+        puts "This command will create an API endpoint pointing to a JSON file in the json/ directory."
+        puts "It will support GET, POST, PUT and DELETE requests."
+        puts "For detailed information on how to format your file, see the GitHub README and/or wiki."
+      when :unserve
+        puts "Stops serving a JSON file under the json/ directory."
+      when :start
+        puts "Starts the server. You must run the serve/unserve commands beforehand, so to set some endpoints."
+        puts "Options:"
+        puts "db:DATABASE\tSets DATABASE as the database where to get the data. Mandatory."
+        puts "port:PORT\tSets PORT as the port where the server will listen to. Default: 8081."
+      end
+    end
+  end
+end

data/lib/midb.rb

@@ -0,0 +1,6 @@
+require 'midb/dbengine_model'
+require 'midb/errors_view'
+require 'midb/security_controller'
+require 'midb/server_controller'
+require 'midb/server_model'
+require 'midb/server_view'

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: midb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- unrar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.20
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.20
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0.1
+- !ruby/object:Gem::Dependency
+  name: ruby-hmac
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: Automatically create a RESTful API for your database, all you need to
+  write is a JSON file!
+email: joszaynka@gmail.com
+executables:
+- midb
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/midb
+- lib/midb.rb
+- lib/midb/dbengine_model.rb
+- lib/midb/errors_view.rb
+- lib/midb/security_controller.rb
+- lib/midb/server_controller.rb
+- lib/midb/server_model.rb
+- lib/midb/server_view.rb
+homepage: http://www.github.com/unrar/midb
+licenses:
+- TPOL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Middleware for databases
+test_files: []