neon 8.4.5 → 8.6.0

package/dist/vendor/postgres-meta/lib/db.js

@@ -0,0 +1,147 @@
+import pg from "pg";
+import { parse } from "postgres-array";
+//#region src/vendor/postgres-meta/lib/db.ts
+pg.types.setTypeParser(pg.types.builtins.INT8, (x) => {
+	const asNumber = Number(x);
+	if (Number.isSafeInteger(asNumber)) return asNumber;
+	else return x;
+});
+pg.types.setTypeParser(pg.types.builtins.DATE, (x) => x);
+pg.types.setTypeParser(pg.types.builtins.INTERVAL, (x) => x);
+pg.types.setTypeParser(pg.types.builtins.TIMESTAMP, (x) => x);
+pg.types.setTypeParser(pg.types.builtins.TIMESTAMPTZ, (x) => x);
+pg.types.setTypeParser(1115, parse);
+pg.types.setTypeParser(1182, parse);
+pg.types.setTypeParser(1185, parse);
+pg.types.setTypeParser(600, (x) => x);
+pg.types.setTypeParser(1017, (x) => x);
+const poolerQueryHandleError = (pgpool, sql, parameters) => {
+	return new Promise((resolve, reject) => {
+		let rejected = false;
+		const connectionErrorHandler = (err) => {
+			if (!rejected) setTimeout(() => {
+				rejected = true;
+				return reject(err);
+			});
+		};
+		pgpool.once("error", connectionErrorHandler);
+		pgpool.query(sql, parameters).then((results) => {
+			if (!rejected) return resolve(results);
+		}).catch((err) => {
+			if (!rejected) {
+				rejected = true;
+				return reject(err);
+			}
+		});
+	});
+};
+const init = (config) => {
+	if (config.connectionString) {
+		const u = new URL(config.connectionString);
+		const sslmode = u.searchParams.get("sslmode");
+		u.searchParams.delete("sslmode");
+		u.searchParams.delete("sslca");
+		u.searchParams.delete("sslkey");
+		u.searchParams.delete("sslcert");
+		u.searchParams.delete("sslrootcert");
+		config.connectionString = u.toString();
+		if (sslmode === null) {} else if (sslmode === "disable") config.ssl = false;
+		else {
+			if (typeof config.ssl !== "object") config.ssl = {};
+			config.ssl.rejectUnauthorized = sslmode === "verify-full";
+		}
+	}
+	let pool = new pg.Pool(config);
+	return {
+		async query(sql, { statementQueryTimeout, parameters } = {}) {
+			const statementTimeoutQueryPrefix = statementQueryTimeout ? `SET statement_timeout='${statementQueryTimeout}s'; SET idle_session_timeout='${statementQueryTimeout}s';` : "";
+			const sqlWithStatementTimeout = `${statementTimeoutQueryPrefix}${sql}`;
+			try {
+				if (!pool) {
+					const transientPool = new pg.Pool(config);
+					let res = await poolerQueryHandleError(transientPool, sqlWithStatementTimeout, parameters);
+					if (Array.isArray(res)) res = res.reverse().find((x) => x.rows.length !== 0) ?? { rows: [] };
+					await transientPool.end();
+					return {
+						data: res.rows,
+						error: null
+					};
+				}
+				let res = await poolerQueryHandleError(pool, sqlWithStatementTimeout, parameters);
+				if (Array.isArray(res)) res = res.reverse().find((x) => x.rows.length !== 0) ?? { rows: [] };
+				return {
+					data: res.rows,
+					error: null
+				};
+			} catch (error) {
+				if (error.constructor.name === "DatabaseError") {
+					let formattedError = "";
+					if (error.severity) formattedError += `${error.severity}:  `;
+					if (error.code) formattedError += `${error.code}: `;
+					if (error.message) formattedError += error.message;
+					formattedError += "\n";
+					if (error.position) {
+						const position = Number(error.position) - 1 - statementTimeoutQueryPrefix.length;
+						error.position = `${position + 1}`;
+						let line = "";
+						let lineNumber = 0;
+						let lineOffset = 0;
+						const lines = sql.split("\n");
+						let currentOffset = 0;
+						for (let i = 0; i < lines.length; i++) {
+							if (currentOffset + lines[i].length > position) {
+								line = lines[i];
+								lineNumber = i + 1;
+								lineOffset = position - currentOffset;
+								break;
+							}
+							currentOffset += lines[i].length + 1;
+						}
+						formattedError += `LINE ${lineNumber}: ${line}\n${" ".repeat(5 + lineNumber.toString().length + 2 + lineOffset)}^\n`;
+					}
+					if (error.detail) formattedError += `DETAIL:  ${error.detail}\n`;
+					if (error.hint) formattedError += `HINT:  ${error.hint}\n`;
+					if (error.internalQuery) formattedError += `QUERY:  ${error.internalQuery}\n`;
+					if (error.where) formattedError += `CONTEXT:  ${error.where}\n`;
+					return {
+						data: null,
+						error: {
+							...error,
+							message: error.message,
+							formattedError
+						}
+					};
+				}
+				try {
+					return {
+						data: null,
+						error: {
+							code: error.code,
+							message: error.message
+						}
+					};
+				} finally {
+					try {
+						await this.end.bind(this);
+					} catch (_endError) {
+						console.error("Failed to end the connection on error: ", {
+							this: this,
+							end: this.end
+						});
+					}
+				}
+			}
+		},
+		async end() {
+			try {
+				const _pool = pool;
+				pool = null;
+				if (_pool) await _pool.end();
+			} catch (endError) {
+				console.error("Failed ending connection pool", endError);
+			}
+		}
+	};
+};
+//#endregion
+export { init };

package/dist/vendor/postgres-meta/lib/generators.js

@@ -0,0 +1,106 @@
+//#region src/vendor/postgres-meta/lib/generators.ts
+async function getGeneratorMetadata(pgMeta, filters = {
+	includedSchemas: [],
+	excludedSchemas: []
+}) {
+	const includedSchemas = filters.includedSchemas ?? [];
+	const excludedSchemas = filters.excludedSchemas ?? [];
+	const { data: schemas, error: schemasError } = await pgMeta.schemas.list({
+		includeSystemSchemas: false,
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0
+	});
+	if (schemasError) return {
+		data: null,
+		error: schemasError
+	};
+	const { data: tables, error: tablesError } = await pgMeta.tables.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeColumns: false
+	});
+	if (tablesError) return {
+		data: null,
+		error: tablesError
+	};
+	const { data: foreignTables, error: foreignTablesError } = await pgMeta.foreignTables.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeColumns: false
+	});
+	if (foreignTablesError) return {
+		data: null,
+		error: foreignTablesError
+	};
+	const { data: views, error: viewsError } = await pgMeta.views.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeColumns: false
+	});
+	if (viewsError) return {
+		data: null,
+		error: viewsError
+	};
+	const { data: materializedViews, error: materializedViewsError } = await pgMeta.materializedViews.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeColumns: false
+	});
+	if (materializedViewsError) return {
+		data: null,
+		error: materializedViewsError
+	};
+	const { data: columns, error: columnsError } = await pgMeta.columns.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeSystemSchemas: false
+	});
+	if (columnsError) return {
+		data: null,
+		error: columnsError
+	};
+	const { data: relationships, error: relationshipsError } = await pgMeta.relationships.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeSystemSchemas: false
+	});
+	if (relationshipsError) return {
+		data: null,
+		error: relationshipsError
+	};
+	const { data: functions, error: functionsError } = await pgMeta.functions.list({
+		includedSchemas: includedSchemas.length > 0 ? includedSchemas : void 0,
+		excludedSchemas: excludedSchemas.length > 0 ? excludedSchemas : void 0,
+		includeSystemSchemas: false
+	});
+	if (functionsError) return {
+		data: null,
+		error: functionsError
+	};
+	const { data: types, error: typesError } = await pgMeta.types.list({
+		includeTableTypes: true,
+		includeArrayTypes: true,
+		includeSystemSchemas: true
+	});
+	if (typesError) return {
+		data: null,
+		error: typesError
+	};
+	await pgMeta.end();
+	return {
+		data: {
+			schemas: schemas.filter(({ name }) => !excludedSchemas.includes(name) && (includedSchemas.length === 0 || includedSchemas.includes(name))),
+			tables,
+			foreignTables,
+			views,
+			materializedViews,
+			columns,
+			relationships,
+			functions: functions.filter(({ return_type }) => !["trigger", "event_trigger"].includes(return_type)),
+			types
+		},
+		error: null
+	};
+}
+//#endregion
+export { getGeneratorMetadata };

package/dist/vendor/postgres-meta/lib/helpers.js

@@ -0,0 +1,26 @@
+import { literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/helpers.ts
+const coalesceRowsToArray = (source, filter) => {
+	return `
+COALESCE(
+  (
+    SELECT
+      array_agg(row_to_json(${source})) FILTER (WHERE ${filter})
+    FROM
+      ${source}
+  ),
+  '{}'
+) AS ${source}`;
+};
+const filterByList = (include, exclude, defaultExclude) => {
+	if (defaultExclude) exclude = defaultExclude.concat(exclude ?? []);
+	if (include?.length) return `IN (${include.map(literal).join(",")})`;
+	else if (exclude?.length) return `NOT IN (${exclude.map(literal).join(",")})`;
+	return "";
+};
+const filterByValue = (ids) => {
+	if (ids?.length) return `IN (${ids.map(literal).join(",")})`;
+	return "";
+};
+//#endregion
+export { coalesceRowsToArray, filterByList, filterByValue };

package/dist/vendor/postgres-meta/lib/index.js

@@ -0,0 +1 @@
+export { default as PostgresMeta } from "./PostgresMeta.js";

package/dist/vendor/postgres-meta/lib/sql/column_privileges.sql.js

@@ -0,0 +1,154 @@
+//#region src/vendor/postgres-meta/lib/sql/column_privileges.sql.ts
+const COLUMN_PRIVILEGES_SQL = (props) => `
+-- Lists each column's privileges in the form of:
+--
+-- [
+--   {
+--     "column_id": "12345.1",
+--     "relation_schema": "public",
+--     "relation_name": "mytable",
+--     "column_name": "mycolumn",
+--     "privileges": [
+--       {
+--         "grantor": "postgres",
+--         "grantee": "myrole",
+--         "privilege_type": "SELECT",
+--         "is_grantable": false
+--       },
+--       ...
+--     ]
+--   },
+--   ...
+-- ]
+--
+-- Modified from information_schema.column_privileges. We try to be as close as
+-- possible to the view definition, obtained from:
+--
+-- select pg_get_viewdef('information_schema.column_privileges');
+--
+-- The main differences are:
+-- - we include column privileges for materialized views
+--   (reason for exclusion in information_schema.column_privileges:
+--    https://www.postgresql.org/message-id/9136.1502740844%40sss.pgh.pa.us)
+-- - we query a.attrelid and a.attnum to generate \`column_id\`
+-- - \`table_catalog\` is omitted
+-- - table_schema -> relation_schema, table_name -> relation_name
+--
+-- Column privileges are intertwined with table privileges in that table
+-- privileges override column privileges. E.g. if we do:
+--
+-- grant all on mytable to myrole;
+--
+-- Then \`myrole\` is granted privileges for ALL columns. Likewise, if we do:
+--
+-- grant all (id) on mytable to myrole;
+-- revoke all on mytable from myrole;
+--
+-- Then the grant on the \`id\` column is revoked.
+--
+-- This is unlike how grants for schemas and tables interact, where you need
+-- privileges for BOTH the schema the table is in AND the table itself in order
+-- to access the table.
+
+select (x.attrelid || '.' || x.attnum) as column_id,
+       nc.nspname as relation_schema,
+       x.relname as relation_name,
+       x.attname as column_name,
+       coalesce(
+         jsonb_agg(
+           jsonb_build_object(
+             'grantor', u_grantor.rolname,
+             'grantee', grantee.rolname,
+             'privilege_type', x.prtype,
+             'is_grantable', x.grantable
+           )
+         ),
+         '[]'
+       ) as privileges
+from
+  (select pr_c.grantor,
+          pr_c.grantee,
+          a.attrelid,
+          a.attnum,
+          a.attname,
+          pr_c.relname,
+          pr_c.relnamespace,
+          pr_c.prtype,
+          pr_c.grantable,
+          pr_c.relowner
+   from
+     (select pg_class.oid,
+             pg_class.relname,
+             pg_class.relnamespace,
+             pg_class.relowner,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).grantor as grantor,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).grantee as grantee,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).privilege_type as privilege_type,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).is_grantable as is_grantable
+      from pg_class
+      where (pg_class.relkind = any (array['r',
+                                           'v',
+                                           'm',
+                                           'f',
+                                           'p'])) ) pr_c(oid, relname, relnamespace, relowner, grantor, grantee, prtype, grantable),
+                                                    pg_attribute a
+   where ((a.attrelid = pr_c.oid)
+          and (a.attnum > 0)
+          and (not a.attisdropped))
+   union select pr_a.grantor,
+                pr_a.grantee,
+                pr_a.attrelid,
+                pr_a.attnum,
+                pr_a.attname,
+                c.relname,
+                c.relnamespace,
+                pr_a.prtype,
+                pr_a.grantable,
+                c.relowner
+   from
+     (select a.attrelid,
+             a.attnum,
+             a.attname,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).grantor as grantor,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).grantee as grantee,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).privilege_type as privilege_type,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).is_grantable as is_grantable
+      from (pg_attribute a
+            join pg_class cc on ((a.attrelid = cc.oid)))
+      where ((a.attnum > 0)
+             and (not a.attisdropped))) pr_a(attrelid, attnum, attname, grantor, grantee, prtype, grantable),
+                                        pg_class c
+   where ((pr_a.attrelid = c.oid)
+          and (c.relkind = any (ARRAY['r',
+                                      'v',
+                                      'm',
+                                      'f',
+                                      'p'])))) x,
+     pg_namespace nc,
+     pg_authid u_grantor,
+  (select pg_authid.oid,
+          pg_authid.rolname
+   from pg_authid
+   union all select (0)::oid as oid,
+                    'PUBLIC') grantee(oid, rolname)
+where ((x.relnamespace = nc.oid)
+       ${props.schemaFilter ? `and nc.nspname ${props.schemaFilter}` : ""}
+       ${props.columnIdsFilter ? `and (x.attrelid || '.' || x.attnum) ${props.columnIdsFilter}` : ""}
+       and (x.grantee = grantee.oid)
+       and (x.grantor = u_grantor.oid)
+       and (x.prtype = any (ARRAY['INSERT',
+                                  'SELECT',
+                                  'UPDATE',
+                                  'REFERENCES']))
+       and (pg_has_role(u_grantor.oid, 'USAGE')
+            or pg_has_role(grantee.oid, 'USAGE')
+            or (grantee.rolname = 'PUBLIC')))
+group by column_id,
+         nc.nspname,
+         x.relname,
+         x.attname
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { COLUMN_PRIVILEGES_SQL };

package/dist/vendor/postgres-meta/lib/sql/columns.sql.js

@@ -0,0 +1,123 @@
+//#region src/vendor/postgres-meta/lib/sql/columns.sql.ts
+const COLUMNS_SQL = (props) => `
+-- Adapted from information_schema.columns
+
+SELECT
+  c.oid :: int8 AS table_id,
+  nc.nspname AS schema,
+  c.relname AS table,
+  (c.oid || '.' || a.attnum) AS id,
+  a.attnum AS ordinal_position,
+  a.attname AS name,
+  CASE
+    WHEN a.atthasdef THEN pg_get_expr(ad.adbin, ad.adrelid)
+    ELSE NULL
+  END AS default_value,
+  CASE
+    WHEN t.typtype = 'd' THEN CASE
+      WHEN bt.typelem <> 0 :: oid
+      AND bt.typlen = -1 THEN 'ARRAY'
+      WHEN nbt.nspname = 'pg_catalog' THEN format_type(t.typbasetype, NULL)
+      ELSE 'USER-DEFINED'
+    END
+    ELSE CASE
+      WHEN t.typelem <> 0 :: oid
+      AND t.typlen = -1 THEN 'ARRAY'
+      WHEN nt.nspname = 'pg_catalog' THEN format_type(a.atttypid, NULL)
+      ELSE 'USER-DEFINED'
+    END
+  END AS data_type,
+  COALESCE(bt.typname, t.typname) AS format,
+  a.attidentity IN ('a', 'd') AS is_identity,
+  CASE
+    a.attidentity
+    WHEN 'a' THEN 'ALWAYS'
+    WHEN 'd' THEN 'BY DEFAULT'
+    ELSE NULL
+  END AS identity_generation,
+  a.attgenerated IN ('s') AS is_generated,
+  NOT (
+    a.attnotnull
+    OR t.typtype = 'd' AND t.typnotnull
+  ) AS is_nullable,
+  (
+    c.relkind IN ('r', 'p')
+    OR c.relkind IN ('v', 'f') AND pg_column_is_updatable(c.oid, a.attnum, FALSE)
+  ) AS is_updatable,
+  uniques.table_id IS NOT NULL AS is_unique,
+  check_constraints.definition AS "check",
+  array_to_json(
+    array(
+      SELECT
+        enumlabel
+      FROM
+        pg_catalog.pg_enum enums
+      WHERE
+        enums.enumtypid = coalesce(bt.oid, t.oid)
+        OR enums.enumtypid = coalesce(bt.typelem, t.typelem)
+      ORDER BY
+        enums.enumsortorder
+    )
+  ) AS enums,
+  col_description(c.oid, a.attnum) AS comment
+FROM
+  pg_attribute a
+  LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid
+  AND a.attnum = ad.adnum
+  JOIN (
+    pg_class c
+    JOIN pg_namespace nc ON c.relnamespace = nc.oid
+  ) ON a.attrelid = c.oid
+  JOIN (
+    pg_type t
+    JOIN pg_namespace nt ON t.typnamespace = nt.oid
+  ) ON a.atttypid = t.oid
+  LEFT JOIN (
+    pg_type bt
+    JOIN pg_namespace nbt ON bt.typnamespace = nbt.oid
+  ) ON t.typtype = 'd'
+  AND t.typbasetype = bt.oid
+  LEFT JOIN (
+    SELECT DISTINCT ON (table_id, ordinal_position)
+      conrelid AS table_id,
+      conkey[1] AS ordinal_position
+    FROM pg_catalog.pg_constraint
+    WHERE contype = 'u' AND cardinality(conkey) = 1
+  ) AS uniques ON uniques.table_id = c.oid AND uniques.ordinal_position = a.attnum
+  LEFT JOIN (
+    -- We only select the first column check
+    SELECT DISTINCT ON (table_id, ordinal_position)
+      conrelid AS table_id,
+      conkey[1] AS ordinal_position,
+      substring(
+        pg_get_constraintdef(pg_constraint.oid, true),
+        8,
+        length(pg_get_constraintdef(pg_constraint.oid, true)) - 8
+      ) AS "definition"
+    FROM pg_constraint
+    WHERE contype = 'c' AND cardinality(conkey) = 1
+    ORDER BY table_id, ordinal_position, oid asc
+  ) AS check_constraints ON check_constraints.table_id = c.oid AND check_constraints.ordinal_position = a.attnum
+WHERE
+  ${props.schemaFilter ? `nc.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `(c.oid || '.' || a.attnum) ${props.idsFilter} AND` : ""}
+  ${props.columnNameFilter ? `(c.relname || '.' || a.attname) ${props.columnNameFilter} AND` : ""}
+  ${props.tableIdFilter ? `c.oid ${props.tableIdFilter} AND` : ""}
+  ${props.tableIdentifierFilter ? `nc.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
+  NOT pg_is_other_temp_schema(nc.oid)
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+  AND (c.relkind IN ('r', 'v', 'm', 'f', 'p'))
+  AND (
+    pg_has_role(c.relowner, 'USAGE')
+    OR has_column_privilege(
+      c.oid,
+      a.attnum,
+      'SELECT, INSERT, UPDATE, REFERENCES'
+    )
+  )
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { COLUMNS_SQL };

package/dist/vendor/postgres-meta/lib/sql/common.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/postgres-meta/lib/sql/config.sql.js

@@ -0,0 +1,32 @@
+//#region src/vendor/postgres-meta/lib/sql/config.sql.ts
+const CONFIG_SQL = (props) => `
+SELECT
+  name,
+  setting,
+  category,
+  TRIM(split_part(category, '/', 1)) AS group,
+  TRIM(split_part(category, '/', 2)) AS subgroup,
+  unit,
+  short_desc,
+  extra_desc,
+  context,
+  vartype,
+  source,
+  min_val,
+  max_val,
+  enumvals,
+  boot_val,
+  reset_val,
+  sourcefile,
+  sourceline,
+  pending_restart
+FROM
+  pg_settings
+ORDER BY
+  category,
+  name
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { CONFIG_SQL };

package/dist/vendor/postgres-meta/lib/sql/extensions.sql.js

@@ -0,0 +1,20 @@
+//#region src/vendor/postgres-meta/lib/sql/extensions.sql.ts
+const EXTENSIONS_SQL = (props) => `
+SELECT
+  e.name,
+  n.nspname AS schema,
+  e.default_version,
+  x.extversion AS installed_version,
+  e.comment
+FROM
+  pg_available_extensions() e(name, default_version, comment)
+  LEFT JOIN pg_extension x ON e.name = x.extname
+  LEFT JOIN pg_namespace n ON x.extnamespace = n.oid
+WHERE
+  true
+  ${props.nameFilter ? `AND e.name ${props.nameFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { EXTENSIONS_SQL };

package/dist/vendor/postgres-meta/lib/sql/foreign_tables.sql.js

@@ -0,0 +1,20 @@
+//#region src/vendor/postgres-meta/lib/sql/foreign_tables.sql.ts
+const FOREIGN_TABLES_SQL = (props) => `
+SELECT
+  c.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS name,
+  obj_description(c.oid) AS comment
+FROM
+  pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE
+  ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
+  ${props.tableIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.tableIdentifierFilter} AND` : ""}
+  c.relkind = 'f'
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { FOREIGN_TABLES_SQL };