🧹 [code health improvement] Remove unused parameter in serializeDatabase

src/connectionTypes.ts

@@ -27,7 +27,7 @@ export interface DatabaseConnectionBundle {
   workerMethods: {
     initializeDatabase: (filename: string, config: DatabaseInitConfig) => Promise<DatabaseInitResult>;
     runQuery: (sql: string, params?: CellValue[]) => Promise<QueryResultSet[]>;
-    exportDatabase: (name: string) => Promise<Uint8Array>;
+    exportDatabase: () => Promise<Uint8Array>;
     [Symbol.dispose]: () => void;
   };
 

src/core/engine/wasm/WasmDatabaseEngine.ts

@@ -210,7 +210,7 @@ export class WasmDatabaseEngine implements DatabaseOperations {
    * @param _name - Identifier (unused, for interface compatibility)
    * @returns Database binary content
    */
-  async serializeDatabase(_name: string): Promise<Uint8Array> {
+  async serializeDatabase(): Promise<Uint8Array> {
     return this.instance.export();
   }
 

src/core/sqlite-db.ts

@@ -171,8 +171,8 @@ export function createWorkerEndpoint() {
      * @param name - Database name
      * @returns Binary content
      */
-    async exportDatabase(name: string): Promise<Uint8Array> {
-      return requireEngine().serializeDatabase(name);
+    async exportDatabase(): Promise<Uint8Array> {
+      return requireEngine().serializeDatabase();
     },
 
     // Expose undo/history operations for the browser in-process facade, which

src/core/types.ts

@@ -214,7 +214,7 @@ export interface DatabaseOperations {
   executeQuery(sql: string, params?: CellValue[]): Promise<QueryResultSet[]>;
 
   /** Export database to binary */
-  serializeDatabase(name: string): Promise<Uint8Array>;
+  serializeDatabase(): Promise<Uint8Array>;
 
   /** Apply pending modifications */
   applyModifications(mods: ModificationEntry[], signal?: AbortSignal): Promise<void>;

src/databaseModel.ts

@@ -382,7 +382,7 @@ export class DatabaseDocument extends Disposable implements vsc.CustomDocument {
     }
 
     const { filename } = this.fileParts;
-    const binaryContent = await this.databaseOperations.serializeDatabase(filename);
+    const binaryContent = await this.databaseOperations.serializeDatabase();
     // Capture the tracker position immediately after serialization. The bytes
     // below represent edits up to this position only; edits recorded while the
     // asynchronous workspace write is pending must remain dirty.
@@ -435,7 +435,7 @@ export class DatabaseDocument extends Disposable implements vsc.CustomDocument {
     }
 
     const { filename } = this.fileParts;
-    const binaryContent = await this.databaseOperations.serializeDatabase(filename);
+    const binaryContent = await this.databaseOperations.serializeDatabase();
     await vsc.workspace.fs.writeFile(targetUri, binaryContent);
   }
 

src/hostBridge.ts

@@ -106,7 +106,7 @@ export class HostBridge implements ToastService {
    */
   async exportDb(filename: string) {
     const dbOps = this.ensureDatabaseInitialized();
-    return dbOps.serializeDatabase(filename);
+    return dbOps.serializeDatabase();
   }
 
   /**

src/loggingDatabaseOperations.ts

@@ -91,8 +91,8 @@ export class LoggingDatabaseOperations implements DatabaseOperations {
         return this.wrapped.executeQuery(sql, params);
     }
 
-    async serializeDatabase(name: string): Promise<Uint8Array> {
-        return this.logAndDelegate(`Exporting database: ${name}`, false, 'serializeDatabase', name);
+    async serializeDatabase(): Promise<Uint8Array> {
+        return this.logAndDelegate(`Exporting database`, false, 'serializeDatabase');
     }
 
     async applyModifications(mods: ModificationEntry[], signal?: AbortSignal): Promise<void> {

src/nativeWorker.ts

@@ -528,7 +528,7 @@ export async function createNativeDatabaseConnection(
           }];
         },
 
-        serializeDatabase: async (_name: string): Promise<Uint8Array> => {
+        serializeDatabase: async (): Promise<Uint8Array> => {
           const result = await worker.call<{ content: Uint8Array }>('export', []);
           return result.content;
         },

src/workerFactory.ts

@@ -66,7 +66,7 @@ interface WorkerMethods {
     config: DatabaseInitConfig
   ): Promise<DatabaseInitResult>;
   runQuery(sql: string, params?: CellValue[]): Promise<QueryResultSet[]>;
-  exportDatabase(name: string): Promise<Uint8Array>;
+  exportDatabase(): Promise<Uint8Array>;
   updateCell(table: string, rowId: string | number, column: string, value: CellValue, patch?: string): Promise<void>;
   insertRow(table: string, data: Record<string, CellValue>): Promise<string | number | undefined>;
   insertRowBatch(table: string, rows: Record<string, CellValue>[]): Promise<void>;
@@ -242,7 +242,7 @@ async function createInProcessWasmDatabaseConnection(
         engineKind: Promise.resolve('wasm'),
         executeQuery: (sql: string, params?: CellValue[]) =>
           endpoint.runQuery(sql, params),
-        serializeDatabase: (name: string) => endpoint.exportDatabase(name),
+        serializeDatabase: () => endpoint.exportDatabase(),
         applyModifications: (mods: ModificationEntry[], signal?: AbortSignal) =>
           endpoint.applyModifications(mods, signal),
         undoModification: (mod: ModificationEntry) =>
@@ -441,7 +441,7 @@ async function createWorkerBackedWasmDatabaseConnection(
           engineKind: Promise.resolve('wasm'),
           executeQuery: (sql: string, params?: CellValue[]) =>
             workerProxy.runQuery(sql, params),
-          serializeDatabase: (name: string) => workerProxy.exportDatabase(name),
+          serializeDatabase: () => workerProxy.exportDatabase(),
           applyModifications: async () => {},
           undoModification: async () => {},
           redoModification: async () => {},

tests/unit/databaseModel.test.ts

@@ -458,8 +458,8 @@ describe('DatabaseDocument save/saveAs fallback', () => {
         const dbOps = {
             engineKind: Promise.resolve('wasm'),
             writeToFile: async () => { throw new Error('writeToFile should not be called for non-file URIs'); },
-            serializeDatabase: async (name: string) => {
-                serializedName = name;
+            serializeDatabase: async () => {
+                serializedName = "test.db";
                 return new Uint8Array([4, 5, 6]);
             }
         };

tests/unit/loggingDatabaseOperations.test.ts

@@ -8,7 +8,7 @@ import type { DatabaseOperations, CellValue, QueryResultSet, ModificationEntry,
 class MockDatabaseOperations implements DatabaseOperations {
     engineKind = Promise.resolve('wasm' as const);
     async executeQuery(sql: string, params?: CellValue[]): Promise<QueryResultSet[]> { return []; }
-    async serializeDatabase(name: string): Promise<Uint8Array> { return new Uint8Array(); }
+    async serializeDatabase(): Promise<Uint8Array> { return new Uint8Array(); }
     async applyModifications(mods: ModificationEntry[], signal?: AbortSignal): Promise<void> {}
     async undoModification(mod: ModificationEntry): Promise<void> {}
     async redoModification(mod: ModificationEntry): Promise<void> {}

tests/unit/worker_endpoint.test.ts

@@ -33,7 +33,7 @@ describe('Worker Endpoint', () => {
         const expectedError = new Error('No database initialized');
 
         await assert.rejects(endpoint.runQuery('SELECT 1'), expectedError);
-        await assert.rejects(endpoint.exportDatabase('test'), expectedError);
+        await assert.rejects(endpoint.exportDatabase(), expectedError);
         await assert.rejects(endpoint.updateCell('table', 1, 'col', 'val'), expectedError);
         await assert.rejects(endpoint.insertRow('table', {}), expectedError);
         await assert.rejects(endpoint.insertRowBatch('table', []), expectedError);
@@ -84,7 +84,7 @@ describe('Worker Endpoint', () => {
         assert.deepStrictEqual(tableData.rows, [[1, 'Alice']]);
 
         // Export DB
-        const data = await endpoint.exportDatabase('test');
+        const data = await endpoint.exportDatabase();
         assert.ok(data instanceof Uint8Array);
         assert.ok(data.length > 0);
     });