neon 8.4.4 → 8.5.0

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

@@ -0,0 +1,173 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { FUNCTIONS_SQL } from "./sql/functions.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaFunctions.ts
+var PostgresMetaFunctions = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeSystemSchemas = false, includedSchemas, excludedSchemas, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		const sql = FUNCTIONS_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, schema = "public", args = [] }) {
+		const schemaFilter = schema ? filterByList([schema], []) : void 0;
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = FUNCTIONS_SQL({ idsFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a function with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name && schema && args) {
+			const nameFilter = filterByValue([name]);
+			const sql = FUNCTIONS_SQL({
+				schemaFilter,
+				nameFilter,
+				args: args.map(literal)
+			});
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find function "${schema}"."${name}"(${args.join(", ")})` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on function retrieve" }
+		};
+	}
+	async create({ name, schema = "public", args = [], definition, return_type = "void", language = "sql", behavior = "VOLATILE", security_definer = false, config_params = {} }) {
+		const sql = this.generateCreateFunctionSql({
+			name,
+			schema,
+			args,
+			definition,
+			return_type,
+			language,
+			behavior,
+			security_definer,
+			config_params
+		});
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({
+			name,
+			schema,
+			args
+		});
+	}
+	async update(id, { name, schema, definition }) {
+		const { data: currentFunc, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const args = currentFunc.argument_types.split(", ");
+		const identityArgs = currentFunc.identity_argument_types;
+		const updateDefinitionSql = typeof definition === "string" ? this.generateCreateFunctionSql({
+			...currentFunc,
+			definition,
+			args,
+			config_params: currentFunc.config_params ?? {}
+		}, { replace: true }) : "";
+		const updateNameSql = name && name !== currentFunc.name ? `ALTER FUNCTION ${ident(currentFunc.schema)}.${ident(currentFunc.name)}(${identityArgs}) RENAME TO ${ident(name)};` : "";
+		const updateSchemaSql = schema && schema !== currentFunc.schema ? `ALTER FUNCTION ${ident(currentFunc.schema)}.${ident(name || currentFunc.name)}(${identityArgs})  SET SCHEMA ${ident(schema)};` : "";
+		const currentSchemaFilter = currentFunc.schema ? filterByList([currentFunc.schema], []) : void 0;
+		const currentNameFilter = currentFunc.name ? filterByValue([currentFunc.name]) : void 0;
+		const sql = `
+      DO LANGUAGE plpgsql $$
+      BEGIN
+        IF ${typeof definition === "string" ? "TRUE" : "FALSE"} THEN
+          ${updateDefinitionSql}
+
+          IF (
+            SELECT id
+            FROM (${FUNCTIONS_SQL({
+			schemaFilter: currentSchemaFilter,
+			nameFilter: currentNameFilter
+		})}) AS f
+            WHERE f.schema = ${literal(currentFunc.schema)}
+            AND f.name = ${literal(currentFunc.name)}
+            AND f.identity_argument_types = ${literal(identityArgs)}
+          ) != ${id} THEN
+            RAISE EXCEPTION 'Cannot find function "${currentFunc.schema}"."${currentFunc.name}"(${identityArgs})';
+          END IF;
+        END IF;
+
+        ${updateNameSql}
+
+        ${updateSchemaSql}
+      END;
+      $$;
+    `;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return await this.retrieve({ id });
+	}
+	async remove(id, { cascade = false } = {}) {
+		const { data: func, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP FUNCTION ${ident(func.schema)}.${ident(func.name)}
+    (${func.identity_argument_types})
+    ${cascade ? "CASCADE" : "RESTRICT"};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: func,
+			error: null
+		};
+	}
+	generateCreateFunctionSql({ name, schema, args, definition, return_type, language, behavior, security_definer, config_params }, { replace = false } = {}) {
+		return `
+      CREATE ${replace ? "OR REPLACE" : ""} FUNCTION ${ident(schema)}.${ident(name)}(${args?.join(", ") || ""})
+      RETURNS ${return_type}
+      AS ${literal(definition)}
+      LANGUAGE ${language}
+      ${behavior}
+      CALLED ON NULL INPUT
+      ${security_definer ? "SECURITY DEFINER" : "SECURITY INVOKER"}
+      ${config_params ? Object.entries(config_params).map(([param, value]) => `SET ${param} ${value[0] === "FROM CURRENT" ? "FROM CURRENT" : "TO " + value}`).join("\n") : ""};
+    `;
+	}
+};
+//#endregion
+export { PostgresMetaFunctions as default };

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

@@ -0,0 +1,42 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { INDEXES_SQL } from "./sql/indexes.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaIndexes.ts
+var PostgresMetaIndexes = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeSystemSchemas = false, includedSchemas, excludedSchemas, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		const sql = INDEXES_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id }) {
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = INDEXES_SQL({ idsFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a index with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on function retrieve" }
+		};
+	}
+};
+//#endregion
+export { PostgresMetaIndexes as default };

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

@@ -0,0 +1,84 @@
+import { coalesceRowsToArray, filterByList, filterByValue } from "./helpers.js";
+import { COLUMNS_SQL } from "./sql/columns.sql.js";
+import { MATERIALIZED_VIEWS_SQL } from "./sql/materialized_views.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaMaterializedViews.ts
+var PostgresMetaMaterializedViews = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includedSchemas, excludedSchemas, limit, offset, includeColumns = false } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, void 0);
+		let sql = generateEnrichedMaterializedViewsSql({
+			includeColumns,
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, schema = "public" }) {
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = generateEnrichedMaterializedViewsSql({
+				includeColumns: true,
+				idsFilter
+			});
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a materialized view with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name) {
+			const materializedViewIdentifierFilter = filterByValue([`${schema}.${name}`]);
+			const sql = generateEnrichedMaterializedViewsSql({
+				includeColumns: true,
+				materializedViewIdentifierFilter
+			});
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a materialized view named ${name} in schema ${schema}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on materialized view retrieve" }
+		};
+	}
+};
+const generateEnrichedMaterializedViewsSql = ({ includeColumns, schemaFilter, materializedViewIdentifierFilter, idsFilter, limit, offset }) => `
+with materialized_views as (${MATERIALIZED_VIEWS_SQL({
+	schemaFilter,
+	limit,
+	offset,
+	materializedViewIdentifierFilter,
+	idsFilter
+})})
+  ${includeColumns ? `, columns as (${COLUMNS_SQL({
+	schemaFilter,
+	limit,
+	offset,
+	tableIdentifierFilter: materializedViewIdentifierFilter,
+	tableIdFilter: idsFilter
+})})` : ""}
+select
+  *
+  ${includeColumns ? `, ${coalesceRowsToArray("columns", "columns.table_id = materialized_views.id")}` : ""}
+from materialized_views`;
+//#endregion
+export { PostgresMetaMaterializedViews as default };

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

@@ -0,0 +1,120 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { POLICIES_SQL } from "./sql/policies.sql.js";
+import { ident } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaPolicies.ts
+var PostgresMetaPolicies = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeSystemSchemas = false, includedSchemas, excludedSchemas, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		let sql = POLICIES_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, table, schema = "public" }) {
+		const schemaFilter = schema ? filterByList([schema], []) : void 0;
+		if (id) {
+			const idsFilter = filterByValue([`${id}`]);
+			const sql = POLICIES_SQL({ idsFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a policy with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name && table) {
+			const functionNameIdentifierFilter = filterByValue([`${table}.${name}`]);
+			const sql = POLICIES_SQL({
+				schemaFilter,
+				functionNameIdentifierFilter
+			});
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a policy named ${name} for table ${schema}.${table}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on policy retrieve" }
+		};
+	}
+	async create({ name, table, schema = "public", definition, check, action = "PERMISSIVE", command = "ALL", roles = ["public"] }) {
+		const definitionClause = definition === void 0 ? "" : `USING (${definition})`;
+		const checkClause = check === void 0 ? "" : `WITH CHECK (${check})`;
+		const sql = `
+CREATE POLICY ${ident(name)} ON ${ident(schema)}.${ident(table)}
+  AS ${action}
+  FOR ${command}
+  TO ${roles.map(ident).join(",")}
+  ${definitionClause} ${checkClause};`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({
+			name,
+			table,
+			schema
+		});
+	}
+	async update(id, { name, definition, check, roles }) {
+		const { data: old, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const alter = `ALTER POLICY ${ident(old.name)} ON ${ident(old.schema)}.${ident(old.table)}`;
+		const nameSql = name === void 0 ? "" : `${alter} RENAME TO ${ident(name)};`;
+		const sql = `BEGIN; ${definition === void 0 ? "" : `${alter} USING (${definition});`} ${check === void 0 ? "" : `${alter} WITH CHECK (${check});`} ${roles === void 0 ? "" : `${alter} TO ${roles.map(ident).join(",")};`} ${nameSql} COMMIT;`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return await this.retrieve({ id });
+	}
+	async remove(id) {
+		const { data: policy, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP POLICY ${ident(policy.name)} ON ${ident(policy.schema)}.${ident(policy.table)};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: policy,
+			error: null
+		};
+	}
+};
+//#endregion
+export { PostgresMetaPolicies as default };

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

@@ -0,0 +1,193 @@
+import { filterByValue } from "./helpers.js";
+import { PUBLICATIONS_SQL } from "./sql/publications.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaPublications.ts
+var PostgresMetaPublications = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ limit, offset }) {
+		let sql = PUBLICATIONS_SQL({
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name }) {
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = PUBLICATIONS_SQL({ idsFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a publication with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name) {
+			const nameFilter = filterByValue([name]);
+			const sql = PUBLICATIONS_SQL({ nameFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data,
+				error
+			};
+			else if (data.length === 0) return {
+				data: null,
+				error: { message: `Cannot find a publication named ${name}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on publication retrieve" }
+		};
+	}
+	async create({ name, publish_insert = false, publish_update = false, publish_delete = false, publish_truncate = false, tables = null }) {
+		let tableClause;
+		if (tables === void 0 || tables === null) tableClause = "FOR ALL TABLES";
+		else if (tables.length === 0) tableClause = "";
+		else tableClause = `FOR TABLE ${tables.map((t) => {
+			if (!t.includes(".")) return ident(t);
+			const [schema, ...rest] = t.split(".");
+			const table = rest.join(".");
+			return `${ident(schema)}.${ident(table)}`;
+		}).join(",")}`;
+		let publishOps = [];
+		if (publish_insert) publishOps.push("insert");
+		if (publish_update) publishOps.push("update");
+		if (publish_delete) publishOps.push("delete");
+		if (publish_truncate) publishOps.push("truncate");
+		const sql = `
+CREATE PUBLICATION ${ident(name)} ${tableClause}
+  WITH (publish = '${publishOps.join(",")}');`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({ name });
+	}
+	async update(id, { name, owner, publish_insert, publish_update, publish_delete, publish_truncate, tables }) {
+		const sql = `
+do $$
+declare
+  id oid := ${literal(id)};
+  old record;
+  new_name text := ${name === void 0 ? null : literal(name)};
+  new_owner text := ${owner === void 0 ? null : literal(owner)};
+  new_publish_insert bool := ${publish_insert ?? null};
+  new_publish_update bool := ${publish_update ?? null};
+  new_publish_delete bool := ${publish_delete ?? null};
+  new_publish_truncate bool := ${publish_truncate ?? null};
+  new_tables text := ${tables === void 0 ? null : literal(tables === null ? "all tables" : tables.map((t) => {
+			if (!t.includes(".")) return ident(t);
+			const [schema, ...rest] = t.split(".");
+			const table = rest.join(".");
+			return `${ident(schema)}.${ident(table)}`;
+		}).join(","))};
+begin
+  select * into old from pg_publication where oid = id;
+  if old is null then
+    raise exception 'Cannot find publication with id %', id;
+  end if;
+
+  if new_tables is null then
+    null;
+  elsif new_tables = 'all tables' then
+    if old.puballtables then
+      null;
+    else
+      -- Need to recreate because going from list of tables <-> all tables with alter is not possible.
+      execute(format('drop publication %1$I; create publication %1$I for all tables;', old.pubname));
+    end if;
+  else
+    if old.puballtables then
+      -- Need to recreate because going from list of tables <-> all tables with alter is not possible.
+      execute(format('drop publication %1$I; create publication %1$I;', old.pubname));
+    elsif exists(select from pg_publication_rel where prpubid = id) then
+      execute(
+        format(
+          'alter publication %I drop table %s',
+          old.pubname,
+          (select string_agg(prrelid::regclass::text, ', ') from pg_publication_rel where prpubid = id)
+        )
+      );
+    end if;
+
+    -- At this point the publication must have no tables.
+
+    if new_tables != '' then
+      execute(format('alter publication %I add table %s', old.pubname, new_tables));
+    end if;
+  end if;
+
+  execute(
+    format(
+      'alter publication %I set (publish = %L);',
+      old.pubname,
+      concat_ws(
+        ', ',
+        case when coalesce(new_publish_insert, old.pubinsert) then 'insert' end,
+        case when coalesce(new_publish_update, old.pubupdate) then 'update' end,
+        case when coalesce(new_publish_delete, old.pubdelete) then 'delete' end,
+        case when coalesce(new_publish_truncate, old.pubtruncate) then 'truncate' end
+      )
+    )
+  );
+
+  execute(format('alter publication %I owner to %I;', old.pubname, coalesce(new_owner, old.pubowner::regrole::name)));
+
+  -- Using the same name in the rename clause gives an error, so only do it if the new name is different.
+  if new_name is not null and new_name != old.pubname then
+    execute(format('alter publication %I rename to %I;', old.pubname, coalesce(new_name, old.pubname)));
+  end if;
+
+  -- We need to retrieve the publication later, so we need a way to uniquely identify which publication this is.
+  -- We can't rely on id because it gets changed if it got recreated.
+  -- We use a temp table to store the unique name - DO blocks can't return a value.
+  create temp table pg_meta_publication_tmp (name) on commit drop as values (coalesce(new_name, old.pubname));
+end $$;
+
+with publications as (${PUBLICATIONS_SQL({})}) select * from publications where name = (select name from pg_meta_publication_tmp);
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return {
+			data: data[0],
+			error
+		};
+	}
+	async remove(id) {
+		const { data: publication, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP PUBLICATION IF EXISTS ${ident(publication.name)};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: publication,
+			error: null
+		};
+	}
+};
+//#endregion
+export { PostgresMetaPublications as default };

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

@@ -0,0 +1,87 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList } from "./helpers.js";
+import { TABLE_RELATIONSHIPS_SQL } from "./sql/table_relationships.sql.js";
+import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaRelationships.ts
+var PostgresMetaRelationships = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeSystemSchemas = false, includedSchemas, excludedSchemas } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		let allTableM2oAndO2oRelationships;
+		{
+			const sql = TABLE_RELATIONSHIPS_SQL({ schemaFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+			allTableM2oAndO2oRelationships = data;
+		}
+		let allViewM2oAndO2oRelationships;
+		{
+			const viewsKeyDependenciesSql = VIEWS_KEY_DEPENDENCIES_SQL({ schemaFilter });
+			const { data: viewsKeyDependencies, error } = await this.query(viewsKeyDependenciesSql);
+			if (error) return {
+				data: null,
+				error
+			};
+			allViewM2oAndO2oRelationships = allTableM2oAndO2oRelationships.flatMap((r) => {
+				const expandKeyDepCols = (colDeps) => {
+					const tableColumns = colDeps.map(({ table_column }) => table_column);
+					const cartesianProduct = (allEntries) => {
+						return allEntries.reduce((results, entries) => results.map((result) => entries.map((entry) => result.concat(entry))).reduce((subResults, result) => subResults.concat(result), []), [[]]);
+					};
+					return cartesianProduct(colDeps.map((cd) => cd.view_columns)).map((viewColumns) => ({
+						tableColumns,
+						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 viewToTableRelationships = viewToTableKeyDeps.flatMap((vtkd) => expandKeyDepCols(vtkd.column_dependencies).map(({ viewColumns }) => ({
+					foreign_key_name: r.foreign_key_name,
+					schema: vtkd.view_schema,
+					relation: vtkd.view_name,
+					columns: viewColumns,
+					is_one_to_one: r.is_one_to_one,
+					referenced_schema: r.referenced_schema,
+					referenced_relation: r.referenced_relation,
+					referenced_columns: r.referenced_columns
+				})));
+				const tableToViewRelationships = tableToViewKeyDeps.flatMap((tvkd) => expandKeyDepCols(tvkd.column_dependencies).map(({ viewColumns }) => ({
+					foreign_key_name: r.foreign_key_name,
+					schema: r.schema,
+					relation: r.relation,
+					columns: r.columns,
+					is_one_to_one: r.is_one_to_one,
+					referenced_schema: tvkd.view_schema,
+					referenced_relation: tvkd.view_name,
+					referenced_columns: viewColumns
+				})));
+				const viewToViewRelationships = viewToTableKeyDeps.flatMap((vtkd) => expandKeyDepCols(vtkd.column_dependencies).flatMap(({ viewColumns }) => tableToViewKeyDeps.flatMap((tvkd) => expandKeyDepCols(tvkd.column_dependencies).map(({ viewColumns: referencedViewColumns }) => ({
+					foreign_key_name: r.foreign_key_name,
+					schema: vtkd.view_schema,
+					relation: vtkd.view_name,
+					columns: viewColumns,
+					is_one_to_one: r.is_one_to_one,
+					referenced_schema: tvkd.view_schema,
+					referenced_relation: tvkd.view_name,
+					referenced_columns: referencedViewColumns
+				})))));
+				return [
+					...viewToTableRelationships,
+					...tableToViewRelationships,
+					...viewToViewRelationships
+				];
+			});
+		}
+		return {
+			data: allTableM2oAndO2oRelationships.concat(allViewM2oAndO2oRelationships),
+			error: null
+		};
+	}
+};
+//#endregion
+export { PostgresMetaRelationships as default };