neon 8.4.4 → 8.5.0

package/{LICENSE → dist/vendor/postgres-meta/LICENSE}

@@ -1,4 +1,3 @@
-
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/

package/dist/vendor/postgres-meta/constants.js

@@ -0,0 +1,14 @@
+//#region src/vendor/postgres-meta/constants.ts
+const GENERATE_TYPES_DEFAULT_SCHEMA = process.env.PG_META_GENERATE_TYPES_DEFAULT_SCHEMA || "public";
+const VALID_UNNAMED_FUNCTION_ARG_TYPES = /* @__PURE__ */ new Set([
+	114,
+	3802,
+	25
+]);
+const VALID_FUNCTION_ARGS_MODE = /* @__PURE__ */ new Set([
+	"in",
+	"inout",
+	"variadic"
+]);
+//#endregion
+export { GENERATE_TYPES_DEFAULT_SCHEMA, VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES };

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

@@ -0,0 +1,49 @@
+import PostgresMetaColumnPrivileges from "./PostgresMetaColumnPrivileges.js";
+import PostgresMetaTables from "./PostgresMetaTables.js";
+import PostgresMetaColumns from "./PostgresMetaColumns.js";
+import PostgresMetaConfig from "./PostgresMetaConfig.js";
+import PostgresMetaExtensions from "./PostgresMetaExtensions.js";
+import PostgresMetaForeignTables from "./PostgresMetaForeignTables.js";
+import PostgresMetaFunctions from "./PostgresMetaFunctions.js";
+import PostgresMetaIndexes from "./PostgresMetaIndexes.js";
+import PostgresMetaMaterializedViews from "./PostgresMetaMaterializedViews.js";
+import PostgresMetaPolicies from "./PostgresMetaPolicies.js";
+import PostgresMetaPublications from "./PostgresMetaPublications.js";
+import PostgresMetaRelationships from "./PostgresMetaRelationships.js";
+import PostgresMetaRoles from "./PostgresMetaRoles.js";
+import PostgresMetaSchemas from "./PostgresMetaSchemas.js";
+import PostgresMetaTablePrivileges from "./PostgresMetaTablePrivileges.js";
+import PostgresMetaTriggers from "./PostgresMetaTriggers.js";
+import PostgresMetaTypes from "./PostgresMetaTypes.js";
+import PostgresMetaVersion from "./PostgresMetaVersion.js";
+import PostgresMetaViews from "./PostgresMetaViews.js";
+import { init } from "./db.js";
+//#region src/vendor/postgres-meta/lib/PostgresMeta.ts
+var PostgresMeta = class {
+	constructor(config) {
+		const { query, end } = init(config);
+		this.query = query;
+		this.end = end;
+		this.columnPrivileges = new PostgresMetaColumnPrivileges(this.query);
+		this.columns = new PostgresMetaColumns(this.query);
+		this.config = new PostgresMetaConfig(this.query);
+		this.extensions = new PostgresMetaExtensions(this.query);
+		this.foreignTables = new PostgresMetaForeignTables(this.query);
+		this.functions = new PostgresMetaFunctions(this.query);
+		this.indexes = new PostgresMetaIndexes(this.query);
+		this.materializedViews = new PostgresMetaMaterializedViews(this.query);
+		this.policies = new PostgresMetaPolicies(this.query);
+		this.publications = new PostgresMetaPublications(this.query);
+		this.relationships = new PostgresMetaRelationships(this.query);
+		this.roles = new PostgresMetaRoles(this.query);
+		this.schemas = new PostgresMetaSchemas(this.query);
+		this.tablePrivileges = new PostgresMetaTablePrivileges(this.query);
+		this.tables = new PostgresMetaTables(this.query);
+		this.triggers = new PostgresMetaTriggers(this.query);
+		this.types = new PostgresMetaTypes(this.query);
+		this.version = new PostgresMetaVersion(this.query);
+		this.views = new PostgresMetaViews(this.query);
+	}
+};
+//#endregion
+export { PostgresMeta as default };

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

@@ -0,0 +1,85 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { COLUMN_PRIVILEGES_SQL } from "./sql/column_privileges.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaColumnPrivileges.ts
+var PostgresMetaColumnPrivileges = 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 = COLUMN_PRIVILEGES_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async grant(grants) {
+		let sql = `
+do $$
+declare
+  col record;
+begin
+${grants.map(({ privilege_type, column_id, grantee, is_grantable }) => {
+			const [relationId, columnNumber] = column_id.split(".");
+			return `
+select *
+from pg_attribute a
+where a.attrelid = ${literal(relationId)}
+  and a.attnum = ${literal(columnNumber)}
+into col;
+execute format(
+  'grant ${privilege_type} (%I) on %s to ${grantee.toLowerCase() === "public" ? "public" : ident(grantee)} ${is_grantable ? "with grant option" : ""}',
+  col.attname,
+  col.attrelid::regclass
+);`;
+		}).join("\n")}
+end $$;
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data,
+			error
+		};
+		const columnIds = [...new Set(grants.map(({ column_id }) => column_id))];
+		const columnIdsFilter = filterByValue(columnIds);
+		sql = COLUMN_PRIVILEGES_SQL({ columnIdsFilter });
+		return await this.query(sql);
+	}
+	async revoke(revokes) {
+		let sql = `
+do $$
+declare
+  col record;
+begin
+${revokes.map(({ privilege_type, column_id, grantee }) => {
+			const [relationId, columnNumber] = column_id.split(".");
+			return `
+select *
+from pg_attribute a
+where a.attrelid = ${literal(relationId)}
+  and a.attnum = ${literal(columnNumber)}
+into col;
+execute format(
+  'revoke ${privilege_type} (%I) on %s from ${grantee.toLowerCase() === "public" ? "public" : ident(grantee)}',
+  col.attname,
+  col.attrelid::regclass
+);`;
+		}).join("\n")}
+end $$;
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data,
+			error
+		};
+		const columnIds = [...new Set(revokes.map(({ column_id }) => column_id))];
+		const columnIdsFilter = filterByValue(columnIds);
+		sql = COLUMN_PRIVILEGES_SQL({ columnIdsFilter });
+		return await this.query(sql);
+	}
+};
+//#endregion
+export { PostgresMetaColumnPrivileges as default };

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

@@ -0,0 +1,235 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { COLUMNS_SQL } from "./sql/columns.sql.js";
+import PostgresMetaTables from "./PostgresMetaTables.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaColumns.ts
+var PostgresMetaColumns = class {
+	constructor(query) {
+		this.query = query;
+		this.metaTables = new PostgresMetaTables(query);
+	}
+	async list({ tableId, includeSystemSchemas = false, includedSchemas, excludedSchemas, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		const tableIdFilter = tableId ? filterByValue([`${tableId}`]) : void 0;
+		const sql = COLUMNS_SQL({
+			schemaFilter,
+			tableIdFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, table, schema = "public" }) {
+		const schemaFilter = schema ? filterByList([schema], []) : void 0;
+		if (id) {
+			const regexp = /^(\d+)\.(\d+)$/;
+			if (!regexp.test(id)) return {
+				data: null,
+				error: { message: "Invalid format for column ID" }
+			};
+			const [tableId, ordinalPos] = id.match(regexp).slice(1).map(Number);
+			const idsFilter = filterByValue([`${tableId}.${ordinalPos}`]);
+			const sql = COLUMNS_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 column with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name && table) {
+			const columnNameFilter = filterByValue([`${table}.${name}`]);
+			const sql = `${COLUMNS_SQL({
+				schemaFilter,
+				columnNameFilter
+			})};`;
+			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 column named ${name} in table ${schema}.${table}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on column retrieve" }
+		};
+	}
+	async create({ table_id, name, type, default_value, default_value_format = "literal", is_identity = false, identity_generation = "BY DEFAULT", is_nullable, is_primary_key = false, is_unique = false, comment, check }) {
+		const { data, error } = await this.metaTables.retrieve({ id: table_id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const { name: table, schema } = data;
+		let defaultValueClause = "";
+		if (is_identity) {
+			if (default_value !== void 0) return {
+				data: null,
+				error: { message: "Columns cannot both be identity and have a default value" }
+			};
+			defaultValueClause = `GENERATED ${identity_generation} AS IDENTITY`;
+		} else if (default_value === void 0) {} else if (default_value_format === "expression") defaultValueClause = `DEFAULT ${default_value}`;
+		else defaultValueClause = `DEFAULT ${literal(default_value)}`;
+		let isNullableClause = "";
+		if (is_nullable !== void 0) isNullableClause = is_nullable ? "NULL" : "NOT NULL";
+		const isPrimaryKeyClause = is_primary_key ? "PRIMARY KEY" : "";
+		const isUniqueClause = is_unique ? "UNIQUE" : "";
+		const checkSql = check === void 0 ? "" : `CHECK (${check})`;
+		const commentSql = comment === void 0 ? "" : `COMMENT ON COLUMN ${ident(schema)}.${ident(table)}.${ident(name)} IS ${literal(comment)}`;
+		const sql = `
+BEGIN;
+  ALTER TABLE ${ident(schema)}.${ident(table)} ADD COLUMN ${ident(name)} ${typeIdent(type)}
+    ${defaultValueClause}
+    ${isNullableClause}
+    ${isPrimaryKeyClause}
+    ${isUniqueClause}
+    ${checkSql};
+  ${commentSql};
+COMMIT;`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return await this.retrieve({
+			name,
+			table,
+			schema
+		});
+	}
+	async update(id, { name, type, drop_default = false, default_value, default_value_format = "literal", is_identity, identity_generation = "BY DEFAULT", is_nullable, is_unique, comment, check }) {
+		const { data: old, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const nameSql = name === void 0 || name === old.name ? "" : `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} RENAME COLUMN ${ident(old.name)} TO ${ident(name)};`;
+		const typeSql = type === void 0 ? "" : `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ALTER COLUMN ${ident(old.name)} SET DATA TYPE ${typeIdent(type)} USING ${ident(old.name)}::${typeIdent(type)};`;
+		let defaultValueSql;
+		if (drop_default) defaultValueSql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ALTER COLUMN ${ident(old.name)} DROP DEFAULT;`;
+		else if (default_value === void 0) defaultValueSql = "";
+		else {
+			const defaultValue = default_value_format === "expression" ? default_value : literal(default_value);
+			defaultValueSql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ALTER COLUMN ${ident(old.name)} SET DEFAULT ${defaultValue};`;
+		}
+		let identitySql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ALTER COLUMN ${ident(old.name)}`;
+		if (is_identity === false) identitySql += " DROP IDENTITY IF EXISTS;";
+		else if (old.is_identity === true) {
+			if (identity_generation === void 0) identitySql = "";
+			else identitySql += ` SET GENERATED ${identity_generation};`;
+		} else if (is_identity === void 0) identitySql = "";
+		else identitySql += ` ADD GENERATED ${identity_generation} AS IDENTITY;`;
+		let isNullableSql;
+		if (is_nullable === void 0) isNullableSql = "";
+		else isNullableSql = is_nullable ? `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ALTER COLUMN ${ident(old.name)} DROP NOT NULL;` : `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ALTER COLUMN ${ident(old.name)} SET NOT NULL;`;
+		let isUniqueSql = "";
+		if (old.is_unique === true && is_unique === false) isUniqueSql = `
+DO $$
+DECLARE
+  r record;
+BEGIN
+  FOR r IN
+    SELECT conname FROM pg_constraint WHERE
+      contype = 'u'
+      AND cardinality(conkey) = 1
+      AND conrelid = ${literal(old.table_id)}
+      AND conkey[1] = ${literal(old.ordinal_position)}
+  LOOP
+    EXECUTE ${literal(`ALTER TABLE ${ident(old.schema)}.${ident(old.table)} DROP CONSTRAINT `)} || quote_ident(r.conname);
+  END LOOP;
+END
+$$;
+`;
+		else if (old.is_unique === false && is_unique === true) isUniqueSql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ADD UNIQUE (${ident(old.name)});`;
+		const commentSql = comment === void 0 ? "" : `COMMENT ON COLUMN ${ident(old.schema)}.${ident(old.table)}.${ident(old.name)} IS ${literal(comment)};`;
+		const checkSql = check === void 0 ? "" : `
+DO $$
+DECLARE
+  v_conname name;
+  v_conkey int2[];
+BEGIN
+  SELECT conname into v_conname FROM pg_constraint WHERE
+    contype = 'c'
+    AND cardinality(conkey) = 1
+    AND conrelid = ${literal(old.table_id)}
+    AND conkey[1] = ${literal(old.ordinal_position)}
+    ORDER BY oid asc
+    LIMIT 1;
+
+  IF v_conname IS NOT NULL THEN
+    EXECUTE format('ALTER TABLE ${ident(old.schema)}.${ident(old.table)} DROP CONSTRAINT %s', v_conname);
+  END IF;
+
+  ${check !== null ? `
+  ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ADD CONSTRAINT ${ident(`${old.table}_${old.name}_check`)} CHECK (${check});
+
+  SELECT conkey into v_conkey FROM pg_constraint WHERE conname = ${literal(`${old.table}_${old.name}_check`)};
+
+  ASSERT v_conkey IS NOT NULL, 'error creating column constraint: check condition must refer to this column';
+  ASSERT cardinality(v_conkey) = 1, 'error creating column constraint: check condition cannot refer to multiple columns';
+  ASSERT v_conkey[1] = ${literal(old.ordinal_position)}, 'error creating column constraint: check condition cannot refer to other columns';
+  ` : ""}
+END
+$$;
+`;
+		const sql = `
+BEGIN;
+  ${isNullableSql}
+  ${typeSql}
+  ${defaultValueSql}
+  ${identitySql}
+  ${isUniqueSql}
+  ${commentSql}
+  ${checkSql}
+  ${nameSql}
+COMMIT;`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return await this.retrieve({ id });
+	}
+	async remove(id, { cascade = false } = {}) {
+		const { data: column, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `ALTER TABLE ${ident(column.schema)}.${ident(column.table)} DROP COLUMN ${ident(column.name)} ${cascade ? "CASCADE" : "RESTRICT"};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: column,
+			error: null
+		};
+	}
+};
+const typeIdent = (type) => {
+	return type.endsWith("[]") ? `${ident(type.slice(0, -2))}[]` : type.includes(".") ? type : ident(type);
+};
+//#endregion
+export { PostgresMetaColumns as default };

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

@@ -0,0 +1,16 @@
+import { CONFIG_SQL } from "./sql/config.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaConfig.ts
+var PostgresMetaConfig = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ limit, offset } = {}) {
+		const sql = CONFIG_SQL({
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+};
+//#endregion
+export { PostgresMetaConfig as default };

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

@@ -0,0 +1,79 @@
+import { filterByValue } from "./helpers.js";
+import { EXTENSIONS_SQL } from "./sql/extensions.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaExtensions.ts
+var PostgresMetaExtensions = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ limit, offset } = {}) {
+		const sql = EXTENSIONS_SQL({
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ name }) {
+		const nameFilter = filterByValue([name]);
+		const sql = EXTENSIONS_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 an extension named ${name}` }
+		};
+		else return {
+			data: data[0],
+			error
+		};
+	}
+	async create({ name, schema, version, cascade = false }) {
+		const sql = `
+CREATE EXTENSION ${ident(name)}
+  ${schema === void 0 ? "" : `SCHEMA ${ident(schema)}`}
+  ${version === void 0 ? "" : `VERSION ${literal(version)}`}
+  ${cascade ? "CASCADE" : ""};`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({ name });
+	}
+	async update(name, { update = false, version, schema }) {
+		let updateSql = "";
+		if (update) updateSql = `ALTER EXTENSION ${ident(name)} UPDATE ${version === void 0 ? "" : `TO ${literal(version)}`};`;
+		const schemaSql = schema === void 0 ? "" : `ALTER EXTENSION ${ident(name)} SET SCHEMA ${ident(schema)};`;
+		const sql = `BEGIN; ${updateSql} ${schemaSql} COMMIT;`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({ name });
+	}
+	async remove(name, { cascade = false } = {}) {
+		const { data: extension, error } = await this.retrieve({ name });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP EXTENSION ${ident(name)} ${cascade ? "CASCADE" : "RESTRICT"};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: extension,
+			error: null
+		};
+	}
+};
+//#endregion
+export { PostgresMetaExtensions as default };

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

@@ -0,0 +1,81 @@
+import { coalesceRowsToArray, filterByList, filterByValue } from "./helpers.js";
+import { COLUMNS_SQL } from "./sql/columns.sql.js";
+import { FOREIGN_TABLES_SQL } from "./sql/foreign_tables.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaForeignTables.ts
+var PostgresMetaForeignTables = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includedSchemas, excludedSchemas, limit, offset, includeColumns = true } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas);
+		const sql = generateEnrichedForeignTablesSql({
+			includeColumns,
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, schema = "public" }) {
+		if (id) {
+			const idsFilter = filterByValue([`${id}`]);
+			const sql = generateEnrichedForeignTablesSql({
+				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 foreign table with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name) {
+			const nameFilter = filterByValue([`${schema}.${name}`]);
+			const sql = generateEnrichedForeignTablesSql({
+				includeColumns: true,
+				tableIdentifierFilter: 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 foreign table named ${name} in schema ${schema}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on foreign table retrieve" }
+		};
+	}
+};
+const generateEnrichedForeignTablesSql = ({ includeColumns, schemaFilter, idsFilter, tableIdentifierFilter, limit, offset }) => `
+with foreign_tables as (${FOREIGN_TABLES_SQL({
+	schemaFilter,
+	tableIdentifierFilter,
+	limit,
+	offset
+})})
+  ${includeColumns ? `, columns as (${COLUMNS_SQL({
+	schemaFilter,
+	tableIdentifierFilter,
+	tableIdFilter: idsFilter
+})})` : ""}
+select
+  *
+  ${includeColumns ? `, ${coalesceRowsToArray("columns", "columns.table_id = foreign_tables.id")}` : ""}
+from foreign_tables`;
+//#endregion
+export { PostgresMetaForeignTables as default };