neon 8.4.5 → 8.6.0

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

@@ -0,0 +1,105 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { SCHEMAS_SQL } from "./sql/schemas.sql.js";
+import { ident } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaSchemas.ts
+var PostgresMetaSchemas = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includedSchemas, excludedSchemas, includeSystemSchemas = false, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		const sql = SCHEMAS_SQL({
+			limit,
+			offset,
+			includeSystemSchemas,
+			nameFilter: schemaFilter
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name }) {
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = SCHEMAS_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 schema with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name) {
+			const nameFilter = filterByValue([name]);
+			const sql = SCHEMAS_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 schema named ${name}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on schema retrieve" }
+		};
+	}
+	async create({ name, owner = "postgres" }) {
+		const sql = `CREATE SCHEMA ${ident(name)} AUTHORIZATION ${ident(owner)};`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({ name });
+	}
+	async update(id, { name, owner }) {
+		const { data: old, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const nameSql = name === void 0 ? "" : `ALTER SCHEMA ${ident(old.name)} RENAME TO ${ident(name)};`;
+		const sql = `BEGIN; ${owner === void 0 ? "" : `ALTER SCHEMA ${ident(old.name)} OWNER TO ${ident(owner)};`} ${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: schema, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP SCHEMA ${ident(schema.name)} ${cascade ? "CASCADE" : "RESTRICT"};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: schema,
+			error: null
+		};
+	}
+};
+//#endregion
+export { PostgresMetaSchemas as default };

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

@@ -0,0 +1,91 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { TABLE_PRIVILEGES_SQL } from "./sql/table_privileges.sql.js";
+import { ident } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaTablePrivileges.ts
+var PostgresMetaTablePrivileges = 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 = TABLE_PRIVILEGES_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, schema = "public" }) {
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = TABLE_PRIVILEGES_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 relation with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name) {
+			const nameIdentifierFilter = filterByValue([`${schema}.${name}`]);
+			const sql = TABLE_PRIVILEGES_SQL({ nameIdentifierFilter });
+			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 relation named ${name} in schema ${schema}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on retrieving table privileges" }
+		};
+	}
+	async grant(grants) {
+		let sql = `
+do $$
+begin
+${grants.map(({ privilege_type, relation_id, grantee, is_grantable }) => `execute format('grant ${privilege_type} on table %s to ${grantee.toLowerCase() === "public" ? "public" : ident(grantee)} ${is_grantable ? "with grant option" : ""}', ${relation_id}::regclass);`).join("\n")}
+end $$;
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data,
+			error
+		};
+		const relationIds = [...new Set(grants.map(({ relation_id }) => relation_id))];
+		sql = TABLE_PRIVILEGES_SQL({ idsFilter: filterByList(relationIds) });
+		return await this.query(sql);
+	}
+	async revoke(revokes) {
+		let sql = `
+do $$
+begin
+${revokes.map((revoke) => `execute format('revoke ${revoke.privilege_type} on table %s from ${revoke.grantee}', ${revoke.relation_id}::regclass);`).join("\n")}
+end $$;
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data,
+			error
+		};
+		const relationIds = [...new Set(revokes.map(({ relation_id }) => relation_id))];
+		sql = TABLE_PRIVILEGES_SQL({ idsFilter: filterByList(relationIds) });
+		return await this.query(sql);
+	}
+};
+//#endregion
+export { PostgresMetaTablePrivileges as default };

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

@@ -0,0 +1,183 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { coalesceRowsToArray, filterByList, filterByValue } from "./helpers.js";
+import { TABLES_SQL } from "./sql/table.sql.js";
+import { COLUMNS_SQL } from "./sql/columns.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaTables.ts
+var PostgresMetaTables = 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 = generateEnrichedTablesSql({
+			includeColumns,
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async retrieve({ id, name, schema = "public" }) {
+		const schemaFilter = schema ? filterByList([schema], []) : void 0;
+		if (id) {
+			const idsFilter = filterByValue([id]);
+			const sql = generateEnrichedTablesSql({
+				schemaFilter,
+				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 table with ID ${id}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else if (name) {
+			const tableIdentifierFilter = filterByValue([`${schema}.${name}`]);
+			const sql = generateEnrichedTablesSql({
+				schemaFilter,
+				includeColumns: true,
+				tableIdentifierFilter
+			});
+			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 table named ${name} in schema ${schema}` }
+			};
+			else return {
+				data: data[0],
+				error
+			};
+		} else return {
+			data: null,
+			error: { message: "Invalid parameters on table retrieve" }
+		};
+	}
+	async create({ name, schema = "public", comment }) {
+		const sql = `BEGIN; ${`CREATE TABLE ${ident(schema)}.${ident(name)} ();`} ${comment === void 0 ? "" : `COMMENT ON TABLE ${ident(schema)}.${ident(name)} IS ${literal(comment)};`} COMMIT;`;
+		const { error } = await this.query(sql);
+		if (error) return {
+			data: null,
+			error
+		};
+		return await this.retrieve({
+			name,
+			schema
+		});
+	}
+	async update(id, { name, schema, rls_enabled, rls_forced, replica_identity, replica_identity_index, primary_keys, comment }) {
+		const { data: old, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const alter = `ALTER TABLE ${ident(old.schema)}.${ident(old.name)}`;
+		const schemaSql = schema === void 0 ? "" : `${alter} SET SCHEMA ${ident(schema)};`;
+		let nameSql = "";
+		if (name !== void 0 && name !== old.name) {
+			const currentSchema = schema === void 0 ? old.schema : schema;
+			nameSql = `ALTER TABLE ${ident(currentSchema)}.${ident(old.name)} RENAME TO ${ident(name)};`;
+		}
+		let enableRls = "";
+		if (rls_enabled !== void 0) {
+			const enable = `${alter} ENABLE ROW LEVEL SECURITY;`;
+			const disable = `${alter} DISABLE ROW LEVEL SECURITY;`;
+			enableRls = rls_enabled ? enable : disable;
+		}
+		let forceRls = "";
+		if (rls_forced !== void 0) {
+			const enable = `${alter} FORCE ROW LEVEL SECURITY;`;
+			const disable = `${alter} NO FORCE ROW LEVEL SECURITY;`;
+			forceRls = rls_forced ? enable : disable;
+		}
+		let replicaSql = "";
+		if (replica_identity === void 0) {} else if (replica_identity === "INDEX") replicaSql = `${alter} REPLICA IDENTITY USING INDEX ${replica_identity_index};`;
+		else replicaSql = `${alter} REPLICA IDENTITY ${replica_identity};`;
+		let primaryKeysSql = "";
+		if (primary_keys === void 0) {} else {
+			if (old.primary_keys.length !== 0) primaryKeysSql += `
+DO $$
+DECLARE
+  r record;
+BEGIN
+  SELECT conname
+    INTO r
+    FROM pg_constraint
+    WHERE contype = 'p' AND conrelid = ${literal(id)};
+  EXECUTE ${literal(`${alter} DROP CONSTRAINT `)} || quote_ident(r.conname);
+END
+$$;
+`;
+			if (primary_keys.length === 0) {} else primaryKeysSql += `${alter} ADD PRIMARY KEY (${primary_keys.map((x) => ident(x.name)).join(",")});`;
+		}
+		const commentSql = comment === void 0 ? "" : `COMMENT ON TABLE ${ident(old.schema)}.${ident(old.name)} IS ${literal(comment)};`;
+		const sql = `
+BEGIN;
+  ${enableRls}
+  ${forceRls}
+  ${replicaSql}
+  ${primaryKeysSql}
+  ${commentSql}
+  ${schemaSql}
+  ${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: table, error } = await this.retrieve({ id });
+		if (error) return {
+			data: null,
+			error
+		};
+		const sql = `DROP TABLE ${ident(table.schema)}.${ident(table.name)} ${cascade ? "CASCADE" : "RESTRICT"};`;
+		{
+			const { error } = await this.query(sql);
+			if (error) return {
+				data: null,
+				error
+			};
+		}
+		return {
+			data: table,
+			error: null
+		};
+	}
+};
+const generateEnrichedTablesSql = ({ includeColumns, schemaFilter, tableIdentifierFilter, idsFilter, limit, offset }) => `
+with tables as (${TABLES_SQL({
+	schemaFilter,
+	tableIdentifierFilter,
+	idsFilter,
+	limit,
+	offset
+})})
+  ${includeColumns ? `, columns as (${COLUMNS_SQL({
+	schemaFilter,
+	tableIdFilter: idsFilter,
+	tableIdentifierFilter
+})})` : ""}
+select
+  *
+  ${includeColumns ? `, ${coalesceRowsToArray("columns", "columns.table_id = tables.id")}` : ""}
+from tables`;
+//#endregion
+export { PostgresMetaTables as default };

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