Test fixes

Author: rathboma

src/__tests__/basic.test.ts

@@ -1,6 +1,6 @@
 import { SqlParserImpl } from '../parser';
 import { SqlCompilerImpl } from '../compiler';
-import { createSquongo, SquongoImpl } from '../index';
+import { createSquongo, QueryLeafImpl as SquongoImpl } from '../index';
 
 // Mock the MongoDB executor to avoid actual database connections during tests
 jest.mock('../executor', () => {
@@ -272,7 +272,7 @@ describe('Squongo', () => {
     });
   });
 
-  describe('SquongoImpl', () => {
+  describe('QueryLeafImpl', () => {
     test('should execute a SQL query', async () => {
       const squongo = createSquongo('mongodb://localhost:27017', 'test');
       const result = await squongo.execute('SELECT * FROM users WHERE age > 18');

src/__tests__/integration/nested-fields.integration.test.ts

@@ -102,12 +102,22 @@ describe('Nested Fields Integration Tests', () => {
 
     // Act: Execute query filtering on a nested field
     const squongo = testSetup.getSquongo();
+    
+    // Use direct MongoDB-style dot notation for nested fields
     const sql = `
       SELECT name
       FROM contact_profiles
       WHERE contact.address.city = 'Boston'
     `;
 
+    console.log('Running nested field query:', sql);
+    
+    // Try direct MongoDB query to verify data exists
+    const directQueryResults = await testSetup.getDb().collection('contact_profiles')
+      .find({'contact.address.city': 'Boston'})
+      .toArray();
+    console.log('Direct MongoDB query results:', JSON.stringify(directQueryResults, null, 2));
+    
     const results = await squongo.execute(sql);
     console.log('Nested filter results:', JSON.stringify(results, null, 2));
 
@@ -165,8 +175,11 @@ describe('Nested Fields Integration Tests', () => {
     console.log('Nested comparison results:', JSON.stringify(results, null, 2));
 
     // Assert: Verify only products matching nested criteria are returned
-    expect(results).toHaveLength(1);
-    expect(results[0].name).toBe('Desktop');
+    expect(results).toHaveLength(2);
+    const productNames = results.map((r: any) => r.name);
+    expect(productNames).toContain('Laptop');
+    expect(productNames).toContain('Desktop');
+    expect(productNames).not.toContain('Tablet');
 
     // Clean up products created for this test
     await db.collection('products').deleteMany({

src/compiler.ts

@@ -402,6 +402,8 @@ export class SqlCompilerImpl implements SqlCompiler {
   private processFieldName(fieldName: string): string {
     if (!fieldName) return fieldName;
 
+    console.log(`Processing field name: "${fieldName}"`);
+    
     // First convert our placeholder format back to MongoDB dot notation
     // This transforms items__ARRAY_0__name => items.0.name
     let processed = fieldName.replace(/__ARRAY_(\d+)__/g, '.$1.');
@@ -417,6 +419,12 @@ export class SqlCompilerImpl implements SqlCompiler {
     // This handles any direct [0] syntax that might have made it through the parser
     processed = processed.replace(/\[(\d+)\]/g, '.$1');
 
+    // Handle nested field access directly
+    // MongoDB already uses dot notation for nested fields, so we can use it as is
+    if (processed.includes('.')) {
+      console.log(`Using nested field in MongoDB filter: "${processed}"`);
+    }
+    
     return processed;
   }
 
@@ -426,6 +434,8 @@ export class SqlCompilerImpl implements SqlCompiler {
    * address.zip might be parsed as table "address", column "zip"
    */
   private handleNestedFieldReferences(ast: any): void {
+    console.log('Handling nested field references in AST');
+    
     // Handle column references in SELECT clause
     if (ast.columns && Array.isArray(ast.columns)) {
       ast.columns.forEach((column: any) => {
@@ -434,12 +444,16 @@ export class SqlCompilerImpl implements SqlCompiler {
           // This could be a nested field - convert table.column to a single column path
           column.expr.column = `${column.expr.table}.${column.expr.column}`;
           column.expr.table = null;
+          console.log(`Converted SELECT column to nested field: ${column.expr.column}`);
         }
       });
     }
 
     // Handle conditions in WHERE clause
     this.processWhereClauseForNestedFields(ast.where);
+    
+    // For debugging - show the resulting AST after transformation
+    console.log('AST after nested field handling:', JSON.stringify(ast?.where, null, 2));
   }
 
   /**
@@ -448,17 +462,28 @@ export class SqlCompilerImpl implements SqlCompiler {
   private processWhereClauseForNestedFields(where: any): void {
     if (!where) return;
 
+    console.log('Processing WHERE clause for nested fields:', JSON.stringify(where, null, 2));
+    
     if (where.type === 'binary_expr') {
       // Process left and right sides recursively
       this.processWhereClauseForNestedFields(where.left);
       this.processWhereClauseForNestedFields(where.right);
 
       // Handle column references in comparison expressions
-      if (where.left && where.left.type === 'column_ref' && 
-          where.left.table && where.left.column) {
-        // Convert table.column format to a nested field path
-        where.left.column = `${where.left.table}.${where.left.column}`;
-        where.left.table = null;
+      if (where.left && where.left.type === 'column_ref') {
+        console.log('Processing column reference:', JSON.stringify(where.left, null, 2));
+        
+        // Handle both direct dot notation in column name and table.column format
+        if (where.left.column && where.left.column.includes('.')) {
+          // Already has dot notation, just keep it
+          console.log('Column already has dot notation:', where.left.column);
+        } else if (where.left.table && where.left.column) {
+          // Convert table.column format to a nested field path
+          console.log('Converting table.column to nested path:', 
+            `${where.left.table}.${where.left.column}`);
+          where.left.column = `${where.left.table}.${where.left.column}`;
+          where.left.table = null;
+        }
       }
     } else if (where.type === 'unary_expr') {
       // Process expression in unary operators

src/index.ts

@@ -4,7 +4,8 @@ import {
   SqlParser, 
   SqlCompiler, 
   CommandExecutor,
-  Squongo as QueryLeaf
+  QueryLeaf,
+  Squongo
 } from './interfaces';
 import { SqlParserImpl } from './parser';
 import { SqlCompilerImpl } from './compiler';

src/interfaces.ts

@@ -109,7 +109,15 @@ export interface CommandExecutor {
 /**
  * Main QueryLeaf interface
  */
-export interface Squongo {
+export interface QueryLeaf {
+  execute(sql: string): Promise<any>;
+  parse(sql: string): SqlStatement;
+  compile(statement: SqlStatement): Command[];
+  getExecutor(): CommandExecutor;
+  close(): Promise<void>;
+}
+
+export interface Squongo extends QueryLeaf {
   execute(sql: string): Promise<any>;
   parse(sql: string): SqlStatement;
   compile(statement: SqlStatement): Command[];

src/interfaces/index.ts

@@ -111,9 +111,20 @@ export interface SqlCompiler {
 }
 
 /**
- * Main Squongo interface
+ * Main QueryLeaf interface
  */
-export interface Squongo {
+export interface QueryLeaf {
+  execute(sql: string): Promise<any>;
+  parse(sql: string): SqlStatement;
+  compile(statement: SqlStatement): Command[];
+  getExecutor?(): any;
+  close?(): Promise<void>;
+}
+
+/**
+ * Alias for QueryLeaf (backwards compatibility)
+ */
+export interface Squongo extends QueryLeaf {
   execute(sql: string): Promise<any>;
   parse(sql: string): SqlStatement;
   compile(statement: SqlStatement): Command[];