turbine-orm 0.48.0 → 0.49.0

package/dist/cjs/cli/studio.js

@@ -45,6 +45,7 @@ exports.PII_REDACTED = void 0;
 exports.startStudio = startStudio;
 exports.handleRequest = handleRequest;
 exports.apiDemoMode = apiDemoMode;
+exports.relationLinksForTable = relationLinksForTable;
 exports.apiTableRows = apiTableRows;
 exports.resolveColumnName = resolveColumnName;
 exports.isTextishType = isTextishType;
@@ -61,8 +62,10 @@ const node_http_1 = require("node:http");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const pg_1 = __importDefault(require("pg"));
+const errors_js_1 = require("../errors.js");
 const introspect_js_1 = require("../introspect.js");
 const index_js_1 = require("../query/index.js");
+const pii_tags_js_1 = require("./pii-tags.js");
 const studio_demo_js_1 = require("./studio-demo.js");
 const studio_ui_generated_js_1 = require("./studio-ui.generated.js");
 // ---------------------------------------------------------------------------
@@ -83,6 +86,7 @@ async function startStudio(options) {
     let metadata;
     let dialect;
     let statementTimeout;
+    let piiTags = null;
     if (demo) {
         // Seeded in-memory SQLite store: no DATABASE_URL, no network. Each launch
         // starts pristine and nothing is ever persisted.
@@ -116,6 +120,14 @@ async function startStudio(options) {
             include: options.include,
             exclude: options.exclude,
         });
+        // PII tags are code-first only, so a live-introspected schema carries none.
+        // Layer them on from the generated metadata when there is one, and record
+        // what happened so the CLI can be explicit about it at startup.
+        if (options.metadataDir) {
+            const source = (0, pii_tags_js_1.loadPiiTags)(options.metadataDir);
+            if (source)
+                piiTags = { path: source.path, applied: (0, pii_tags_js_1.applyPiiTags)(metadata, source.tags) };
+        }
         statementTimeout = options.adapter?.statementTimeout?.(30) ?? {
             // Postgres rejects parameters in `SET LOCAL` (`SET LOCAL ... = $1` is a
             // syntax error). `set_config(name, value, is_local=true)` is the
@@ -165,6 +177,7 @@ async function startStudio(options) {
     return {
         authToken,
         url,
+        piiTags,
         dispose: async () => {
             await new Promise((resolve) => server.close(() => resolve()));
             await pool.end();
@@ -386,6 +399,8 @@ async function apiSchema(res, ctx) {
             foreignKey: rel.foreignKey,
             referenceKey: rel.referenceKey,
         })),
+        // Click-through navigation targets, derived from relation metadata only.
+        ...relationLinksForTable(tbl, ctx.metadata, ctx.showPii === true),
     }));
     // Row counts (cheap enough to fetch inline).
     const counts = new Map();
@@ -422,6 +437,91 @@ async function apiSchema(res, ctx) {
         demo: ctx.demo === true,
     });
 }
+/** Own-property lookup: a key like `constructor` must not resolve off the prototype. */
+function ownLookup(map, key) {
+    return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+/** True when `columnName` on `table` is PII-tagged and currently redacted. */
+function isRedactedColumn(table, columnName, showPii) {
+    if (showPii)
+        return false;
+    const col = table.columns.find((c) => c.name === columnName);
+    return col?.pii === true;
+}
+/**
+ * Resolve a relation key to a single column name on `table`, or `null`. Composite
+ * (array) keys return null: a composite reference has no single cell to click, so
+ * those relations simply produce no link rather than a half-working one.
+ */
+function singleRelationColumn(table, key) {
+    if (typeof key !== 'string')
+        return null;
+    return resolveColumnName(table, key);
+}
+function relationLinksForTable(table, metadata, showPii) {
+    const foreignKeys = [];
+    const referencedBy = [];
+    const seenFkColumns = new Set();
+    for (const [name, rel] of Object.entries(table.relations)) {
+        const target = metadata.tables[rel.to];
+        if (!target)
+            continue;
+        if (rel.type === 'belongsTo') {
+            // The FK lives on this table; the reference key on the target.
+            const column = singleRelationColumn(table, rel.foreignKey);
+            const targetColumn = singleRelationColumn(target, rel.referenceKey);
+            if (!column || !targetColumn)
+                continue;
+            if (seenFkColumns.has(column))
+                continue;
+            if (isRedactedColumn(table, column, showPii) || isRedactedColumn(target, targetColumn, showPii))
+                continue;
+            seenFkColumns.add(column);
+            foreignKeys.push({ column, relation: name, targetTable: target.name, targetColumn });
+            continue;
+        }
+        if (rel.type === 'hasMany' || rel.type === 'hasOne') {
+            // The FK lives on the child table; the reference key on this one.
+            const column = singleRelationColumn(table, rel.referenceKey);
+            const targetColumn = singleRelationColumn(target, rel.foreignKey);
+            if (!column || !targetColumn)
+                continue;
+            if (isRedactedColumn(table, column, showPii) || isRedactedColumn(target, targetColumn, showPii))
+                continue;
+            referencedBy.push({ column, relation: name, targetTable: target.name, targetColumn });
+        }
+        // manyToMany deliberately produces no link: navigating it means traversing a
+        // junction table, which the single-column filter path cannot express.
+    }
+    // Inbound references declared only on the OTHER side. A `defineSchema` author
+    // routinely writes `comments.user -> users` without also declaring
+    // `users.comments`, and scanning only this table's own hasMany/hasOne made
+    // those children unreachable even though the child grid visibly renders the
+    // FK. Scan every other table's belongsTo relations that point here.
+    const seenInbound = new Set(referencedBy.map((r) => `${r.targetTable}.${r.targetColumn}`));
+    for (const other of Object.values(metadata.tables)) {
+        if (other.name === table.name)
+            continue;
+        for (const [name, rel] of Object.entries(other.relations)) {
+            if (rel.type !== 'belongsTo' || rel.to !== table.name)
+                continue;
+            const column = singleRelationColumn(table, rel.referenceKey);
+            const targetColumn = singleRelationColumn(other, rel.foreignKey);
+            if (!column || !targetColumn)
+                continue;
+            if (seenInbound.has(`${other.name}.${targetColumn}`))
+                continue;
+            if (isRedactedColumn(table, column, showPii) || isRedactedColumn(other, targetColumn, showPii))
+                continue;
+            seenInbound.add(`${other.name}.${targetColumn}`);
+            // Named for the direction the user travels: from this row, to the rows of
+            // `other` that reference it. `relation` is the child's own relation name,
+            // which is what the child table calls this link.
+            referencedBy.push({ column, relation: name, targetTable: other.name, targetColumn });
+        }
+    }
+    return { foreignKeys, referencedBy };
+}
 // ---------------------------------------------------------------------------
 // API: /api/tables/:name?limit=&offset=&orderBy=&dir=
 // ---------------------------------------------------------------------------
@@ -663,6 +763,63 @@ function parseTableFilters(raw, table, redactedPii) {
 // ---------------------------------------------------------------------------
 // API: /api/builder — Turbine ORM findMany spec runner
 // ---------------------------------------------------------------------------
+/**
+ * Refuse a builder query that FILTERS or SORTS on a redacted PII column.
+ *
+ * Redacting the cells is not enough on its own: `where: { email: { startsWith:
+ * 'a' } }` answers a question about the hidden value, and so does an `isNull`,
+ * and so does an `orderBy`. The Data tab already refuses all three
+ * (`parseTableFilters`); the builder route accepted them, which mattered the
+ * moment PII tags actually started reaching Studio's metadata.
+ *
+ * Walks the whole args tree: top-level `where` / `orderBy`, boolean
+ * combinators, and each `with` level against that relation's target table.
+ * `select` is NOT refused: it returns values, and those values are redacted on
+ * the way out.
+ */
+function assertNoPiiPredicates(args, tableName, metadata, showPii) {
+    if (showPii)
+        return;
+    const visitClause = (node, table, depth) => {
+        if (!table || depth > 10 || node === null || typeof node !== 'object')
+            return;
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'AND' || key === 'OR' || key === 'NOT') {
+                for (const item of Array.isArray(value) ? value : [value])
+                    visitClause(item, table, depth + 1);
+                continue;
+            }
+            const relation = Object.hasOwn(table.relations, key) ? table.relations[key] : undefined;
+            if (relation) {
+                // some / none / every / is / isNot wrappers all resolve against the target.
+                visitClause(value, metadata.tables[relation.to], depth + 1);
+                continue;
+            }
+            const column = ownLookup(table.columnMap, key) ?? key;
+            if (isRedactedColumn(table, column, showPii)) {
+                throw new errors_js_1.ValidationError(`[turbine] Column "${column}" on "${table.name}" is PII-tagged and redacted, so it cannot be used ` +
+                    `in a where or orderBy: filtering or sorting on a hidden value reveals it. ` +
+                    `Restart Studio with --show-pii to query it.`);
+            }
+        }
+    };
+    const visitLevel = (level, table, depth) => {
+        if (!table || depth > 10)
+            return;
+        visitClause(level.where, table, depth);
+        visitClause(level.orderBy, table, depth);
+        const withClause = level.with;
+        if (!withClause || typeof withClause !== 'object')
+            return;
+        for (const [relName, spec] of Object.entries(withClause)) {
+            const relation = Object.hasOwn(table.relations, relName) ? table.relations[relName] : undefined;
+            if (!relation || spec === true || spec === null || typeof spec !== 'object')
+                continue;
+            visitLevel(spec, metadata.tables[relation.to], depth + 1);
+        }
+    };
+    visitLevel(args, metadata.tables[tableName], 0);
+}
 async function apiBuilder(req, res, ctx) {
     const body = await readJsonBody(req);
     const tableName = typeof body?.table === 'string' ? body.table : '';
@@ -681,6 +838,7 @@ async function apiBuilder(req, res, ctx) {
             // when unset.
             dialect: ctx.dialect,
         });
+        assertNoPiiPredicates(args, tableName, ctx.metadata, ctx.showPii === true);
         deferred = qi.buildFindMany(args);
     }
     catch (err) {

package/dist/cjs/cli/ui.js

@@ -230,9 +230,14 @@ function stripAnsi(s) {
 // ---------------------------------------------------------------------------
 function redactUrl(url) {
     return (url
-        // Userinfo credentials: `:secret@` in any authority (global: a string may
-        // carry more than one URL, e.g. a primary + replica connection pair).
-        .replace(/:([^@/:]+)@/g, ':***@')
+        // Userinfo credentials. Anchored on `<scheme>://<user>:` and consuming up
+        // to the LAST `@` before the next `/` (or end of authority), because a
+        // password may legally contain `:`, `/`, and even `@` in percent-decoded
+        // form. The previous `:([^@/:]+)@` could not span any of those, so
+        // `postgres://u:pa/ss@host/db` came through completely unredacted and
+        // `postgres://u:a@b@host/db` leaked the tail. Global: one string may
+        // carry several URLs (a primary + replica pair).
+        .replace(/(\w+:\/\/[^/@\s]*?:)[^\s]*?@(?=[^@\s]*(?:[/?#]|$))/g, '$1***@')
         // Query-string password params: `password=`, `sslpassword=`, and similar,
         // case-insensitive. Value runs up to the next `&`, `#`, or end of string.
         .replace(/([?&][^=&#]*password)=([^&#]*)/gi, '$1=***'));

package/dist/cjs/client.js

@@ -314,9 +314,29 @@ class TurbineClient {
         // constructor with an opaque "Cannot read properties of undefined
         // (reading 'tables')". Fail fast with an actionable message instead.
         if (!schema || typeof schema !== 'object' || !schema.tables) {
+            // A `defineSchema()` result is the most common wrong shape here: it is a
+            // SchemaDef (`{ tables: { users: { columns: { id: ... } } } }`-ish builder
+            // output), not runtime SchemaMetadata, so name the conversion rather than
+            // just the requirement.
+            const looksLikeSchemaDef = schema !== null && typeof schema === 'object' && Object.hasOwn(schema, 'name') === false;
             throw new errors_js_1.ValidationError('[turbine] TurbineClient requires schema metadata as its second argument. ' +
                 'Run `npx turbine generate` and use the generated client (`turbine()` from your output dir), ' +
-                'or pass the generated `schemaMetadata` object: new TurbineClient(config, schemaMetadata).');
+                'or pass the generated `schemaMetadata` object: new TurbineClient(config, schemaMetadata).' +
+                (looksLikeSchemaDef
+                    ? ' If you have a `defineSchema()` result, convert it first with `schemaDefToMetadata(def)`.'
+                    : ''));
+        }
+        // A wrong-SHAPED schema (a `defineSchema()` result, whose tables carry no
+        // `columns` array) used to survive this check and die later as
+        // `TypeError: this.tableMeta.columns is not iterable`, several frames from
+        // the cause. Validate one table's shape here, where the fix is obvious.
+        for (const [name, meta] of Object.entries(schema.tables)) {
+            if (!meta || typeof meta !== 'object' || !Array.isArray(meta.columns)) {
+                throw new errors_js_1.ValidationError(`[turbine] Table "${name}" in the schema passed to TurbineClient has no \`columns\` array, so this is ` +
+                    'not runtime SchemaMetadata. A `defineSchema()` result is a SchemaDef: convert it with ' +
+                    '`schemaDefToMetadata(def)`, or use the metadata emitted by `npx turbine generate`.');
+            }
+            break;
         }
         /**
          * Parse int8 (bigint, OID 20) as JavaScript number instead of string.

package/dist/cjs/dialect.js

@@ -55,6 +55,8 @@ exports.postgresDialect = {
     nullJsonLiteral: 'NULL',
     aggSupportsInlineOrderBy: true,
     supportsVector: true,
+    supportsFullTextSearch: true,
+    supportsArrayColumns: true,
     supportsListenNotify: true,
     supportsRLS: true,
     supportsAdvisoryLock: true,

package/dist/cjs/index-stats.js

@@ -60,7 +60,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STATS_THRESHOLDS = void 0;
+exports.EXPRESSION_COLUMN = exports.STATS_THRESHOLDS = void 0;
 exports.emptyStatsSnapshot = emptyStatsSnapshot;
 exports.formatBytes = formatBytes;
 exports.scoreMissingIndex = scoreMissingIndex;
@@ -131,6 +131,14 @@ exports.STATS_THRESHOLDS = {
      */
     heatMinQueriesPerMin: 1,
 };
+/**
+ * Placeholder for an index column that is an EXPRESSION, not a plain column
+ * (`pg_index.indkey` stores 0 for those, and no `pg_attribute` row has attnum 0).
+ * It keeps expression POSITIONS in `IndexStat.columns` instead of silently
+ * collapsing `(tenant_id, lower(email))` to `['tenant_id']`, which would make a
+ * functional index look like a droppable prefix of an unrelated plain index.
+ */
+exports.EXPRESSION_COLUMN = '(expression)';
 /** Build an empty (fully unavailable) snapshot - the honest "no stats" baseline. */
 function emptyStatsSnapshot(notices = []) {
     return {
@@ -335,6 +343,30 @@ function findInvalidIndexes(snapshot) {
 function isConstraintBacking(idx) {
     return idx.isPrimary || idx.isUnique || idx.isExclusion === true || idx.isReplicaIdent;
 }
+/** The structured counterpart of {@link describeIndexShape}. */
+function indexShape(idx) {
+    const kinds = [];
+    if (idx.hasExpressions === true || idx.columns.includes(exports.EXPRESSION_COLUMN))
+        kinds.push('expression');
+    if (idx.predicate != null)
+        kinds.push('partial');
+    if (idx.accessMethod !== undefined && idx.accessMethod !== 'btree')
+        kinds.push('non-btree');
+    return { kinds, accessMethod: idx.accessMethod ?? null, definition: idx.indexDef ?? null };
+}
+/** Describe an index's non-plain-btree properties, or null when it is plain. */
+function describeIndexShape(idx) {
+    const parts = [];
+    if (idx.hasExpressions === true || idx.columns.includes(exports.EXPRESSION_COLUMN))
+        parts.push('expression index');
+    if (idx.predicate != null)
+        parts.push(`partial index (WHERE ${idx.predicate})`);
+    if (idx.accessMethod !== undefined && idx.accessMethod !== 'btree')
+        parts.push(`${idx.accessMethod} index`);
+    if (parts.length === 0)
+        return null;
+    return `${parts.join('; ')}${idx.indexDef ? `: ${idx.indexDef}` : ''}`;
+}
 /**
  * Indexes never (or barely) scanned since the last stats reset. Report-only:
  * counters reset on a crash/reset and REPLICA READS NEVER FEED PRIMARY COUNTERS,
@@ -344,9 +376,11 @@ function isConstraintBacking(idx) {
  */
 function findUnusedIndexes(snapshot, options = {}) {
     const minScans = options.minScans ?? exports.STATS_THRESHOLDS.unusedMinScans;
+    const probes = options.relationProbes ?? [];
     return snapshot.indexes
         .filter((idx) => idx.isValid && !isConstraintBacking(idx))
         .filter((idx) => idx.idxScan !== undefined && idx.idxScan < minScans)
+        .filter((idx) => !servesRelationProbe(idx, probes))
         .map((idx) => ({
         table: idx.table,
         indexName: idx.indexName,
@@ -354,6 +388,8 @@ function findUnusedIndexes(snapshot, options = {}) {
         idxScan: idx.idxScan ?? 0,
         sizeBytes: idx.sizeBytes ?? null,
         dropSql: (0, index_advisor_js_1.buildDropIndexSql)(idx.indexName, { concurrently: true }),
+        caveat: describeIndexShape(idx),
+        shape: indexShape(idx),
     }))
         .sort((a, b) => (b.sizeBytes ?? 0) - (a.sizeBytes ?? 0) || a.indexName.localeCompare(b.indexName));
 }
@@ -363,6 +399,52 @@ function isLeadingPrefix(prefix, columns) {
         return false;
     return prefix.every((c, i) => columns[i] === c);
 }
+/** Whether two column lists are identical, in order. */
+function sameColumns(a, b) {
+    return a.length === b.length && a.every((c, i) => b[i] === c);
+}
+/**
+ * Whether this index answers a relation probe Turbine actually issues: the
+ * probe's columns are the index's leading columns (an exact match, or a wider
+ * index whose prefix serves the probe). Such an index is never handed a DROP,
+ * because the missing-index half of the same report demands it.
+ */
+function servesRelationProbe(idx, probes) {
+    if (probes.length === 0)
+        return false;
+    if (idx.accessMethod !== undefined && idx.accessMethod !== 'btree')
+        return false;
+    if (idx.predicate != null)
+        return false;
+    return probes.some((p) => p.table === idx.table && (sameColumns(p.columns, idx.columns) || isLeadingPrefix(p.columns, idx.columns)));
+}
+/**
+ * Whether prefix coverage is even a meaningful question for this pair. Only a
+ * plain btree has leading-prefix semantics, and only two indexes of the SAME
+ * shape are interchangeable:
+ *
+ *   - access method must be btree on BOTH (a GIN index on a column answers
+ *     queries a btree cannot, and vice versa);
+ *   - neither may contain an expression column (`lower(email)` is a different
+ *     lookup from `email`, and an unresolved expression slot makes the column
+ *     list an unreliable basis for a drop verdict);
+ *   - the partial predicates must be IDENTICAL (both absent, or the same text).
+ *     A full index does technically answer a partial index's lookups, but it is
+ *     not the same object and the partial one exists to be small.
+ *
+ * Anything unknown (an access method or expression flag the collector could not
+ * read) answers "not comparable": doctor stays silent rather than suggesting a
+ * drop it cannot justify.
+ */
+function isCoverageComparable(narrow, wider) {
+    if (narrow.accessMethod !== 'btree' || wider.accessMethod !== 'btree')
+        return false;
+    if (narrow.hasExpressions !== false || wider.hasExpressions !== false)
+        return false;
+    if (narrow.columns.includes(exports.EXPRESSION_COLUMN) || wider.columns.includes(exports.EXPRESSION_COLUMN))
+        return false;
+    return (narrow.predicate ?? null) === (wider.predicate ?? null);
+}
 /**
  * Non-unique indexes whose column list is a leading prefix of a WIDER index on
  * the same table. A btree serves any leading-prefix lookup, so the narrow index
@@ -371,6 +453,9 @@ function isLeadingPrefix(prefix, columns) {
  * Uniqueness compatibility: only a NON-unique index is ever reported. A unique
  * or primary-key prefix is load-bearing (it enforces a constraint), so it is
  * never called redundant even when a wider index shares its leading columns.
+ *
+ * Shape compatibility: see {@link isCoverageComparable}. A functional, partial,
+ * or non-btree index is never reported as covered by a plain btree.
  */
 function findRedundantIndexes(snapshot) {
     const byTable = new Map();
@@ -393,7 +478,18 @@ function findRedundantIndexes(snapshot) {
                 continue;
             if (narrow.columns.length === 0)
                 continue;
-            const wider = list.find((w) => w.indexName !== narrow.indexName && isLeadingPrefix(narrow.columns, w.columns));
+            // Prefer a genuinely wider index; fall back to an exact duplicate, which
+            // is the most obvious index problem there is and which a strict
+            // leading-prefix test (prefix.length < columns.length) can never see. For
+            // a duplicate pair only ONE side is reported: the later name, so the
+            // report never tells you to drop both copies.
+            const wider = list.find((w) => w.indexName !== narrow.indexName &&
+                isCoverageComparable(narrow, w) &&
+                isLeadingPrefix(narrow.columns, w.columns)) ??
+                list.find((w) => w.indexName < narrow.indexName &&
+                    !isConstraintBacking(w) &&
+                    isCoverageComparable(narrow, w) &&
+                    sameColumns(narrow.columns, w.columns));
             if (!wider)
                 continue;
             out.push({
@@ -419,6 +515,7 @@ function findRedundantIndexes(snapshot) {
  */
 function auditDoctorIndexes(snapshot, doctorNames, options = {}) {
     const minScans = options.minScans ?? exports.STATS_THRESHOLDS.unusedMinScans;
+    const probes = options.relationProbes ?? [];
     const out = [];
     for (const idx of snapshot.indexes) {
         if (!idx.isValid || isConstraintBacking(idx))
@@ -428,14 +525,16 @@ function auditDoctorIndexes(snapshot, doctorNames, options = {}) {
             continue;
         if (idx.idxScan === undefined || idx.idxScan >= minScans)
             continue;
+        const stillProbed = servesRelationProbe(idx, probes);
         out.push({
             table: idx.table,
             indexName: idx.indexName,
             columns: idx.columns,
             idxScan: idx.idxScan,
             sizeBytes: idx.sizeBytes ?? null,
-            dropSql: (0, index_advisor_js_1.buildDropIndexSql)(idx.indexName, { concurrently: true }),
+            dropSql: stillProbed ? null : (0, index_advisor_js_1.buildDropIndexSql)(idx.indexName, { concurrently: true }),
             ambiguous: candidates.length > 1,
+            stillProbed,
         });
     }
     return out.sort((a, b) => a.indexName.localeCompare(b.indexName));
@@ -538,19 +637,28 @@ async function collectStatsSnapshot(options) {
             }
         }
         // --- invalid + all indexes (whole schema, for invalid detection) -------
-        const indexRows = await run('pg_index', `SELECT c.relname AS table_name,
+        const indexRows = await run('pg_index', 
+        // The column list LEFT JOINs pg_attribute so an EXPRESSION slot (indkey = 0,
+        // which no pg_attribute row matches) survives as a marker instead of being
+        // dropped by an inner join, which silently shortened functional indexes.
+        `SELECT c.relname AS table_name,
               ic.relname AS index_name,
               i.indisvalid, i.indisunique, i.indisprimary, i.indisreplident,
               EXISTS (SELECT 1 FROM pg_constraint con
                        WHERE con.conindid = i.indexrelid AND con.contype = 'x') AS is_exclusion,
               s.idx_scan::text AS idx_scan,
               pg_relation_size(i.indexrelid)::text AS index_size,
-              (SELECT array_agg(a.attname::text ORDER BY k.ord)
+              am.amname AS access_method,
+              (i.indexprs IS NOT NULL) AS has_expressions,
+              pg_get_expr(i.indpred, i.indrelid) AS predicate,
+              pg_get_indexdef(i.indexrelid) AS index_def,
+              (SELECT array_agg(coalesce(a.attname::text, '${exports.EXPRESSION_COLUMN}') ORDER BY k.ord)
                  FROM unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)
-                 JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum) AS columns
+                 LEFT JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum) AS columns
          FROM pg_index i
          JOIN pg_class c ON c.oid = i.indrelid
          JOIN pg_class ic ON ic.oid = i.indexrelid
+         JOIN pg_am am ON am.oid = ic.relam
          JOIN pg_namespace n ON n.oid = c.relnamespace
          LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.indexrelid
         WHERE n.nspname = $1`, [options.schema]);
@@ -560,6 +668,10 @@ async function collectStatsSnapshot(options) {
                     table: row.table_name,
                     indexName: row.index_name,
                     columns: row.columns ?? [],
+                    accessMethod: row.access_method,
+                    hasExpressions: row.has_expressions,
+                    predicate: row.predicate,
+                    indexDef: row.index_def ?? undefined,
                     idxScan: row.idx_scan == null ? undefined : Number(row.idx_scan),
                     isValid: row.indisvalid,
                     isUnique: row.indisunique,

package/dist/cjs/mssql.js

@@ -493,6 +493,11 @@ exports.mssqlDialect = {
     supportsReturning: false,
     supportsILike: false,
     supportsVector: false,
+    // SQL Server full-text is `CONTAINS`/`FREETEXT` over a full-text catalog: a
+    // different surface with different semantics, not the emitted tsvector form.
+    supportsFullTextSearch: false,
+    // No array column type (a JSON column is not an array column).
+    supportsArrayColumns: false,
     supportsListenNotify: false,
     supportsRLS: false,
     // SQL Server has OUTER APPLY, not FROM-clause LATERAL: the lateral pick plan

package/dist/cjs/mysql.js

@@ -377,6 +377,11 @@ exports.mysqlDialect = {
     supportsReturning: false,
     supportsILike: false,
     supportsVector: false,
+    // MySQL full-text is `MATCH(col) AGAINST(...)` over a FULLTEXT index: a
+    // different surface with different semantics, not the emitted tsvector form.
+    supportsFullTextSearch: false,
+    // No array column type (a JSON column is not an array column).
+    supportsArrayColumns: false,
     supportsListenNotify: false,
     supportsRLS: false,
     // MySQL 8.0.14+ supports LATERAL, but the opt-in lateral pick plan stays