sqlite: implement Database#location()

Author: BurningEnlightenment

src/node_sqlite.cc

@@ -4582,13 +4582,34 @@ class IsInTransactionOperation : private OperationBase {
   }
 };
 
+class LocationOperation : private OperationBase {
+ public:
+  LocationOperation(Global<Promise::Resolver>&& resolver,
+                    std::pmr::string&& db_name)
+      : OperationBase(std::move(resolver)), db_name_(std::move(db_name)) {}
+
+  OperationResult operator()(sqlite3* connection) {
+    const char* location = sqlite3_db_filename(connection, db_name_.c_str());
+    transfer::literal location_literal{transfer::null{}};
+    if (location && location[0] != '\0') {
+      location_literal = transfer::text{location, std::strlen(location)};
+    }
+    return OperationResult::ResolveValue(
+        this, transfer::value{std::move(location_literal)});
+  }
+
+ private:
+  std::pmr::string db_name_;
+};
+
 using Operation = std::variant<ExecOperation,
                                StatementGetOperation,
                                StatementAllOperation,
                                StatementRunOperation,
                                PrepareStatementOperation,
                                FinalizeStatementOperation,
                                IsInTransactionOperation,
+                               LocationOperation,
                                CloseOperation>;
 
 template <typename T, typename V>
@@ -4891,6 +4912,7 @@ v8::Local<v8::FunctionTemplate> CreateDatabaseConstructorTemplate(
   SetProtoMethod(isolate, tmpl, "prepare", Database::Prepare);
   SetProtoMethod(isolate, tmpl, "exec", Database::Exec);
   SetProtoMethod(isolate, tmpl, "isInTransaction", Database::IsInTransaction);
+  SetProtoMethod(isolate, tmpl, "location", Database::Location);
 
   Local<String> sqlite_type_key = FIXED_ONE_BYTE_STRING(isolate, "sqlite-type");
   Local<v8::Symbol> sqlite_type_symbol =
@@ -5106,6 +5128,29 @@ Statement::Statement(Environment* env,
   }
 }
 
+void Database::Location(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Database* db;
+  ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  REJECT_AND_RETURN_ON_INVALID_STATE(
+      env, args, !db->IsOpen(), "database is not open");
+
+  std::pmr::string db_name;
+  if (args.Length() > 0) {
+    REJECT_AND_RETURN_ON_INVALID_ARG_TYPE(
+        env,
+        args,
+        !args[0]->IsString(),
+        "The \"dbName\" argument must be a string.");
+    Utf8Value db_name_utf8(env->isolate(), args[0].As<String>());
+    db_name = std::pmr::string(*db_name_utf8, db_name_utf8.length());
+  } else {
+    db_name = "main";
+  }
+  args.GetReturnValue().Set(
+      db->Schedule<LocationOperation>(std::move(db_name)));
+}
+
 Statement::~Statement() {
   if (!IsDisposed()) {
     // Our operations keep a BaseObjectPtr to this Statement, so we can be sure

src/node_sqlite.h

@@ -471,6 +471,7 @@ class Database final : public DatabaseCommon {
   static void Prepare(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Exec(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void IsInTransaction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Location(const v8::FunctionCallbackInfo<v8::Value>& args);
   // static void CreateTagStore(const v8::FunctionCallbackInfo<v8::Value>&
   // args); static void Location(const v8::FunctionCallbackInfo<v8::Value>&
   // args); static void EnableLoadExtension(

test/parallel/test-sqlite-database-async.mjs

@@ -560,40 +560,41 @@ suite('Database.prototype.isInTransaction()', { timeout: 1000 }, () => {
   });
 });
 
-suite.skip('Database.prototype.location()', { timeout: 1000 }, () => {
-  test('throws if database is not open', (t) => {
+suite('Database.prototype.location()', { timeout: 1000 }, () => {
+  test('throws if database is not open', async (t) => {
     const db = new Database(nextDb(), { open: false });
 
-    t.assert.throws(() => {
-      db.location();
+    await t.assert.rejects(async () => {
+      await db.location();
     }, {
       code: 'ERR_INVALID_STATE',
       message: /database is not open/,
     });
   });
 
-  test('throws if provided dbName is not string', (t) => {
+  test('throws if provided dbName is not string', async (t) => {
     const db = new Database(nextDb());
     t.after(async () => { await db.close(); });
 
-    t.assert.throws(() => {
-      db.location(null);
+    await t.assert.rejects(async () => {
+      await db.location(null);
     }, {
       code: 'ERR_INVALID_ARG_TYPE',
       message: /The "dbName" argument must be a string/,
     });
   });
 
-  test('returns null when connected to in-memory database', (t) => {
+  test('returns null when connected to in-memory database', async (t) => {
     const db = new Database(':memory:');
-    t.assert.strictEqual(db.location(), null);
+    t.after(async () => { await db.close(); });
+    t.assert.strictEqual(await db.location(), null);
   });
 
-  test('returns db path when connected to a persistent database', (t) => {
+  test('returns db path when connected to a persistent database', async (t) => {
     const dbPath = nextDb();
     const db = new Database(dbPath);
     t.after(async () => { await db.close(); });
-    t.assert.strictEqual(db.location(), dbPath);
+    t.assert.strictEqual(await db.location(), dbPath);
   });
 
   test('returns that specific db path when attached', async (t) => {
@@ -608,7 +609,7 @@ suite.skip('Database.prototype.location()', { timeout: 1000 }, () => {
     const escapedPath = otherPath.replace("'", "''");
     await db.exec(`ATTACH DATABASE '${escapedPath}' AS other`);
 
-    t.assert.strictEqual(db.location('other'), otherPath);
+    t.assert.strictEqual(await db.location('other'), otherPath);
   });
 });