dbtour 0.6.0 → 0.7.0

package/dist/cli.js

@@ -14,7 +14,7 @@ import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
 import { configFile, defaultConfigText, modelFile, parseConfig, resolveConnection } from "./config.js";
-import { emptyModel, validate } from "./model.js";
+import { emptyModel, scope, validate } from "./model.js";
 import { applyNotes, parseNotes } from "./notes.js";
 import { answerLine } from "./mcp.js";
 import { loadAddon, loadSource } from "./plugins.js";
@@ -119,7 +119,10 @@ async function extract(io) {
 function importer(cwd) {
     return (specifier) => import(__rewriteRelativeImportExtension(specifier.startsWith('.') || specifier.startsWith('/') ? pathToFileURL(resolve(cwd, specifier)).href : specifier));
 }
-/** <out>/schema.json with the notes merged in, as render and mcp read it. */
+/**
+ * <out>/schema.json with the notes merged in, as render and mcp read it: scoped first, so with several
+ * databases the notes may name a table with its database or, where only one has it, without.
+ */
 function readModel(io, config) {
     const modelPath = join(io.cwd, config.out, modelFile);
     if (!existsSync(modelPath))
@@ -127,10 +130,11 @@ function readModel(io, config) {
     const checked = validate(JSON.parse(readFileSync(modelPath, 'utf8')));
     if (!checked.ok)
         throw new Error(`${join(config.out, modelFile)} is not a model:\n  ${checked.errors.join('\n  ')}`);
+    const model = scope(checked.model);
     const notesPath = join(io.cwd, config.notes);
     if (!existsSync(notesPath))
-        return checked.model;
-    const applied = applyNotes(checked.model, parseNotes(readFileSync(notesPath, 'utf8')));
+        return model;
+    const applied = applyNotes(model, parseNotes(readFileSync(notesPath, 'utf8')));
     for (const warning of applied.warnings)
         io.error(warning);
     return applied.model;

package/dist/mcp.js

@@ -2,7 +2,7 @@
 // table, read it, join two) instead of being handed all of it. JSON-RPC, one message per line; written here
 // rather than taken from the SDK, since four methods are all it needs and core keeps its one dependency.
 // Read-only and structure only, like the model: there are no rows to give.
-import { findTable, tableRef } from "./model.js";
+import { findTables, localRef, tableRef } from "./model.js";
 import { driverName, formatCount, renderTableMarkdown } from "./render/markdown.js";
 import { buildIndex, search } from "./search.js";
 // The versions this server speaks, newest first. It uses only initialize, ping, tools/list and tools/call,
@@ -14,7 +14,7 @@ export const overviewLimit = 100;
 // Enough hits to choose from without reading past the good ones; the agent can ask for up to the maximum.
 const searchDefault = 20;
 const searchMaximum = 100;
-const instructions = `dbtour knows the structure of this project's databases: tables, views, columns, keys, relations, indexes and the descriptions people wrote. It never holds rows. Start with overview for the databases and their largest tables; search finds a table or column by any part of its name or description; table gives one table's columns, keys and relations as Markdown; path gives the joins between two tables. Name tables as schema.table, and read a table before writing SQL against it.`;
+const instructions = `dbtour knows the structure of this project's databases: tables, views, columns, keys, relations, indexes and the descriptions people wrote. It never holds rows. Start with overview for the databases and their largest tables; search finds a table or column by any part of its name or description; table gives one table's columns, keys and relations as Markdown; path gives the joins between two tables. Name tables as overview and search do (schema.table, or Database:schema.table when there are several databases), and read a table before writing SQL against it.`;
 const readOnly = { readOnlyHint: true, openWorldHint: false };
 export const toolList = [
     {
@@ -44,7 +44,7 @@ export const toolList = [
         description: 'One table or view as Markdown: its columns with types, keys and descriptions, the relations both ways, indexes, constraints, a view\'s SQL and a diagram of its neighbours. Read it before writing SQL against the table.',
         inputSchema: {
             type: 'object',
-            properties: { ref: { type: 'string', description: 'schema.table, like dbo.Orders. A bare name works when only one schema has it.' } },
+            properties: { ref: { type: 'string', description: 'schema.table, like dbo.Orders, or Sales:dbo.Orders with several databases. A shorter name works when only one table has it.' } },
             required: ['ref'],
         },
         annotations: readOnly,
@@ -56,8 +56,8 @@ export const toolList = [
         inputSchema: {
             type: 'object',
             properties: {
-                from: { type: 'string', description: 'The table to start from, schema.table.' },
-                to: { type: 'string', description: 'The table to reach, schema.table.' },
+                from: { type: 'string', description: 'The table to start from, named as table takes it.' },
+                to: { type: 'string', description: 'The table to reach, named as table takes it.' },
             },
             required: ['from', 'to'],
         },
@@ -226,20 +226,34 @@ function searchText(model, query, limit) {
         return `Nothing matches "${query}". Every word must match: try fewer words, or part of a name.`;
     return hits.map((h) => `- ${h.kind} ${h.title}: ${h.detail}`).join('\n');
 }
-/** What an agent wrote, as the table it means: exact, then ignoring case, then a bare name in one schema. */
+/**
+ * What an agent wrote, as the table it means: exact, then ignoring case, as the whole name, the name without
+ * its database, or a bare table name. A name several tables answer to is a problem that lists them.
+ */
 function resolve(model, written) {
     const parts = written.trim().split('.');
     // schema.table.column is the table; a bare name is looked up by name alone.
     const wanted = parts.length === 3 ? parts.slice(0, 2).join('.') : parts.join('.');
-    if (parts.length >= 2 && parts.length <= 3 && !parts.includes('') && findTable(model, wanted))
-        return { ref: wanted };
-    const all = model.databases.flatMap((d) => d.schemas.flatMap((s) => s.tables.map((t) => tableRef(s.name, t.name))));
+    const several = (refs) => ({ problem: `${refs.slice(0, -1).join(', ')} and ${refs.at(-1)} are ${refs.length === 2 ? 'both' : 'all'} called ${wanted}: ask for one by the name given here.` });
+    if (parts.length >= 2 && parts.length <= 3 && !parts.includes('')) {
+        const exact = findTables(model, wanted).map((f) => f.ref);
+        if (exact.length === 1)
+            return { ref: exact[0] };
+        if (exact.length > 1)
+            return several(exact);
+    }
+    const all = [...new Set(model.databases.flatMap((d) => d.schemas.flatMap((s) => s.tables.map((t) => tableRef(s.name, t.name)))))];
     const lower = wanted.toLowerCase();
-    const matches = [...new Set(all)].filter((ref) => ref.toLowerCase() === lower || (!lower.includes('.') && ref.slice(ref.indexOf('.') + 1).toLowerCase() === lower));
+    // The whole name, the name an agent writes when it does not know there are several databases, the table's.
+    const forms = (ref) => {
+        const local = localRef(model, ref);
+        return [ref, local, local.slice(local.indexOf('.') + 1)];
+    };
+    const matches = all.filter((ref) => forms(ref).some((form) => form.toLowerCase() === lower));
     if (matches.length === 1)
         return { ref: matches[0] };
     if (matches.length > 1)
-        return { problem: `${matches.slice(0, -1).join(', ')} and ${matches.at(-1)} are ${matches.length === 2 ? 'both' : 'all'} called ${wanted}: ask for one as schema.table.` };
+        return several(matches);
     const name = wanted.slice(wanted.lastIndexOf('.') + 1);
     const near = [...new Set(hitsFor(model, name, searchDefault).filter((h) => h.kind === 'table' || h.kind === 'view').map((h) => h.ref))].slice(0, 5);
     return { problem: `"${written}" is not a table. ${near.length > 0 ? `Did you mean ${near.join(', ')}?` : 'overview lists them, and search finds one by any part of its name.'}` };
@@ -258,9 +272,11 @@ function quote(driver, name) {
         return `\`${name.replace(/`/g, '``')}\``;
     return `"${name.replace(/"/g, '""')}"`;
 }
-function quoteRef(driver, ref, column) {
-    const dot = ref.indexOf('.');
-    const names = [ref.slice(0, dot), ref.slice(dot + 1), ...(column === undefined ? [] : [column])];
+/** schema.table as its database names it, quoted: the SQL runs in the database the path was found in. */
+function quoteRef(model, driver, ref, column) {
+    const local = localRef(model, ref);
+    const dot = local.indexOf('.');
+    const names = [local.slice(0, dot), local.slice(dot + 1), ...(column === undefined ? [] : [column])];
     return names.map((name) => quote(driver, name)).join('.');
 }
 function pathText(model, from, to) {
@@ -283,13 +299,13 @@ function pathText(model, from, to) {
         return `No relation connects ${from} and ${to}, declared or in the notes. If they are related all the same, add the relation to dbtour.notes.yaml so the docs and this path know it.`;
     }
     const { driver } = best.database;
-    const lines = [`FROM ${quoteRef(driver, from)}`];
+    const lines = [`FROM ${quoteRef(model, driver, from)}`];
     let at = from;
     for (const step of best.steps) {
         const mine = step.forward ? step.relation.to.columns : step.relation.from.columns;
         const theirs = step.forward ? step.relation.from.columns : step.relation.to.columns;
-        const on = mine.map((column, i) => `${quoteRef(driver, step.table, column)} = ${quoteRef(driver, at, theirs[i] ?? theirs[0])}`).join(' AND ');
-        lines.push(`JOIN ${quoteRef(driver, step.table)} ON ${on}${step.relation.virtual ? ' -- from the notes, not a declared key' : ''}`);
+        const on = mine.map((column, i) => `${quoteRef(model, driver, step.table, column)} = ${quoteRef(model, driver, at, theirs[i] ?? theirs[0])}`).join(' AND ');
+        lines.push(`JOIN ${quoteRef(model, driver, step.table)} ON ${on}${step.relation.virtual ? ' -- from the notes, not a declared key' : ''}`);
         at = step.table;
     }
     const where = model.databases.length > 1 ? `In ${best.database.name}, ` : '';

package/dist/model.d.ts

@@ -201,11 +201,35 @@ export interface TableRef {
 }
 export declare function tableRef(schema: string, table: string): string;
 export declare function parseRef(ref: string): TableRef;
+/** Between a database and its schema in a ref: not a dot, which already parts schema, table and column. */
+export declare const databaseSeparator = ":";
+/**
+ * The model as everything reads it. Refs carry no database, so two databases with a dbo.Customers would
+ * share one name; with several databases, each schema is named `Database:schema` and every relation, group
+ * and link, and every history table, names its tables that way. Whatever builds a ref from a schema and a table then builds a name
+ * that is unique, and one database keeps the names it has always had. A group or link naming a table in
+ * both databases is left for the notes to report. It runs once, as the model is read: a schema a source
+ * itself named Sales:dbo becomes Sales:Sales:dbo, apart from its dbo, so nothing is taken as scoped already.
+ */
+export declare function scope(model: Model): Model;
+/**
+ * A ref as its own database names it, for SQL that runs there: Sales:dbo.Orders is dbo.Orders. Only a
+ * scoped model's database is taken off, so with one database a colon in a name stays part of it.
+ */
+export declare function localRef(model: Model, ref: string): string;
 export interface Found {
     database: Database;
     schema: Schema;
     table: Table;
+    /** The table's name as the model writes it, with its database when the model is scoped. */
+    ref: string;
 }
+/**
+ * Every table a ref can mean. One written with its database, or in a model of one database, means at most
+ * one; `dbo.Customers` in a scoped model means each database's dbo.Customers.
+ */
+export declare function findTables(model: Model, ref: string): Found[];
+/** The one table a ref means; nothing when it means none, or several. */
 export declare function findTable(model: Model, ref: string): Found | undefined;
 /** Unique on its own, by a constraint or an index, and not the primary key, which says so already. */
 export declare function isUniqueColumn(table: Table, column: string): boolean;

package/dist/model.js

@@ -1,6 +1,7 @@
 // The model: what every source writes and everything else reads. Kept to plain JSON so it can be committed,
 // diffed and handed to a page or an agent. Refs name tables as `schema.table` and columns as
-// `schema.table.column`.
+// `schema.table.column`; read through scope(), a model with several databases names them
+// `Database:schema.table`.
 export const MODEL_VERSION = 1;
 export function emptyModel() {
     return { dbtour: MODEL_VERSION, databases: [], apis: [], links: [], groups: [] };
@@ -16,18 +17,77 @@ export function parseRef(ref) {
     const [schema, table, column] = parts;
     return column === undefined ? { schema, table } : { schema, table, column };
 }
-export function findTable(model, ref) {
-    const { schema: schemaName, table: tableName } = parseRef(ref);
-    for (const database of model.databases) {
+/** Between a database and its schema in a ref: not a dot, which already parts schema, table and column. */
+export const databaseSeparator = ':';
+/**
+ * The model as everything reads it. Refs carry no database, so two databases with a dbo.Customers would
+ * share one name; with several databases, each schema is named `Database:schema` and every relation, group
+ * and link, and every history table, names its tables that way. Whatever builds a ref from a schema and a table then builds a name
+ * that is unique, and one database keeps the names it has always had. A group or link naming a table in
+ * both databases is left for the notes to report. It runs once, as the model is read: a schema a source
+ * itself named Sales:dbo becomes Sales:Sales:dbo, apart from its dbo, so nothing is taken as scoped already.
+ */
+export function scope(model) {
+    if (model.databases.length < 2)
+        return model;
+    const scoped = structuredClone(model);
+    for (const database of scoped.databases) {
+        const prefix = database.name + databaseSeparator;
         for (const schema of database.schemas) {
-            if (schema.name !== schemaName)
-                continue;
-            const table = schema.tables.find((t) => t.name === tableName);
-            if (table)
-                return { database, schema, table };
+            schema.name = prefix + schema.name;
+            for (const table of schema.tables) {
+                if (table.temporal)
+                    table.temporal.history = prefix + table.temporal.history;
+                if (table.historyOf)
+                    table.historyOf = prefix + table.historyOf;
+            }
         }
+        for (const relation of database.relations)
+            for (const end of [relation.from, relation.to])
+                end.table = prefix + end.table;
     }
-    return undefined;
+    const qualify = (ref) => findTable(scoped, ref)?.ref ?? ref;
+    for (const group of scoped.groups)
+        group.tables = group.tables.map(qualify);
+    for (const link of scoped.links)
+        link.tables = link.tables.map(qualify);
+    return scoped;
+}
+/**
+ * A ref as its own database names it, for SQL that runs there: Sales:dbo.Orders is dbo.Orders. Only a
+ * scoped model's database is taken off, so with one database a colon in a name stays part of it.
+ */
+export function localRef(model, ref) {
+    if (model.databases.length < 2)
+        return ref;
+    const database = model.databases.find((d) => ref.startsWith(d.name + databaseSeparator));
+    return database ? ref.slice(database.name.length + databaseSeparator.length) : ref;
+}
+/**
+ * Every table a ref can mean. One written with its database, or in a model of one database, means at most
+ * one; `dbo.Customers` in a scoped model means each database's dbo.Customers.
+ */
+export function findTables(model, ref) {
+    const { schema: schemaName, table: tableName } = parseRef(ref);
+    const found = [];
+    for (const exact of [true, false]) {
+        for (const database of model.databases) {
+            for (const schema of database.schemas) {
+                const named = exact ? schema.name === schemaName : schema.name === database.name + databaseSeparator + schemaName;
+                const table = named ? schema.tables.find((t) => t.name === tableName) : undefined;
+                if (table)
+                    found.push({ database, schema, table, ref: tableRef(schema.name, table.name) });
+            }
+        }
+        if (found.length > 0)
+            break;
+    }
+    return found;
+}
+/** The one table a ref means; nothing when it means none, or several. */
+export function findTable(model, ref) {
+    const found = findTables(model, ref);
+    return found.length === 1 ? found[0] : undefined;
 }
 /** Unique on its own, by a constraint or an index, and not the primary key, which says so already. */
 export function isUniqueColumn(table, column) {
@@ -94,6 +154,18 @@ export function validate(value) {
     if (errors.length > 0)
         return { ok: false, errors };
     const typed = value;
+    // Several databases are told apart by name in their refs (see scope), so each needs one of its own that a
+    // ref can carry.
+    if (typed.databases.length > 1) {
+        const seen = new Set();
+        for (const { name } of typed.databases) {
+            if (seen.has(name))
+                errors.push(`two databases are named ${name}: give each source its own name in dbtour.yaml`);
+            seen.add(name);
+            if (/[.:/\\]/.test(name))
+                errors.push(`the database name ${name} has a dot, a colon or a slash, which a ref or a file name would read as a separator: give its source another name in dbtour.yaml`);
+        }
+    }
     typed.databases.forEach((database, i) => {
         const refs = new Set(database.schemas.flatMap((s) => s.tables.map((t) => tableRef(s.name, t.name))));
         database.relations.forEach((relation, j) => {

package/dist/notes.js

@@ -1,7 +1,7 @@
 // The notes file: what people add that the database cannot say. Merged into the model at render time and
 // winning over it, so a production database nobody may alter still gets documented.
 import { parse } from 'yaml';
-import { findTable, parseRef, tableRef } from "./model.js";
+import { findTables, parseRef } from "./model.js";
 export function parseNotes(text) {
     const raw = parse(text) ?? {};
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
@@ -64,12 +64,21 @@ export function parseNotes(text) {
 export function applyNotes(input, notes) {
     const model = structuredClone(input);
     const warnings = [];
+    // The one table a name in the notes means, or a warning: a name two databases share wants its database.
+    const find = (ref, what) => {
+        const found = findTables(model, ref);
+        if (found.length === 1)
+            return found[0];
+        if (found.length === 0)
+            warnings.push(`notes: ${what}`);
+        else
+            warnings.push(`notes: ${parseRef(ref).schema}.${parseRef(ref).table} is in ${found.map((f) => f.database.name).join(' and ')}: write ${found.map((f) => f.ref).join(' or ')}`);
+        return undefined;
+    };
     for (const [ref, tableNotes] of Object.entries(notes.tables)) {
-        const found = findTable(model, ref);
-        if (!found) {
-            warnings.push(`notes: ${ref} is not a table in the model`);
+        const found = find(ref, `${ref} is not a table in the model`);
+        if (!found)
             continue;
-        }
         if (tableNotes.description !== undefined)
             found.table.description = tableNotes.description;
         for (const [name, description] of Object.entries(tableNotes.columns ?? {})) {
@@ -82,30 +91,26 @@ export function applyNotes(input, notes) {
         }
     }
     for (const note of notes.relations) {
-        const from = parseRef(note.from);
-        const to = parseRef(note.to);
+        const missing = `relation ${note.from} → ${note.to} names a table that is not in the model`;
+        const fromTable = find(note.from, missing);
+        const toTable = fromTable && find(note.to, missing);
+        if (!fromTable || !toTable)
+            continue;
+        if (fromTable.database !== toTable.database) {
+            warnings.push(`notes: relation ${note.from} → ${note.to} joins ${fromTable.database.name} to ${toTable.database.name}: relations stay inside one database`);
+            continue;
+        }
         const relation = {
-            from: { table: tableRef(from.schema, from.table), columns: [from.column] },
-            to: { table: tableRef(to.schema, to.table), columns: [to.column] },
+            from: { table: fromTable.ref, columns: [parseRef(note.from).column] },
+            to: { table: toTable.ref, columns: [parseRef(note.to).column] },
             virtual: true,
         };
-        const fromTable = findTable(model, relation.from.table);
-        const toTable = findTable(model, relation.to.table);
-        if (!fromTable || !toTable) {
-            warnings.push(`notes: relation ${note.from} → ${note.to} names a table that is not in the model`);
-            continue;
-        }
         const exists = fromTable.database.relations.some((r) => sameEnd(r.from, relation.from) && sameEnd(r.to, relation.to));
         if (!exists)
             fromTable.database.relations.push(relation);
     }
     for (const group of notes.groups) {
-        const tables = group.tables.filter((ref) => {
-            if (findTable(model, ref))
-                return true;
-            warnings.push(`notes: group ${group.name} lists ${ref}, which is not a table in the model`);
-            return false;
-        });
+        const tables = group.tables.flatMap((ref) => find(ref, `group ${group.name} lists ${ref}, which is not a table in the model`)?.ref ?? []);
         model.groups.push({ ...group, tables });
     }
     return { model, warnings };

package/dist/render/markdown.d.ts

@@ -18,6 +18,8 @@ export declare function formatCount(n: number): string;
 export declare function formatBytes(bytes: number): string;
 /** The sentence under a table's title: the count is the database's estimate, so it says about, and when. */
 export declare function statsLine(stats: TableStats, readAt?: string): string;
+/** A table's page under tables/: Sales:dbo.Orders is in a folder for its database, dbo.Orders is not. */
+export declare function tableFile(ref: string): string;
 /** One table's page on its own: what the page hands to an agent. */
 export declare function renderTableMarkdown(model: Model, ref: string): string;
 export { findTable };

package/dist/render/markdown.js

@@ -1,6 +1,6 @@
 // Markdown GitHub shows: an index with every table, and one page per table with its columns, keys,
 // relations both ways, indexes, constraints and the diagram of its neighbourhood.
-import { findTable, isUniqueColumn, relationsOf, tableRef } from "../model.js";
+import { databaseSeparator, findTable, isUniqueColumn, relationsOf, tableRef } from "../model.js";
 import { erDiagram, neighbourhood } from "./mermaid.js";
 // Mermaid lays out a whole database only while it is small; above this many tables the index shows the
 // groups and each table page shows its own neighbourhood instead.
@@ -11,7 +11,7 @@ export function renderMarkdown(model) {
         for (const schema of database.schemas) {
             for (const table of schema.tables) {
                 const ref = tableRef(schema.name, table.name);
-                files[`tables/${ref}.md`] = renderTable(model, ref, table, database);
+                files[`tables/${tableFile(ref)}`] = renderTable(model, ref, table, database);
             }
         }
     }
@@ -36,7 +36,7 @@ function renderIndex(model) {
             for (const table of schema.tables) {
                 const ref = tableRef(schema.name, table.name);
                 const size = !sized ? '' : table.stats ? ` ${formatCount(table.stats.rows)} | ${formatBytes(table.stats.dataBytes + table.stats.indexBytes)} |` : '  |  |';
-                parts.push(`| [${ref}](tables/${ref}.md) | ${table.kind} | ${table.columns.length} |${size} ${cell(table.description)} |`);
+                parts.push(`| [${ref}](${href(`tables/${tableFile(ref)}`)}) | ${table.kind} | ${table.columns.length} |${size} ${cell(table.description)} |`);
             }
         }
         parts.push('');
@@ -49,7 +49,7 @@ function renderIndex(model) {
         parts.push(`## ${group.name}\n`);
         if (group.description)
             parts.push(`${group.description}\n`);
-        parts.push(group.tables.map((ref) => `- [${ref}](tables/${ref}.md)`).join('\n') + '\n');
+        parts.push(group.tables.map((ref) => `- [${ref}](${href(`tables/${tableFile(ref)}`)})`).join('\n') + '\n');
         parts.push(mermaid(erDiagram(model, group.tables)));
     }
     const refs = model.databases.flatMap((d) => d.schemas.flatMap((s) => s.tables.map((t) => tableRef(s.name, t.name))));
@@ -166,12 +166,28 @@ export function statsLine(stats, readAt) {
     const when = readAt ? `, as the database counted them on ${readAt.slice(0, 10)}` : '';
     return `About ${formatCount(stats.rows)} rows · ${formatBytes(stats.dataBytes)} of data · ${formatBytes(stats.indexBytes)} of indexes${when}.`;
 }
+/** A table's page under tables/: Sales:dbo.Orders is in a folder for its database, dbo.Orders is not. */
+export function tableFile(ref) {
+    return ref.replace(databaseSeparator, '/') + '.md';
+}
+/** A link from one table's page to another's: the file beside it, or up and across to another folder. */
+function pageLink(from, to) {
+    const folder = (ref) => (ref.includes(databaseSeparator) ? ref.slice(0, ref.indexOf(databaseSeparator)) : '');
+    const file = tableFile(to);
+    if (folder(from) === folder(to))
+        return href(file.slice(file.indexOf('/') + 1));
+    return href((folder(from) ? '../' : '') + file);
+}
+/** A path as a link's destination: each part encoded, so a space or a # in a name still reaches its file. */
+function href(path) {
+    return path.split('/').map((part) => (part === '..' ? part : encodeURIComponent(part))).join('/');
+}
 /** One table's page on its own: what the page hands to an agent. */
 export function renderTableMarkdown(model, ref) {
     const found = findTable(model, ref);
     if (!found)
         throw new Error(`${ref} is not a table in the model`);
-    return renderTable(model, ref, found.table, found.database);
+    return renderTable(model, found.ref, found.table, found.database);
 }
 function renderTable(model, ref, table, database) {
     const parts = [`# ${ref}\n`];
@@ -183,7 +199,7 @@ function renderTable(model, ref, table, database) {
     if (listed.length > 0) {
         parts.push('## Features\n');
         // A table the feature names gets a link when it is in the model, as a relation's would.
-        const linked = (f) => (f.ref && f.detail && findTable(model, f.ref) ? f.detail.replace(f.ref, `[${f.ref}](${f.ref}.md)`) : f.detail);
+        const linked = (f) => (f.ref && f.detail && findTable(model, f.ref) ? f.detail.replace(f.ref, `[${f.ref}](${pageLink(ref, f.ref)})`) : f.detail);
         parts.push(listed.map((f) => `- **${f.name}**${f.detail ? `: ${linked(f)}` : ''}`).join('\n') + '\n');
     }
     const relations = relationsOf(model, ref);
@@ -198,7 +214,7 @@ function renderTable(model, ref, table, database) {
                 continue;
             const { table: toTable, columns } = relation.to;
             const state = [relation.virtual ? 'notes' : '', ...enforcement(relation)].filter(Boolean);
-            keys.push(`FK → [${toTable}](${toTable}.md).${columns[i] ?? columns.join(',')}${state.length ? ` (${state.join(', ')})` : ''}`);
+            keys.push(`FK → [${toTable}](${pageLink(ref, toTable)}).${columns[i] ?? columns.join(',')}${state.length ? ` (${state.join(', ')})` : ''}`);
         }
         if (isUniqueColumn(table, column.name))
             keys.push('unique');
@@ -210,7 +226,7 @@ function renderTable(model, ref, table, database) {
     if (relations.in.length > 0) {
         parts.push('## Referenced by\n');
         const lines = relations.in
-            .map((r) => `- [${r.from.table}](${r.from.table}.md).${r.from.columns.join(', ')}${r.virtual ? ' (notes)' : ''}`)
+            .map((r) => `- [${r.from.table}](${pageLink(ref, r.from.table)}).${r.from.columns.join(', ')}${r.virtual ? ' (notes)' : ''}`)
             .sort();
         parts.push(lines.join('\n') + '\n');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbtour",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Tour your database and its API: searchable docs, relations and diagrams, generated from the schema, kept in the repo.",
   "type": "module",
   "license": "MIT",