neon 8.4.5 → 8.5.0

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

@@ -0,0 +1,156 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { TRIGGERS_SQL } from "./sql/triggers.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaTriggers.ts
+var PostgresMetaTriggers = 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 = TRIGGERS_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, schema = "public", table }) {
+		const schemaFilter = schema ? filterByList([schema], []) : void 0;
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = TRIGGERS_SQL({ idsFilter });
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+			const triggerRecord = data && data[0];
+			if (triggerRecord) return {
+				data: triggerRecord,
+				error: null
+			};
+			return {
+				data: null,
+				error: { message: `Cannot find a trigger with ID ${id}` }
+			};
+		}
+		if (name && schema && table) {
+			const nameFilter = filterByValue([name]);
+			const tableNameFilter = filterByValue([table]);
+			const sql = TRIGGERS_SQL({
+				schemaFilter,
+				nameFilter,
+				tableNameFilter
+			});
+			const { data, error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+			const triggerRecord = data && data[0];
+			if (triggerRecord) return {
+				data: triggerRecord,
+				error: null
+			};
+			return {
+				data: null,
+				error: { message: `Cannot find a trigger with name ${name} on table "${schema}"."${table}"` }
+			};
+		}
+		return {
+			data: null,
+			error: { message: "Invalid parameters on trigger retrieve" }
+		};
+	}
+	/**
+	* Creates trigger
+	*
+	* @param {Object} obj - An object.
+	* @param {string} obj.name - Trigger name.
+	* @param {string} obj.schema - Name of schema that trigger is for.
+	* @param {string} obj.table - Unqualified table, view, or foreign table name that trigger is for.
+	* @param {string} obj.function_schema - Name of schema that function is for.
+	* @param {string} obj.function_name - Unqualified name of the function to execute.
+	* @param {('BEFORE'|'AFTER'|'INSTEAD OF')} obj.activation - Determines when function is called
+	* during event occurrence.
+	* @param {Array<string>} obj.events - Event(s) that will fire the trigger. Array of the following options: 'INSERT' | 'UPDATE' | 'UPDATE
+	* OF column_name1,column_name2' | 'DELETE' | 'TRUNCATE'.
+	* @param {('ROW'|'STATEMENT')} obj.orientation - Trigger function for every row affected by event or
+	* once per statement. Defaults to 'STATEMENT'.
+	* @param {string} obj.condition - Boolean expression that will trigger function.
+	* For example: 'old.* IS DISTINCT FROM new.*'
+	* @param {Array<string>} obj.function_args - array of arguments to be passed to function when trigger is fired.
+	* For example: ['arg1', 'arg2']
+	*/
+	async create({ name, schema = "public", table, function_schema = "public", function_name, function_args, activation, events, orientation, condition }) {
+		const qualifiedTableName = `${ident(schema)}.${ident(table)}`;
+		const qualifiedFunctionName = `${ident(function_schema)}.${ident(function_name)}`;
+		const triggerEvents = events.join(" OR ");
+		const triggerOrientation = orientation ? `FOR EACH ${orientation}` : "";
+		const triggerCondition = condition ? `WHEN (${condition})` : "";
+		const functionArgs = `${function_args?.map(literal).join(",") ?? ""}`;
+		const sql = `CREATE TRIGGER ${ident(name)} ${activation} ${triggerEvents} ON ${qualifiedTableName} ${triggerOrientation} ${triggerCondition} EXECUTE FUNCTION ${qualifiedFunctionName}(${functionArgs});`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({
+			name,
+			table,
+			schema
+		});
+	}
+	async update(id, { name, enabled_mode }) {
+		const { data: old, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		let enabledModeSql = "";
+		switch (enabled_mode) {
+			case "ORIGIN":
+				enabledModeSql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ENABLE TRIGGER ${ident(old.name)};`;
+				break;
+			case "DISABLED":
+				enabledModeSql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} DISABLE TRIGGER ${ident(old.name)};`;
+				break;
+			case "REPLICA":
+			case "ALWAYS": enabledModeSql = `ALTER TABLE ${ident(old.schema)}.${ident(old.table)} ENABLE ${enabled_mode} TRIGGER ${ident(old.name)};`;
+		}
+		const nameSql = name && name !== old.name ? `ALTER TRIGGER ${ident(old.name)} ON ${ident(old.schema)}.${ident(old.table)} RENAME TO ${ident(name)};` : "";
+		const sql = `BEGIN; ${enabledModeSql}; ${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: triggerRecord, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const { name, schema, table } = triggerRecord;
+		const sql = `DROP TRIGGER ${ident(name)} ON ${ident(schema)}.${ident(table)} ${cascade ? "CASCADE" : ""};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: triggerRecord,
+			error: null
+		};
+	}
+};
+//#endregion
+export { PostgresMetaTriggers as default };

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

@@ -0,0 +1,22 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList } from "./helpers.js";
+import { TYPES_SQL } from "./sql/types.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaTypes.ts
+var PostgresMetaTypes = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeTableTypes = false, includeArrayTypes = false, includeSystemSchemas = false, includedSchemas, excludedSchemas, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		const sql = TYPES_SQL({
+			schemaFilter,
+			limit,
+			offset,
+			includeTableTypes,
+			includeArrayTypes
+		});
+		return await this.query(sql);
+	}
+};
+//#endregion
+export { PostgresMetaTypes as default };

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

@@ -0,0 +1,20 @@
+import { VERSION_SQL } from "./sql/version.sql.js";
+//#region src/vendor/postgres-meta/lib/PostgresMetaVersion.ts
+var PostgresMetaVersion = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async retrieve() {
+		const { data, error } = await this.query(VERSION_SQL());
+		if (error) return {
+			data,
+			error
+		};
+		return {
+			data: data[0],
+			error
+		};
+	}
+};
+//#endregion
+export { PostgresMetaVersion as default };

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

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

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

@@ -0,0 +1,8 @@
+//#region src/vendor/postgres-meta/lib/constants.ts
+const DEFAULT_SYSTEM_SCHEMAS = [
+	"information_schema",
+	"pg_catalog",
+	"pg_toast"
+];
+//#endregion
+export { DEFAULT_SYSTEM_SCHEMAS };

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