orchid-orm 1.72.7 → 1.72.9

package/dist/migrations/index.mjs

@@ -1,18 +1,26 @@
 import { astToMigration, concatSchemaAndName, createMigrationInterface, dbColumnToAst, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, promptSelect, rakeDbCommands, saveMigratedVersion, structureToAst, tableToAst, writeMigrationFile } from "rake-db";
-import { ArrayColumn, DomainColumn, EnumColumn, RawSql, UnknownColumn, VirtualColumn, addCode, codeToString, colors, columnsShapeToCode, deepCompare, emptyArray, emptyObject, exhaustive, getColumnBaseType, getDriverErrorCode, getFreeSetAlias, getImportPath, getQuerySchema, getSupportedDefaultPrivileges, pathToLog, pluralize, pushTableDataCode, quoteObjectKey, singleQuote, toArray, toCamelCase, toPascalCase, toSnakeCase } from "pqb/internal";
+import { ArrayColumn, DomainColumn, EnumColumn, RawSql, UnknownColumn, VirtualColumn, addCode, codeToString, colors, columnsShapeToCode, deepCompare, emptyArray, emptyObject, exhaustive, getColumnBaseType, getDriverErrorCode, getFreeSetAlias, getImportPath, getQuerySchema, getSupportedDefaultPrivileges, pathToLog, pluralize, pushTableDataCode, queryToSql, quoteObjectKey, raw, rawSqlToSql, singleQuote, sqlToRawSql, toArray, toCamelCase, toPascalCase, toSnakeCase } from "pqb/internal";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import fs from "node:fs/promises";
 import typescript from "typescript";
 export * from "rake-db";
-const compareSqlExpressions = async (tableExpressions, adapter) => {
-	if (!tableExpressions.length) return;
+const viewDataToSql = (viewData, viewName) => {
+	return sqlToRawSql(viewDataToQuerySql(viewData, viewName));
+};
+const viewDataToQuerySql = (viewData, viewName) => {
+	if (viewData.query) return queryToSql(viewData.query);
+	if (viewData.sql !== void 0) return rawSqlToSql(viewData.sql);
+	throw new Error(`Either sql or query is required for view ${viewName}`);
+};
+const compareSqlExpressions = async (expressions, adapter) => {
+	if (!expressions.length) return;
 	let id = 1;
-	for (const { source, compare, handle } of tableExpressions) {
+	for (const { source, compare, handle } of expressions) {
 		const viewName = `orchidTmpView${id++}`;
 		const values = [];
 		const combinedQueries = [
-			`CREATE TEMPORARY VIEW ${viewName} AS (SELECT ${compare.map(({ inDb, inCode }, i) => `${inDb} AS "*inDb-${i}*", ${inCode.map((s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`).join(", ")}`).join(", ")} FROM ${source})`,
+			`CREATE TEMPORARY VIEW ${viewName} AS (SELECT ${compare.map(({ inDb, inCode }, i) => `${inDb} AS "*inDb-${i}*", ${inCode.map((s, j) => `(${typeof s === "string" ? s : s.toSQL({ values })}) "*inCode-${i}-${j}*"`).join(", ")}`).join(", ")}${source ? ` FROM ${source}` : ""})`,
 			`SELECT pg_get_viewdef('${viewName}') v`,
 			`DROP VIEW ${viewName}`
 		].join("; ");
@@ -27,6 +35,50 @@ const compareSqlExpressions = async (tableExpressions, adapter) => {
 		handle(compareSqlExpressionResult(result.rows[0].v, compare[0].inCode));
 	}
 };
+const compareViewsExpressions = async (adapter, compare) => {
+	if (!compare.length) return;
+	const queries = [];
+	let id = 1;
+	compare.forEach(({ inCode, ast }, i) => {
+		const viewName = `orchidTmpView${id++}ForViews`;
+		queries.push({ batch: [
+			`SAVEPOINT "${viewName}S"`,
+			`CREATE TEMPORARY${"recursive" in ast.options && ast.options.recursive ? " RECURSIVE" : ""} VIEW "${viewName}" (${ast.options.columns?.map((column) => `"${column}"`).join(", ")}) AS (${inCode})`,
+			`SELECT ${i} i, '${viewName}' v, pg_get_viewdef('"${viewName}"') sql`,
+			`DROP VIEW "${viewName}"`,
+			`RELEASE SAVEPOINT "${viewName}S"`
+		] });
+	});
+	let results;
+	try {
+		const sql = queries.flatMap((q) => q.batch).join(";");
+		const query = () => adapter.query(sql, []);
+		results = await (adapter.isInTransaction() ? adapter.savepoint("orchidOrmGeneratorViews", query) : query());
+	} catch {
+		results = (await Promise.all(queries.map(async ({ batch: queries }, i) => {
+			const sql = queries.join(";");
+			const query = () => adapter.query(sql, []);
+			return await (adapter.isInTransaction() ? adapter.savepoint(`orchidOrmGeneratorViews${i}`, query) : query()).catch((err) => {
+				if (typeof err === "object") {
+					const code = getDriverErrorCode(err);
+					if (code === "42703" || code === "42704" || code === "42P01") return [];
+				}
+				throw err;
+			});
+		}))).flat();
+	}
+	const handled = /* @__PURE__ */ new Set();
+	for (const result of results) for (const row of result.rows) if ("sql" in row) {
+		const { i, v } = row;
+		const cmp = compare[i];
+		const hasQuote = !!cmp.inDb.match(/\w*WITH RECURSIVE "/);
+		if (row.sql.replaceAll(hasQuote ? v : `"${v}"`, cmp.ast.name) !== cmp.inDb) cmp.onNotEqual();
+		handled.add(i);
+	}
+	compare.forEach((cmp, i) => {
+		if (!handled.has(i)) cmp.onNotEqual();
+	});
+};
 const compareSqlExpressionResult = (resultSql, inCode) => {
 	let pos = 7;
 	const rgx = /\s+AS\s+"\*(inDb-\d+|inCode-\d+-\d+)\*",?/g;
@@ -84,8 +136,9 @@ const processSchemas = async (ast, dbStructure, { codeItems: { schemas }, verify
 			if (i) {
 				const from = dropSchemas[i - 1];
 				dropSchemas.splice(i - 1, 1);
+				const views = dbStructure.views || [];
 				renameSchemaInStructures(dbStructure.tables, from, schema);
-				renameSchemaInStructures(dbStructure.views, from, schema);
+				renameSchemaInStructures(views, from, schema);
 				renameSchemaInStructures(dbStructure.indexes, from, schema);
 				renameSchemaInStructures(dbStructure.excludes, from, schema);
 				renameSchemaInStructures(dbStructure.constraints, from, schema);
@@ -412,7 +465,7 @@ const renameColumn = (columns, from, to) => {
 const processDomains = async (ast, adapter, domainsMap, dbStructure, { codeItems: { domains }, structureToAstCtx, currentSchema, internal: { generatorIgnore } }, pendingDbTypes) => {
 	const codeDomains = [];
 	if (domains) for (const { schemaName, name, column } of domains) codeDomains.push(makeComparableDomain(currentSchema, schemaName, name, column));
-	const tableExpressions = [];
+	const expressions = [];
 	const holdCodeDomains = /* @__PURE__ */ new Set();
 	for (const domain of dbStructure.domains) {
 		if (generatorIgnore?.schemas?.includes(domain.schemaName) || generatorIgnore?.domains?.includes(domain.name)) continue;
@@ -438,7 +491,7 @@ const processDomains = async (ast, adapter, domainsMap, dbStructure, { codeItems
 			pushCompareDefault(compare, domain, found);
 			pushCompareChecks(compare, domain, found);
 			const source = `(VALUES (NULL::${getColumnDbType(dbColumn, currentSchema)})) t(value)`;
-			tableExpressions.push({
+			expressions.push({
 				compare,
 				source,
 				handle(i) {
@@ -469,8 +522,8 @@ const processDomains = async (ast, adapter, domainsMap, dbStructure, { codeItems
 		ast.push(createAst(codeDomain));
 		pendingDbTypes.add(codeDomain.schemaName, codeDomain.name);
 	}
-	if (tableExpressions.length) {
-		await compareSqlExpressions(tableExpressions, adapter);
+	if (expressions.length) {
+		await compareSqlExpressions(expressions, adapter);
 		if (holdCodeDomains.size) for (const codeDomain of holdCodeDomains.keys()) {
 			ast.push(createAst(codeDomain));
 			pendingDbTypes.add(codeDomain.schemaName, codeDomain.name);
@@ -1668,18 +1721,19 @@ const processTables = async (ast, domainsMap, adapter, dbStructure, config, { st
 		values: [],
 		expressions: []
 	};
-	const tableExpressions = [];
+	const expressions = [];
 	const { changeTables, changeTableSchemas, dropTables, tableShapes } = collectChangeAndDropTables(adapter, config, tables, dbStructure, currentSchema, createTables, generatorIgnore);
 	applyChangeTableSchemas(changeTableSchemas, currentSchema, ast);
 	await applyCreateOrRenameTables(dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, verifying);
-	await applyChangeTables(adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, tableExpressions, verifying, pendingDbTypes);
+	await applyChangeTables(adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, expressions, verifying, pendingDbTypes);
 	processForeignKeys(config, ast, changeTables, currentSchema, tableShapes);
-	await Promise.all([applyCompareSql(compareSql, adapter), compareSqlExpressions(tableExpressions, adapter)]);
+	await Promise.all([applyCompareSql(compareSql, adapter), compareSqlExpressions(expressions, adapter)]);
 	await processTableRls(adapter, ast, dbStructure, tables, currentSchema, generatorIgnore);
 	for (const dbTable of dropTables) ast.push(tableToAst(structureToAstCtx, dbStructure, dbTable, "drop", domainsMap));
 };
 const collectCreateTables = (tables, dbStructure, currentSchema) => {
 	return tables.reduce((acc, codeTable) => {
+		if (codeTable.internal.generatorIgnored) return acc;
 		const tableSchema = codeTable.q.schema ?? currentSchema;
 		if (!dbStructure.tables.some((t) => t.name === codeTable.table && t.schemaName === tableSchema)) acc.push(codeTable);
 		return acc;
@@ -1699,7 +1753,7 @@ const collectChangeAndDropTables = (adapter, config, tables, dbStructure, curren
 	});
 	const { schema: migrationsSchema = "public", table: migrationsTable } = getMigrationsSchemaAndTable(adapter, config);
 	for (const dbTable of dbStructure.tables) {
-		if (dbTable.name === migrationsTable && dbTable.schemaName === migrationsSchema || generatorIgnore?.schemas?.includes(dbTable.schemaName) || ignoreTables?.some(({ schema, table }) => table === dbTable.name && schema === dbTable.schemaName)) continue;
+		if (dbTable.name === migrationsTable && dbTable.schemaName === migrationsSchema || generatorIgnore?.schemas?.includes(dbTable.schemaName) || ignoreTables?.some(({ schema, table }) => table === dbTable.name && schema === dbTable.schemaName) || isDefinitionIgnoredDbTable(tables, dbTable, currentSchema)) continue;
 		const codeTable = tables.find((t) => t.table === dbTable.name && (t.q.schema ?? currentSchema) === dbTable.schemaName);
 		if (codeTable) {
 			addChangeTable(dbStructure, changeTables, tableShapes, currentSchema, dbTable, codeTable);
@@ -1724,6 +1778,15 @@ const collectChangeAndDropTables = (adapter, config, tables, dbStructure, curren
 		tableShapes
 	};
 };
+const isDefinitionIgnoredDbTable = (tables, dbTable, currentSchema) => {
+	let hasIgnoredSameName = false;
+	for (const codeTable of tables) {
+		if (codeTable.table !== dbTable.name) continue;
+		if ((codeTable.q.schema ?? currentSchema) === dbTable.schemaName) return !!codeTable.internal.generatorIgnored;
+		if (codeTable.internal.generatorIgnored) hasIgnoredSameName = true;
+	}
+	return hasIgnoredSameName;
+};
 const applyChangeTableSchemas = (changeTableSchemas, currentSchema, ast) => {
 	for (const { codeTable, dbTable } of changeTableSchemas) {
 		const fromSchema = dbTable.schemaName;
@@ -1738,7 +1801,7 @@ const applyChangeTableSchemas = (changeTableSchemas, currentSchema, ast) => {
 		});
 	}
 };
-const applyChangeTables = async (adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, tableExpressions, verifying, pendingDbTypes) => {
+const applyChangeTables = async (adapter, changeTables, structureToAstCtx, dbStructure, domainsMap, ast, currentSchema, config, compareSql, expressions, verifying, pendingDbTypes) => {
 	const compareExpressions = [];
 	const typeCastsCache = {};
 	for (const changeTableData of changeTables) {
@@ -1760,7 +1823,7 @@ const applyChangeTables = async (adapter, changeTables, structureToAstCtx, dbStr
 			}
 			const tableName = codeTable.table;
 			const source = `(VALUES (${types.map((x) => `NULL::${x}`).join(", ")})) "${tableName}"(${names.map((x) => `"${x}"`).join(", ")})`;
-			tableExpressions.push(...compareExpressions.map((x) => ({
+			expressions.push(...compareExpressions.map((x) => ({
 				...x,
 				source
 			})));
@@ -2382,13 +2445,16 @@ const normalizeRoleName = (name) => {
 };
 const getSchemaWideTargets = (dbStructure, targetKey, schemas) => {
 	const selectedSchemas = new Set(schemas);
-	if (targetKey === "tables") return [...dbStructure.tables.map((table) => ({
-		target: `${table.schemaName}.${table.name}`,
-		outputTarget: `${table.schemaName}.${table.name}`
-	})), ...dbStructure.views.map((view) => ({
-		target: `${view.schemaName}.${view.name}`,
-		outputTarget: `${view.schemaName}.${view.name}`
-	}))].filter((item) => selectedSchemas.has(item.target.split(".")[0]));
+	if (targetKey === "tables") {
+		const views = dbStructure.views || [];
+		return [...dbStructure.tables.map((table) => ({
+			target: `${table.schemaName}.${table.name}`,
+			outputTarget: `${table.schemaName}.${table.name}`
+		})), ...views.map((view) => ({
+			target: `${view.schemaName}.${view.name}`,
+			outputTarget: `${view.schemaName}.${view.name}`
+		}))].filter((item) => selectedSchemas.has(item.target.split(".")[0]));
+	}
 	if (targetKey === "sequences" || targetKey === "routines") return getSchemaWideGrantTargets(dbStructure, targetKey, selectedSchemas);
 	return [];
 };
@@ -2455,6 +2521,264 @@ const addGrantAst = (ast, action, grant, privileges, privilegeKey) => {
 		grantedBy: grant.grantedBy
 	});
 };
+const processViews = async (ast, adapter, dbStructure, { codeItems: { views: allViews }, currentSchema, internal: { generatorIgnore } }) => {
+	const createViews = [];
+	const changeViews = [];
+	const dropViews = [];
+	const ignoredViews = makeIgnoredViews$1(generatorIgnore, currentSchema);
+	const views = allViews.filter((view) => !view.materialized);
+	for (const codeView of views) {
+		if (isIgnoredView$1(ignoredViews, generatorIgnore, currentSchema, codeView)) continue;
+		const schemaName = codeView.q.schema ?? currentSchema;
+		const dbView = dbStructure.views?.find((view) => view.schemaName === schemaName && view.name === codeView.name);
+		if (dbView) changeViews.push({
+			codeView,
+			dbView
+		});
+		else createViews.push(codeView);
+	}
+	for (const dbView of dbStructure.views ?? []) {
+		if (generatorIgnore?.schemas?.includes(dbView.schemaName) || ignoredViews.some((ignore) => matchesIgnoredView$1(ignore, dbView, currentSchema))) continue;
+		if (!views.find((view) => view.name === dbView.name && (view.q.schema ?? currentSchema) === dbView.schemaName)) dropViews.push(dbView);
+	}
+	for (const codeView of createViews) ast.push(codeViewToAst$1(codeView, currentSchema, "create"));
+	await applyChangeViews$1(ast, adapter, changeViews, currentSchema);
+	for (const dbView of dropViews) ast.push(dbViewToAst$1(dbView, currentSchema, "drop"));
+};
+const applyChangeViews$1 = async (ast, adapter, changeViews, currentSchema) => {
+	const compare = [];
+	for (const { codeView, dbView } of changeViews) {
+		const from = dbViewToAst$1(dbView, currentSchema, "drop");
+		const to = codeViewToAst$1(codeView, currentSchema, "create");
+		if (!isViewOptionsEqual(from.options, to.options)) {
+			pushRecreateView$1(ast, from, to);
+			continue;
+		}
+		const codeSql = typeof to.sql === "string" ? to.sql : to.sql.toSQL({ values: [] });
+		compare.push({
+			inDb: dbView.sql,
+			inCode: codeSql,
+			ast: to,
+			onNotEqual() {
+				pushRecreateView$1(ast, from, to);
+			}
+		});
+	}
+	await compareViewsExpressions(adapter, compare);
+};
+const pushRecreateView$1 = (ast, from, to) => {
+	ast.push(from, to);
+};
+const codeViewToAst$1 = (view, currentSchema, action) => {
+	const schema = view.q.schema ?? currentSchema;
+	const sql = viewDataToSql(view.viewData, view.name);
+	return {
+		type: "view",
+		action,
+		schema: schema === currentSchema ? void 0 : schema,
+		name: view.name,
+		shape: view.shape,
+		sql,
+		options: {
+			recursive: view.viewData.recursive,
+			columns: Object.keys(view.shape),
+			checkOption: view.viewData.checkOption,
+			securityBarrier: view.viewData.securityBarrier,
+			securityInvoker: view.viewData.securityInvoker ?? true
+		},
+		deps: []
+	};
+};
+const dbViewToAst$1 = (view, currentSchema, action) => {
+	return {
+		type: "view",
+		action,
+		schema: view.schemaName === currentSchema ? void 0 : view.schemaName,
+		name: view.name,
+		shape: {},
+		sql: raw({ raw: view.sql }),
+		options: dbViewOptionsToAst(view),
+		deps: view.deps
+	};
+};
+const dbViewOptionsToAst = (view) => {
+	const options = {};
+	options.columns = view.columns.map((column) => column.name);
+	if (view.isRecursive) options.recursive = true;
+	if (view.with) for (const pair of view.with) {
+		const [key, value] = pair.split("=");
+		switch (key) {
+			case "check_option":
+				if (value === "LOCAL" || value === "CASCADED") options.checkOption = value;
+				break;
+			case "security_barrier":
+				options.securityBarrier = value === "true";
+				break;
+			case "security_invoker":
+				options.securityInvoker = value === "true";
+				break;
+		}
+	}
+	return options;
+};
+const isViewOptionsEqual = (from, to) => {
+	return from.recursive === to.recursive && from.checkOption === to.checkOption && (from.securityBarrier ?? false) === (to.securityBarrier ?? false) && (from.securityInvoker ?? false) === (to.securityInvoker ?? false) && isStringArrayEqual$1(from.columns, to.columns);
+};
+const isStringArrayEqual$1 = (a, b) => {
+	if ((a?.length ?? 0) !== (b?.length ?? 0)) return false;
+	if (!a?.length && !b?.length) return true;
+	return !!a?.every((item, i) => item === b?.[i]);
+};
+const makeIgnoredViews$1 = (generatorIgnore, currentSchema) => {
+	const views = generatorIgnore?.views;
+	if (!views) return [];
+	return views.map((name) => {
+		if (typeof name !== "string") return { name };
+		const parts = name.split(".");
+		return parts.length === 2 ? {
+			schema: parts[0],
+			name: parts[1]
+		} : {
+			schema: currentSchema,
+			name
+		};
+	});
+};
+const isIgnoredView$1 = (ignoredViews, generatorIgnore, currentSchema, codeView) => {
+	const schemaName = codeView.q.schema ?? currentSchema;
+	return generatorIgnore?.schemas?.includes(schemaName) === true || ignoredViews.some((ignore) => {
+		return matchesIgnoredView$1(ignore, {
+			schemaName,
+			name: codeView.name
+		}, currentSchema);
+	});
+};
+const matchesIgnoredView$1 = (ignore, view, currentSchema) => {
+	return typeof ignore.name === "string" ? ignore.schema === view.schemaName && ignore.name === view.name : ignore.name.test(normalizedViewName$1(view, currentSchema));
+};
+const normalizedViewName$1 = (view, currentSchema) => {
+	return view.schemaName === currentSchema ? view.name : `${view.schemaName}.${view.name}`;
+};
+const processMaterializedViews = async (ast, adapter, dbStructure, { codeItems: { views: allViews }, currentSchema, internal: { generatorIgnore } }) => {
+	const views = allViews.filter((view) => view.materialized);
+	const createViews = [];
+	const changeViews = [];
+	const dropViews = [];
+	const ignoredViews = makeIgnoredViews(generatorIgnore, currentSchema);
+	for (const codeView of views) {
+		if (isIgnoredView(ignoredViews, generatorIgnore, currentSchema, codeView)) continue;
+		const schemaName = codeView.q.schema ?? currentSchema;
+		const dbView = dbStructure.materializedViews?.find((view) => view.schemaName === schemaName && view.name === codeView.name);
+		if (dbView) changeViews.push({
+			codeView,
+			dbView
+		});
+		else createViews.push(codeView);
+	}
+	for (const dbView of dbStructure.materializedViews ?? []) {
+		if (generatorIgnore?.schemas?.includes(dbView.schemaName) || ignoredViews.some((ignore) => matchesIgnoredView(ignore, dbView, currentSchema))) continue;
+		if (!views.find((view) => view.name === dbView.name && (view.q.schema ?? currentSchema) === dbView.schemaName)) dropViews.push(dbView);
+	}
+	for (const codeView of createViews) ast.push(codeViewToAst(codeView, currentSchema, "create"));
+	await applyChangeViews(ast, adapter, changeViews, currentSchema);
+	for (const dbView of dropViews) ast.push(dbViewToAst(dbView, currentSchema, "drop"));
+};
+const applyChangeViews = async (ast, adapter, changeViews, currentSchema) => {
+	const compare = [];
+	for (const { codeView, dbView } of changeViews) {
+		const from = dbViewToAst(dbView, currentSchema, "drop");
+		const to = codeViewToAst(codeView, currentSchema, "create");
+		if (!isMaterializedViewOptionsEqual(from.options, to.options)) {
+			pushRecreateView(ast, from, to);
+			continue;
+		}
+		const codeSql = typeof to.sql === "string" ? to.sql : to.sql.toSQL({ values: [] });
+		compare.push({
+			inDb: dbView.sql,
+			inCode: codeSql,
+			ast: to,
+			onNotEqual() {
+				pushRecreateView(ast, from, to);
+			}
+		});
+	}
+	await compareViewsExpressions(adapter, compare);
+};
+const pushRecreateView = (ast, from, to) => {
+	ast.push(from, to);
+};
+const codeViewToAst = (view, currentSchema, action) => {
+	const schema = view.q.schema ?? currentSchema;
+	const sql = viewDataToSql(view.viewData, view.name);
+	return {
+		type: "materializedView",
+		action,
+		schema: schema === currentSchema ? void 0 : schema,
+		name: view.name,
+		shape: view.shape,
+		sql,
+		options: {
+			columns: Object.keys(view.shape),
+			withData: view.viewData.withData
+		},
+		deps: []
+	};
+};
+const dbViewToAst = (view, currentSchema, action) => {
+	return {
+		type: "materializedView",
+		action,
+		schema: view.schemaName === currentSchema ? void 0 : view.schemaName,
+		name: view.name,
+		shape: {},
+		sql: raw({ raw: view.sql }),
+		options: dbMaterializedViewOptionsToAst(view),
+		deps: view.deps
+	};
+};
+const dbMaterializedViewOptionsToAst = (view) => {
+	const options = { columns: view.columns.map((column) => column.name) };
+	if (!view.isPopulated) options.withData = false;
+	return options;
+};
+const isMaterializedViewOptionsEqual = (from, to) => {
+	return (from.withData ?? true) === (to.withData ?? true) && isStringArrayEqual(from.columns, to.columns);
+};
+const isStringArrayEqual = (a, b) => {
+	if ((a?.length ?? 0) !== (b?.length ?? 0)) return false;
+	if (!a?.length && !b?.length) return true;
+	return !!a?.every((item, i) => item === b?.[i]);
+};
+const makeIgnoredViews = (generatorIgnore, currentSchema) => {
+	const views = generatorIgnore?.views;
+	if (!views) return [];
+	return views.map((name) => {
+		if (typeof name !== "string") return { name };
+		const parts = name.split(".");
+		return parts.length === 2 ? {
+			schema: parts[0],
+			name: parts[1]
+		} : {
+			schema: currentSchema,
+			name
+		};
+	});
+};
+const isIgnoredView = (ignoredViews, generatorIgnore, currentSchema, codeView) => {
+	const schemaName = codeView.q.schema ?? currentSchema;
+	return generatorIgnore?.schemas?.includes(schemaName) === true || ignoredViews.some((ignore) => {
+		return matchesIgnoredView(ignore, {
+			schemaName,
+			name: codeView.name
+		}, currentSchema);
+	});
+};
+const matchesIgnoredView = (ignore, view, currentSchema) => {
+	return typeof ignore.name === "string" ? ignore.schema === view.schemaName && ignore.name === view.name : ignore.name.test(normalizedViewName(view, currentSchema));
+};
+const normalizedViewName = (view, currentSchema) => {
+	return view.schemaName === currentSchema ? view.name : `${view.schemaName}.${view.name}`;
+};
 /**
 * This is needed to compare SQLs of table expressions.
 * Need to exclude table columns of pending types, such as enums or domains,
@@ -2481,6 +2805,8 @@ const composeMigration = async (adapter, config, ast, dbStructure, params) => {
 	await processDomains(ast, adapter, domainsMap, dbStructure, params, pendingDbTypes);
 	await processEnums(ast, dbStructure, params, pendingDbTypes);
 	await processTables(ast, domainsMap, adapter, dbStructure, config, params, pendingDbTypes);
+	await processViews(ast, adapter, dbStructure, params);
+	await processMaterializedViews(ast, adapter, dbStructure, params);
 	return astToMigration(currentSchema, config, ast);
 };
 const rollbackErr = /* @__PURE__ */ new Error("Rollback");
@@ -2656,7 +2982,12 @@ const report = (ast, config, currentSchema) => {
 		case "domain":
 			code.push(`${a.action === "create" ? green("+ create domain") : red("- drop domain")} ${dbItemName(a, currentSchema)}`);
 			break;
+		case "materializedView":
+			code.push(`${a.action === "create" ? green("+ create materialized view") : red("- drop materialized view")} ${dbItemName(a, currentSchema)}`);
+			break;
 		case "view":
+			code.push(`${a.action === "create" ? green("+ create view") : red("- drop view")} ${dbItemName(a, currentSchema)}`);
+			break;
 		case "collation":
 		case "constraint": break;
 		case "renameTableItem":
@@ -2814,7 +3145,8 @@ const generate = async (adapters, config, args, afterPull) => {
 	const { columnTypes, internal } = db.$qb;
 	const structureParams = {
 		loadDefaultPrivileges: internal.roles?.some((role) => role.defaultPrivileges !== void 0) ?? false,
-		loadGrants: !!internal.grants || hasCodeTablesWithGrants(db)
+		loadGrants: !!internal.grants || hasCodeItemsWithGrants(db),
+		loadViews: hasCodeViews(db)
 	};
 	const rolesDbStructureParam = internal.roles ? internal.managedRolesSql ? { whereSql: internal.managedRolesSql } : emptyObject : void 0;
 	const { dbStructure } = await migrateAndPullStructures(adapters, config, db, rolesDbStructureParam, structureParams, afterPull);
@@ -2822,6 +3154,7 @@ const generate = async (adapters, config, args, afterPull) => {
 	const adapterSchema = adapter.getSchema();
 	const currentSchema = (typeof adapterSchema === "function" ? adapterSchema() : adapterSchema) ?? "public";
 	const codeItems = await getActualItems(db, currentSchema, internal, columnTypes);
+	const generatorIgnore = getGeneratorIgnoreWithDefinitionIgnoredTableLikes(internal.generatorIgnore, codeItems.tables, codeItems.views);
 	const effectiveGrants = getEffectiveGrants(internal.grants, codeItems);
 	const generateMigrationParams = {
 		structureToAstCtx: makeStructureToAstCtx(config, currentSchema),
@@ -2829,6 +3162,7 @@ const generate = async (adapters, config, args, afterPull) => {
 		currentSchema,
 		internal: {
 			...internal,
+			generatorIgnore,
 			grants: effectiveGrants
 		}
 	};
@@ -2879,6 +3213,7 @@ const migrateAndPullStructures = async (adapters, config, db, roles, structurePa
 		schemas: [],
 		tables: [],
 		views: [],
+		materializedViews: [],
 		indexes: [],
 		excludes: [],
 		constraints: [],
@@ -2893,7 +3228,8 @@ const migrateAndPullStructures = async (adapters, config, db, roles, structurePa
 		rls: hasCodeTablesWithRls(db),
 		roles,
 		loadDefaultPrivileges: structureParams?.loadDefaultPrivileges,
-		loadGrants: structureParams?.loadGrants
+		loadGrants: structureParams?.loadGrants,
+		loadViews: structureParams?.loadViews
 	})));
 	const dbStructure = dbStructures[0];
 	for (let i = 1; i < dbStructures.length; i++) compareDbStructures(dbStructure, dbStructures[i], i);
@@ -2906,11 +3242,17 @@ const hasCodeTablesWithRls = (db) => {
 	}
 	return false;
 };
-const hasCodeTablesWithGrants = (db) => {
+const hasCodeViews = (db) => {
+	return !!Object.keys(db.$views ?? {}).length;
+};
+const hasCodeItemsWithGrants = (db) => {
 	for (const key in db) {
 		if (key[0] === "$") continue;
 		if (db[key].internal.tableGrants?.length) return true;
 	}
+	const views = db.$views;
+	if (!views) return false;
+	for (const key in views) if (views[key].internal.tableGrants?.length) return true;
 	return false;
 };
 const getEffectiveGrants = (grants, codeItems) => {
@@ -2928,8 +3270,41 @@ const getEffectiveGrants = (grants, codeItems) => {
 			effectiveGrants.push(internalGrant);
 		}
 	}
+	for (const view of codeItems.views) {
+		const viewGrants = view.internal.tableGrants;
+		if (!viewGrants?.length) continue;
+		const viewTarget = view.q.schema ? `${view.q.schema}.${view.name}` : view.name;
+		for (const grant of viewGrants) {
+			const internalGrant = {
+				...grant,
+				to: toArray(grant.to),
+				tables: [viewTarget]
+			};
+			effectiveGrants.push(internalGrant);
+		}
+	}
 	return effectiveGrants.length ? effectiveGrants : void 0;
 };
+const getGeneratorIgnoreWithDefinitionIgnoredTableLikes = (generatorIgnore, tables, views) => {
+	const ignoredTables = new Set(generatorIgnore?.tables);
+	const ignoredViews = new Set(generatorIgnore?.views);
+	let hasDefinitionIgnoredTableLikes = false;
+	for (const table of tables) {
+		if (!table.internal.generatorIgnored) continue;
+		hasDefinitionIgnoredTableLikes = true;
+		ignoredTables.add(table.q.schema ? `${table.q.schema}.${table.table}` : table.table);
+	}
+	for (const view of views) {
+		if (!view.internal.generatorIgnored) continue;
+		hasDefinitionIgnoredTableLikes = true;
+		ignoredViews.add(view.q.schema ? `${view.q.schema}.${view.name}` : view.name);
+	}
+	return hasDefinitionIgnoredTableLikes ? {
+		...generatorIgnore,
+		tables: [...ignoredTables],
+		views: [...ignoredViews]
+	} : generatorIgnore;
+};
 const compareDbStructures = (a, b, i, path) => {
 	let err;
 	if (typeof a !== typeof b) err = true;
@@ -2946,6 +3321,7 @@ const getActualItems = async (db, currentSchema, internal, columnTypes) => {
 		schemas: /* @__PURE__ */ new Set(void 0),
 		enums: /* @__PURE__ */ new Map(),
 		tables: [],
+		views: [],
 		domains: []
 	};
 	codeItems.schemas.add(currentSchema);
@@ -2971,25 +3347,26 @@ const getActualItems = async (db, currentSchema, internal, columnTypes) => {
 			},
 			q: { schema: getQuerySchema(table) }
 		});
-		for (const key in table.relations) {
+		if (!table.internal.generatorIgnored) for (const key in table.relations) {
 			const column = table.shape[key];
 			if (column && "joinTable" in column) processHasAndBelongsToManyColumn(column, habtmTables, codeItems);
 		}
-		for (const key in table.shape) {
-			const column = table.shape[key];
-			if (column.data.computed) delete table.shape[key];
-			else if (column instanceof DomainColumn) {
-				const [schemaName = currentSchema, name] = getSchemaAndTableFromName(currentSchema, column.dataType);
-				domains.set(column.dataType, {
-					schemaName,
-					name,
-					column: column.data.as ?? UnknownColumn.instance
-				});
-			} else {
-				const en = column.dataType === "enum" ? column : column instanceof ArrayColumn && column.data.item.dataType === "enum" ? column.data.item : void 0;
-				if (en) processEnumColumn(en, currentSchema, codeItems);
-			}
-		}
+		processCodeItemShape(table.shape, currentSchema, codeItems, domains);
+	}
+	const views = db.$views;
+	if (views) for (const key in views) {
+		const view = views[key];
+		const schema = getQuerySchema(view);
+		if (schema) codeItems.schemas.add(schema);
+		codeItems.views.push({
+			name: view.table,
+			shape: view.shape,
+			internal: view.internal,
+			q: { schema },
+			materialized: view.internal.materialized,
+			viewData: view.internal.viewData ?? {}
+		});
+		processCodeItemShape(view.shape, currentSchema, codeItems, domains);
 	}
 	if (internal.extensions) for (const extension of internal.extensions) {
 		const [schema] = getSchemaAndTableFromName(currentSchema, extension.name);
@@ -3016,6 +3393,23 @@ const getActualItems = async (db, currentSchema, internal, columnTypes) => {
 	if (internal.grants) for (const grant of internal.grants) addGrantSchemas(codeItems.schemas, currentSchema, grant);
 	return codeItems;
 };
+const processCodeItemShape = (shape, currentSchema, codeItems, domains) => {
+	for (const key in shape) {
+		const column = shape[key];
+		if (column.data.computed) delete shape[key];
+		else if (column instanceof DomainColumn) {
+			const [schemaName = currentSchema, name] = getSchemaAndTableFromName(currentSchema, column.dataType);
+			domains.set(column.dataType, {
+				schemaName,
+				name,
+				column: column.data.as ?? UnknownColumn.instance
+			});
+		} else {
+			const en = column.dataType === "enum" ? column : column instanceof ArrayColumn && column.data.item.dataType === "enum" ? column.data.item : void 0;
+			if (en) processEnumColumn(en, currentSchema, codeItems);
+		}
+	}
+};
 const addGrantSchemas = (schemas, currentSchema, grant) => {
 	for (const schema of [
 		...grant.schemas ?? [],