Export & Import

Fix up export and import functionality for internal sources

Author: Brayden

src/export/csv.ts

@@ -1,13 +1,15 @@
 import { getTableData, createExportResponse } from './index';
 import { createResponse } from '../utils';
 import { DataSource } from '../types';
+import { StarbaseDBConfiguration } from '../handler';
 
 export async function exportTableToCsvRoute(
     tableName: string,
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<Response> {
     try {
-        const data = await getTableData(tableName, dataSource);
+        const data = await getTableData(tableName, dataSource, config);
 
         if (data === null) {
             return createResponse(undefined, `Table '${tableName}' does not exist.`, 404);

src/export/dump.ts

@@ -1,29 +1,31 @@
 import { executeOperation } from '.';
+import { StarbaseDBConfiguration } from '../handler';
 import { DataSource } from '../types';
 import { createResponse } from '../utils';
 
 export async function dumpDatabaseRoute(
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<Response> {
     try {
         // Get all table names
-        const tablesResult = await executeOperation([{ sql: "SELECT name FROM sqlite_master WHERE type='table';" }], dataSource)
+        const tablesResult = await executeOperation([{ sql: "SELECT name FROM sqlite_master WHERE type='table';" }], dataSource, config)
 
         const tables = tablesResult.map((row: any) => row.name);
         let dumpContent = "SQLite format 3\0";  // SQLite file header
 
         // Iterate through all tables
         for (const table of tables) {
             // Get table schema
-            const schemaResult = await executeOperation([{ sql: `SELECT sql FROM sqlite_master WHERE type='table' AND name='${table}';` }], dataSource)
+            const schemaResult = await executeOperation([{ sql: `SELECT sql FROM sqlite_master WHERE type='table' AND name='${table}';` }], dataSource, config)
 
             if (schemaResult.length) {
                 const schema = schemaResult[0].sql;
                 dumpContent += `\n-- Table: ${table}\n${schema};\n\n`;
             }
 
             // Get table data
-            const dataResult = await executeOperation([{ sql: `SELECT * FROM ${table};` }], dataSource)
+            const dataResult = await executeOperation([{ sql: `SELECT * FROM ${table};` }], dataSource, config)
 
             for (const row of dataResult) {
                 const values = Object.values(row).map(value => 

src/export/index.ts

@@ -1,25 +1,32 @@
 import { DataSource } from "../types";
 import { executeTransaction } from "../operation";
-
-export async function executeOperation(queries: { sql: string, params?: any[] }[], dataSource: DataSource): Promise<any> {
-    const results: any[] = (await executeTransaction(queries, false, dataSource)) as any[];
+import { StarbaseDBConfiguration } from "../handler";
+
+export async function executeOperation(queries: { sql: string, params?: any[] }[], dataSource: DataSource, config: StarbaseDBConfiguration): Promise<any> {
+    const results: any[] = (await executeTransaction({
+        queries,
+        isRaw: false,
+        dataSource,
+        config
+    })) as any[];
     return results?.length > 0 ? results[0] : undefined;
 }
 
 export async function getTableData(
     tableName: string,
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<any[] | null> {
     try {
         // Verify if the table exists
-        const tableExistsResult = await executeOperation([{ sql: `SELECT name FROM sqlite_master WHERE type='table' AND name=?;`, params: [tableName] }], dataSource)
+        const tableExistsResult = await executeOperation([{ sql: `SELECT name FROM sqlite_master WHERE type='table' AND name=?;`, params: [tableName] }], dataSource, config)
 
         if (tableExistsResult.length === 0) {
             return null;
         }
 
         // Get table data
-        const dataResult = await executeOperation([{ sql: `SELECT * FROM ${tableName};` }], dataSource)
+        const dataResult = await executeOperation([{ sql: `SELECT * FROM ${tableName};` }], dataSource, config)
         return dataResult;
     } catch (error: any) {
         console.error('Table Data Fetch Error:', error);

src/export/json.ts

@@ -1,13 +1,15 @@
 import { getTableData, createExportResponse } from './index';
 import { createResponse } from '../utils';
 import { DataSource } from '../types';
+import { StarbaseDBConfiguration } from '../handler';
 
 export async function exportTableToJsonRoute(
     tableName: string,
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<Response> {
     try {
-        const data = await getTableData(tableName, dataSource);
+        const data = await getTableData(tableName, dataSource, config);
 
         if (data === null) {
             return createResponse(undefined, `Table '${tableName}' does not exist.`, 404);

src/handler.ts

@@ -155,7 +155,7 @@ export class StarbaseDB {
 
     if (this.getFeature("export")) {
       app.get("/export/dump", this.isInternalSource, async () => {
-        return dumpDatabaseRoute(this.dataSource);
+        return dumpDatabaseRoute(this.dataSource, this.config);
       });
 
       app.get(
@@ -164,7 +164,7 @@ export class StarbaseDB {
         this.hasTableName,
         async (c) => {
           const tableName = c.req.valid("param").tableName;
-          return exportTableToJsonRoute(tableName, this.dataSource);
+          return exportTableToJsonRoute(tableName, this.dataSource, this.config);
         }
       );
 
@@ -174,14 +174,14 @@ export class StarbaseDB {
         this.hasTableName,
         async (c) => {
           const tableName = c.req.valid("param").tableName;
-          return exportTableToCsvRoute(tableName, this.dataSource);
+          return exportTableToCsvRoute(tableName, this.dataSource, this.config);
         }
       );
     }
 
     if (this.getFeature("import")) {
       app.post("/import/dump", this.isInternalSource, async (c) => {
-        return importDumpRoute(c.req.raw, this.dataSource);
+        return importDumpRoute(c.req.raw, this.dataSource, this.config);
       });
 
       app.post(
@@ -190,7 +190,7 @@ export class StarbaseDB {
         this.hasTableName,
         async (c) => {
           const tableName = c.req.valid("param").tableName;
-          return importTableFromJsonRoute(tableName, request, this.dataSource);
+          return importTableFromJsonRoute(tableName, request, this.dataSource, this.config);
         }
       );
 
@@ -200,7 +200,7 @@ export class StarbaseDB {
         this.hasTableName,
         async (c) => {
           const tableName = c.req.valid("param").tableName;
-          return importTableFromCsvRoute(tableName, request, this.dataSource);
+          return importTableFromCsvRoute(tableName, request, this.dataSource, this.config);
         }
       );
     }

src/import/csv.ts

@@ -1,6 +1,7 @@
 import { createResponse } from '../utils';
 import { DataSource } from '../types';
 import { executeOperation } from '../export';
+import { StarbaseDBConfiguration } from '../handler';
 
 interface ColumnMapping {
     [key: string]: string;
@@ -14,7 +15,8 @@ interface CsvData {
 export async function importTableFromCsvRoute(
     tableName: string,
     request: Request,
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<Response> {
     try {
         if (!request.body) {
@@ -67,7 +69,7 @@ export async function importTableFromCsvRoute(
             const statement = `INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`;
 
             try {
-                await executeOperation([{ sql: statement, params: values }], dataSource)
+                await executeOperation([{ sql: statement, params: values }], dataSource, config)
                 successCount++;
             } catch (error: any) {
                 failedStatements.push({

src/import/dump.ts

@@ -1,6 +1,7 @@
 import { createResponse } from '../utils';
 import { DataSource } from '../types';
 import { executeOperation } from '../export';
+import { StarbaseDBConfiguration } from '../handler';
 
 function parseSqlStatements(sqlContent: string): string[] {
     const lines = sqlContent.split('\n');
@@ -31,7 +32,8 @@ function parseSqlStatements(sqlContent: string): string[] {
 
 export async function importDumpRoute(
     request: Request,
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<Response> {
     if (request.method !== 'POST') {
         return createResponse(undefined, 'Method not allowed', 405);
@@ -66,7 +68,7 @@ export async function importDumpRoute(
         const results = [];
         for (const statement of sqlStatements) {
             try {
-                const result = await executeOperation([{ sql: statement }], dataSource)
+                const result = await executeOperation([{ sql: statement }], dataSource, config)
                 results.push({ statement, success: true, result });
             } catch (error: any) {
                 console.error(`Error executing statement: ${statement}`, error);

src/import/json.ts

@@ -1,6 +1,7 @@
 import { createResponse } from '../utils';
 import { executeOperation } from '../export';
 import { DataSource } from '../types';
+import { StarbaseDBConfiguration } from '../handler';
 
 interface ColumnMapping {
     [key: string]: string;
@@ -14,7 +15,8 @@ interface JsonData {
 export async function importTableFromJsonRoute(
     tableName: string,
     request: Request,
-    dataSource: DataSource
+    dataSource: DataSource,
+    config: StarbaseDBConfiguration
 ): Promise<Response> {
     try {
         if (!request.body) {
@@ -60,7 +62,7 @@ export async function importTableFromJsonRoute(
             const statement = `INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`;
 
             try {
-                await executeOperation([{ sql: statement, params: values }], dataSource)
+                await executeOperation([{ sql: statement, params: values }], dataSource, config)
                 successCount++;
             } catch (error: any) {
                 failedStatements.push({