neon 8.4.5 → 8.6.0

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 };

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

@@ -0,0 +1,203 @@
+import { filterByValue } from "./helpers.js";
+import { ROLES_SQL } from "./sql/roles.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaRoles.ts
+function changeRoleConfig2Object(config) {
+	if (!config) return null;
+	return config.reduce((acc, cur) => {
+		const [key, value] = cur.split("=");
+		acc[key] = value;
+		return acc;
+	}, {});
+}
+var PostgresMetaRoles = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeDefaultRoles = false, limit, offset } = {}) {
+		const sql = ROLES_SQL({
+			limit,
+			offset,
+			includeDefaultRoles
+		});
+		const result = await this.query(sql);
+		if (result.data) result.data = result.data.map((role) => {
+			role.config = changeRoleConfig2Object(role.config);
+			return role;
+		});
+		return result;
+	}
+	async retrieve({ id, name }) {
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = ROLES_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 role with ID ${id}` }
+			};
+			else {
+				data[0].config = changeRoleConfig2Object(data[0].config);
+				return {
+					data: data[0],
+					error
+				};
+			}
+		} else if (name) {
+			const nameFilter = filterByValue([name]);
+			const sql = ROLES_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 role named ${name}` }
+			};
+			else {
+				data[0].config = changeRoleConfig2Object(data[0].config);
+				return {
+					data: data[0],
+					error
+				};
+			}
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on role retrieve" }
+		};
+	}
+	async create({ name, is_superuser = false, can_create_db = false, can_create_role = false, inherit_role = true, can_login = false, is_replication_role = false, can_bypass_rls = false, connection_limit = -1, password, valid_until, member_of, members, admins, config }) {
+		const isSuperuserClause = is_superuser ? "SUPERUSER" : "NOSUPERUSER";
+		const canCreateDbClause = can_create_db ? "CREATEDB" : "NOCREATEDB";
+		const canCreateRoleClause = can_create_role ? "CREATEROLE" : "NOCREATEROLE";
+		const inheritRoleClause = inherit_role ? "INHERIT" : "NOINHERIT";
+		const canLoginClause = can_login ? "LOGIN" : "NOLOGIN";
+		const isReplicationRoleClause = is_replication_role ? "REPLICATION" : "NOREPLICATION";
+		const canBypassRlsClause = can_bypass_rls ? "BYPASSRLS" : "NOBYPASSRLS";
+		const connectionLimitClause = `CONNECTION LIMIT ${connection_limit}`;
+		const passwordClause = password === void 0 ? "" : `PASSWORD ${literal(password)}`;
+		const validUntilClause = valid_until === void 0 ? "" : `VALID UNTIL ${literal(valid_until)}`;
+		const memberOfClause = member_of === void 0 ? "" : `IN ROLE ${member_of.join(",")}`;
+		const membersClause = members === void 0 ? "" : `ROLE ${members.join(",")}`;
+		const adminsClause = admins === void 0 ? "" : `ADMIN ${admins.join(",")}`;
+		let configClause = "";
+		if (config !== void 0) configClause = Object.keys(config).map((k) => {
+			const v = config[k];
+			if (!k || !v) return "";
+			return `ALTER ROLE ${name} SET ${k} = ${v};`;
+		}).join("\n");
+		const sql = `
+BEGIN;
+CREATE ROLE ${ident(name)}
+WITH
+  ${isSuperuserClause}
+  ${canCreateDbClause}
+  ${canCreateRoleClause}
+  ${inheritRoleClause}
+  ${canLoginClause}
+  ${isReplicationRoleClause}
+  ${canBypassRlsClause}
+  ${connectionLimitClause}
+  ${passwordClause}
+  ${validUntilClause}
+  ${memberOfClause}
+  ${membersClause}
+  ${adminsClause};
+${configClause ? configClause : ""}
+COMMIT;`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({ name });
+	}
+	async update(id, { name, is_superuser, can_create_db, can_create_role, inherit_role, can_login, is_replication_role, can_bypass_rls, connection_limit, password, valid_until, config }) {
+		const { data: old, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const nameSql = name === void 0 ? "" : `ALTER ROLE ${ident(old.name)} RENAME TO ${ident(name)};`;
+		let isSuperuserClause = "";
+		if (is_superuser !== void 0) isSuperuserClause = is_superuser ? "SUPERUSER" : "NOSUPERUSER";
+		let canCreateDbClause = "";
+		if (can_create_db !== void 0) canCreateDbClause = can_create_db ? "CREATEDB" : "NOCREATEDB";
+		let canCreateRoleClause = "";
+		if (can_create_role !== void 0) canCreateRoleClause = can_create_role ? "CREATEROLE" : "NOCREATEROLE";
+		let inheritRoleClause = "";
+		if (inherit_role !== void 0) inheritRoleClause = inherit_role ? "INHERIT" : "NOINHERIT";
+		let canLoginClause = "";
+		if (can_login !== void 0) canLoginClause = can_login ? "LOGIN" : "NOLOGIN";
+		let isReplicationRoleClause = "";
+		if (is_replication_role !== void 0) isReplicationRoleClause = is_replication_role ? "REPLICATION" : "NOREPLICATION";
+		let canBypassRlsClause = "";
+		if (can_bypass_rls !== void 0) canBypassRlsClause = can_bypass_rls ? "BYPASSRLS" : "NOBYPASSRLS";
+		const connectionLimitClause = connection_limit === void 0 ? "" : `CONNECTION LIMIT ${connection_limit}`;
+		const passwordClause = password === void 0 ? "" : `PASSWORD ${literal(password)}`;
+		const validUntilClause = valid_until === void 0 ? "" : `VALID UNTIL ${literal(valid_until)}`;
+		let configClause = "";
+		if (config !== void 0) configClause = config.map((c) => {
+			const { op, path, value } = c;
+			const k = path;
+			const v = value || null;
+			if (!k) throw new Error(`Invalid config value ${value}`);
+			switch (op) {
+				case "add":
+				case "replace": return `ALTER ROLE ${ident(old.name)} SET ${ident(k)} = ${literal(v)};`;
+				case "remove": return `ALTER ROLE ${ident(old.name)} RESET ${ident(k)};`;
+				default: throw new Error(`Invalid config op ${op}`);
+			}
+		}).filter(Boolean).join("");
+		const sql = `
+BEGIN;
+  ALTER ROLE ${ident(old.name)}
+    ${isSuperuserClause}
+    ${canCreateDbClause}
+    ${canCreateRoleClause}
+    ${inheritRoleClause}
+    ${canLoginClause}
+    ${isReplicationRoleClause}
+    ${canBypassRlsClause}
+    ${connectionLimitClause}
+    ${passwordClause}
+    ${validUntilClause};
+  ${configClause ? configClause : ""}
+  ${nameSql}
+COMMIT;`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return await this.retrieve({ id });
+	}
+	async remove(id) {
+		const { data: role, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP ROLE ${ident(role.name)};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: role,
+			error: null
+		};
+	}
+};
+//#endregion
+export { changeRoleConfig2Object, PostgresMetaRoles as default };