feat(database): GetCredentials & GetKind

Author: skuzzis

generators/docsgen/functions/GenerateClassConstructor.mjs

@@ -13,7 +13,7 @@ ${lang == "cs" ? `using SwiftlyS2.API.${category.category.includes("sdk") ? cate
     if (lang == "cs") {
         let cls = category.data.title.split(" ").join("")
 
-        outString += `var ${pageContent.name.toLowerCase()} = new ${cls}.${pageContent.name}`
+        outString += `var ${pageContent.name.toLowerCase()} = new ${pageContent.override_class ? pageContent.override_class["cs"] : `${cls}.${pageContent.name}`}`
     } else if (lang == "lua") {
         if (pageContent.override_variable) v = ""
         outString += `local ${pageContent.name.toLowerCase()} = ${v}${v == "" ? "" : ":"}${pageContent.name}`

generators/documentation/docs/database/database.json

@@ -1,10 +1,15 @@
 {
     "kind": "class",
     "name": "Database",
+    "override_class": {
+        "lua": "Database",
+        "cs": "Database.DB"
+    },
     "description": "This is the Database class.",
     "constructor": {
         "arguments": {
-            "connection_name": "string"
+            "connection_name": "string",
+            "skip_default_connection": "bool?"
         },
         "return": "Database"
     },
@@ -58,6 +63,16 @@
                 }
             },
             "return": "void"
+        },
+        {
+            "name": "GetCredentials",
+            "arguments": {},
+            "return": "string:string"
+        },
+        {
+            "name": "GetKind",
+            "arguments": {},
+            "return": "string"
         }
     ]
 }

src/network/database/DatabaseManager.cpp

@@ -60,12 +60,16 @@ void DatabaseManager::LoadDatabases()
         }
 
         if (!db) {
-            PLUGIN_PRINTF("Database", "Invalid database kind for \"%s\": %s.\n", connectionName, connection_details["kind"].c_str());
-            continue;
+            PLUGIN_PRINTF("Database", "Database kind %s used by \"%s\" doesn't have an extension. It will be registered but queries will not be executed.\n", connection_details["kind"].c_str(), connectionName);
+            databases.insert({ connectionName, nullptr });
+        }
+        else {
+            db->SetConnectionConfig(connection_details);
+            databases.insert({ connectionName, db });
         }
 
-        db->SetConnectionConfig(connection_details);
-        databases.insert({ connectionName, db });
+        databases_credentials.insert({ connectionName, connection_details });
+        database_kind.insert({ connectionName, connection_details["kind"] });
     }
 
     if (modified) {
@@ -83,6 +87,20 @@ IDatabase* DatabaseManager::GetDatabase(std::string name)
     return databases.at(name);
 }
 
+std::map<std::string, std::string> DatabaseManager::GetDatabaseCredentials(std::string name)
+{
+    if (databases.find(name) == databases.end()) return {};
+
+    return databases_credentials[name];
+}
+
+std::string DatabaseManager::GetDatabaseKind(std::string name)
+{
+    if (databases.find(name) == databases.end()) return "unknown";
+
+    return database_kind[name];
+}
+
 EXT_API void swiftly_RegisterDBDriver(void* driverPtr)
 {
     dbDrivers.push_back((DBDriver*)driverPtr);

src/network/database/DatabaseManager.h

@@ -9,10 +9,15 @@ class DatabaseManager
 private:
     const char* databasesPath = "addons/swiftly/configs/databases.json";
     std::map<std::string, IDatabase*> databases;
+    std::map<std::string, std::map<std::string, std::string>> databases_credentials;
+    std::map<std::string, std::string> database_kind;
 
 public:
     void LoadDatabases();
     IDatabase* GetDatabase(std::string name);
+
+    std::map<std::string, std::string> GetDatabaseCredentials(std::string name);
+    std::string GetDatabaseKind(std::string name);
 };
 
 extern DatabaseManager g_dbManager;

src/scripting/network/database.cpp

@@ -36,19 +36,17 @@ LoadScriptingComponent(database, [](PluginObject plugin, EContext* ctx) -> void
         bool shouldSkipDefaultConnection = context->GetArgumentOr<bool>(1, false);
 
         auto db = g_dbManager.GetDatabase(connection_name);
-        if (!db && connection_name != "default_connection") {
+        if (!db && connection_name != "default_connection" && g_dbManager.GetDatabaseKind(connection_name) != "unknown") {
             PRINTF("Database connection \"%s\" doesn't exists inside the database configurations. Automatically falling back to \"default_connection\".\n", connection_name.c_str());
             if (!shouldSkipDefaultConnection) db = g_dbManager.GetDatabase("default_connection");
         }
 
-        if (!db) {
-            PRINTF("An error has occured while trying to connect to database \"%s\":\nError: Invalid connection inside `addons/swiftly/configs/databases.json`\n", connection_name.c_str());
-        }
-        else if (!db->Connect()) {
+        if (!db->Connect()) {
             PRINTF("An error has occured while trying to connect to database \"%s\":\nError: %s\n", connection_name.c_str(), db->GetError().c_str());
         }
 
         data->SetData("db", db);
+        data->SetData("connection_name", connection_name);
     });
 
     ADD_CLASS_FUNCTION("DB", "IsConnected", [](FunctionContext* context, ClassData* data) -> void {
@@ -62,21 +60,24 @@ LoadScriptingComponent(database, [](PluginObject plugin, EContext* ctx) -> void
         IDatabase* db = data->GetData<IDatabase*>("db");
         std::string str = context->GetArgumentOr<std::string>(0, "");
 
-        if (!db || !db->IsConnected()) return context->SetReturn(str);
+        if (!db) return context->SetReturn(str);
+        if (!db->IsConnected()) return context->SetReturn(str);
 
         context->SetReturn(db->EscapeValue(str));
     });
 
     ADD_CLASS_FUNCTION("DB", "GetVersion", [](FunctionContext* context, ClassData* data) -> void {
         IDatabase* db = data->GetData<IDatabase*>("db");
-        if (!db || !db->IsConnected()) return context->SetReturn("");
+        if (!db) return context->SetReturn("");
+        if (!db->IsConnected()) return context->SetReturn("");
 
         context->SetReturn(db->GetVersion());
     });
 
     ADD_CLASS_FUNCTION("DB", "Query", [](FunctionContext* context, ClassData* data) -> void {
         IDatabase* db = data->GetData<IDatabase*>("db");
-        if (!db || !db->IsConnected()) return;
+        if (!db) return;
+        if (!db->IsConnected()) return;
 
         std::string query = context->GetArgumentOr<std::string>(0, "");
         if (query == "") return;
@@ -87,8 +88,19 @@ LoadScriptingComponent(database, [](PluginObject plugin, EContext* ctx) -> void
 
     ADD_CLASS_FUNCTION("DB", "QueryBuilder", [](FunctionContext* context, ClassData* data) -> void {
         IDatabase* db = data->GetData<IDatabase*>("db");
-        if (!db || !db->IsConnected()) return context->SetReturn(nullptr);
+        if (!db) return context->SetReturn(nullptr);
+        if (!db->IsConnected()) return context->SetReturn(nullptr);
 
         context->SetReturn(db->ProvideQueryBuilderTable());
     });
+
+    ADD_CLASS_FUNCTION("DB", "GetCredentials", [](FunctionContext* context, ClassData* data) -> void {
+        std::string connection_name = data->GetData<std::string>("connection_name");
+        context->SetReturn(g_dbManager.GetDatabaseCredentials(connection_name));
+    });
+
+    ADD_CLASS_FUNCTION("DB", "GetKind", [](FunctionContext* context, ClassData* data) -> void {
+        std::string connection_name = data->GetData<std::string>("connection_name");
+        context->SetReturn(g_dbManager.GetDatabaseKind(connection_name));
+    });
 })