0.6

Author: sted

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-## Unreleased
+## 0.6.0 - 2026-04-17
 
 ### Added
 * Configurable JWT token expiry (`TokenExpiry` config, default 24h)
@@ -18,6 +18,8 @@
 * TLS minimum version enforced to TLS 1.2
 * Session keys now use SHA-256 hash instead of raw token strings
 * Removed hardcoded JWT secret from sample config
+* RPC calls now emit named parameters in a deterministic order (function-signature order, falling back to alphabetical), so `pg_stat_statements` aggregates identical calls under a single `queryid` instead of one per JSON key permutation
+* M2M view relationship synthesis now deterministically prefers view junctions over base-table junctions (fixes a flaky "permission denied" error when the base junction lived in a schema the caller lacked USAGE on)
 
 ### Improved
 * Session improvements and tests

README.md

@@ -8,7 +8,7 @@ It is mostly compatible with [PostgREST](https://postgrest.org/en/stable/), with
 
 The main differences are:
 
-* SmoothDB is in development and beta quality. Prefer PostgREST for now, which is rock solid
+* SmoothDB is actively developed and maturing quickly; PostgREST remains the more battle-tested option for critical production workloads
 * SmoothDB is faster and has a lower CPU load 
 * It is written in Go
 * Can be used both stand-alone and as a library (the main motivation for writing this)
@@ -19,6 +19,10 @@ The main differences are:
 See [TODO.md](TODO.md) for the many things to be completed.
 Please create issues to let me know your priorities.
 
+## About this project
+
+SmoothDB is not *vibe-coded*. It was started in 2022 as a solid, versatile middleware meant to serve as a reliable building block for data-driven applications. Since 2025 we have been pairing that foundation with strong LLMs to harden, review, and extend the code — aiming to follow the high bar set by PostgREST in correctness, safety, and API fidelity.
+
 ## Getting started
 
 ### Install

database/querybuilder.go

@@ -810,6 +810,54 @@ func onConflictClause(table, schema string, fields []string,
 	return s
 }
 
+// orderedRecordKeys returns record's keys in a deterministic order for use
+// when building RPC CALL sites. When a function signature is available and
+// has no unnamed parameters, IN/INOUT/VARIADIC argument names are emitted in
+// declared order; any extra keys (or the whole record when no signature is
+// known) follow in alphabetical order. columnFields, when non-empty,
+// restricts which keys are included.
+func orderedRecordKeys(record Record, columnFields map[string]struct{}, f *Function) []string {
+	included := func(key string) bool {
+		if len(columnFields) == 0 {
+			return true
+		}
+		_, ok := columnFields[key]
+		return ok
+	}
+
+	var keys []string
+	seen := map[string]bool{}
+	if f != nil && !f.HasUnnamed {
+		for _, arg := range f.Arguments {
+			// Only IN-like modes are passed as input params.
+			// Mode 0 is the default (IN) when proargmodes is NULL.
+			if arg.Mode != 0 && arg.Mode != 'i' && arg.Mode != 'b' && arg.Mode != 'v' {
+				continue
+			}
+			if _, ok := record[arg.Name]; !ok {
+				continue
+			}
+			if !included(arg.Name) {
+				continue
+			}
+			keys = append(keys, arg.Name)
+			seen[arg.Name] = true
+		}
+	}
+	var extra []string
+	for k := range record {
+		if seen[k] {
+			continue
+		}
+		if !included(k) {
+			continue
+		}
+		extra = append(extra, k)
+	}
+	sort.Strings(extra)
+	return append(keys, extra...)
+}
+
 type CommonBuilder struct{}
 
 func (CommonBuilder) BuildInsert(table string, records []Record, parts *QueryParts, options *QueryOptions, info *SchemaInfo) (
@@ -1192,15 +1240,21 @@ func (CommonBuilder) BuildExecute(name string, record Record, parts *QueryParts,
 	query string, valueList []any, err error) {
 
 	stack := BuildStack{info: info}
+	schema := options.Schema
+
+	var f *Function
+	if info != nil {
+		f = info.GetFunction(_s(name, schema))
+	}
+
+	// Determine a deterministic key order so identical RPC calls generate
+	// identical SQL (pg_stat_statements hashes by normalized query). Prefer
+	// the declared function-signature order; fall back to alphabetical.
+	keys := orderedRecordKeys(record, parts.columnFields, f)
+
 	var pairs string
 	var i int
-	for key := range record {
-		// check if there are specified columns
-		if len(parts.columnFields) > 0 {
-			if _, ok := parts.columnFields[key]; !ok {
-				continue
-			}
-		}
+	for _, key := range keys {
 		if pairs != "" {
 			pairs += ", "
 		}
@@ -1213,11 +1267,9 @@ func (CommonBuilder) BuildExecute(name string, record Record, parts *QueryParts,
 		valueList = append(valueList, record[key])
 	}
 
-	schema := options.Schema
 	// Extract the return type and discover if it is a table.
 	// In that case, we will use its name and schema to compose the select clause
 	var t, s string
-	f := info.GetFunction(_s(name, schema))
 	if f != nil {
 		rettype := info.GetTypeById(f.ReturnTypeId)
 		if rettype.IsTable {

database/querybuilder_test.go

@@ -332,3 +332,151 @@ func TestRecursiveParserErrors(t *testing.T) {
 		}
 	}
 }
+
+// TestBuildExecuteDeterministicOrder guards against the pg_stat_statements
+// fragmentation bug (see CollHub doc 27565): named RPC parameters must be
+// emitted in a stable order regardless of Go map iteration so identical calls
+// hash to the same queryid.
+func TestBuildExecuteDeterministicOrder(t *testing.T) {
+	record := Record{
+		"p_a": 1,
+		"p_b": "hello",
+		"p_c": 2,
+		"p_d": 3.14,
+		"p_e": true,
+	}
+
+	// Without SchemaInfo: fall back to alphabetical key order.
+	t.Run("no schema info", func(t *testing.T) {
+		var first string
+		for i := 0; i < 50; i++ {
+			q, _, err := CommonBuilder{}.BuildExecute("fn", record, &QueryParts{}, &QueryOptions{}, nil)
+			if err != nil {
+				t.Fatalf("BuildExecute error: %v", err)
+			}
+			if i == 0 {
+				first = q
+				continue
+			}
+			if q != first {
+				t.Fatalf("non-deterministic SQL across runs:\n  first: %s\n  got:   %s", first, q)
+			}
+		}
+		// Alphabetical: p_a, p_b, p_c, p_d, p_e
+		want := `SELECT * FROM "fn"("p_a" := $1, "p_b" := $2, "p_c" := $3, "p_d" := $4, "p_e" := $5) t `
+		if first != want {
+			t.Errorf("expected alphabetical order\n  want: %s\n  got:  %s", want, first)
+		}
+	})
+
+	// With SchemaInfo: use declared signature order.
+	t.Run("with signature", func(t *testing.T) {
+		info := &SchemaInfo{
+			cachedTypes: map[uint32]Type{0: {}},
+			cachedFunctions: map[string]Function{
+				"fn": {
+					Name:   "fn",
+					Schema: "",
+					Arguments: []Argument{
+						{Name: "p_c", Mode: 'i'},
+						{Name: "p_a", Mode: 'i'},
+						{Name: "p_e", Mode: 'i'},
+						{Name: "p_b", Mode: 'i'},
+						{Name: "p_d", Mode: 'i'},
+					},
+				},
+			},
+		}
+		var first string
+		var firstValues []any
+		for i := 0; i < 50; i++ {
+			q, v, err := CommonBuilder{}.BuildExecute("fn", record, &QueryParts{}, &QueryOptions{}, info)
+			if err != nil {
+				t.Fatalf("BuildExecute error: %v", err)
+			}
+			if i == 0 {
+				first = q
+				firstValues = v
+				continue
+			}
+			if q != first {
+				t.Fatalf("non-deterministic SQL across runs:\n  first: %s\n  got:   %s", first, q)
+			}
+			if !compareValues(v, firstValues) {
+				t.Fatalf("non-deterministic values across runs:\n  first: %v\n  got:   %v", firstValues, v)
+			}
+		}
+		// Signature order: p_c, p_a, p_e, p_b, p_d
+		want := `SELECT * FROM "fn"("p_c" := $1, "p_a" := $2, "p_e" := $3, "p_b" := $4, "p_d" := $5) t `
+		if first != want {
+			t.Errorf("expected signature order\n  want: %s\n  got:  %s", want, first)
+		}
+		wantValues := []any{2, 1, true, "hello", 3.14}
+		if !compareValues(firstValues, wantValues) {
+			t.Errorf("values must follow key order\n  want: %v\n  got:  %v", wantValues, firstValues)
+		}
+	})
+
+	// Extra record keys not in signature come after, in alphabetical order.
+	t.Run("extra keys after signature", func(t *testing.T) {
+		info := &SchemaInfo{
+			cachedTypes: map[uint32]Type{0: {}},
+			cachedFunctions: map[string]Function{
+				"fn": {
+					Name:   "fn",
+					Schema: "",
+					Arguments: []Argument{
+						{Name: "p_a", Mode: 'i'},
+						{Name: "p_b", Mode: 'i'},
+					},
+				},
+			},
+		}
+		rec := Record{"p_b": 2, "p_a": 1, "z_extra": 99, "a_extra": 98}
+		var first string
+		for i := 0; i < 50; i++ {
+			q, _, err := CommonBuilder{}.BuildExecute("fn", rec, &QueryParts{}, &QueryOptions{}, info)
+			if err != nil {
+				t.Fatalf("BuildExecute error: %v", err)
+			}
+			if i == 0 {
+				first = q
+				continue
+			}
+			if q != first {
+				t.Fatalf("non-deterministic SQL:\n  first: %s\n  got:   %s", first, q)
+			}
+		}
+		want := `SELECT * FROM "fn"("p_a" := $1, "p_b" := $2, "a_extra" := $3, "z_extra" := $4) t `
+		if first != want {
+			t.Errorf("unexpected order\n  want: %s\n  got:  %s", want, first)
+		}
+	})
+
+	// OUT/TABLE-mode arguments must not be emitted as input params.
+	t.Run("skip out mode args", func(t *testing.T) {
+		info := &SchemaInfo{
+			cachedTypes: map[uint32]Type{0: {}},
+			cachedFunctions: map[string]Function{
+				"fn": {
+					Name:   "fn",
+					Schema: "",
+					Arguments: []Argument{
+						{Name: "p_in", Mode: 'i'},
+						{Name: "p_out", Mode: 'o'},
+						{Name: "p_tbl", Mode: 't'},
+					},
+				},
+			},
+		}
+		rec := Record{"p_in": 1}
+		q, _, err := CommonBuilder{}.BuildExecute("fn", rec, &QueryParts{}, &QueryOptions{}, info)
+		if err != nil {
+			t.Fatalf("BuildExecute error: %v", err)
+		}
+		want := `SELECT * FROM "fn"("p_in" := $1) t `
+		if q != want {
+			t.Errorf("OUT/TABLE args should be skipped\n  want: %s\n  got:  %s", want, q)
+		}
+	})
+}

database/schemainfo.go

@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"sort"
 
 	"github.com/samber/lo"
 )
@@ -499,8 +500,17 @@ func (si *SchemaInfo) addViewRelationships(deps []ViewColDep) {
 	// M2M view relationships: for each existing M2M between base tables,
 	// create M2M rels for view surfaces on both sides and the junction.
 	// Only process each M2M pair once (deduplicate by junction + sorted table pair).
+	// Iterate the relationships map in sorted key order so the deduplication
+	// below (first junction wins) is deterministic across runs, and prefers
+	// view junctions so callers only need privileges on the exposed schema.
 	seen := map[string]bool{}
-	for _, rels := range si.cachedRelationships {
+	relKeys := make([]string, 0, len(si.cachedRelationships))
+	for k := range si.cachedRelationships {
+		relKeys = append(relKeys, k)
+	}
+	sort.Strings(relKeys)
+	for _, k := range relKeys {
+		rels := si.cachedRelationships[k]
 		for _, rel := range rels {
 			if rel.Type != M2M {
 				continue
@@ -522,6 +532,26 @@ func (si *SchemaInfo) addViewRelationships(deps []ViewColDep) {
 			tableSurfaces := collectSurfaces(tName, tSchema, rel.Columns)
 			relSurfaces := collectSurfaces(rName, rSchema, rel.RelatedColumns)
 			juncSurfaces := collectSurfaces(jTable, jSchema, append(rel.JColumns, rel.JRelatedColumns...))
+			// Prefer view junctions over base-table junctions so the
+			// synthesized M2M between two view endpoints goes through a
+			// junction exposed in the same (or similarly accessible)
+			// schema, rather than leaking into a hidden base schema the
+			// caller may not have USAGE on. Stable alphabetical tiebreak
+			// keeps the choice deterministic across runs.
+			sortViewsFirst := func(s []surfaceEntry) {
+				sort.SliceStable(s, func(i, j int) bool {
+					if s[i].isView != s[j].isView {
+						return s[i].isView
+					}
+					if s[i].schema != s[j].schema {
+						return s[i].schema < s[j].schema
+					}
+					return s[i].name < s[j].name
+				})
+			}
+			sortViewsFirst(tableSurfaces)
+			sortViewsFirst(relSurfaces)
+			sortViewsFirst(juncSurfaces)
 
 			for _, ts := range tableSurfaces {
 				for _, rs := range relSurfaces {

go.mod

@@ -19,8 +19,8 @@ require (
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-isatty v0.0.21 // indirect
 	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/text v0.35.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
 )

go.sum

@@ -24,6 +24,8 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.21 h1:xYae+lCNBP7QuW4PUnNG61ffM4hVIfm+zUzDuSzYLGs=
+github.com/mattn/go-isatty v0.0.21/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -60,10 +62,14 @@ golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
 golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
 golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
 golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
 golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
 golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
 gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=