neon 8.4.5 → 8.6.0

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

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