fix(ci): add missing transpiler package to git tracking

The pkg/transpiler/ directory was created but never committed,
causing the WASM build and other CI jobs to fail with
"no required module provides package .../pkg/transpiler".

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

pkg/transpiler/dialect_rules.go

@@ -0,0 +1,64 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transpiler
+
+import (
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+	"github.com/ajitpratap0/GoSQLX/pkg/transpiler/rules"
+)
+
+type dialectPair struct {
+	from, to keywords.SQLDialect
+}
+
+var ruleRegistry = map[dialectPair][]RewriteRule{}
+
+func init() {
+	register(keywords.DialectMySQL, keywords.DialectPostgreSQL,
+		rules.MySQLAutoIncrementToSerial,
+		rules.MySQLBacktickToDoubleQuote,
+		rules.MySQLLimitCommaToOffset,
+		rules.MySQLBooleanToPgBool,
+	)
+	register(keywords.DialectPostgreSQL, keywords.DialectMySQL,
+		rules.PgSerialToAutoIncrement,
+		rules.PgDoubleQuoteToBacktick,
+		rules.PgILikeToLower,
+	)
+	register(keywords.DialectPostgreSQL, keywords.DialectSQLite,
+		rules.PgSerialToIntegerPK,
+		rules.PgArrayToJSON,
+	)
+}
+
+func register(from, to keywords.SQLDialect, rs ...RewriteRule) {
+	key := dialectPair{from, to}
+	ruleRegistry[key] = append(ruleRegistry[key], rs...)
+}
+
+// RulesFor returns the registered rewrite rules for a dialect pair.
+// Returns nil (empty) for unregistered or same-dialect pairs.
+// Exported for testing.
+func RulesFor(from, to keywords.SQLDialect) []RewriteRule {
+	if from == to {
+		return nil
+	}
+	return ruleRegistry[dialectPair{from, to}]
+}
+
+// rulesFor is the internal version used by Transpile.
+func rulesFor(from, to keywords.SQLDialect) []RewriteRule {
+	return RulesFor(from, to)
+}

pkg/transpiler/dialect_rules_test.go

@@ -0,0 +1,42 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transpiler_test
+
+import (
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+	"github.com/ajitpratap0/GoSQLX/pkg/transpiler"
+)
+
+func TestRulesFor_MySQLToPostgres_NonEmpty(t *testing.T) {
+	rules := transpiler.RulesFor(keywords.DialectMySQL, keywords.DialectPostgreSQL)
+	if len(rules) == 0 {
+		t.Error("expected at least one rule for MySQL→PostgreSQL")
+	}
+}
+
+func TestRulesFor_SameDialect_Empty(t *testing.T) {
+	rules := transpiler.RulesFor(keywords.DialectPostgreSQL, keywords.DialectPostgreSQL)
+	if len(rules) != 0 {
+		t.Errorf("expected no rules for same dialect, got %d", len(rules))
+	}
+}
+
+func TestRulesFor_UnregisteredPair_Empty(t *testing.T) {
+	rules := transpiler.RulesFor(keywords.DialectOracle, keywords.DialectClickHouse)
+	// Unknown pair → no rules (passthrough).
+	_ = rules // should be 0 length, no panic
+}

pkg/transpiler/rules/mysql_to_pg.go

@@ -0,0 +1,98 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package rules contains individual dialect rewrite rules used by the transpiler.
+package rules
+
+import (
+	"strings"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+)
+
+// MySQLAutoIncrementToSerial rewrites columns that use the AUTO_INCREMENT
+// constraint to use the PostgreSQL SERIAL (or BIGSERIAL) type instead.
+//
+// MySQL:      id INT AUTO_INCREMENT PRIMARY KEY
+// PostgreSQL: id SERIAL PRIMARY KEY
+func MySQLAutoIncrementToSerial(stmt ast.Statement) error {
+	ct, ok := stmt.(*ast.CreateTableStatement)
+	if !ok {
+		return nil
+	}
+	for i := range ct.Columns {
+		col := &ct.Columns[i]
+		// AUTO_INCREMENT is stored as a boolean flag on ColumnConstraint,
+		// but the parser may also emit it as a constraint with Type "AUTO_INCREMENT".
+		// Check both representations.
+		hasAutoInc := false
+		newConstraints := col.Constraints[:0]
+		for _, c := range col.Constraints {
+			if c.AutoIncrement || strings.EqualFold(c.Type, "AUTO_INCREMENT") {
+				hasAutoInc = true
+				// Drop this constraint — it will be encoded in the type name.
+				continue
+			}
+			newConstraints = append(newConstraints, c)
+		}
+		if hasAutoInc {
+			col.Constraints = newConstraints
+			switch strings.ToUpper(col.Type) {
+			case "BIGINT":
+				col.Type = "BIGSERIAL"
+			default:
+				col.Type = "SERIAL"
+			}
+		}
+	}
+	return nil
+}
+
+// MySQLBacktickToDoubleQuote is a no-op: the GoSQLX tokenizer strips backtick
+// quoting and stores raw identifier names in the AST.  The formatter applies
+// the correct quoting style for the target dialect.
+func MySQLBacktickToDoubleQuote(_ ast.Statement) error {
+	return nil
+}
+
+// MySQLLimitCommaToOffset is a no-op: the GoSQLX parser already normalises
+// MySQL's `LIMIT offset, count` syntax into the AST's Limit / Offset fields,
+// which are emitted by the formatter in standard `LIMIT n OFFSET m` form.
+func MySQLLimitCommaToOffset(_ ast.Statement) error {
+	return nil
+}
+
+// MySQLBooleanToPgBool rewrites TINYINT columns (MySQL's conventional boolean
+// representation) to BOOLEAN for PostgreSQL.
+//
+// Only TINYINT with no explicit size argument is rewritten.  TINYINT with
+// other sizes (e.g. TINYINT(4)) is left unchanged.
+//
+// MySQL:      active TINYINT(1)  or  active TINYINT
+// PostgreSQL: active BOOLEAN
+func MySQLBooleanToPgBool(stmt ast.Statement) error {
+	ct, ok := stmt.(*ast.CreateTableStatement)
+	if !ok {
+		return nil
+	}
+	for i := range ct.Columns {
+		col := &ct.Columns[i]
+		// ColumnDef.Type is a bare type string like "TINYINT", "TINYINT(1)", etc.
+		t := strings.ToUpper(strings.TrimSpace(col.Type))
+		if t == "TINYINT" || t == "TINYINT(1)" {
+			col.Type = "BOOLEAN"
+		}
+	}
+	return nil
+}

pkg/transpiler/rules/mysql_to_pg_test.go

@@ -0,0 +1,86 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package rules_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+	"github.com/ajitpratap0/GoSQLX/pkg/transpiler"
+)
+
+// transpileMyToPg is a test helper that runs Transpile MySQL→PostgreSQL.
+func transpileMyToPg(t *testing.T, sql string) string {
+	t.Helper()
+	result, err := transpiler.Transpile(sql, keywords.DialectMySQL, keywords.DialectPostgreSQL)
+	if err != nil {
+		t.Fatalf("Transpile MySQL→PG %q: %v", sql, err)
+	}
+	return result
+}
+
+func containsCI(s, sub string) bool {
+	return strings.Contains(strings.ToUpper(s), strings.ToUpper(sub))
+}
+
+func TestMySQLAutoIncrement_ToSerial(t *testing.T) {
+	in := "CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255))"
+	out := transpileMyToPg(t, in)
+	if !containsCI(out, "SERIAL") && !containsCI(out, "BIGSERIAL") {
+		t.Errorf("expected SERIAL in output, got: %s", out)
+	}
+}
+
+func TestMySQLBigintAutoIncrement_ToBigserial(t *testing.T) {
+	in := "CREATE TABLE events (id BIGINT AUTO_INCREMENT PRIMARY KEY, name TEXT)"
+	out := transpileMyToPg(t, in)
+	if !containsCI(out, "BIGSERIAL") {
+		t.Errorf("expected BIGSERIAL in output for BIGINT AUTO_INCREMENT, got: %s", out)
+	}
+}
+
+func TestMySQLTinyint1_ToBoolean(t *testing.T) {
+	in := "CREATE TABLE flags (id INT PRIMARY KEY, active TINYINT(1))"
+	out := transpileMyToPg(t, in)
+	if !containsCI(out, "BOOLEAN") {
+		t.Errorf("expected BOOLEAN in output for TINYINT(1), got: %s", out)
+	}
+}
+
+func TestMySQL_SelectPassthrough(t *testing.T) {
+	in := "SELECT id, name FROM users WHERE id = 1"
+	out := transpileMyToPg(t, in)
+	if out == "" {
+		t.Error("expected non-empty output for basic SELECT")
+	}
+	if !containsCI(out, "SELECT") {
+		t.Errorf("output should contain SELECT, got: %s", out)
+	}
+}
+
+func TestMySQLLimitComma_ToOffset(t *testing.T) {
+	// The parser normalises LIMIT offset, count → Limit/Offset AST fields.
+	// The formatter then emits LIMIT n OFFSET m.
+	in := "SELECT * FROM users LIMIT 10, 20"
+	out := transpileMyToPg(t, in)
+	if out == "" {
+		t.Error("expected non-empty output")
+	}
+	// Either OFFSET appears (properly rewritten) or at minimum LIMIT is present.
+	if !containsCI(out, "LIMIT") {
+		t.Errorf("expected LIMIT keyword in output, got: %s", out)
+	}
+}

pkg/transpiler/rules/pg_to_mysql.go

@@ -0,0 +1,87 @@
+// Copyright 2026 GoSQLX Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package rules
+
+import (
+	"strings"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+)
+
+// PgSerialToAutoIncrement rewrites PostgreSQL SERIAL / BIGSERIAL / SMALLSERIAL
+// column types to the MySQL equivalent (INT / BIGINT with AUTO_INCREMENT).
+//
+// PostgreSQL: id SERIAL PRIMARY KEY
+// MySQL:      id INT AUTO_INCREMENT PRIMARY KEY
+func PgSerialToAutoIncrement(stmt ast.Statement) error {
+	ct, ok := stmt.(*ast.CreateTableStatement)
+	if !ok {
+		return nil
+	}
+	for i := range ct.Columns {
+		col := &ct.Columns[i]
+		switch strings.ToUpper(col.Type) {
+		case "SERIAL", "SMALLSERIAL":
+			col.Type = "INT"
+			col.Constraints = append(col.Constraints, ast.ColumnConstraint{AutoIncrement: true})
+		case "BIGSERIAL":
+			col.Type = "BIGINT"
+			col.Constraints = append(col.Constraints, ast.ColumnConstraint{AutoIncrement: true})
+		}
+	}
+	return nil
+}
+
+// PgDoubleQuoteToBacktick is a no-op: the GoSQLX AST stores raw (unquoted)
+// identifier names.  The formatter uses the target dialect's quoting style.
+func PgDoubleQuoteToBacktick(_ ast.Statement) error {
+	return nil
+}
+
+// PgILikeToLower rewrites PostgreSQL ILIKE to a LOWER() … LIKE LOWER() pair
+// that is compatible with MySQL.
+//
+// PostgreSQL: col ILIKE '%alice%'
+// MySQL:      LOWER(col) LIKE LOWER('%alice%')
+func PgILikeToLower(stmt ast.Statement) error {
+	return ast.Walk(&ilikeLowerer{}, stmt)
+}
+
+type ilikeLowerer struct{}
+
+func (v *ilikeLowerer) Visit(node ast.Node) (ast.Visitor, error) {
+	if node == nil {
+		return nil, nil
+	}
+	bin, ok := node.(*ast.BinaryExpression)
+	if !ok {
+		return v, nil
+	}
+	if !strings.EqualFold(bin.Operator, "ILIKE") {
+		return v, nil
+	}
+	// Rewrite: left ILIKE right  →  LOWER(left) LIKE LOWER(right)
+	bin.Operator = "LIKE"
+	bin.Left = &ast.FunctionCall{
+		Name:      "LOWER",
+		Arguments: []ast.Expression{bin.Left},
+	}
+	bin.Right = &ast.FunctionCall{
+		Name:      "LOWER",
+		Arguments: []ast.Expression{bin.Right},
+	}
+	// Return nil so we do not recurse into the newly-created LOWER() wrappers.
+	return nil, nil
+}