@supabase/postgrest-typegen 0.6.0 → 0.7.0

package/dist/introspection/index.d.ts

@@ -13,6 +13,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[];
 }
 /**
  * Introspect a database into the `GeneratorMetadata` contract.

package/dist/introspection/index.js

@@ -42,7 +42,7 @@ export async function introspect(db, opts = {}) {
         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 })),

package/dist/introspection/relationships.d.ts

@@ -10,7 +10,8 @@ import type { Queryable } from "./index.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
@@ -33,15 +34,22 @@ 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 declare function expandViewRelationships(allTableM2oAndO2oRelationships: PostgresRelationship[], viewsKeyDependencies: ViewKeyDependency[]): PostgresRelationship[];
+export declare function expandViewRelationships(allTableM2oAndO2oRelationships: PostgresRelationship[], viewsKeyDependencies: ViewKeyDependency[], isTableEmitted: (relationship: PostgresRelationship) => boolean): PostgresRelationship[];
 /**
  * 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 declare function listRelationships(db: Queryable, schemaFilter: string): Promise<PostgresRelationship[]>;
+export declare function listRelationships(db: Queryable, schemaFilter: string, extraSearchPath?: string[]): Promise<PostgresRelationship[]>;
 export {};

package/dist/introspection/relationships.js

@@ -1,3 +1,4 @@
+import { DEFAULT_SYSTEM_SCHEMAS, filterByList } from "./sql/helpers.js";
 import { TABLE_RELATIONSHIPS_SQL } from "./sql/table_relationships.sql.js";
 import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.js";
 /**
@@ -5,10 +6,22 @@ import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.js"
  * 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, viewsKeyDependencies) {
+export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKeyDependencies, isTableEmitted) {
+    const keyDepsByConstraint = new Map();
+    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) => {
             const tableColumns = colDeps.map(({ table_column }) => table_column);
@@ -19,14 +32,8 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
                 viewColumns,
             }));
         };
-        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 }) => ({
             foreign_key_name: r.foreign_key_name,
             schema: vtkd.view_schema,
@@ -37,7 +44,7 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
             referenced_relation: r.referenced_relation,
             referenced_columns: r.referenced_columns,
         })));
-        const tableToViewRelationships = tableToViewKeyDeps.flatMap((tvkd) => expandKeyDepCols(tvkd.column_dependencies).map(({ viewColumns }) => ({
+        const tableToViewRelationships = (isTableEmitted(r) ? tableToViewKeyDeps : []).flatMap((tvkd) => expandKeyDepCols(tvkd.column_dependencies).map(({ viewColumns }) => ({
             foreign_key_name: r.foreign_key_name,
             schema: r.schema,
             relation: r.relation,
@@ -67,12 +74,27 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
 /**
  * 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, schemaFilter) {
-    const { rows: allTableM2oAndO2oRelationships } = await db.query(TABLE_RELATIONSHIPS_SQL({ schemaFilter }));
-    const { rows: viewsKeyDependencies } = await db.query(VIEWS_KEY_DEPENDENCIES_SQL({ schemaFilter }));
-    const allViewM2oAndO2oRelationships = expandViewRelationships(allTableM2oAndO2oRelationships, viewsKeyDependencies);
-    return allTableM2oAndO2oRelationships.concat(allViewM2oAndO2oRelationships);
+export async function listRelationships(db, schemaFilter, extraSearchPath = []) {
+    const tableRelationshipsQuery = db.query(TABLE_RELATIONSHIPS_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.map(relationshipKey));
+    const allViewM2oAndO2oRelationships = expandViewRelationships(allTableRelationships, viewsKeyDependencies, (r) => emittedKeys.has(relationshipKey(r)));
+    return tableRelationships.concat(allViewM2oAndO2oRelationships);
 }
+const NON_SYSTEM_SCHEMAS_FILTER = filterByList(undefined, undefined, DEFAULT_SYSTEM_SCHEMAS);
+const relationshipKey = (r) => JSON.stringify([r.schema, r.relation, r.foreign_key_name]);
+const keyDependencyKey = (tableSchema, tableName, constraintName, constraintType) => JSON.stringify([tableSchema, tableName, constraintName, constraintType]);

package/dist/introspection/sql/views_key_dependencies.sql.d.ts

@@ -1,2 +1,4 @@
 import type { SchemaFilterProps } from "./common.ts";
-export declare const VIEWS_KEY_DEPENDENCIES_SQL: (props: SchemaFilterProps) => string;
+export declare const VIEWS_KEY_DEPENDENCIES_SQL: (props: SchemaFilterProps & {
+    extraSearchPath?: string[];
+}) => string;

package/dist/introspection/sql/views_key_dependencies.sql.js

@@ -1,3 +1,4 @@
+import { filterByList } from "./helpers.js";
 import { literal } from "./pg-format.js";
 export const VIEWS_KEY_DEPENDENCIES_SQL = (props) => /* SQL */ `
 -- Adapted from
@@ -27,7 +28,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
@@ -39,7 +39,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
@@ -120,6 +120,18 @@ group by sch.nspname, tbl.relname,  rep.view_schema, rep.view_name, pks_fks.conn
 -- make sure we only return key for which all columns are referenced in the view - no partial PKs or FKs
 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 = [], }) {
+    if (!schemaFilter)
+        return "";
+    if (extraSearchPath.length === 0)
+        return `and n.nspname ${schemaFilter}`;
+    return `and (n.nspname ${schemaFilter} or n.nspname ${filterByList(extraSearchPath)})`;
+}
 /**
  * The rewrites, innermost first, that turn the `pg_node_tree` text of a view
  * definition into JSON exposing only `targetList`, `resno`, `resorigtbl` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.6.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/introspection/index.ts

@@ -31,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[];
 }
 
 /**
@@ -83,7 +89,7 @@ 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 })),

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/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.