autorest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c854866f2912dfd5420837fc1aadbb19e8c61de643682c72e2ccff56256d8685
+  data.tar.gz: c5be271a7e68f590840621f86ef96216406200fa1e3eafd2b3d4ed49efe7fc5c
+SHA512:
+  metadata.gz: eb6f7672555ac4bbd854a7a9635805a593a9a2562e3abd5e9d7974a93eaa02c866704a644268a9d65f97fd92094ad470d0905899e155c99b0276bccf895187ec
+  data.tar.gz: e6499256011494ed17c5b697c88777699599caeb4068903f5d11abd4ffa077f99ccaea32c0ab85b39d1ac28211705fb90f79c3622b004ef36bca3d0608ff0454

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Harish Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# 🌐 AutoREST
+[![made-with-ruby](https://img.shields.io/badge/Made%20with-Ruby-red)](https://www.ruby-lang.org)
+
+Generate full-featured API servers for your database tables in seconds.
+
+# ℹ About
+AutoREST is a database-agnostic RESTful API generator for Ruby. With just your database credentials, it scaffolds a live API server supporting CRUD operations — no Rails, no boilerplate.
+
+**Supported Databases**:
+
+* SQLite
+* MySQL
+* PostgreSQL
+* Oracle
+
+# ✨ Features
+
+* 🛠 Generates RESTful APIs from your database schema
+* 🔌 Pluggable DB adapter system
+* 🎛 CLI interface powered by [Thor](https://github.com/rails/thor)
+* 🗃 Supports major relational DBs via corresponding gems
+* 🔥 Runs on Puma + Rack
+
+# 🚀 Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'autorest'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it as a gem:
+
+```bash
+$ gem install autorest
+```
+> Note: Depending on the DB you use, you may need to install additional gems manually:
+>  * `sqlite3`
+>  * `mysql2`
+>  * `pg`
+>  * `ruby-oci8`
+
+# 🏃🏻‍♀️ Quickstart
+To get your hand on AutoREST, run:
+
+```bash
+autorest boot sqlite://[path/to/sqlite.db]/[table_name]
+```
+
+If you want to try with MySQL/PostgreSQL/Oracle, run:
+
+```bash
+autorest boot mysql://[username]:[password]@[host]:[port]/[database]/[table_name]
+```
+
+for PostgreSQL (or) Oracle, use `pg://` (or) `orcl://` respectively instead of `mysql://`
+
+Now you can access the server at `http://localhost:7914`
+
+# 🖥 CLI usage
+1. Via Interactive CLI
+
+```bash
+$ autorest new
+```
+
+2. Via YAML config file
+
+```bash
+$ autorest server <path/to/config>.yml
+```
+
+3. Via DSN
+
+```bash
+$ autorest boot mysql://[username]:[password]@[host]:[port]/[database]/[table_name]
+```
+
+# 📦 Configuration example
+```yaml
+db:
+  kind: mysql # sqlite, mysql, pg, orcl
+  host: localhost
+  port: 3306
+  user: root
+  passwd: secret
+  name: mydb # for sqlite: path/to/sqlite.db, for oracle: SID
+  tables: [users, posts]
+
+server:
+  host: 127.0.0.1
+  port: 8080
+```
+
+# 🌐 API endpoints
+Once the server is running, you can access the following RESTful API endpoints for the selected tables:
+
+* `GET /<table>` - Returns all rows from table
+* `GET /<table>/:id` - Returns a single row by ID (or any primary key)
+* `POST /<table>` - Creates a new row in table
+* `PUT /<table>/:id` - Updates an existing row by ID (or any primary key)
+* `PATCH /<table>/:id` - Updates an existing row by ID (or any primary key)
+* `DELETE /users/:id` - Deletes a user by ID
+
+The `PATCH` method simply allows one to update a subset of the columns, whereas the `PUT` method allows one to update all columns.
+
+# ✍🏻 Contributing
+Contributions are welcome! While the basic functionality of this project works, there is a lot of room for improvement.  If you have any suggestions or find any bugs, please [open an issue](https://github.com/harishtpj/AutoREST/issues/new/choose) or [create a pull request](https://github.com/harishtpj/AutoREST/pulls).
+
+# 📝 License
+
+#### Copyright © 2025 [M.V.Harish Kumar](https://github.com/harishtpj). <br>
+
+#### This project is [MIT](https://github.com/harishtpj/AutoREST/blob/0341e153b1a8a1df139ff7225cb5f997818db89b/LICENSE) licensed.

data/bin/autorest

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "autorest"
+
+AutoREST::CLI.start(ARGV)

data/lib/autorest/db/adapter.rb

@@ -0,0 +1,180 @@
+# Database Adapter class for AutoREST.
+#
+# This abstract class serves as a base class for specific database adapters such as
+# SQLite, MySQL, PostgreSQL, and Oracle. It defines the common interface that all
+# adapters must implement. These include methods for preparing the database (e.g., 
+# fetching table and column metadata), executing SQL queries, and managing database
+# connections.
+#
+# @abstract
+class AutoREST::DBAdapter
+
+    # Initializes a new DBAdapter instance.
+    #
+    # @param db_kind [Symbol] The type of database (e.g., :sqlite, :mysql, :pg, :orcl)
+    # @param db_name [String] The database name or SID (for Oracle)
+    # @param db_conn [Object] The database connection object
+    def initialize(db_kind, db_name, db_conn)
+        @db_kind = db_kind
+        @dbname = db_name
+        @db_conn = db_conn
+        @tables = nil
+    end
+
+    # Prepares the database by fetching metadata, such as tables and columns.
+    # This method must be implemented by subclasses.
+    #
+    # @raise [NotImplementedError] If the method is not implemented by a subclass.
+    # @abstract
+    def prepare
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    # Executes a raw SQL query.
+    #
+    # @param sql [String] The SQL query to execute
+    # @return [Array<Hash>] The result of the query as an array of hashes
+    # @abstract
+    def exec_sql(sql)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    # Escapes input data to safely use in SQL queries.
+    #
+    # @param input [String] The raw input data
+    # @return [String] The escaped input data
+    # @abstract
+    def escape(input)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    # Sets the access tables for the database. If no tables are specified, all tables are accessible.
+    #
+    # @param access_tab [Array<String>] A list of tables the user has access to
+    # @return [void]
+    def set_access_tables(access_tab)
+        @access_tables = access_tab.empty? ? @tables.keys : access_tab
+    end
+
+    # Returns the list of table names in the database.
+    #
+    # @return [Array<String>] A list of table names
+    def tables
+        prepare if @tables.nil?
+        @tables.keys
+    end
+
+    # Returns the list of column names for a given table.
+    #
+    # @param table_name [String] The name of the table
+    # @return [Array<String>] A list of column names
+    def columns(table_name)
+        prepare if @tables.nil?
+        @tables[table_name].keys
+    end
+
+    # Returns the rows of a table for the specified columns.
+    #
+    # @param table_name [String] The name of the table
+    # @param cols [String, Array<String>] The columns to retrieve (defaults to "*")
+    # @return [Array<Hash>, String] The rows of the table as an array of hashes, or an error message
+    def rows(table_name, cols = "*")
+        prepare if @tables.nil?
+        return "404: Table #{table_name} does not exist" unless @tables.include?(table_name)
+        return "403: Insufficient rights to access Table #{table_name}" unless @access_tables.include?(table_name)
+        result = exec_sql("select #{escape(cols)} from #{escape(table_name)}")
+        return "404: Table #{table_name} is empty" if result.empty?
+        result
+    end
+
+    # Returns a specific row in a table identified by its primary key value.
+    #
+    # @param table_name [String] The name of the table
+    # @param value [String, Integer] The value of the primary key
+    # @param cols [String, Array<String>] The columns to retrieve (defaults to "*")
+    # @return [Hash, String] The row as a hash, or an error message
+    def row(table_name, value, cols = "*")
+        prepare if @tables.nil?
+        return "404: Table #{table_name} does not exist" unless @tables.include?(table_name)
+        return "403: Insufficient rights to access Table #{table_name}" unless @access_tables.include?(table_name)
+        return "502: Table does not have primary key" if pkey(table_name).nil?
+        result = exec_sql("select #{escape(cols)} from #{table_name} where #{pkey(table_name)} = #{value.inspect}")
+        return "404: Row not found" if result.empty?
+        result
+    end
+
+    # Inserts a new row into a table.
+    #
+    # @param table_name [String] The name of the table
+    # @param data [Hash] The data to insert, where keys are column names and values are column values
+    # @return [Hash, String] The inserted row as a hash, or an error message
+    def insert(table_name, data)
+        prepare if @tables.nil?
+        return "404: Table #{table_name} does not exist" unless @tables.include?(table_name)
+        return "403: Insufficient rights to access Table #{table_name}" unless @access_tables.include?(table_name)
+        return "409: Row already exists" if has_row(table_name, data[pkey(table_name)])
+        cols = data.keys.join(", ")
+        values = data.values.map(&:inspect).join(", ")
+        exec_sql("insert into #{escape(table_name)} (#{cols}) values (#{values})")
+        row(table_name, data[pkey(table_name)])
+    end
+
+    # Updates an existing row in a table.
+    #
+    # @param table_name [String] The name of the table
+    # @param pk [String, Integer] The primary key of the row to update
+    # @param value [Hash] The new values for the row, where keys are column names and values are column values
+    # @param patch [Boolean] If true, allows the partial changes, for PATCH requests (defaults to false)
+    # @return [Hash, String] The updated row as a hash, or an error message
+    def update(table_name, pk, value, patch = false)
+        prepare if @tables.nil?
+        return "404: Table #{table_name} does not exist" unless @tables.include?(table_name)
+        return "403: Insufficient rights to update Table #{table_name}" unless @access_tables.include?(table_name)
+        return "404: Row not found" unless has_row(table_name, pk)
+        return "422: Primary key mismatch" if (pk != value[pkey(table_name)].to_s && !patch)
+        return "422: Invalid data" if (value.keys & columns(table_name) != value.keys)
+        kvpairs = value.map { |k, v| "#{k} = #{v.inspect}" }.join(", ")
+        exec_sql("update #{escape(table_name)} set #{kvpairs} where #{pkey(table_name)} = #{pk.inspect}")
+        row(table_name, pk)
+    end
+
+    # Deletes a row from a table.
+    #
+    # @param table_name [String] The name of the table
+    # @param value [String, Integer] The value of the primary key of the row to delete
+    # @return [Hash, String] The deleted row as a hash, or an error message
+    def del_row(table_name, value)
+        prepare if @tables.nil?
+        return "404: Table #{table_name} does not exist" unless @tables.include?(table_name)
+        return "403: Insufficient rights to delete Table #{table_name}" unless @access_tables.include?(table_name)
+        result = row(table_name, value)
+        return result if result.is_a?(String)
+        exec_sql("delete from #{escape(table_name)} where #{pkey(table_name)} = #{value.inspect}")
+        result
+    end
+
+    # Closes the database connection.
+    #
+    # @return [void]
+    def close
+        @db_conn.close
+    end
+
+    private
+        # Returns the primary key column name for a given table.
+        #
+        # @param table_name [String] The name of the table
+        # @return [String, nil] The primary key column name, or nil if no primary key exists
+        def pkey(table_name)
+            @tables[table_name].keys.find { |k| @tables[table_name][k][:pk] }
+        end
+
+        # Checks if a row exists in the table based on the primary key value.
+        #
+        # @param table_name [String] The name of the table
+        # @param value [String, Integer] The value of the primary key
+        # @return [Boolean] True if the row exists, false otherwise
+        def has_row(table_name, value)
+            !row(table_name, value).is_a?(String)
+        end
+end

data/lib/autorest/db/mysql.rb

@@ -0,0 +1,57 @@
+# DB Adapter for MySQL database
+begin
+    require "mysql2"
+rescue LoadError
+    warn "Please install the 'mysql2' gem to use MySQL database."
+end
+
+require_relative "adapter"
+
+# MySQL adapter for AutoREST.
+#
+# Uses the `mysql2` gem to connect and interact with a MySQL database.
+# Automatically detects tables and primary key columns.
+#
+# @example Initialize adapter
+#   db = AutoREST::MySQLDB.new("localhost", 3306, "root", "password", "mydb")
+#
+class AutoREST::MySQLDB < AutoREST::DBAdapter
+
+    # @param host [String] Hostname of the MySQL server
+    # @param port [Integer] Port number
+    # @param user [String] Username
+    # @param passwd [String] Password
+    # @param dbname [String] Name of the MySQL database
+    def initialize(host, port, user, passwd, dbname)
+        conn = Mysql2::Client.new(host: host, port: port, username: user, password: passwd, database: dbname)
+        super(:mysql, dbname, conn)
+    end
+
+    # Loads table metadata including columns and primary keys.
+    # @return [void]
+    def prepare
+        @tables = {}
+        @db_conn.query("show tables").each do |t|
+            tname = t["Tables_in_#{@dbname}"]
+            row_details = @db_conn.query("desc #{tname}")
+            @tables[tname] = {}
+            row_details.each do |row|
+                @tables[tname][row["Field"]] = {type: row["Type"], pk: row["Key"] == "PRI"}
+            end
+        end
+    end
+
+    # Executes a raw SQL query.
+    # @param sql [String] The SQL query to run
+    # @return [Array<Hash>] Resulting rows
+    def exec_sql(sql)
+        @db_conn.query(sql).to_a
+    end
+
+    # Escapes identifiers or values for safe usage in queries.
+    # @param input [String] Table or column name
+    # @return [String] Escaped string
+    def escape(input)
+        @db_conn.escape(input)
+    end
+end

data/lib/autorest/db/oracle.rb

@@ -0,0 +1,90 @@
+# DB Adapter for Oracle database
+begin
+    ENV['NLS_LANG'] ||= 'AMERICAN_AMERICA.US7ASCII'
+    require "oci8"
+rescue LoadError
+    warn "Please install the 'ruby-oci8' gem to use Oracle database."
+end
+
+require_relative "adapter"
+
+# Oracle DB adapter for AutoREST.
+#
+# Uses the `oci8` gem to connect and interact with an Oracle database.
+# Retrieves tables and primary key details from Oracle's user-owned tables and constraints.
+#
+# @example Initialize adapter
+#   db = AutoREST::OracleDB.new("localhost", 1521, "sys", "secret", "ORCL")
+#
+class AutoREST::OracleDB < AutoREST::DBAdapter
+
+    # @param host [String] Hostname of the Oracle server
+    # @param port [Integer] Port number
+    # @param user [String] Username
+    # @param passwd [String] Password
+    # @param sid [String] Oracle SID (System Identifier)
+    def initialize(host, port, user, passwd, sid)
+        conn = OCI8.new(user, passwd, "//#{host}:#{port}/#{sid}")
+        conn.autocommit = true
+        super(:orcl, sid, conn)
+    end
+
+    # Loads table metadata including columns and primary keys.
+    #
+    # Queries Oracle's `user_tab_columns` and `user_cons_columns` system views to get
+    # the column details and primary key information.
+    #
+    # @return [void]
+    def prepare
+        desc_query = <<~SQL
+        SELECT c.column_name,
+                c.data_type,
+                CASE WHEN pk.pk_column IS NOT NULL THEN 'YES' ELSE 'NO' END AS primary_key
+        FROM user_tab_columns c
+        LEFT JOIN (
+            SELECT ucc.column_name AS pk_column
+            FROM user_cons_columns ucc
+            JOIN user_constraints uc
+            ON ucc.constraint_name = uc.constraint_name
+            WHERE uc.constraint_type = 'P'
+            AND uc.table_name = :1
+        ) pk ON c.column_name = pk.pk_column
+        WHERE c.table_name = :1
+        SQL
+
+        @tables = {}
+        @db_conn.exec("select * from cat") do |t|
+            tname = t[0]
+            @tables[tname] = {}
+            @db_conn.exec(desc_query, tname) do |row|
+                @tables[tname][row[0]] = {type: row[1], pk: row[2] == "YES"}
+            end
+        end
+    end
+
+    # Executes a raw SQL query.
+    # @param sql [String] The SQL query to run
+    # @return [Array<Hash>] Resulting rows
+    def exec_sql(sql)
+        cursor = @db_conn.exec(sql)
+        cols = cursor.get_col_names
+        res = []
+        while row = cursor.fetch
+            res << Hash[cols.zip(row)]
+        end
+        res
+    end
+
+    # Closes the database connection.
+    # @return [void]
+    def close
+        @db_conn.logoff
+    end
+
+    # Escapes a string input to safely use in SQL queries.
+    # @param input [String] Raw user input
+    # @return [String] Escaped string
+    def escape(input)
+        input.to_s.gsub("'", "''")
+    end
+end

data/lib/autorest/db/postgres.rb

@@ -0,0 +1,80 @@
+# DB Adapter for PostgreSQL database
+begin
+    require "pg"
+rescue LoadError
+    warn "Please install the 'pg' gem to use PostgreSQL database."
+end
+
+require_relative "adapter"
+
+# PostgreSQL adapter for AutoREST.
+#
+# Uses the `pg` gem to connect and interact with a PostgreSQL database.
+# Detects tables and their primary keys by querying PostgreSQL system catalogs.
+#
+# @example Initialize adapter
+#   db = AutoREST::PostgresDB.new("localhost", 5432, "postgres", "secret", "mydb")
+#
+class AutoREST::PostgresDB < AutoREST::DBAdapter
+
+    # @param host [String] Hostname of the PostgreSQL server
+    # @param port [Integer] Port number
+    # @param user [String] Username
+    # @param passwd [String] Password
+    # @param dbname [String] Name of the PostgreSQL database
+    def initialize(host, port, user, passwd, dbname)
+        conn = PG.connect(host: host, port: port, user: user, password: passwd, dbname: dbname)
+        super(:pg, dbname, conn)
+    end
+
+    # Loads table metadata including columns and primary keys.
+    #
+    # It excludes system tables by filtering out `pg_catalog` and `information_schema` schemas.
+    #
+    # @return [void]
+    def prepare
+        desc_query = <<-SQL
+        SELECT
+            a.attname AS cname,
+            pg_catalog.format_type(a.atttypid, a.atttypmod) AS dtype,
+            coalesce(i.indisprimary, false) AS pk
+        FROM
+            pg_catalog.pg_attribute a
+        JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+        JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+        LEFT JOIN pg_catalog.pg_index i
+            ON c.oid = i.indrelid
+            AND a.attnum = ANY(i.indkey)
+            AND i.indisprimary
+        WHERE
+            c.relname = $1
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+        ORDER BY a.attnum;
+        SQL
+        @tables = {}
+        @db_conn.exec("SELECT tablename FROM pg_catalog.pg_tables
+        WHERE schemaname NOT IN ('pg_catalog', 'information_schema')").each do |t|
+            tname = t["tablename"]
+            row_details = @db_conn.exec_params(desc_query, [tname])
+            @tables[tname] = {}
+            row_details.each do |row|
+                @tables[tname][row["cname"]] = {type: row["type"], pk: row["pk"]}
+            end
+        end
+    end
+
+    # Executes a raw SQL query.
+    # @param sql [String] The SQL query to run
+    # @return [Array<Hash>] Resulting rows
+    def exec_sql(sql)
+        @db_conn.exec(sql).to_a
+    end
+
+    # Escapes a string input to safely use in SQL queries.
+    # @param input [String] Raw user input
+    # @return [String] Escaped string
+    def escape(input)
+        @db_conn.escape_string(input)
+    end
+end

data/lib/autorest/db/sqlite.rb

@@ -0,0 +1,54 @@
+# DB Adapter for SQLite database
+begin
+    require "sqlite3"
+rescue LoadError
+    warn "Please install the 'sqlite3' gem to use SQLite database."
+end
+
+require_relative "adapter"
+
+# SQLite adapter for AutoREST.
+#
+# Uses the `sqlite3` gem to connect and query the SQLite database.
+# Automatically discovers tables and primary keys.
+#
+# @example Initialize adapter
+#   db = AutoREST::SQLiteDB.new("data.db")
+#
+class AutoREST::SQLiteDB < AutoREST::DBAdapter
+    
+    # @param dbname [String] Path to the SQLite database file
+    def initialize(dbname)
+        conn = SQLite3::Database.new(dbname)
+        conn.results_as_hash = true
+        super(:sqlite, dbname, conn)
+    end
+
+    # Loads table metadata including columns and primary keys.
+    # @return [void]
+    def prepare
+        @tables = {}
+        @db_conn.execute("SELECT name FROM sqlite_master WHERE type='table'").each do |t|
+            tname = t['name']
+            row_details = @db_conn.execute("select name, type, pk from pragma_table_info('#{tname}')")
+            @tables[tname] = {}
+            row_details.each do |row|
+                @tables[tname][row['name']] = {type: row['type'], pk: row['pk'] == 1}
+            end
+        end
+    end
+
+    # Executes a raw SQL query.
+    # @param sql [String] The SQL query to run
+    # @return [Array<Hash>] Resulting rows
+    def exec_sql(sql)
+        @db_conn.execute(sql)
+    end
+
+    # Escapes identifiers or values for safe usage in queries.
+    # @param input [String] Table or column name
+    # @return [String] Escaped string
+    def escape(input)
+        SQLite3::Database.quote(input)
+    end
+end

data/lib/autorest/server.rb

@@ -0,0 +1,123 @@
+# The main server instance for AutoREST
+require "sinatra/base"
+
+# The main server instance for AutoREST.
+#
+# This class sets up a Sinatra web server that acts as the interface for
+# interacting with the AutoREST API. It handles requests related to various
+# database operations such as querying, inserting, updating, and deleting rows.
+#
+# @note This server is designed to work with different database adapters like
+#       SQLite, MySQL, PostgreSQL, and Oracle, as provided by the AutoREST framework.
+#
+# @example Starting the server
+#   AutoREST::Server.new(db_conn).run!
+#
+# @see AutoREST::DBAdapter
+class AutoREST::Server < Sinatra::Base
+    # Initializes a new AutoREST::Server instance.
+    #
+    # @param db_conn [AutoREST::DBAdapter] The database connection object to interact with
+    def initialize(db_conn)
+        super()
+        @db_conn = db_conn
+    end
+
+    before do
+        content_type :json
+    end
+
+    helpers do
+        # Helper method to return a formatted error response.
+        #
+        # @param msg [String] The error message to return
+        # @param status [Integer] The HTTP status code to return (default is 400)
+        # @return [String] The JSON-formatted error response
+        def error(msg, status = 400)
+            halt status, { error: msg }.to_json
+        end
+
+        # Helper method to parse the body of the incoming request as JSON.
+        #
+        # @param req [Sinatra::Request] The incoming request object
+        # @return [Hash] The parsed JSON body
+        def get_body(req)
+            req.body.rewind
+            JSON.parse(req.body.read)
+        end
+    end
+
+    get '/' do
+        { message: "Welcome to AutoREST API Server" }.to_json
+    end
+
+    get '/:table/?' do |tname|
+        cols = params["only"] || "*"
+        q = @db_conn.rows(tname, cols)
+        if q.is_a?(String)
+            code, msg = q.split(": ", 2)
+            error(msg, code.to_i)
+        end
+        q.to_json
+    end
+
+    post '/:table/?' do |tname|
+        data = get_body(request)
+        error("Incomplete request body") if data.empty?
+        q = @db_conn.insert(tname, data)
+        if q.is_a?(String)
+            code, msg = q.split(": ", 2)
+            error(msg, code.to_i)
+        end
+        q.to_json
+    end
+
+    get '/:table/:pk/?' do |tname, pk|
+        cols = params["only"] || "*"
+        pk = pk.match?(/\A-?\d+(\.\d+)?\z/) ? pk.to_i : pk
+        q = @db_conn.row(tname, pk, cols)
+        if q.is_a?(String)
+            code, msg = q.split(": ", 2)
+            error(msg, code.to_i)
+        end
+        q.to_json
+    end
+
+    put '/:table/:pk/?' do |tname, pk|
+        data = get_body(request)
+        error("Incomplete request body") if (data.empty? || data.keys != @db_conn.columns(tname))
+        pk = pk.match?(/\A-?\d+(\.\d+)?\z/) ? pk.to_i : pk
+        q = @db_conn.update(tname, pk, data)
+        if q.is_a?(String)
+            code, msg = q.split(": ", 2)
+            error(msg, code.to_i)
+        end
+        q.to_json
+    end
+
+    patch '/:table/:pk/?' do |tname, pk|
+        data = get_body(request)
+        error("Incomplete request body") if data.empty?
+        pk = pk.match?(/\A-?\d+(\.\d+)?\z/) ? pk.to_i : pk
+        q = @db_conn.update(tname, pk, data, true)
+        if q.is_a?(String)
+            code, msg = q.split(": ", 2)
+            error(msg, code.to_i)
+        end
+        q.to_json
+    end
+
+    delete '/:table/:pk/?' do |tname, pk|
+        pk = pk.match?(/\A-?\d+(\.\d+)?\z/) ? pk.to_i : pk
+        q = @db_conn.del_row(tname, pk)
+        if q.is_a?(String)
+            code, msg = q.split(": ", 2)
+            error(msg, code.to_i)
+        end
+        q.to_json
+    end
+
+    error 500 do
+        { error: "Internal Server Error" }.to_json
+    end
+end

data/lib/autorest/version.rb

@@ -0,0 +1,3 @@
+module AutoREST
+    VERSION = "0.1.0"
+end

data/lib/autorest.rb

@@ -0,0 +1,153 @@
+# The main executable for AutoREST
+#
+# This file defines the command-line interface (CLI) for the AutoREST gem using Thor.
+# The CLI allows users to generate a new AutoREST API server, start the server using 
+# a configuration file or DSN, and view the current version of the API.
+#
+# Commands:
+# - `version`: Prints the version of AutoREST.
+# - `new`: Creates a new AutoREST API server project.
+# - `server FILE`: Starts the AutoREST API server using a configuration file.
+# - `boot DSN`: Starts the AutoREST API server using a DSN.
+#
+# The commands involve setting up a database connection and starting a server with 
+# specified parameters such as the host, port, and database tables.
+
+require "thor"
+require "tty-prompt"
+require "rack"
+require "rack/handler/puma"
+require "yaml"
+require "uri"
+
+require_relative "autorest/version"
+require_relative "autorest/server"
+
+class AutoREST::CLI < Thor
+
+    # Determines if the program should exit on failure
+    def self.exit_on_failure?
+        true
+    end
+
+    map "-v" => "version"
+    desc "version", "Prints the version of AutoREST"
+    # Prints the version of AutoREST
+    def version
+        puts "AutoREST v#{AutoREST::VERSION}"
+    end
+
+    map "-n" => "new"
+    desc "new", "Creates a new AutoREST API server"
+    # Creates a new AutoREST API server project
+    # Prompts the user for database details and creates a configuration file.
+    def new
+        prompt = TTY::Prompt.new
+        opts = {db: {}, server: { host: "localhost", port: 7914 } }
+        puts "Welcome to AutoREST API Server Generator"
+        project_name = prompt.ask("Enter the project's name:")
+        opts[:db][:kind] = prompt.select("Select your database:",
+                                {"SQLite" => :sqlite, "MySQL" => :mysql, "PostgreSQL" => :pg, "Oracle" => :orcl}, 
+                                default: "SQLite")
+
+        if opts[:db][:kind] == :sqlite
+            require_relative "autorest/db/sqlite"
+            opts[:db][:name] = prompt.ask("Enter location of DB file:")
+            db = AutoREST::SQLiteDB.new(opts[:db][:name])
+        else
+            def_port = {mysql: 3306, pg: 5432, orcl: 1521}
+            def_usr = {mysql: "root", pg: "postgres", orcl: "SYS"}
+            opts[:db][:host] = prompt.ask("Enter hostname of DB:", default: "localhost")
+            opts[:db][:port] = prompt.ask("Enter port of DB:", default: def_port[opts[:db][:kind]])
+            opts[:db][:user] = prompt.ask("Enter username:", default: def_usr[opts[:db][:kind]])
+            opts[:db][:passwd] = prompt.ask("Enter password:", echo: false)
+            opts[:db][:name] = prompt.ask("Enter database #{opts[:db][:kind] == :orcl ? "SID" : "name"}:")
+            case opts[:db][:kind]
+            when :mysql
+                require_relative "autorest/db/mysql"
+                db = AutoREST::MySQLDB.new(opts[:db][:host], opts[:db][:port], opts[:db][:user], opts[:db][:passwd], opts[:db][:name])
+            when :pg
+                require_relative "autorest/db/postgres"
+                db = AutoREST::PostgresDB.new(opts[:db][:host], opts[:db][:port], opts[:db][:user], opts[:db][:passwd], opts[:db][:name])
+            when :orcl
+                require_relative "autorest/db/oracle"
+                db = AutoREST::OracleDB.new(opts[:db][:host], opts[:db][:port], opts[:db][:user], opts[:db][:passwd], opts[:db][:name])
+            end
+        end
+
+        opts[:db][:tables] = prompt.multi_select("Select tables from database:", db.tables)
+        db.set_access_tables(opts[:db][:tables])
+        puts "Creating configuration file..."
+        File.open("#{project_name}.yml", "w") do |f|
+            f.write(opts.to_yaml)
+        end
+        puts "Successfully completed!"
+        start_server(db)
+    end
+
+    map "-S" => "server"
+    desc "server FILE", "Starts the AutoREST API server using a config file"
+    # Starts the AutoREST API server using a configuration file
+    # Loads the configuration file and starts the server with the specified database settings.
+    def server(file)
+        opts = YAML.load_file(file)
+        case opts[:db][:kind]
+        when :sqlite
+            require_relative "autorest/db/sqlite"
+            db = AutoREST::SQLiteDB.new(opts[:db][:name])
+        when :mysql
+            require_relative "autorest/db/mysql"
+            db = AutoREST::MySQLDB.new(opts[:db][:host], opts[:db][:port], opts[:db][:user], opts[:db][:passwd], opts[:db][:name])
+        when :pg
+            require_relative "autorest/db/postgres"
+            db = AutoREST::PostgresDB.new(opts[:db][:host], opts[:db][:port], opts[:db][:user], opts[:db][:passwd], opts[:db][:name])
+        when :orcl
+            require_relative "autorest/db/oracle"
+            db = AutoREST::OracleDB.new(opts[:db][:host], opts[:db][:port], opts[:db][:user], opts[:db][:passwd], opts[:db][:name])
+        end
+        db.prepare
+        db.set_access_tables(opts[:db][:tables])
+        servinfo = opts.fetch(:server, { host: "localhost", port: 7914})
+        start_server(db, servinfo[:host], servinfo[:port])
+    end
+
+    map "-s" => "boot"
+    desc "boot DSN", "Starts the AutoREST API server using a DSN"
+    # Starts the AutoREST API server using a DSN (Data Source Name)
+    # Parses the DSN and starts the server using the corresponding database.
+    def boot(dsn)
+        uri = URI.parse(dsn)
+        if uri.scheme == "sqlite"
+            require_relative "autorest/db/sqlite"
+            db = AutoREST::SQLiteDB.new(uri.host)
+            table, *_ = uri.path.sub(/^\//, '').split('/')
+        else
+            database, table = uri.path.sub(/^\//, '').split('/')
+            passwd = URI.decode_www_form_component(uri.password)
+            case uri.scheme
+            when "mysql"
+                require_relative "autorest/db/mysql"
+                db = AutoREST::MySQLDB.new(uri.host, uri.port, uri.user, passwd, database)
+            when "pg"
+                require_relative "autorest/db/postgres"
+                db = AutoREST::PostgresDB.new(uri.host, uri.port, uri.user, passwd, database)
+            when "orcl"
+                require_relative "autorest/db/oracle"
+                db = AutoREST::OracleDB.new(uri.host, uri.port, uri.user, passwd, database)
+            end
+        end
+        db.prepare
+        db.set_access_tables([table])
+        start_server(db)
+    end
+
+    no_commands do
+        # Starts the AutoREST server
+        def start_server(db, host = "localhost", port = 7914)
+            server = AutoREST::Server.new(db)
+            puts "Starting server..."
+            Rack::Handler::Puma.run(server, Host: host, Port: port)
+            db.close
+        end
+    end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: autorest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- M.V. Harish Kumar
+bindir: bin
+cert_chain: []
+date: 2025-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: AutoREST is a lightweight CLI tool that turns your SQL database into
+  a fully working RESTful API server using Puma and Rack. Supports SQLite, MySQL,
+  PostgreSQL, and Oracle.
+email:
+- harishtpj@outlook.com
+executables:
+- autorest
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/autorest
+- lib/autorest.rb
+- lib/autorest/db/adapter.rb
+- lib/autorest/db/mysql.rb
+- lib/autorest/db/oracle.rb
+- lib/autorest/db/postgres.rb
+- lib/autorest/db/sqlite.rb
+- lib/autorest/server.rb
+- lib/autorest/version.rb
+homepage: https://github.com/harishtpj/AutoREST
+licenses:
+- MIT
+metadata: {}
+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: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Tool to generate RESTful APIs
+test_files: []