fix: Propagate raw query

Author: Ehesp

src/do.ts

@@ -102,7 +102,7 @@ export class StarbaseDBDurableObject extends DurableObject {
   //   }
   // }
 
-  public async executeRawQuery<
+  private async executeRawQuery<
     T extends Record<string, SqlStorageValue> = Record<string, SqlStorageValue>
   >(opts: { sql: string; params?: unknown[] }) {
     const { sql, params } = opts;
@@ -116,15 +116,7 @@ export class StarbaseDBDurableObject extends DurableObject {
         cursor = this.sql.exec<T>(sql);
       }
 
-      return {
-        cursor,
-        columns: cursor.columnNames,
-        rows: Array.from(cursor.raw()),
-        meta: {
-          rows_read: cursor.rowsRead,
-          rows_written: cursor.rowsWritten,
-        },
-      };
+      return cursor;
     } catch (error) {
       console.error("SQL Execution Error:", error);
       throw error;
@@ -136,13 +128,20 @@ export class StarbaseDBDurableObject extends DurableObject {
     params?: unknown[];
     isRaw?: boolean;
   }) {
-    const result = await this.executeRawQuery(opts);
-
+    const cursor = await this.executeRawQuery(opts);
+    
     if (opts.isRaw) {
-      return result;
+      return {
+        columns: cursor.columnNames,
+        rows: Array.from(cursor.raw()),
+        meta: {
+          rows_read: cursor.rowsRead,
+          rows_written: cursor.rowsWritten,
+        },
+      };
     }
 
-    return result.cursor.toArray();
+    return cursor.toArray();
   }
 
   public executeTransaction(

src/handler.ts

@@ -243,12 +243,13 @@ export class StarbaseDB {
           return { sql, params };
         });
 
-        const response = await executeTransaction(
+        const response = await executeTransaction({
           queries,
           isRaw,
-          this.dataSource,
-          this.config
-        );
+          dataSource: this.dataSource,
+          config: this.config,
+        });
+        
         return createResponse(response, undefined, 200);
       } else if (typeof sql !== "string" || !sql.trim()) {
         return createResponse(undefined, 'Invalid or empty "sql" field.', 400);

src/operation.ts

@@ -182,86 +182,85 @@ export async function executeQuery(opts: {
     return [];
   }
 
-  try {
-    // If the allowlist feature is enabled, we should verify the query is allowed before proceeding.
-    await isQueryAllowed({
-      sql: sql,
-      isEnabled: config?.features?.allowlist ?? false,
-      dataSource,
-      config,
-    });
+  // If the allowlist feature is enabled, we should verify the query is allowed before proceeding.
+  await isQueryAllowed({
+    sql: sql,
+    isEnabled: config?.features?.allowlist ?? false,
+    dataSource,
+    config,
+  });
 
-    // If the row level security feature is enabled, we should apply our policies to this SQL statement.
-    sql = await applyRLS({
-      sql,
-      isEnabled: config?.features?.rls ?? true,
-      dataSource,
-      config,
-    });
+  // If the row level security feature is enabled, we should apply our policies to this SQL statement.
+  sql = await applyRLS({
+    sql,
+    isEnabled: config?.features?.rls ?? true,
+    dataSource,
+    config,
+  });
 
-    // Run the beforeQuery hook for any third party logic to be applied before execution.
-    const { sql: updatedSQL, params: updatedParams } = await beforeQuery({
-      sql,
-      params,
+  // Run the beforeQuery hook for any third party logic to be applied before execution.
+  const { sql: updatedSQL, params: updatedParams } = await beforeQuery({
+    sql,
+    params,
+    dataSource,
+    config,
+  });
+
+  // If the query was modified by RLS then we determine it isn't currently a valid candidate
+  // for caching. In the future we will support queries impacted by RLS and caching their
+  // results.
+  if (!isRaw) {
+    // If a cached version of this query request exists, this function will fetch the cached results.
+    const cache = await beforeQueryCache({
+      sql: updatedSQL,
+      params: updatedParams,
       dataSource,
-      config,
     });
 
-    // If the query was modified by RLS then we determine it isn't currently a valid candidate
-    // for caching. In the future we will support queries impacted by RLS and caching their
-    // results.
-    if (!isRaw) {
-      // If a cached version of this query request exists, this function will fetch the cached results.
-      const cache = await beforeQueryCache({
-        sql: updatedSQL,
-        params: updatedParams,
-        dataSource,
-      });
-
-      if (cache) {
-        return cache as QueryResponse;
-      }
-    }
-
-    let result;
-
-    if (dataSource.source === "internal") {
-      result = await dataSource.rpc.executeQuery({
-        sql: updatedSQL,
-        params: updatedParams,
-      });
-    } else {
-      result = await executeExternalQuery({
-        sql: updatedSQL,
-        params: updatedParams,
-        dataSource,
-        config,
-      });
+    if (cache) {
+      return cache as QueryResponse;
     }
+  }
 
-    // If this is a cacheable query, this function will handle that logic.
-    if (!isRaw) {
-      await afterQueryCache({ sql, params: updatedParams, result, dataSource });
-    }
+  let result;
 
-    return await afterQuery({
+  if (dataSource.source === "internal") {
+    result = await dataSource.rpc.executeQuery({
       sql: updatedSQL,
-      result,
+      params: updatedParams,
       isRaw,
+    });
+  } else {
+    result = await executeExternalQuery({
+      sql: updatedSQL,
+      params: updatedParams,
       dataSource,
       config,
     });
-  } catch (error: any) {
-    throw new Error(error.message ?? "An error occurred");
   }
+
+  // If this is a cacheable query, this function will handle that logic.
+  if (!isRaw) {
+    await afterQueryCache({ sql, params: updatedParams, result, dataSource });
+  }
+
+  return await afterQuery({
+    sql: updatedSQL,
+    result,
+    isRaw,
+    dataSource,
+    config,
+  });
 }
 
-export async function executeTransaction(
-  queries: { sql: string; params?: any[] }[],
-  isRaw: boolean,
-  dataSource: DataSource,
-  config: StarbaseDBConfiguration
-): Promise<QueryResponse> {
+export async function executeTransaction(opts: {
+  queries: { sql: string; params?: any[] }[];
+  isRaw: boolean;
+  dataSource: DataSource;
+  config: StarbaseDBConfiguration;
+}): Promise<QueryResponse> {
+  const { queries, isRaw, dataSource, config } = opts;
+
   if (!dataSource) {
     console.error("Data source not found.");
     return [];
@@ -277,6 +276,7 @@ export async function executeTransaction(
       dataSource,
       config,
     });
+
     results.push(result);
   }