chore: fix autoincreament and crud from struct

src/Jorm.jl

@@ -4,11 +4,12 @@ using DataFrames
 using LibPQ
 
 # Write your package code here.
-export RawSQL,@raw_sql,tablename
+export RawSQL,@raw_sql,tablename,getmodel_data
 export connect,disconnect,SQLiteConnectionString
 export create_table,delete_table
-export read_one_sql,insert_sql,update_sql,delete_sql,filter_by_sql,groupby_sql
-export read_one,insert!,update!,delete!
+export read_one_sql,insert_sql,update_sql,delete_sql,filter_by_sql,groupby_sql,read_all_sql
+export read_one,insert!,update!,delete!,read_all
+export delete_db,drop_all_tables
 
 
 """
@@ -33,6 +34,17 @@ macro raw_sql(v::String)
 end
 
 
+# """
+#     to_raw_sql(data::String)
+#         -> RawSQL
+
+# Create a `RawSQL` instance from a given SQL query string.
+# """
+# function to_raw_sql(data::String)
+#     query = RawSQL(data)
+#     return query
+# end
+
 # Model  ==> TableName
 # Struct ==> TableName 
 
@@ -138,22 +150,36 @@ end
     create_table(db::SQLite.DB, model, tableName)
     Creates a table in the database based on the model.
 """
-function create_table(db::SQLite.DB, model, tableName)
+function create_table(db::SQLite.DB, model::Type, tableName)
+    # Create an instance of the model to access its fields
     fields = fieldnames(model)
-    field_types = [typeof(getfield(model(), field)) for field in fields]
+    field_types = fieldtypes(model)
+    # field_types = [typeof(getfield(model, field)) for field in fields]
     field_definitions = [ "$(field) $(typeof_to_sql(field_type))" for (field, field_type) in zip(fields, field_types) ]
     query = "CREATE TABLE IF NOT EXISTS $tableName (id INTEGER PRIMARY KEY AUTOINCREMENT, $(join(field_definitions, ", ")))"
-    SQLite.execute!(db, query)
+    DBInterface.execute(db, query)
 end
 
+# Define the typeof_to_sql function
 function typeof_to_sql(field_type)
-        if field_type == Int
-            return "INTEGER"
-        elseif field_type == String
-            return "TEXT"
-        else
-            error("Unsupported field type: $field_type")
-        end
+    if field_type == Int64
+        return "INTEGER"
+    elseif field_type == Float64
+        return "REAL"
+    elseif field_type == String
+        return "TEXT"
+    elseif field_type == DateTime
+        return "TEXT"  # SQLite does not have a specific datetime type, so we use TEXT
+    else
+        error("Unsupported type: $field_type")
+    end
+end
+
+function getmodel_data(model)
+    fields = fieldnames(model)
+    field_types = [typeof(getfield(model, field)) for field in fields]
+    field_definitions = [ "$(field) $(typeof_to_sql(field_type))" for (field, field_type) in zip(fields, field_types) ]
+    return field_definitions
 end
 
 function delete_table(db::SQLite.DB, model) 
@@ -189,6 +215,70 @@ function ls_tables(connection_string::Jorm.SQLiteConnectionString)
 end
 
 
+"""
+    drop_all_tables(connection_string::SQLiteConnectionString) 
+    Delete or Drop all tables for a given table 
+"""
+function drop_all_tables(connection_string::Jorm.SQLiteConnectionString)
+    # Connect to the database
+    db = SQLite.DB(connection_string.database_name)
+
+    # Retrieve table names
+    query = "SELECT name FROM sqlite_master WHERE type='table'"
+    results = DBInterface.execute(db, query)
+    tables = [row.name for row in results]
+
+    # Drop each table
+    for table in tables
+        if table != "sqlite_sequence"  # Avoid dropping sqlite_sequence which is used for autoincrement
+            drop_query = "DROP TABLE IF EXISTS $table"
+            DBInterface.execute(db, drop_query)
+        end
+    end
+
+    # Close the database connection
+    close(db)
+end
+
+"""
+    delete_db(connection_string::Jorm.SQLiteConnectionString)
+    Deletes or removes a an sqlite database
+
+"""
+function delete_db(connection_string::Jorm.SQLiteConnectionString)
+    db_path = connection_string.database_name
+    if isfile(db_path)
+        rm(db_path)
+        println("SQLite database deleted successfully.")
+    else
+        println("SQLite database file not found.")
+    end
+end
+
+
+"""
+    delete_db(connection_string::Jorm.PostgreSQLConnectionString)
+    Deletes or removes a an PostgreSQL database
+
+"""
+function delete_db(connection_string::Jorm.PostgreSQLConnectionString)
+    # conn = LibPQ.connect("host=$host user=$user password=$password dbname=postgres")
+    # query = "DROP DATABASE $db_name"
+    LibPQ.Connection(
+        "host=" * connection_string.endpoint * " user=" * connection_string.username * " password=" * connection_string.password * " port=" * string(connection_string.port) * " dbname=" * connection_string.database_name
+    )
+    query = "DROP DATABASE $db_name"
+    try
+        LibPQ.execute(conn, query)
+        println("PostgreSQL database deleted successfully.")
+    catch e
+        println("Error deleting PostgreSQL database: $e")
+    finally
+        LibPQ.close(conn)
+    end
+end
+
+
 """
     delete_all(db::SQLite.DB, model) 
     Deletes all data in the table for the given model
@@ -202,42 +292,50 @@ end
 
 
 # Function to generate the SQL query for reading one record
-function read_one_sql(model, id)
+function read_one_sql(model)
     query = "SELECT * FROM $(tablename(model)) WHERE id = ?"
-    return query
+    return RawSQL(query)
+end
+
+# Function to generate the SQL query for reading all record
+function read_all_sql(model)
+    query = "SELECT * FROM $(tablename(model))"
+    return RawSQL(query)
 end
 
 # Function to generate the SQL query for creating a new record
-function insert_sql(model, data)
+function insert_sql(model)
     columns = join(fieldnames(model), ", ")
     placeholders = join(repeat("?", length(fieldnames(model))), ", ")
     query = "INSERT INTO $(tablename(model)) ($columns) VALUES ($placeholders)"
-    return query
+    return RawSQL(query)
 end
 
 # Function to generate the SQL query for updating a record
-function update_sql(model, id, data)
+function update_sql(model)
     columns = join([string(field, " = ?") for field in fieldnames(model)], ", ")
     query = "UPDATE $(tablename(model)) SET $columns WHERE id = ?"
-    return query
+    return RawSQL(query)
 end
 
 # Function to generate the SQL query for deleting a record
-function delete_sql(model, id)
+function delete_sql(model)
     query = "DELETE FROM $(tablename(model)) WHERE id = ?"
-    return query
+    return RawSQL(query)
 end
 
 # Wrapper function to display the SQL syntax
 function show_sql(func, args...)
     if func == insert!
-        return insert_sql(args, args)
+        return insert_sql(args)
     elseif func == update!
-        return update_sql(args, args, args)
+        return update_sql(args)
     elseif func == delete!
-        return delete_sql(args, args)
+        return delete_sql(args)
     elseif func == read_one
-        return read_one_sql(args, args)
+        return read_one_sql(args)
+    elseif func == read_all
+        return read_all_sql(args)
     else
         error("Unsupported function")
     end
@@ -281,7 +379,7 @@ function filter_by_sql(table_name; kwargs...)
 
     # Construct the SQL query
     query = "SELECT * FROM $table_name $where_clause"
-    return query, params
+    return RawSQL(query), params
 end
 
 # CRUD functions using the above SQL generation and execution
@@ -290,19 +388,29 @@ end
     Returns a given model object when given the ID  
 """
 function read_one(db::SQLite.DB, model, id)
-    query = read_one_sql(model, id)
+    query = read_one_sql(model)
     params = Any[id]
     result = Jorm.execute_query(db, query, params)
     return result
 end
 
+"""
+    read_all(db::SQLite.DB, model) 
+    Returns all data of a given model object 
+"""
+function read_all(db::SQLite.DB, model)
+    query = read_all_sql(model)
+    result = Jorm.execute_query(db, query)
+    return result
+end
+
 
 """
-    insert!(db::SQLite.DB, model, data) 
+    insert!(db::SQLite.DB, model::Type, data) 
     Insert or Add data to the DB for a given model
 """
-function insert!(db::SQLite.DB, model, data)
-    query = insert_sql(model, data)
+function insert!(db::SQLite.DB, model::Type, data)
+    query = insert_sql(model)
     params = Any[getfield(data, field) for field in fieldnames(model)]
     Jorm.execute_query(db, query, params)
 end
@@ -313,7 +421,7 @@ end
     Update data to the DB for a given model
 """
 function update!(db::SQLite.DB, model, id, data)
-    query = update_sql(model, id, data)
+    query = update_sql(model)
     params = Any[getfield(data, field) for field in fieldnames(model)]
     push!(params, id)
     Jorm.execute_query(db, query, params)
@@ -325,7 +433,7 @@ end
     Delete data for a given model
 """
 function delete!(db::SQLite.DB, model, id)
-    query = delete_sql(model, id)
+    query = delete_sql(model)
     params = Any[id]
     Jorm.execute_query(db, query, params)
 end