test: add data to database before serializing to ensure compatibility

Empty in-memory databases may not be serializable on some SQLite versions
(like system SQLite on macOS). Added table creation and data insertion
to make the database serializable across all platforms.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/bun.js/bindings/sqlite/JSSQLStatement.cpp

@@ -1275,8 +1275,12 @@ JSC_DEFINE_HOST_FUNCTION(jsSQLStatementSerialize, (JSC::JSGlobalObject * lexical
     }
     sqlite3_int64 length = -1;
     unsigned char* data = sqlite3_serialize(db, attachedName.utf8().data(), &length, 0);
-    if (data == nullptr && length) [[unlikely]] {
-        throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Out of memory"_s));
+    if (data == nullptr) [[unlikely]] {
+        if (length > 0) {
+            throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Out of memory"_s));
+        } else {
+            throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, String("database does not exist or cannot be serialized"_s)));
+        }
         return {};
     }
 

test/integration/vite-build/vite-build.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import fs from "fs";
-import { bunExe, bunEnv as env, tmpdirSync, isASAN } from "harness";
+import { bunExe, bunEnv as env, isASAN, tmpdirSync } from "harness";
 import path from "path";
 
 const ASAN_MULTIPLIER = isASAN ? 3 : 1;

test/regression/issue/6549.test.ts

@@ -0,0 +1,60 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+
+test("serialize with invalid argument should throw proper error (issue 6549)", () => {
+  const db = new Database(":memory:");
+
+  // This should throw a proper SQLite error, not "Out of memory"
+  expect(() => {
+    db.serialize(function () {});
+  }).toThrow();
+
+  // The error should not be "Out of memory"
+  try {
+    db.serialize(function () {});
+  } catch (error) {
+    expect(error.message).not.toBe("Out of memory");
+    // Should be a more specific error about the database not existing
+    expect(error.message.toLowerCase()).toContain("does not exist");
+  }
+
+  db.close();
+});
+
+test("serialize with valid database name should work", () => {
+  const db = new Database(":memory:");
+
+  // Create a table and insert data to make database serializable
+  db.run("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)");
+  db.run("INSERT INTO test (name) VALUES ('test_data')");
+
+  // This should work with the default "main" database
+  const result = db.serialize();
+  expect(result).toBeInstanceOf(Buffer);
+  expect(result.length).toBeGreaterThan(0);
+
+  // Also test with explicit "main" parameter
+  const result2 = db.serialize("main");
+  expect(result2).toBeInstanceOf(Buffer);
+  expect(result2.length).toBeGreaterThan(0);
+
+  db.close();
+});
+
+test("serialize with nonexistent database name should throw proper error", () => {
+  const db = new Database(":memory:");
+
+  expect(() => {
+    db.serialize("nonexistent_db");
+  }).toThrow();
+
+  // The error should not be "Out of memory"
+  try {
+    db.serialize("nonexistent_db");
+  } catch (error) {
+    expect(error.message).not.toBe("Out of memory");
+    expect(error.message.toLowerCase()).toContain("does not exist");
+  }
+
+  db.close();
+});