@supabase/postgrest-typegen 0.5.0 → 0.7.0

package/dist/rpc.js

@@ -18,18 +18,25 @@ import { compareStrings } from "./collation.js";
 /** json, jsonb and text: the types PostgREST accepts for a single unnamed parameter. */
 const UNNAMED_ARG_TYPE_IDS = new Set([114, 3802, 25]);
 const INPUT_ARG_MODES = new Set(["in", "inout", "variadic"]);
+/** A NUL separator cannot occur in an identifier, so names with dots never collide. */
+const qualifiedKey = (schema, name) => `${schema}\0${name}`;
 export function resolveRpcFunctions(metadata) {
     const schemaNames = new Set(metadata.schemas.map(({ name }) => name));
     const typesById = new Map(metadata.types.map((type) => [type.id, type]));
     const relationTypesById = new Map(metadata.types
         .filter((type) => type.type_relation_id !== null)
         .map((type) => [type.id, type]));
-    const relationsById = new Map([
+    const relations = [
         ...metadata.tables,
         ...metadata.foreignTables,
         ...metadata.views,
         ...metadata.materializedViews,
-    ].map((relation) => [relation.id, relation]));
+    ];
+    const relationsById = new Map(relations.map((relation) => [relation.id, relation]));
+    const relationsBySchemaName = new Map(relations.map((relation) => [
+        qualifiedKey(relation.schema, relation.name),
+        relation,
+    ]));
     const columnNamesByRelationId = new Map();
     for (const column of metadata.columns) {
         let names = columnNamesByRelationId.get(column.table_id);
@@ -66,11 +73,14 @@ export function resolveRpcFunctions(metadata) {
     // the rendered argument list may still name the relation.
     const computedFieldOf = ({ fn, inArgs }) => {
         const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
-        const argType = soleInArg && relationTypesById.get(soleInArg.type_id);
+        if (!soleInArg)
+            return null;
+        const argType = relationTypesById.get(soleInArg.type_id);
         const relation = argType
             ? relationsById.get(argType.type_relation_id)
-            : [...relationsById.values()].find((relation) => relation.schema === fn.schema &&
-                relation.name === fn.argument_types);
+            : typesById.has(soleInArg.type_id)
+                ? undefined
+                : relationsBySchemaName.get(qualifiedKey(fn.schema, fn.argument_types));
         if (!relation || relation.schema !== fn.schema)
             return null;
         if (columnNamesByRelationId.get(relation.id)?.has(fn.name))
@@ -125,12 +135,13 @@ export function resolveRpcFunctions(metadata) {
                 }
             }
         }
-        // A sole unnamed row parameter makes the function a computed field, which
-        // PostgREST only exposes under `/rpc` when it also returns rows.
+        // PostgREST passes a sole unnamed parameter only when it is json, jsonb or
+        // text, so a function taking a row this way is a computed field or a
+        // computed relationship, reachable by embedding it from its relation and
+        // never through `/rpc`, whatever it returns.
         if (soleInArg &&
             soleInArg.name === "" &&
-            relationTypesById.has(soleInArg.type_id) &&
-            returnRelationName(fn) === null) {
+            relationTypesById.has(soleInArg.type_id)) {
             return `the function ${fn.schema}.${fn.name} with parameter or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache`;
         }
         return null;
@@ -145,9 +156,7 @@ export function resolveRpcFunctions(metadata) {
                 mode: arg.mode,
                 ...typeReference(arg.type_id),
                 has_default: arg.has_default === true,
-                relation_id: relationId !== undefined &&
-                    relationId !== null &&
-                    relationsById.has(relationId)
+                relation_id: relationId !== undefined && relationsById.has(relationId)
                     ? relationId
                     : null,
             };
@@ -199,7 +208,7 @@ export function resolveRpcFunctions(metadata) {
         const candidate = { fn, inArgs };
         if (!isCallable(candidate))
             continue;
-        const key = `${fn.schema}.${fn.name}`;
+        const key = qualifiedKey(fn.schema, fn.name);
         let group = groups.get(key);
         if (!group) {
             group = [];

package/dist/types.js

@@ -179,8 +179,8 @@ const rpcFunctionReturnsSchema = rpcTypeReferenceSchema.merge({
      */
     relation_id: "number | null",
     /**
-     * The columns of a `RETURNS TABLE (…)` or `OUT` parameter result, in name
-     * order; `null` for every other return type.
+     * The columns of a `RETURNS TABLE (…)` result, in name order; `null` for
+     * every other return type, including a record built from `OUT` parameters.
      */
     columns: rpcTypeReferenceSchema.merge({ name: "string" }).array().or("null"),
 });
@@ -217,9 +217,10 @@ const rpcFunctionOverloadSchema = type({
     computed_field_of: "number | null",
     /**
      * Why PostgREST cannot resolve a call to this overload, when it cannot: the
-     * function conflicts with another overload, or it is a computed field that
-     * returns no rows. Generators surface the message instead of a callable
-     * signature.
+     * function conflicts with another overload, or its sole parameter is an
+     * unnamed row, which PostgREST never matches under `/rpc` (the function is
+     * a computed field or computed relationship, reached by embedding).
+     * Generators surface the message instead of a callable signature.
      */
     error: "string | null",
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -63,7 +63,7 @@
     "test": "bun scripts/run-tests.ts test/"
   },
   "dependencies": {
-    "arktype": "2.2.8"
+    "arktype": "2.2.9"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
@@ -75,8 +75,8 @@
     "@types/pg": "^8.23.1",
     "knip": "^6.32.3",
     "oxfmt": "0.66.0",
-    "oxlint": "1.87.0",
-    "oxlint-tsgolint": "7.0.2004",
+    "oxlint": "1.90.0",
+    "oxlint-tsgolint": "7.0.2005",
     "pg": "^8.23.0",
     "testcontainers": "^12.1.0",
     "typescript": "7.0.2"

package/src/generation/typescript.ts

@@ -121,7 +121,6 @@ export const generateTypescript = async (
     relationships,
     types,
   } = metadata;
-  // Documents predating the collection (still valid version 1) resolve it here.
   const rpcFunctions = metadata.rpcFunctions ?? resolveRpcFunctions(metadata);
   const {
     detectOneToOneRelationships = false,
@@ -334,7 +333,11 @@ export const generateTypescript = async (
     // Without that metadata PostgREST still returns an array, so the collapse would make
     // the type diverge from the actual response.
     const collapsibleSingleRow = setof_options?.is_one_to_one === true;
-    return `${returnType}${overload.is_set_returning && !collapsibleSingleRow ? "[]" : ""}
+    const isArray =
+      overload.error === null &&
+      overload.is_set_returning &&
+      !collapsibleSingleRow;
+    return `${returnType}${isArray ? "[]" : ""}
                           ${setofOptionsInfo}`;
   };
 

package/src/introspection/index.ts

@@ -14,7 +14,9 @@ import { PRIMARY_KEYS_SQL } from "./sql/primary_keys.sql.ts";
 import { SCHEMAS_SQL } from "./sql/schemas.sql.ts";
 import { TABLES_SQL } from "./sql/table.sql.ts";
 import { TYPES_SQL } from "./sql/types.sql.ts";
+import { VIEW_DEFINITIONS_SQL } from "./sql/view_definitions.sql.ts";
 import { VIEWS_SQL } from "./sql/views.sql.ts";
+import { applyViewColumnNullability } from "./view-nullability.ts";
 
 /**
  * Minimal structural database interface. `pg.Pool` / `pg.Client` satisfy it,
@@ -29,6 +31,12 @@ export interface Queryable {
 export interface IntrospectOptions {
   includedSchemas?: string[];
   excludedSchemas?: string[];
+  /**
+   * PostgREST's `db-extra-search-path` schemas. A view in a generated schema
+   * that selects from a view in one of them keeps the relationships of the
+   * underlying tables, as in PostgREST. Nothing in these schemas is generated.
+   */
+  extraSearchPath?: string[];
 }
 
 /**
@@ -72,6 +80,7 @@ export async function introspect(
     relationships,
     functions,
     types,
+    viewDefinitions,
   ] = await Promise.all([
     queryRows(SCHEMAS_SQL({ schemaFilter: systemExcludingFilter })),
     queryRows(TABLES_SQL({ schemaFilter: systemExcludingFilter })),
@@ -80,9 +89,10 @@ export async function introspect(
     queryRows(MATERIALIZED_VIEWS_SQL({ schemaFilter: plainFilter })),
     queryRows(COLUMNS_SQL({ schemaFilter: systemExcludingFilter })),
     queryRows(PRIMARY_KEYS_SQL({ schemaFilter: systemExcludingFilter })),
-    listRelationships(db, systemExcludingFilter),
+    listRelationships(db, systemExcludingFilter, opts.extraSearchPath),
     queryRows(FUNCTIONS_SQL({ schemaFilter: systemExcludingFilter })),
     queryRows(TYPES_SQL),
+    queryRows(VIEW_DEFINITIONS_SQL({ schemaFilter: systemExcludingFilter })),
   ]);
 
   const metadata = {
@@ -92,7 +102,7 @@ export async function introspect(
     foreignTables,
     views,
     materializedViews,
-    columns,
+    columns: applyViewColumnNullability(columns, viewDefinitions),
     primaryKeys,
     relationships,
     functions: functions.filter(

package/src/introspection/node-tree.ts

@@ -0,0 +1,129 @@
+/**
+ * A value in the text form of a `pg_node_tree`: a scalar token, `null` for
+ * `<>`, a list, or a node. Integer, OID and bitmapset lists (`(i 1 2)`,
+ * `(o 23)`, `(b 3)`) lose their marker and become lists of scalar tokens.
+ */
+export type NodeTreeValue = string | null | NodeTreeValue[] | NodeTreeNode;
+
+export interface NodeTreeNode {
+  type: string;
+  fields: Record<string, NodeTreeValue>;
+}
+
+interface Token {
+  raw: string;
+  text: string;
+}
+
+const LIST_MARKERS = new Set(["i", "o", "b", "x"]);
+const WHITESPACE = " \t\n";
+const PUNCTUATION = "(){}";
+
+/**
+ * Parse the text form of a `pg_node_tree` (for example
+ * `pg_rewrite.ev_action::text`), following the tokenizer of PostgreSQL's
+ * `read.c`: tokens are separated by whitespace, `(`, `)`, `{` and `}` are
+ * tokens of their own, and a backslash escapes the next character.
+ */
+export function parseNodeTree(text: string): NodeTreeValue {
+  const tokens = tokenize(text);
+  let position = 0;
+
+  const peek = (): Token | undefined => tokens[position];
+  const next = (): Token => {
+    const token = tokens[position++];
+    if (token === undefined) {
+      throw new Error("Unexpected end of pg_node_tree");
+    }
+    return token;
+  };
+  const isFieldEnd = (token: Token | undefined) =>
+    token === undefined || token.raw === "}" || token.raw.startsWith(":");
+
+  const parseValue = (): NodeTreeValue => {
+    const token = next();
+    if (token.raw === "{") {
+      const type = next().text;
+      const fields: Record<string, NodeTreeValue> = {};
+      while (peek()?.raw !== "}") {
+        const name = next().raw.slice(1);
+        fields[name] = isFieldEnd(peek()) ? null : parseValue();
+        // Some fields span several tokens, such as a constant's
+        // `:constvalue 4 [ 1 0 0 0 ]`; only the first one is kept.
+        while (!isFieldEnd(peek())) {
+          parseValue();
+        }
+      }
+      next();
+      return { type, fields };
+    }
+    if (token.raw === "(") {
+      const items: NodeTreeValue[] = [];
+      const first = peek();
+      if (first !== undefined && LIST_MARKERS.has(first.raw)) {
+        next();
+      }
+      while (peek()?.raw !== ")") {
+        items.push(parseValue());
+      }
+      next();
+      return items;
+    }
+    if (token.raw === "<>") {
+      return null;
+    }
+    return token.text;
+  };
+
+  const value = parseValue();
+  if (position !== tokens.length) {
+    throw new Error("Trailing tokens after pg_node_tree");
+  }
+  return value;
+}
+
+function tokenize(text: string): Token[] {
+  const tokens: Token[] = [];
+  let index = 0;
+  while (index < text.length) {
+    const character = text.charAt(index);
+    if (WHITESPACE.includes(character)) {
+      index++;
+      continue;
+    }
+    if (PUNCTUATION.includes(character)) {
+      tokens.push({ raw: character, text: character });
+      index++;
+      continue;
+    }
+    const start = index;
+    let unescaped = "";
+    while (index < text.length) {
+      const current = text.charAt(index);
+      if (current === "\\" && index + 1 < text.length) {
+        unescaped += text.charAt(index + 1);
+        index += 2;
+        continue;
+      }
+      if (WHITESPACE.includes(current) || PUNCTUATION.includes(current)) {
+        break;
+      }
+      unescaped += current;
+      index++;
+    }
+    tokens.push({ raw: text.slice(start, index), text: unescaped });
+  }
+  return tokens;
+}
+
+export function isNode(
+  value: NodeTreeValue | undefined,
+  type?: string,
+): value is NodeTreeNode {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (type === undefined || value.type === type)
+  );
+}

package/src/introspection/relationships.ts

@@ -1,5 +1,6 @@
 import type { PostgresRelationship } from "../types.ts";
 import type { Queryable } from "./index.ts";
+import { DEFAULT_SYSTEM_SCHEMAS, filterByList } from "./sql/helpers.ts";
 import { TABLE_RELATIONSHIPS_SQL } from "./sql/table_relationships.sql.ts";
 import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.ts";
 
@@ -13,7 +14,8 @@ import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.ts"
  *     by mapping a base table's foreign key columns onto the view columns that
  *     select them (`VIEWS_KEY_DEPENDENCIES_SQL` + the cartesian-product
  *     expansion below). This second part is pure TypeScript, not SQL — ported
- *     verbatim from upstream.
+ *     from postgres-meta, except that the expansion sees every non-system
+ *     schema's foreign keys, as PostgREST does (see `listRelationships`).
  *
  * Adapted from:
  * https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L392
@@ -39,13 +41,32 @@ export type ViewKeyDependency = {
  * view↔view relationships implied by the view key dependencies. Pure function
  * (no database) so the cartesian-product expansion can be unit-tested directly.
  *
- * Ported verbatim from `PostgresMetaRelationships.list()` (the body of the
- * `allViewM2oAndO2oRelationships` block).
+ * Ported from `PostgresMetaRelationships.list()` (the body of the
+ * `allViewM2oAndO2oRelationships` block). Every table relationship feeds the
+ * expansion, but a table→view relationship is emitted on the table itself, so
+ * `isTableEmitted` keeps it to the tables the caller returns relationships for.
  */
 export function expandViewRelationships(
   allTableM2oAndO2oRelationships: PostgresRelationship[],
   viewsKeyDependencies: ViewKeyDependency[],
+  isTableEmitted: (relationship: PostgresRelationship) => boolean,
 ): PostgresRelationship[] {
+  const keyDepsByConstraint = new Map<string, ViewKeyDependency[]>();
+  for (const vkd of viewsKeyDependencies) {
+    const key = keyDependencyKey(
+      vkd.table_schema,
+      vkd.table_name,
+      vkd.constraint_name,
+      vkd.constraint_type,
+    );
+    let bucket = keyDepsByConstraint.get(key);
+    if (!bucket) {
+      bucket = [];
+      keyDepsByConstraint.set(key, bucket);
+    }
+    bucket.push(vkd);
+  }
+
   return allTableM2oAndO2oRelationships.flatMap((r) => {
     const expandKeyDepCols = (
       colDeps: ColDep[],
@@ -68,20 +89,19 @@ export function expandViewRelationships(
       }));
     };
 
-    const viewToTableKeyDeps = viewsKeyDependencies.filter(
-      (vkd) =>
-        vkd.table_schema === r.schema &&
-        vkd.table_name === r.relation &&
-        vkd.constraint_name === r.foreign_key_name &&
-        vkd.constraint_type === "f",
-    );
-    const tableToViewKeyDeps = viewsKeyDependencies.filter(
-      (vkd) =>
-        vkd.table_schema === r.referenced_schema &&
-        vkd.table_name === r.referenced_relation &&
-        vkd.constraint_name === r.foreign_key_name &&
-        vkd.constraint_type === "f_ref",
-    );
+    const viewToTableKeyDeps =
+      keyDepsByConstraint.get(
+        keyDependencyKey(r.schema, r.relation, r.foreign_key_name, "f"),
+      ) ?? [];
+    const tableToViewKeyDeps =
+      keyDepsByConstraint.get(
+        keyDependencyKey(
+          r.referenced_schema,
+          r.referenced_relation,
+          r.foreign_key_name,
+          "f_ref",
+        ),
+      ) ?? [];
 
     const viewToTableRelationships = viewToTableKeyDeps.flatMap((vtkd) =>
       expandKeyDepCols(vtkd.column_dependencies).map(({ viewColumns }) => ({
@@ -96,7 +116,9 @@ export function expandViewRelationships(
       })),
     );
 
-    const tableToViewRelationships = tableToViewKeyDeps.flatMap((tvkd) =>
+    const tableToViewRelationships = (
+      isTableEmitted(r) ? tableToViewKeyDeps : []
+    ).flatMap((tvkd) =>
       expandKeyDepCols(tvkd.column_dependencies).map(({ viewColumns }) => ({
         foreign_key_name: r.foreign_key_name,
         schema: r.schema,
@@ -139,26 +161,62 @@ export function expandViewRelationships(
 /**
  * List all relationships (table↔table plus the view-derived ones) for the
  * schemas selected by `schemaFilter`, the `IN (…)`/`NOT IN (…)` fragment
- * `introspect()` builds with the system schemas excluded. Errors from the
- * injected `Queryable` propagate by throwing — callers adapt.
+ * `introspect()` builds with the system schemas excluded. Like PostgREST, view
+ * expansion sees the foreign keys of every non-system schema, so a view over a
+ * table in a schema that is not selected keeps the table's foreign keys; only
+ * the views and tables in the selected schemas get relationships. Views in the
+ * `extraSearchPath` schemas are followed to their base tables but get no
+ * relationships of their own. Errors from the injected `Queryable` propagate
+ * by throwing — callers adapt.
  */
 export async function listRelationships(
   db: Queryable,
   schemaFilter: string,
+  extraSearchPath: string[] = [],
 ): Promise<PostgresRelationship[]> {
-  const { rows: allTableM2oAndO2oRelationships } = await db.query(
+  const tableRelationshipsQuery = db.query(
     TABLE_RELATIONSHIPS_SQL({ schemaFilter }),
   );
-  const { rows: viewsKeyDependencies } = await db.query(
-    VIEWS_KEY_DEPENDENCIES_SQL({ schemaFilter }),
-  );
+  const [
+    { rows: tableRelationships },
+    { rows: allTableRelationships },
+    { rows: viewsKeyDependencies },
+  ] = await Promise.all([
+    tableRelationshipsQuery,
+    schemaFilter === NON_SYSTEM_SCHEMAS_FILTER
+      ? tableRelationshipsQuery
+      : db.query(
+          TABLE_RELATIONSHIPS_SQL({ schemaFilter: NON_SYSTEM_SCHEMAS_FILTER }),
+        ),
+    db.query(VIEWS_KEY_DEPENDENCIES_SQL({ schemaFilter, extraSearchPath })),
+  ]);
 
+  const emittedKeys = new Set(
+    (tableRelationships as PostgresRelationship[]).map(relationshipKey),
+  );
   const allViewM2oAndO2oRelationships = expandViewRelationships(
-    allTableM2oAndO2oRelationships as PostgresRelationship[],
+    allTableRelationships as PostgresRelationship[],
     viewsKeyDependencies as ViewKeyDependency[],
+    (r) => emittedKeys.has(relationshipKey(r)),
   );
 
-  return (allTableM2oAndO2oRelationships as PostgresRelationship[]).concat(
+  return (tableRelationships as PostgresRelationship[]).concat(
     allViewM2oAndO2oRelationships,
   );
 }
+
+const NON_SYSTEM_SCHEMAS_FILTER = filterByList(
+  undefined,
+  undefined,
+  DEFAULT_SYSTEM_SCHEMAS,
+);
+
+const relationshipKey = (r: PostgresRelationship) =>
+  JSON.stringify([r.schema, r.relation, r.foreign_key_name]);
+
+const keyDependencyKey = (
+  tableSchema: string,
+  tableName: string,
+  constraintName: string,
+  constraintType: ViewKeyDependency["constraint_type"],
+) => JSON.stringify([tableSchema, tableName, constraintName, constraintType]);

package/src/introspection/sql/view_definitions.sql.ts

@@ -0,0 +1,45 @@
+import type { SchemaFilterProps } from "./common.ts";
+
+/**
+ * The query tree of every view and materialized view in the filtered schemas,
+ * plus every view they read from in any schema, with the `NOT NULL` columns
+ * each one references. `inferNonNullViewColumns` resolves view column
+ * nullability from it.
+ */
+export const VIEW_DEFINITIONS_SQL = (props: SchemaFilterProps) => /* SQL */ `
+WITH RECURSIVE view_closure(oid) AS (
+  SELECT c.oid
+  FROM pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE
+    ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+    c.relkind IN ('v', 'm')
+  UNION
+  SELECT dep.refobjid
+  FROM view_closure vc
+  JOIN pg_rewrite r ON r.ev_class = vc.oid AND r.rulename = '_RETURN'
+  JOIN pg_depend dep ON dep.classid = 'pg_rewrite' :: regclass
+    AND dep.objid = r.oid
+    AND dep.refclassid = 'pg_class' :: regclass
+  JOIN pg_class rc ON rc.oid = dep.refobjid AND rc.relkind IN ('v', 'm')
+)
+SELECT
+  r.ev_class :: int8 AS view_id,
+  r.ev_action :: text AS definition,
+  COALESCE(
+    (
+      SELECT json_agg(json_build_array(dep.refobjid :: int8, dep.refobjsubid))
+      FROM pg_depend dep
+      JOIN pg_attribute a ON a.attrelid = dep.refobjid AND a.attnum = dep.refobjsubid
+      JOIN pg_type t ON t.oid = a.atttypid
+      WHERE dep.classid = 'pg_rewrite' :: regclass
+        AND dep.objid = r.oid
+        AND dep.refclassid = 'pg_class' :: regclass
+        AND dep.refobjsubid > 0
+        AND (a.attnotnull OR t.typtype = 'd' AND t.typnotnull)
+    ),
+    '[]'
+  ) AS non_null_columns
+FROM view_closure vc
+JOIN pg_rewrite r ON r.ev_class = vc.oid AND r.rulename = '_RETURN'
+`;

package/src/introspection/sql/views_key_dependencies.sql.ts

@@ -1,8 +1,9 @@
 import type { SchemaFilterProps } from "./common.ts";
+import { filterByList } from "./helpers.ts";
 import { literal } from "./pg-format.ts";
 
 export const VIEWS_KEY_DEPENDENCIES_SQL = (
-  props: SchemaFilterProps,
+  props: SchemaFilterProps & { extraSearchPath?: string[] },
 ) => /* SQL */ `
 -- Adapted from
 -- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L820
@@ -31,7 +32,6 @@ pks_fks as (
   from pg_constraint
   left join lateral unnest(confkey) with ordinality as _(col, ord) on true
   where contype='f'
-  ${props.schemaFilter ? `and connamespace::regnamespace::text ${props.schemaFilter}` : ""}
 ),
 views as (
   select
@@ -43,7 +43,7 @@ views as (
   join pg_namespace n on n.oid = c.relnamespace
   join pg_rewrite r on r.ev_class = c.oid
   where c.relkind in ('v', 'm') 
-    ${props.schemaFilter ? `and n.nspname ${props.schemaFilter}` : ""}
+    ${viewSchemaFilter(props)}
 ),
 transform_json as (
   select
@@ -125,6 +125,20 @@ group by sch.nspname, tbl.relname,  rep.view_schema, rep.view_name, pks_fks.conn
 having ncol = array_length(array_agg(row(col.attname, view_columns) order by pks_fks.ord), 1)
 `;
 
+/**
+ * Like PostgREST, the views followed to their base tables also include the
+ * `db-extra-search-path` schemas; the recursion still starts from the selected
+ * schemas only.
+ */
+function viewSchemaFilter({
+  schemaFilter,
+  extraSearchPath = [],
+}: SchemaFilterProps & { extraSearchPath?: string[] }): string {
+  if (!schemaFilter) return "";
+  if (extraSearchPath.length === 0) return `and n.nspname ${schemaFilter}`;
+  return `and (n.nspname ${schemaFilter} or n.nspname ${filterByList(extraSearchPath)})`;
+}
+
 /**
  * One text rewrite of the `pg_node_tree` to JSON conversion: a `replace`, or
  * a global `regexp_replace` when `isRegex` is set.