@shortlink-org/portolan 0.1.0 → 0.2.0

package/plugins/extract-sql/maps_rust.go

@@ -1,333 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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"])
-	}
-}