Merge pull request #277 from retran/feature/catalogdb-interface

refactor: extract CatalogDB interface for WASM portability

Author: ako

mdl/catalog/builder.go

@@ -3,7 +3,6 @@
 package catalog
 
 import (
-	"database/sql"
 	"fmt"
 	"strings"
 	"time"
@@ -79,7 +78,7 @@ type Builder struct {
 	snapshot     *Snapshot
 	progress     ProgressFunc
 	hierarchy    *hierarchy
-	tx           *sql.Tx // Transaction for batched inserts
+	tx           CatalogTx // Transaction for batched inserts
 	fullMode     bool    // If true, do full parsing (activities/widgets)
 	sourceMode   bool    // If true, build source FTS table (implies full)
 	describeFunc DescribeFunc

mdl/catalog/catalog.go

@@ -8,13 +8,11 @@ import (
 	"fmt"
 	"strings"
 	"time"
-
-	_ "modernc.org/sqlite"
 )
 
 // Catalog provides SQL querying over Mendix project metadata.
 type Catalog struct {
-	db            *sql.DB
+	db            CatalogDB
 	projectID     string
 	projectName   string
 	mendixVersion string
@@ -58,17 +56,15 @@ type ProgressFunc func(table string, count int)
 
 // New creates a new catalog with an in-memory SQLite database.
 func New() (*Catalog, error) {
-	db, err := sql.Open("sqlite", ":memory:")
+	db, err := NewSqliteCatalogDB()
 	if err != nil {
 		return nil, fmt.Errorf("failed to open in-memory database: %w", err)
 	}
+	return NewFromDB(db)
+}
 
-	// Enable foreign keys
-	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
-		db.Close()
-		return nil, fmt.Errorf("failed to enable foreign keys: %w", err)
-	}
-
+// NewFromDB creates a catalog from an existing CatalogDB.
+func NewFromDB(db CatalogDB) (*Catalog, error) {
 	c := &Catalog{
 		db:        db,
 		projectID: "default",
@@ -193,8 +189,8 @@ func (c *Catalog) Query(sqlQuery string) (*QueryResult, error) {
 	return result, rows.Err()
 }
 
-// DB returns the underlying database connection for direct access.
-func (c *Catalog) DB() *sql.DB {
+// CatalogDB returns the underlying database abstraction.
+func (c *Catalog) CatalogDB() CatalogDB {
 	return c.db
 }
 
@@ -263,17 +259,11 @@ type CacheInfo struct {
 
 // NewFromFile opens a catalog from a persisted SQLite file.
 func NewFromFile(path string) (*Catalog, error) {
-	db, err := sql.Open("sqlite", path)
+	db, err := NewSqliteCatalogDBFromFile(path)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open catalog file: %w", err)
 	}
 
-	// Enable foreign keys
-	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
-		db.Close()
-		return nil, fmt.Errorf("failed to enable foreign keys: %w", err)
-	}
-
 	c := &Catalog{
 		db:        db,
 		projectID: "default",
@@ -286,7 +276,14 @@ func NewFromFile(path string) (*Catalog, error) {
 
 // SaveToFile saves the catalog to a SQLite file.
 // This copies the in-memory database to a file for persistence.
+// Requires the underlying CatalogDB to be a *SqliteCatalogDB.
 func (c *Catalog) SaveToFile(path string) error {
+	sdb, ok := c.db.(*SqliteCatalogDB)
+	if !ok {
+		return fmt.Errorf("SaveToFile requires a SQLite-backed catalog")
+	}
+	rawDB := sdb.RawDB()
+
 	// Open destination file database
 	destDB, err := sql.Open("sqlite", path)
 	if err != nil {
@@ -296,17 +293,17 @@ func (c *Catalog) SaveToFile(path string) error {
 
 	// Use SQLite backup API via VACUUM INTO (SQLite 3.27+)
 	// Fall back to manual copy if not available
-	_, err = c.db.Exec(fmt.Sprintf("VACUUM INTO '%s'", path))
+	_, err = rawDB.Exec(fmt.Sprintf("VACUUM INTO '%s'", path))
 	if err != nil {
 		// Fall back: export and import
-		return c.saveToFileManual(path)
+		return c.saveToFileManual(path, rawDB)
 	}
 
 	return nil
 }
 
 // saveToFileManual saves by dumping and restoring (fallback method).
-func (c *Catalog) saveToFileManual(path string) error {
+func (c *Catalog) saveToFileManual(path string, rawDB *sql.DB) error {
 	// Open destination
 	destDB, err := sql.Open("sqlite", path)
 	if err != nil {
@@ -315,7 +312,7 @@ func (c *Catalog) saveToFileManual(path string) error {
 	defer destDB.Close()
 
 	// Get list of tables
-	rows, err := c.db.Query("SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+	rows, err := rawDB.Query("SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
 	if err != nil {
 		return err
 	}
@@ -339,7 +336,7 @@ func (c *Catalog) saveToFileManual(path string) error {
 		}
 
 		// Copy data
-		srcRows, err := c.db.Query(fmt.Sprintf("SELECT * FROM %s", t.name))
+		srcRows, err := rawDB.Query(fmt.Sprintf("SELECT * FROM %s", t.name))
 		if err != nil {
 			return err
 		}
@@ -377,7 +374,7 @@ func (c *Catalog) saveToFileManual(path string) error {
 	}
 
 	// Copy views
-	rows, err = c.db.Query("SELECT sql FROM sqlite_master WHERE type='view'")
+	rows, err = rawDB.Query("SELECT sql FROM sqlite_master WHERE type='view'")
 	if err != nil {
 		return err
 	}
@@ -394,7 +391,7 @@ func (c *Catalog) saveToFileManual(path string) error {
 	rows.Close()
 
 	// Copy indexes
-	rows, err = c.db.Query("SELECT sql FROM sqlite_master WHERE type='index' AND sql IS NOT NULL")
+	rows, err = rawDB.Query("SELECT sql FROM sqlite_master WHERE type='index' AND sql IS NOT NULL")
 	if err != nil {
 		return err
 	}

mdl/catalog/catalog_test.go

@@ -124,7 +124,7 @@ func TestQueryWithData(t *testing.T) {
 	defer cat.Close()
 
 	// Insert test data
-	_, err = cat.DB().Exec(
+	_, err = cat.CatalogDB().Exec(
 		"INSERT INTO modules (Id, Name, QualifiedName, ModuleName) VALUES (?, ?, ?, ?)",
 		"mod-1", "TestModule", "TestModule", "TestModule",
 	)
@@ -280,7 +280,7 @@ func TestSaveAndLoadFromFile(t *testing.T) {
 	}
 
 	cat.SetProject("proj-1", "TestApp", "10.0.0")
-	_, err = cat.DB().Exec(
+	_, err = cat.CatalogDB().Exec(
 		"INSERT INTO modules (Id, Name, QualifiedName, ModuleName) VALUES (?, ?, ?, ?)",
 		"mod-1", "MyModule", "MyModule", "MyModule",
 	)
@@ -359,7 +359,7 @@ func TestRoleMappingsTable(t *testing.T) {
 	}
 
 	for _, m := range mappings {
-		_, err := cat.DB().Exec(
+		_, err := cat.CatalogDB().Exec(
 			"INSERT INTO role_mappings (UserRoleName, ModuleRoleName, ModuleName) VALUES (?, ?, ?)",
 			m.userRole, m.moduleRole, m.module,
 		)

mdl/catalog/catalogdb.go

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package catalog
+
+import "database/sql"
+
+// CatalogDB abstracts the database layer used by Catalog and LintContext.
+// The primary implementation wraps modernc.org/sqlite for native builds;
+// a js/wasm build will supply a host-backed implementation.
+type CatalogDB interface {
+	Query(query string, args ...any) (*sql.Rows, error)
+	QueryRow(query string, args ...any) *sql.Row
+	Exec(query string, args ...any) (sql.Result, error)
+	Begin() (CatalogTx, error)
+	Close() error
+}
+
+// CatalogTx abstracts a database transaction. Builder uses this for bulk
+// inserts with prepared statements.
+type CatalogTx interface {
+	Prepare(query string) (*sql.Stmt, error)
+	Exec(query string, args ...any) (sql.Result, error)
+	QueryRow(query string, args ...any) *sql.Row
+	Commit() error
+	Rollback() error
+}

mdl/catalog/catalogdb_sqlite.go

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+
+//go:build !js
+
+package catalog
+
+import (
+	"database/sql"
+
+	_ "modernc.org/sqlite"
+)
+
+// SqliteCatalogDB wraps *sql.DB from modernc.org/sqlite.
+type SqliteCatalogDB struct {
+	db *sql.DB
+}
+
+// NewSqliteCatalogDB opens an in-memory SQLite database.
+func NewSqliteCatalogDB() (*SqliteCatalogDB, error) {
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		return nil, err
+	}
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		db.Close()
+		return nil, err
+	}
+	return &SqliteCatalogDB{db: db}, nil
+}
+
+// NewSqliteCatalogDBFromFile opens a file-based SQLite database.
+func NewSqliteCatalogDBFromFile(path string) (*SqliteCatalogDB, error) {
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		db.Close()
+		return nil, err
+	}
+	return &SqliteCatalogDB{db: db}, nil
+}
+
+func (s *SqliteCatalogDB) Query(query string, args ...any) (*sql.Rows, error) {
+	return s.db.Query(query, args...)
+}
+
+func (s *SqliteCatalogDB) QueryRow(query string, args ...any) *sql.Row {
+	return s.db.QueryRow(query, args...)
+}
+
+func (s *SqliteCatalogDB) Exec(query string, args ...any) (sql.Result, error) {
+	return s.db.Exec(query, args...)
+}
+
+func (s *SqliteCatalogDB) Begin() (CatalogTx, error) {
+	return s.db.Begin()
+}
+
+func (s *SqliteCatalogDB) Close() error {
+	return s.db.Close()
+}
+
+// RawDB returns the underlying *sql.DB. Used only for SQLite-specific
+// operations like VACUUM INTO in SaveToFile.
+func (s *SqliteCatalogDB) RawDB() *sql.DB {
+	return s.db
+}
+
+// WrapSqlDB wraps an existing *sql.DB as a CatalogDB.
+// Used by tests that create their own in-memory databases.
+func WrapSqlDB(db *sql.DB) *SqliteCatalogDB {
+	return &SqliteCatalogDB{db: db}
+}