@shortlink-org/portolan 0.1.0

package/plugins/extract-sql/maps_rust.go

@@ -0,0 +1,333 @@
+package main
+
+// The same fact read out of a repository written in Rust, where sqlx puts the
+// statement first and the values after it, one `bind` each:
+//
+//	sqlx::query("INSERT INTO orders (id, customer_id, placed_at) VALUES ($1, $2, $3)")
+//	    .bind(order.id)
+//	    .bind(&order.customer_id)
+//	    .bind(order.placed_at)
+//
+// or, in the checked macros, as arguments after the literal:
+//
+//	sqlx::query!("INSERT INTO orders (id, customer_id) VALUES ($1, $2)", order.id, order.customer_id)
+//
+// Read off the text like the TypeScript one, for the same reason: the
+// statement is a string literal, the values are expressions right after it,
+// and each is a field chain from the aggregate, possibly borrowed, possibly
+// wrapped in one conversion. Anything else is left unmapped.
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/pgplex/pgparser/nodes"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+func readMapsRust(root, repositoryDir, aggregate string, b *plugin.Builder) map[string]map[string]string {
+	out := map[string]map[string]string{}
+	dir := mapSourceDir(root, repositoryDir, aggregate)
+	entries, err := os.ReadDir(filepath.Join(root, filepath.FromSlash(dir)))
+	if err != nil {
+		return out
+	}
+	root_ := title(aggregate)
+	for _, entry := range entries {
+		name := entry.Name()
+		if entry.IsDir() || !strings.HasSuffix(name, ".rs") {
+			continue
+		}
+		source, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(dir), name))
+		if err != nil {
+			continue
+		}
+		for _, stmt := range rustInsertCalls(string(source)) {
+			table, columns, values := parseInsert(stmt.sql)
+			if table == "" {
+				continue
+			}
+			mapped := out[table]
+			if mapped == nil {
+				mapped = map[string]string{}
+				out[table] = mapped
+			}
+			numbers := placeholderNumbers(stmt.sql)
+			if numbers == nil || countParams(values) != len(numbers) {
+				if countParams(values) > 0 {
+					b.Warn(table, "the insert into "+table+" has placeholders this reader cannot number; its columns are left unmapped")
+				}
+				continue
+			}
+			seen := 0
+			for i, column := range columns {
+				if i >= len(values) {
+					break
+				}
+				if _, ok := values[i].(*nodes.ParamRef); !ok {
+					continue
+				}
+				number := numbers[seen]
+				seen++
+				if number < 1 || number > len(stmt.args) {
+					b.Warn(table, "the insert refers to $"+itoa(number)+" but the call binds "+itoa(len(stmt.args))+" values; "+column+" is left unmapped")
+					continue
+				}
+				field := fieldOfRust(stmt.args[number-1])
+				if field == "" {
+					continue
+				}
+				mapped[column] = root_ + "." + field
+			}
+		}
+	}
+
+	return out
+}
+
+// rustInsertCalls walks the source the way insertCalls does, with what Rust
+// adds to the reading: raw strings, `r"…"` and `r#"…"#`, which is how a long
+// statement is usually written; char literals, `'x'` and `'\n'`; and a
+// lifetime, `'a`, which opens no literal at all and must not be read as one.
+// A literal that holds an INSERT is a statement, and its values are the
+// `.bind(…)` chain after the call that holds it, or the arguments after it
+// inside a macro.
+func rustInsertCalls(source string) []tsInsert {
+	var out []tsInsert
+	for i := 0; i < len(source); i++ {
+		c := source[i]
+		switch {
+		case c == '/' && i+1 < len(source) && source[i+1] == '/':
+			for i < len(source) && source[i] != '\n' {
+				i++
+			}
+		case c == '/' && i+1 < len(source) && source[i+1] == '*':
+			end := strings.Index(source[i+2:], "*/")
+			if end < 0 {
+				return out
+			}
+			i += 2 + end + 1
+		case c == '\'':
+			if end := charLiteralEnd(source, i); end > 0 {
+				i = end
+			}
+		case c == '"', c == 'r' && rawStringAt(source, i):
+			start, end, hashes := stringLiteral(source, i)
+			if end < 0 {
+				return out
+			}
+			sql := source[start:end]
+			i = end + hashes
+			if !strings.Contains(strings.ToUpper(sql), "INSERT INTO") {
+				continue
+			}
+			j := skipSpace(source, i+1)
+			if j >= len(source) {
+				continue
+			}
+			if source[j] == ',' {
+				// A trailing comma inside the call is not the start of the
+				// macro's arguments: the next thing decides.
+				j = skipSpace(source, j+1)
+			}
+			if j >= len(source) {
+				continue
+			}
+			if source[j] == ')' {
+				// The builder shape: the values are bound one at a time after
+				// the call closes.
+				args, last := bindChain(source, j+1)
+				out = append(out, tsInsert{sql: sql, args: args})
+				i = last
+			} else {
+				// The macro shape: the values are the rest of the call.
+				args, close := argsUntilClose(source, j)
+				out = append(out, tsInsert{sql: sql, args: args})
+				i = close
+			}
+		}
+	}
+
+	return out
+}
+
+// rawStringAt says whether the `r` at i opens a raw string: `r"` or `r#…"`.
+// An `r` inside a longer word, `order`, is not one, and the caller only asks
+// about an `r` that is not preceded by an identifier character.
+func rawStringAt(source string, i int) bool {
+	if i > 0 && isIdent(source[i-1]) {
+		return false
+	}
+	j := i + 1
+	for j < len(source) && source[j] == '#' {
+		j++
+	}
+
+	return j < len(source) && source[j] == '"'
+}
+
+// stringLiteral reads the literal opening at i and answers with the bounds of
+// its content, the index of its closing quote, and how many `#` follow that
+// quote for a raw string.
+func stringLiteral(source string, i int) (int, int, int) {
+	if source[i] == '"' {
+		end := closingQuote(source, i)
+
+		return i + 1, end, 0
+	}
+	hashes := 0
+	j := i + 1
+	for source[j] == '#' {
+		hashes++
+		j++
+	}
+	closer := `"` + strings.Repeat("#", hashes)
+	end := strings.Index(source[j+1:], closer)
+	if end < 0 {
+		return 0, -1, 0
+	}
+
+	return j + 1, j + 1 + end, hashes
+}
+
+// charLiteralEnd is the index of the quote closing a char literal at i, or
+// -1 when the quote at i is a lifetime's and closes nothing.
+func charLiteralEnd(source string, i int) int {
+	if i+2 < len(source) && source[i+1] == '\\' {
+		end := strings.IndexByte(source[i+2:], '\'')
+		if end < 0 {
+			return -1
+		}
+
+		return i + 2 + end
+	}
+	if i+2 < len(source) && source[i+2] == '\'' {
+		return i + 2
+	}
+
+	return -1
+}
+
+// argsUntilClose splits the arguments from i to the `)` that closes the call
+// they are in, and answers with the index of that paren.
+func argsUntilClose(source string, i int) ([]string, int) {
+	depth := 0
+	var quote byte
+	for j := i; j < len(source); j++ {
+		c := source[j]
+		if quote != 0 {
+			if c == '\\' {
+				j++
+			} else if c == quote {
+				quote = 0
+			}
+			continue
+		}
+		switch c {
+		case '"':
+			quote = c
+		case '[', '(', '{':
+			depth++
+		case ']', '}':
+			depth--
+		case ')':
+			if depth == 0 {
+				return splitTopLevel(source[i:j]), j
+			}
+			depth--
+		}
+	}
+
+	return nil, len(source) - 1
+}
+
+// bindChain reads `.bind(x)` calls one after another from i, stepping over
+// whitespace and comments between them, and answers with what each was
+// handed and the index it stopped at.
+func bindChain(source string, i int) ([]string, int) {
+	var args []string
+	last := i - 1
+	for {
+		j := skipSpaceAndComments(source, i)
+		if !strings.HasPrefix(source[j:], ".bind(") {
+			return args, last
+		}
+		open := j + len(".bind")
+		close := matchingBracket(source, open)
+		if close < 0 {
+			return args, last
+		}
+		args = append(args, strings.TrimSpace(source[open+1:close]))
+		last = close
+		i = close + 1
+	}
+}
+
+func skipSpaceAndComments(source string, i int) int {
+	for {
+		i = skipSpace(source, i)
+		if strings.HasPrefix(source[i:], "//") {
+			for i < len(source) && source[i] != '\n' {
+				i++
+			}
+			continue
+		}
+		if strings.HasPrefix(source[i:], "/*") {
+			end := strings.Index(source[i+2:], "*/")
+			if end < 0 {
+				return len(source)
+			}
+			i += 2 + end + 2
+			continue
+		}
+
+		return i
+	}
+}
+
+func isIdent(c byte) bool {
+	return c == '_' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9'
+}
+
+var rustChain = regexp.MustCompile(`^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)+$`)
+
+// fieldOfRust follows a bound value back to the field it carries, the way
+// fieldOfTS does: `order.customer_id` is customer_id, `&order.customer_id`
+// and `*order.version` the same, `order.status.as_str()` is status,
+// `Some(order.placed_at)` and `i64::from(order.version)` are placed_at and
+// version. A bare name, a literal, a call that makes its own value -
+// `Uuid::new_v4()` - and a call over several values carry no field.
+func fieldOfRust(expr string) string {
+	expr = strings.TrimSpace(expr)
+	expr = strings.TrimSuffix(expr, "?")
+	for strings.HasPrefix(expr, "&") || strings.HasPrefix(expr, "*") {
+		expr = strings.TrimSpace(strings.TrimLeft(expr, "&*"))
+		expr = strings.TrimSpace(strings.TrimPrefix(expr, "mut "))
+	}
+	for strings.HasSuffix(expr, ")") {
+		open := openingParen(expr)
+		if open <= 0 {
+			return ""
+		}
+		callee, inner := expr[:open], expr[open+1:len(expr)-1]
+		args := splitTopLevel(inner)
+		switch {
+		case rustChain.MatchString(callee) && len(args) == 0:
+			// A method on the value: the value is the chain before it.
+			expr = callee[:strings.LastIndex(callee, ".")]
+		case len(args) == 1:
+			// A conversion wrapped round the value.
+			return fieldOfRust(args[0])
+		default:
+			return ""
+		}
+	}
+	if !rustChain.MatchString(expr) {
+		return ""
+	}
+	parts := strings.Split(expr, ".")
+
+	return strings.Join(parts[1:], ".")
+}

package/plugins/extract-sql/maps_rust_test.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"testing"
+)
+
+// The same rule as for Go and TypeScript, read off text: the chain from the
+// aggregate, a borrow or a dereference in front of it, one conversion round
+// it, a method on the value stripped.
+func TestFieldOfRustFollowsTheChainBorrowsAndOneWrapper(t *testing.T) {
+	cases := map[string]string{
+		"order.id":                       "id",
+		"&order.customer_id":             "customer_id",
+		"&mut order.lines":               "lines",
+		"*order.version":                 "version",
+		"order.status.as_str()":          "status",
+		"order.total.amount_minor":       "total.amount_minor",
+		"order.total.currency.code()":    "total.currency",
+		"Some(order.placed_at)":          "placed_at",
+		"i64::from(order.version)":       "version",
+		"order.basket_id.to_string()":    "basket_id",
+		"&order.customer_id.as_deref()?": "customer_id",
+		"Uuid::new_v4()":                 "",
+		"serde_json::to_value(&event)?":  "",
+		"combine(order.a, order.b)":      "",
+		"TOPIC":                          "",
+		"1":                              "",
+		"\"literal\"":                    "",
+		"Utc::now()":                     "",
+	}
+	for in, want := range cases {
+		if got := fieldOfRust(in); got != want {
+			t.Errorf("fieldOfRust(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestRustInsertCallsReadBothShapesAndStepOverLifetimes(t *testing.T) {
+	source := `
+impl<'a> PostgresOrders<'a> {
+    async fn save(&self, tx: &mut Transaction<'_, Postgres>, order: &Order) -> Result<(), Error> {
+        sqlx::query("BEGIN").execute(&mut **tx).await?; // a literal before, which must not swallow what follows
+        let sep = ',';
+        sqlx::query(
+            r#"INSERT INTO orders (id, customer_id, version) VALUES ($1, $2, 1)"#,
+        )
+        .bind(order.id)
+        // the customer auth vouched for
+        .bind(&order.customer_id)
+        .execute(&mut **tx)
+        .await?;
+        let rows = sqlx::query("SELECT * FROM orders WHERE id = $1").bind(id).fetch_all(pool).await?;
+        sqlx::query!("INSERT INTO outbox (uuid, payload) VALUES ($1, $2)", Uuid::new_v4(), serde_json::to_value(&event)?)
+            .execute(&mut **tx)
+            .await?;
+        Ok(())
+    }
+}
+`
+	calls := rustInsertCalls(source)
+	if len(calls) != 2 {
+		t.Fatalf("found %d inserts, want 2", len(calls))
+	}
+	if len(calls[0].args) != 2 || calls[0].args[1] != "&order.customer_id" {
+		t.Fatalf("first insert args = %q", calls[0].args)
+	}
+	if len(calls[1].args) != 2 || calls[1].args[1] != "serde_json::to_value(&event)?" {
+		t.Fatalf("second insert args = %q", calls[1].args)
+	}
+}

package/plugins/extract-sql/maps_test.go

@@ -0,0 +1,204 @@
+package main
+
+import (
+	"go/ast"
+	"go/parser"
+	"strings"
+	"testing"
+
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+func builderFor(t *testing.T) *plugin.Builder {
+	t.Helper()
+
+	return &plugin.Builder{}
+}
+
+func expr(t *testing.T, src string) ast.Expr {
+	t.Helper()
+
+	parsed, err := parser.ParseExpr(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return parsed
+}
+
+// The column carries the value object, not the conversion applied to it on the
+// way out - and the conversion is written both ways round.
+func TestFieldOfFollowsBothCallShapes(t *testing.T) {
+	s := scope{packages: map[string]bool{"time": true, "pgtype": true, "uuid": true}}
+	cases := map[string]string{
+		"u.ID":                       "ID",
+		"u.Email.String()":           "Email",
+		"nullable(s.RevokedAt)":      "RevokedAt",
+		"pgtype.Text(u.Email)":       "Email",
+		"time.Now()":                 "",
+		"uuid.NewString()":           "",
+		"combine(u.A, u.B)":          "",
+		"localVariable":              "",
+		`"literal"`:                  "",
+		"q.ID()":                     "ID",
+		"q.Total().AmountMinor()":    "Total",
+		"q.Total().Currency()":       "Total",
+		"q.IssuedAt().Format(\"x\")": "IssuedAt",
+	}
+
+	for src, want := range cases {
+		if got := fieldOf(expr(t, src), s); got != want {
+			t.Errorf("fieldOf(%s) = %q, want %q", src, got, want)
+		}
+	}
+}
+
+// Inside Save the aggregate is the parameter typed as the root, and nothing
+// else: the loop variable over its lines carries the line's fields, and a
+// mapping from those to the aggregate would be a claim about the wrong type.
+func TestFieldOfReadsOnlyTheRootWhenTheFunctionNamesIt(t *testing.T) {
+	s := scope{packages: map[string]bool{}, roots: map[string]bool{"q": true}}
+	cases := map[string]string{
+		"q.ID()":        "ID",
+		"q.BasketID()":  "BasketID",
+		"l.SKU()":       "",
+		"l.Quantity":    "",
+		"raised.Name()": "",
+	}
+
+	for src, want := range cases {
+		if got := fieldOf(expr(t, src), s); got != want {
+			t.Errorf("fieldOf(%s) = %q, want %q", src, got, want)
+		}
+	}
+}
+
+// The variable of a range loop stands for one element of what it walks, so a
+// column written from it carries a field of the elements of a field.
+func TestFieldOfFollowsARangeVariable(t *testing.T) {
+	s := scope{
+		packages: map[string]bool{},
+		roots:    map[string]bool{"q": true},
+		aliases:  map[string]ast.Expr{"l": expr(t, "q.Lines()"), "raised": expr(t, "events"), "l2": expr(t, "l2.Items")},
+	}
+	cases := map[string]string{
+		"l.SKU()":                  "Lines.SKU",
+		"l.UnitPrice().Currency()": "Lines.UnitPrice",
+		"raised.Name()":            "",
+		"l2.Name":                  "",
+	}
+
+	for src, want := range cases {
+		if got := fieldOf(expr(t, src), s); got != want {
+			t.Errorf("fieldOf(%s) = %q, want %q", src, got, want)
+		}
+	}
+}
+
+// Pricing keeps its fields unexported and writes rows off getters, and its
+// lines are written from a loop variable over them.
+func TestMapsThroughGetters(t *testing.T) {
+	b := builderFor(t)
+	mapped := readMaps("../../examples/shop/pricing", "internal/infrastructure/repository/quote", "quote", b)
+
+	want := map[string]map[string]string{
+		"quotes": {
+			"id":          "Quote.ID",
+			"basket_id":   "Quote.BasketID",
+			"total_minor": "Quote.Total",
+			"currency":    "Quote.Total",
+			"state":       "Quote.State",
+			"issued_at":   "Quote.IssuedAt",
+			"expires_at":  "Quote.ExpiresAt",
+		},
+		"quote_lines": {
+			"quote_id":         "Quote.ID",
+			"sku":              "Quote.Lines.SKU",
+			"quantity":         "Quote.Lines.Quantity",
+			"unit_price_minor": "Quote.Lines.UnitPrice",
+			"currency":         "Quote.Lines.UnitPrice",
+		},
+	}
+	for table, columns := range want {
+		for column, field := range columns {
+			if got := mapped[table][column]; got != field {
+				t.Errorf("%s.%s -> %q, want %q", table, column, got, field)
+			}
+		}
+		if len(mapped[table]) != len(columns) {
+			t.Errorf("%s: mapped %v, want exactly %v", table, mapped[table], columns)
+		}
+	}
+	if len(mapped["outbox"]) != 0 {
+		t.Errorf("outbox: mapped %v, want nothing", mapped["outbox"])
+	}
+}
+
+// The grammar port keeps a placeholder as a node with no number on it, so the
+// numbers are read off the text. Taking the order of the nodes instead would
+// be right for every statement written in ascending order and silently wrong
+// for the one that is not.
+func TestPlaceholderNumbersComeFromTheText(t *testing.T) {
+	got := placeholderNumbers("INSERT INTO t (a, b, c) VALUES ($2, $1, 1)")
+	if len(got) != 2 || got[0] != 2 || got[1] != 1 {
+		t.Errorf("numbers = %v, want [2 1]", got)
+	}
+
+	// A RETURNING clause is not a value being written.
+	got = placeholderNumbers("INSERT INTO t (a) VALUES ($1) RETURNING id")
+	if len(got) != 1 || got[0] != 1 {
+		t.Errorf("numbers = %v, want [1]", got)
+	}
+}
+
+// A statement is routinely assembled from a shared column list rather than
+// written whole.
+func TestStringValueFoldsConstantsAndConcatenation(t *testing.T) {
+	constants := map[string]string{"columns": "id, name"}
+
+	got, ok := stringValue(expr(t, "`INSERT INTO t (`+columns+`) VALUES ($1, $2)`"), constants)
+	if !ok || !strings.Contains(got, "id, name") {
+		t.Errorf("folded = %q ok=%v", got, ok)
+	}
+
+	// Anything that cannot be folded is left alone rather than read half
+	// resolved.
+	if _, ok := stringValue(expr(t, "prefix + buildRest()"), constants); ok {
+		t.Error("a call is not a constant")
+	}
+}
+
+// The whole point of the field: no rule over column names produces
+// password_hash -> Password, and the statement that writes the row does.
+func TestMapsAgainstTheRealService(t *testing.T) {
+	b := builderFor(t)
+	mapped := readMaps("../../examples/auth", "internal/user/infrastructure/repository", "user", b)
+
+	users := mapped["users"]
+	if users["password_hash"] != "User.Password" {
+		t.Errorf("password_hash -> %q", users["password_hash"])
+	}
+	if users["email"] != "User.Email" {
+		t.Errorf("email -> %q", users["email"])
+	}
+	// `version` is written as a literal 1, so nothing carries it from the
+	// aggregate and the column stays unmapped rather than guessed at.
+	if got, ok := users["version"]; ok {
+		t.Errorf("version should be unmapped, got %q", got)
+	}
+}
+
+// The session repository builds its statement from a constant column list and
+// wraps one value in a conversion, so it exercises both readings at once.
+func TestMapsThroughAConstantColumnList(t *testing.T) {
+	b := builderFor(t)
+	mapped := readMaps("../../examples/auth", "internal/session/infrastructure/repository", "session", b)
+
+	sessions := mapped["sessions"]
+	if sessions["revoked_at"] != "Session.RevokedAt" {
+		t.Errorf("revoked_at -> %q", sessions["revoked_at"])
+	}
+	if sessions["user_id"] != "Session.UserID" {
+		t.Errorf("user_id -> %q", sessions["user_id"])
+	}
+}