@shortlink-org/portolan 0.1.0

package/plugins/extract-sql/ddl_test.go

@@ -0,0 +1,401 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/shortlink-org/portolan/catalog"
+)
+
+func read(t *testing.T, sql string) ([]relation, []string) {
+	t.Helper()
+
+	relations, _, unread, err := readDDL(sql, "test.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return relations, unread
+}
+
+func TestColumnsKeysAndNullability(t *testing.T) {
+	relations, _ := read(t, `
+CREATE TABLE users (
+    id            text        PRIMARY KEY,
+    email         text        NOT NULL,
+    nickname      text,
+    version       bigint      NOT NULL
+);`)
+
+	if len(relations) != 1 {
+		t.Fatalf("expected one table, got %d", len(relations))
+	}
+
+	got := map[string]catalog.Column{}
+	for _, column := range relations[0].table.Columns {
+		got[column.Name] = column
+	}
+
+	if !got["id"].PK {
+		t.Error("id is the primary key")
+	}
+	// A primary key is not null whether or not anybody wrote it down.
+	if got["id"].Nullable {
+		t.Error("a primary key is never nullable")
+	}
+	if got["email"].Nullable {
+		t.Error("email is NOT NULL")
+	}
+	if !got["nickname"].Nullable {
+		t.Error("nickname has no constraint, so it is nullable")
+	}
+}
+
+// The grammar normalises the standard names to PostgreSQL's internal ones. The
+// catalog asks for the type as declared, so they are put back.
+func TestTypesKeepTheirWrittenSpelling(t *testing.T) {
+	relations, _ := read(t, `
+CREATE TABLE t (
+    a bigint,
+    b timestamptz,
+    c boolean,
+    d char(3),
+    e jsonb
+);`)
+
+	want := map[string]string{
+		"a": "bigint",
+		"b": "timestamptz",
+		"c": "boolean",
+		"d": "char(3)",
+		"e": "jsonb",
+	}
+
+	for _, column := range relations[0].table.Columns {
+		if got := column.Type; got != want[column.Name] {
+			t.Errorf("%s: type = %q, want %q", column.Name, got, want[column.Name])
+		}
+	}
+}
+
+func TestTableLevelPrimaryKey(t *testing.T) {
+	relations, _ := read(t, `
+CREATE TABLE order_items (
+    order_id uuid NOT NULL,
+    line_no  integer NOT NULL,
+    PRIMARY KEY (order_id, line_no)
+);`)
+
+	for _, column := range relations[0].table.Columns {
+		if !column.PK {
+			t.Errorf("%s is part of the composite key", column.Name)
+		}
+	}
+}
+
+func TestForeignKey(t *testing.T) {
+	relations, _ := read(t, `
+CREATE TABLE lines (
+    id       uuid PRIMARY KEY,
+    order_id uuid NOT NULL REFERENCES orders (id) ON DELETE CASCADE
+);`)
+
+	var fk *catalog.FK
+	for _, column := range relations[0].table.Columns {
+		if column.Name == "order_id" {
+			fk = column.FK
+		}
+	}
+
+	if fk == nil {
+		t.Fatal("order_id has a foreign key")
+	}
+	if fk.Table != "orders" || fk.Column != "id" || fk.OnDelete != "cascade" {
+		t.Errorf("fk = %+v", fk)
+	}
+}
+
+func TestIndexesCarryTheirColumnsAndUniqueness(t *testing.T) {
+	relations, _ := read(t, `
+CREATE TABLE sessions (id text PRIMARY KEY, user_id text, issued_at timestamptz);
+CREATE UNIQUE INDEX sessions_token_key ON sessions (id);
+CREATE INDEX sessions_user_id_idx ON sessions (user_id, issued_at);`)
+
+	indexes := relations[0].indexes
+	if len(indexes) != 2 {
+		t.Fatalf("expected two indexes, got %d", len(indexes))
+	}
+	if !indexes[0].Unique || indexes[0].Name != "sessions_token_key" {
+		t.Errorf("first index = %+v", indexes[0])
+	}
+	if indexes[1].Unique || strings.Join(indexes[1].Columns, ",") != "user_id,issued_at" {
+		t.Errorf("second index = %+v", indexes[1])
+	}
+}
+
+// A migration this reader does not model is reported. Quietly skipping one
+// would leave the catalog confidently wrong about the schema.
+func TestUnreadStatementsAreReported(t *testing.T) {
+	relations, unread := read(t, `
+CREATE TABLE t (id text PRIMARY KEY);
+ALTER TABLE t ADD COLUMN extra text;
+CREATE INDEX elsewhere_idx ON other_table (id);`)
+
+	if len(unread) != 1 {
+		t.Fatalf("expected one note, got %v", unread)
+	}
+	if got := relations[0].table.Columns[1].Name; got != "extra" {
+		t.Errorf("ALTER ADD COLUMN was not applied: %q", got)
+	}
+	if !strings.Contains(strings.Join(unread, " "), "other_table") {
+		t.Errorf("an index on a table from another file should be named: %v", unread)
+	}
+}
+
+func TestMigrationsBuildFinalSchemaState(t *testing.T) {
+	state := newDDLState()
+	steps := []string{
+		`CREATE TABLE accounts (id uuid PRIMARY KEY, email text, obsolete text);`,
+		`ALTER TABLE accounts ADD COLUMN version integer NOT NULL;
+         ALTER TABLE accounts ALTER COLUMN email SET NOT NULL;
+         CREATE UNIQUE INDEX accounts_email_key ON accounts (email);`,
+		`ALTER TABLE accounts RENAME COLUMN email TO login;
+         ALTER TABLE accounts ALTER COLUMN version TYPE bigint;
+         ALTER TABLE accounts DROP COLUMN obsolete;
+         ALTER TABLE accounts RENAME TO users;`,
+	}
+	for i, sql := range steps {
+		unread, err := state.apply(sql, fmt.Sprintf("%03d.sql", i+1))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(unread) != 0 {
+			t.Fatalf("migration %d left unread DDL: %v", i+1, unread)
+		}
+	}
+
+	if len(state.relations) != 1 || state.relations[0].table.Name != "users" {
+		t.Fatalf("relations = %+v", state.relations)
+	}
+	r := state.relations[0]
+	if len(r.table.Columns) != 3 {
+		t.Fatalf("columns = %+v", r.table.Columns)
+	}
+	want := map[string]string{"id": "uuid", "login": "text", "version": "bigint"}
+	for _, column := range r.table.Columns {
+		if column.Type != want[column.Name] {
+			t.Errorf("column %s type = %q, want %q", column.Name, column.Type, want[column.Name])
+		}
+		if column.Name == "login" && column.Nullable {
+			t.Error("renamed login column lost NOT NULL")
+		}
+	}
+	if len(r.indexes) != 1 || strings.Join(r.indexes[0].Columns, ",") != "login" {
+		t.Errorf("index did not follow renamed column: %+v", r.indexes)
+	}
+}
+
+func TestPostgresSchemasKeepRelationsDistinct(t *testing.T) {
+	state := newDDLState()
+	unread, err := state.apply(`
+CREATE SCHEMA sales;
+CREATE SCHEMA audit;
+CREATE TABLE sales.orders (id uuid PRIMARY KEY, tenant_id uuid NOT NULL);
+CREATE TABLE audit.orders (id uuid PRIMARY KEY, payload jsonb NOT NULL);
+CREATE TABLE sales.order_lines (
+    id uuid PRIMARY KEY,
+    order_id uuid NOT NULL REFERENCES sales.orders (id)
+);
+CREATE INDEX orders_tenant_idx ON sales.orders (tenant_id);
+CREATE VIEW sales.order_ids AS SELECT id FROM sales.orders;
+`, "001.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(unread) != 0 {
+		t.Fatalf("nothing should be left unread: %v", unread)
+	}
+	if len(state.relations) != 3 {
+		t.Fatalf("relations = %+v", state.relations)
+	}
+	if state.relations[state.relationAt["sales.orders"]].table.Name != "sales.orders" ||
+		state.relations[state.relationAt["audit.orders"]].table.Name != "audit.orders" {
+		t.Fatalf("schema-qualified relations were merged: %+v", state.relationAt)
+	}
+	if got := state.relations[state.relationAt["sales.orders"]].indexes; len(got) != 1 || got[0].Name != "orders_tenant_idx" {
+		t.Errorf("schema-qualified index was not attached: %+v", got)
+	}
+
+	unread, err = state.apply(`ALTER TABLE sales.orders SET SCHEMA archive;`, "002.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(unread) != 0 {
+		t.Fatalf("SET SCHEMA should be applied: %v", unread)
+	}
+	if _, exists := state.relationAt["sales.orders"]; exists {
+		t.Error("old qualified table name still exists")
+	}
+	if _, exists := state.relationAt["archive.orders"]; !exists {
+		t.Fatalf("moved table is missing: %+v", state.relationAt)
+	}
+	lines := state.relations[state.relationAt["sales.order_lines"]]
+	if fk := lines.table.Columns[1].FK; fk == nil || fk.Table != "archive.orders" {
+		t.Errorf("foreign key did not follow SET SCHEMA: %+v", fk)
+	}
+	if got := strings.Join(state.views[0].reads, ","); got != "archive.orders" {
+		t.Errorf("view lineage did not follow SET SCHEMA: %q", got)
+	}
+}
+
+func TestPostgresEnumsAreRenderedInColumnTypes(t *testing.T) {
+	state := newDDLState()
+	steps := []string{
+		`CREATE SCHEMA billing;
+         CREATE TYPE billing.payment_status AS ENUM ('pending', 'paid');
+         CREATE TABLE billing.payments (
+             id uuid PRIMARY KEY,
+             status billing.payment_status NOT NULL,
+             history billing.payment_status[] NOT NULL
+         );`,
+		`ALTER TYPE billing.payment_status ADD VALUE 'authorized' BEFORE 'paid';
+         ALTER TYPE billing.payment_status RENAME VALUE 'pending' TO 'created';`,
+		`ALTER TYPE billing.payment_status SET SCHEMA public;`,
+	}
+	for i, sql := range steps {
+		unread, err := state.apply(sql, fmt.Sprintf("%03d.sql", i+1))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(unread) != 0 {
+			t.Fatalf("migration %d left unread DDL: %v", i+1, unread)
+		}
+	}
+
+	table := state.relations[state.relationAt["billing.payments"]].table
+	got := map[string]string{}
+	for _, column := range table.Columns {
+		got[column.Name] = state.renderType(column.Type)
+	}
+	if got["status"] != "payment_status enum(created | authorized | paid)" {
+		t.Errorf("status type = %q", got["status"])
+	}
+	if got["history"] != "payment_status enum(created | authorized | paid)[]" {
+		t.Errorf("history type = %q", got["history"])
+	}
+}
+
+// A view is the other half of what a migration builds, and the half a table
+// cannot express: no key, no constraints, and what it reads instead.
+func TestReadsAViewAndWhereItsColumnsComeFrom(t *testing.T) {
+	sql := `
+CREATE TABLE payments (id text PRIMARY KEY, order_id text NOT NULL, amount_minor bigint NOT NULL);
+CREATE TABLE refunds (id text PRIMARY KEY, payment_id text NOT NULL, amount_minor bigint NOT NULL);
+CREATE VIEW v_payment_state AS
+SELECT p.id AS payment_id, p.order_id, coalesce(sum(r.amount_minor), 0) AS refunded_minor
+  FROM payments p
+  LEFT JOIN refunds r ON r.payment_id = p.id
+ GROUP BY p.id;
+`
+
+	_, views, unread, err := readDDL(sql, "test.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(unread) != 0 {
+		t.Fatalf("nothing should be left unread: %v", unread)
+	}
+	if len(views) != 1 {
+		t.Fatalf("want one view, got %d", len(views))
+	}
+
+	view := views[0]
+	if view.name != "v_payment_state" {
+		t.Errorf("name %q", view.name)
+	}
+	if strings.Join(view.reads, ",") != "payments,refunds" {
+		t.Errorf("reads %v", view.reads)
+	}
+
+	want := map[string]string{
+		"payment_id":     "payments.id",
+		"order_id":       "payments.order_id",
+		"refunded_minor": "refunds.amount_minor",
+	}
+	if len(view.columns) != len(want) {
+		t.Fatalf("columns %v", view.columns)
+	}
+	for _, column := range view.columns {
+		if strings.Join(column.from, ",") != want[column.name] {
+			t.Errorf("%s comes from %v, want %q", column.name, column.from, want[column.name])
+		}
+	}
+
+	// The definition is the SQL somebody wrote, not the tree printed back.
+	if !strings.HasPrefix(view.definition, "CREATE VIEW v_payment_state AS") || !strings.HasSuffix(view.definition, ";") {
+		t.Errorf("definition %q", view.definition)
+	}
+}
+
+// A column copied from another service's row is a fact the migration declares,
+// because the statement that creates the column cannot show it.
+func TestReadsWhereACopiedColumnCameFrom(t *testing.T) {
+	sql := `
+CREATE TABLE packages (
+    id       text NOT NULL PRIMARY KEY,
+    -- from: shop.oms.pg.orders.ship_to
+    ship_to  text NOT NULL,
+    -- from: packages.id
+    label_of text NOT NULL,
+    weight_g integer NOT NULL
+);
+`
+
+	copies := readCopies(sql, "delivery.core.pg")
+
+	if got := strings.Join(copies["packages"]["ship_to"], ","); got != "shop.oms.pg.orders.ship_to" {
+		t.Errorf("ship_to came from %q", got)
+	}
+	// A column of this store may be named without it.
+	if got := strings.Join(copies["packages"]["label_of"], ","); got != "delivery.core.pg.packages.id" {
+		t.Errorf("label_of came from %q", got)
+	}
+	if _, said := copies["packages"]["weight_g"]; said {
+		t.Error("a column with no comment above it says nothing")
+	}
+	if _, said := copies["packages"]["id"]; said {
+		t.Error("the comment belongs to the column under it, not the one before")
+	}
+}
+
+// The other spelling of a view: the grammar calls it a CREATE TABLE AS whose
+// object is a matview, and the difference a reader needs is that the rows are
+// kept and can be stale.
+func TestReadsAMaterializedView(t *testing.T) {
+	sql := `
+CREATE TABLE routes (id text PRIMARY KEY, planned_for date NOT NULL);
+CREATE TABLE route_stops (route_id text NOT NULL, seq integer NOT NULL);
+CREATE MATERIALIZED VIEW mv_route_load AS
+SELECT r.id AS route_id, count(s.seq) AS stops
+  FROM routes r LEFT JOIN route_stops s ON s.route_id = r.id
+ GROUP BY r.id;
+`
+
+	_, views, unread, err := readDDL(sql, "test.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(unread) != 0 {
+		t.Fatalf("nothing should be left unread: %v", unread)
+	}
+	if len(views) != 1 || !views[0].materialized {
+		t.Fatalf("views = %+v", views)
+	}
+	if strings.Join(views[0].reads, ",") != "routes,route_stops" {
+		t.Errorf("reads %v", views[0].reads)
+	}
+	if !strings.HasPrefix(views[0].definition, "CREATE MATERIALIZED VIEW mv_route_load AS") {
+		t.Errorf("definition %q", views[0].definition)
+	}
+}

package/plugins/extract-sql/describe.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	_ "embed"
+
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+//go:embed options.schema.json
+var optionsSchema []byte
+
+func descriptor() plugin.Descriptor {
+	return plugin.Descriptor{
+		Name:    "extract-sql",
+		Summary: "Reads a service's migrations and answers with the store it builds: tables, columns, keys, and which aggregate each table persists.",
+		Phases:  []string{plugin.PhaseExtract},
+		Options: optionsSchema,
+	}
+}

package/plugins/extract-sql/describe_test.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/shortlink-org/portolan/plugin/schematest"
+)
+
+func TestOptionsSchemaMatchesStruct(t *testing.T) {
+	schematest.Check(t, optionsSchema, Options{})
+}

package/plugins/extract-sql/layout.go

@@ -0,0 +1,221 @@
+package main
+
+import (
+	"io/fs"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+type storagePackage struct {
+	name       string
+	dir        string
+	migrations string
+}
+
+type storageLayout struct {
+	repositories []storagePackage
+	projectors   []storagePackage
+	source       string
+}
+
+// discoverStorageLayout keeps filesystem conventions in one place. Explicit
+// roots retain the original "one child package per aggregate" contract, while
+// omitted roots discover both horizontal and feature-sliced Go layouts.
+func discoverStorageLayout(root, repositories, projectors string) storageLayout {
+	var layout storageLayout
+
+	if repositories != "" {
+		layout.repositories = packagesUnder(root, repositories, "repository")
+	} else {
+		layout.repositories = discoverPackages(root, "repository")
+	}
+	if projectors != "" {
+		layout.projectors = packagesUnder(root, projectors, "projector")
+	} else {
+		layout.projectors = discoverPackages(root, "projector")
+	}
+
+	if repositories != "" {
+		layout.source = filepath.ToSlash(filepath.Join(root, filepath.FromSlash(repositories)))
+		return layout
+	}
+	if projectors != "" {
+		layout.source = filepath.ToSlash(filepath.Join(root, filepath.FromSlash(projectors)))
+		return layout
+	}
+
+	dirs := make([]string, 0, len(layout.repositories)+len(layout.projectors))
+	for _, pkg := range layout.repositories {
+		dirs = append(dirs, pkg.dir)
+	}
+	for _, pkg := range layout.projectors {
+		dirs = append(dirs, pkg.dir)
+	}
+	layout.source = storageSource(root, dirs)
+
+	return layout
+}
+
+func packagesUnder(root, base, kind string) []storagePackage {
+	base = filepath.ToSlash(filepath.Clean(base))
+	var out []storagePackage
+
+	// A feature slice points directly at its repository adapter, with
+	// migrations immediately below it.
+	if hasUpMigrations(root, path.Join(base, "migrations")) {
+		name := packageName(strings.Split(base, "/"), kind)
+		if name == "" {
+			name = path.Base(base)
+		}
+		return []storagePackage{{name: name, dir: base, migrations: path.Join(base, "migrations")}}
+	}
+
+	for _, child := range subdirs(root, base) {
+		dir := path.Join(base, child)
+		migrations := path.Join(dir, "migrations")
+		if hasUpMigrations(root, migrations) {
+			out = append(out, storagePackage{name: child, dir: dir, migrations: migrations})
+		}
+	}
+
+	sortStoragePackages(out)
+	return out
+}
+
+func discoverPackages(root, kind string) []storagePackage {
+	base := filepath.Join(root, "internal")
+	seen := map[string]bool{}
+	var out []storagePackage
+
+	_ = filepath.WalkDir(base, func(filename string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		if !entry.IsDir() {
+			return nil
+		}
+		if filename != base && strings.HasPrefix(entry.Name(), ".") {
+			return filepath.SkipDir
+		}
+		if entry.Name() != "migrations" {
+			return nil
+		}
+
+		rel, err := filepath.Rel(root, filename)
+		if err != nil {
+			return filepath.SkipDir
+		}
+		migrations := filepath.ToSlash(rel)
+		if !hasUpMigrations(root, migrations) {
+			return filepath.SkipDir
+		}
+		dir := path.Dir(migrations)
+		parts := strings.Split(dir, "/")
+		name := packageName(parts, kind)
+		if name == "" || seen[dir] {
+			return filepath.SkipDir
+		}
+		seen[dir] = true
+		out = append(out, storagePackage{name: name, dir: dir, migrations: migrations})
+
+		return filepath.SkipDir
+	})
+
+	sortStoragePackages(out)
+	return out
+}
+
+// packageName accepts these shapes and ignores migrations belonging to the
+// other adapter kind:
+//
+//	internal/infrastructure/repository/user
+//	internal/user/infrastructure/repository
+//	internal/user/infrastructure/projector/directory
+func packageName(parts []string, kind string) string {
+	for i, part := range parts {
+		if part != kind {
+			continue
+		}
+		if i+1 < len(parts) {
+			return parts[i+1]
+		}
+		if i >= 2 && parts[i-1] == "infrastructure" {
+			return parts[i-2]
+		}
+	}
+	return ""
+}
+
+func hasUpMigrations(root, dir string) bool {
+	entries, err := os.ReadDir(filepath.Join(root, filepath.FromSlash(dir)))
+	if err != nil {
+		return false
+	}
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".sql") && !strings.HasSuffix(entry.Name(), ".down.sql") {
+			return true
+		}
+	}
+	return false
+}
+
+func sortStoragePackages(packages []storagePackage) {
+	sort.Slice(packages, func(i, j int) bool {
+		if packages[i].name != packages[j].name {
+			return packages[i].name < packages[j].name
+		}
+		return packages[i].dir < packages[j].dir
+	})
+}
+
+func storageSource(root string, dirs []string) string {
+	if len(dirs) == 0 {
+		return ""
+	}
+	sort.Strings(dirs)
+	if len(dirs) == 1 {
+		return filepath.ToSlash(filepath.Join(root, filepath.FromSlash(dirs[0])))
+	}
+
+	parent := path.Dir(dirs[0])
+	sameParent := true
+	for _, dir := range dirs[1:] {
+		if path.Dir(dir) != parent {
+			sameParent = false
+			break
+		}
+	}
+	if sameParent {
+		return filepath.ToSlash(filepath.Join(root, filepath.FromSlash(parent)))
+	}
+
+	parts := strings.Split(dirs[0], "/")
+	for _, dir := range dirs[1:] {
+		other := strings.Split(dir, "/")
+		if len(other) != len(parts) {
+			return filepath.ToSlash(filepath.Join(root, "internal"))
+		}
+		for i := range parts {
+			if parts[i] != other[i] {
+				parts[i] = "*"
+			}
+		}
+	}
+
+	return filepath.ToSlash(filepath.Join(root, filepath.FromSlash(strings.Join(parts, "/"))))
+}
+
+// mapSourceDir accepts both supported repository shapes: a collection root
+// with one child package per aggregate, and a feature repository package that
+// is already the aggregate's source directory.
+func mapSourceDir(root, repositoryDir, aggregate string) string {
+	child := path.Join(repositoryDir, aggregate)
+	if info, err := os.Stat(filepath.Join(root, filepath.FromSlash(child))); err == nil && info.IsDir() {
+		return child
+	}
+
+	return repositoryDir
+}

package/plugins/extract-sql/layout_test.go

@@ -0,0 +1,55 @@
+package main
+
+import "testing"
+
+func TestDiscoversHorizontalAndFeatureStoragePackages(t *testing.T) {
+	root := writeTree(t, map[string]string{
+		"internal/infrastructure/repository/quote/migrations/0001_quote.sql":           `CREATE TABLE quotes (id text PRIMARY KEY);`,
+		"internal/user/infrastructure/repository/migrations/0001_user.sql":             `CREATE TABLE users (id text PRIMARY KEY);`,
+		"internal/search/infrastructure/projector/results/migrations/0001_results.sql": `CREATE TABLE results (id text PRIMARY KEY);`,
+	})
+
+	layout := discoverStorageLayout(root, "", "")
+	if len(layout.repositories) != 2 {
+		t.Fatalf("repositories = %+v", layout.repositories)
+	}
+	if layout.repositories[0].name != "quote" || layout.repositories[0].dir != "internal/infrastructure/repository/quote" {
+		t.Errorf("horizontal repository = %+v", layout.repositories[0])
+	}
+	if layout.repositories[1].name != "user" || layout.repositories[1].dir != "internal/user/infrastructure/repository" {
+		t.Errorf("feature repository = %+v", layout.repositories[1])
+	}
+	if len(layout.projectors) != 1 || layout.projectors[0].name != "results" {
+		t.Errorf("projectors = %+v", layout.projectors)
+	}
+}
+
+func TestFeatureRepositoriesProduceAStableSourcePattern(t *testing.T) {
+	root := writeTree(t, map[string]string{
+		"internal/user/infrastructure/repository/migrations/0001_user.sql":       `CREATE TABLE users (id text PRIMARY KEY);`,
+		"internal/session/infrastructure/repository/migrations/0001_session.sql": `CREATE TABLE sessions (id text PRIMARY KEY);`,
+	})
+
+	layout := discoverStorageLayout(root, "", "")
+	want := root + "/internal/*/infrastructure/repository"
+	if layout.source != want {
+		t.Errorf("source = %q, want %q", layout.source, want)
+	}
+}
+
+func TestExplicitRootAcceptsCollectionAndFeaturePackage(t *testing.T) {
+	root := writeTree(t, map[string]string{
+		"src/infrastructure/repository/order/migrations/0001_order.sql":    `CREATE TABLE orders (id text PRIMARY KEY);`,
+		"internal/user/infrastructure/repository/migrations/0001_user.sql": `CREATE TABLE users (id text PRIMARY KEY);`,
+	})
+
+	collection := discoverStorageLayout(root, "src/infrastructure/repository", "missing")
+	if len(collection.repositories) != 1 || collection.repositories[0].name != "order" {
+		t.Errorf("collection = %+v", collection.repositories)
+	}
+
+	feature := discoverStorageLayout(root, "internal/user/infrastructure/repository", "missing")
+	if len(feature.repositories) != 1 || feature.repositories[0].name != "user" {
+		t.Errorf("feature = %+v", feature.repositories)
+	}
+}