rake-db 2.36.19 → 2.37.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ArrayColumn, Column, CustomTypeColumn, DomainColumn, EnumColumn, PostgisGeographyPointColumn, RawSql, TimestampColumn, TimestampTZColumn, UnknownColumn, addCode, assignDbDataToColumn, backtickQuote, codeToString, colors, constraintInnerToCode, consumeColumnName, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getColumnTypes, getDriverErrorCode, getImportPath, getStackTrace, indexInnerToCode, isRawSQL, logParamToLogObject, makeColumnTypes, makeColumnsByType, parseTableData, parseTableDataInput, pathToLog, primaryKeyInnerToCode, pushTableDataCode, quoteIdentifier, quoteObjectKey, raw, rawSqlToCode, referencesArgsToCode, setCurrentColumnName, setDefaultLanguage, singleQuote, tableDataMethods, toArray, toCamelCase, toSnakeCase } from "pqb/internal";
+import { ArrayColumn, Column, CustomTypeColumn, DomainColumn, EnumColumn, PostgisGeographyPointColumn, RawSql, TimestampColumn, TimestampTZColumn, UnknownColumn, addCode, assignDbDataToColumn, backtickQuote, codeToString, colors, constraintInnerToCode, consumeColumnName, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getColumnTypes, getDriverErrorCode, getForeignKeyTableInstance, getImportPath, getStackTrace, indexInnerToCode, isRawSQL, logParamToLogObject, makeColumnTypes, makeColumnsByType, parseTableData, parseTableDataInput, pathToLog, primaryKeyInnerToCode, pushTableDataCode, quoteIdentifier, quoteObjectKey, raw, rawSqlToCode, referencesArgsToCode, setCurrentColumnName, setDefaultLanguage, singleQuote, tableDataMethods, toArray, toCamelCase, toSnakeCase } from "pqb/internal";
 import path, { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createDbWithAdapter } from "pqb";
@@ -182,7 +182,7 @@ const addColumnComment = (comments, name, item) => {
 };
 const getForeignKeyTable = (schema, fnOrTable) => {
 	if (typeof fnOrTable === "string") return getSchemaAndTableFromName(schema, fnOrTable);
-	const item = new (fnOrTable())();
+	const item = getForeignKeyTableInstance(fnOrTable());
 	return [item.schema, item.table];
 };
 const getConstraintName = (table, constraint, snakeCase) => {
@@ -371,7 +371,8 @@ const primaryKeyToSql = (primaryKey) => {
 };
 const interpolateSqlValues = ({ text, values }) => {
 	return values?.length ? text.replace(/\$(\d+)/g, (_, n) => {
-		return escapeForMigration(values[+n - 1]);
+		const i = +n - 1;
+		return escapeForMigration(values[i]);
 	}) : text;
 };
 const nameColumnChecks = (table, column, checks) => checks.map((check, i) => ({
@@ -409,6 +410,33 @@ const migrationsSchemaTableSql = (adapter, config) => {
 };
 var RakeDbError = class extends Error {};
 var NoPrimaryKey = class extends RakeDbError {};
+const getTableFactoryConfig = ({ baseTable, defineTable }) => {
+	if (baseTable && defineTable) throw new Error("Configure either baseTable or defineTable, not both");
+	if (defineTable) {
+		if (!defineTable.types) throw new Error("defineTable is missing types");
+		if (!defineTable.exportAs) throw new Error("defineTable is missing exportAs");
+		if (typeof defineTable.getFilePath !== "function") throw new Error("defineTable is missing getFilePath");
+		return {
+			columnTypes: defineTable.types,
+			exportAs: defineTable.exportAs,
+			getFilePath: defineTable.getFilePath,
+			nowSQL: defineTable.nowSQL,
+			snakeCase: defineTable.snakeCase,
+			language: defineTable.language
+		};
+	}
+	if (baseTable) {
+		const { types, snakeCase, language } = baseTable.prototype || {};
+		return {
+			columnTypes: types,
+			exportAs: baseTable.exportAs,
+			getFilePath: baseTable.getFilePath,
+			nowSQL: baseTable.nowSQL,
+			snakeCase,
+			language
+		};
+	}
+};
 const createTable$1 = async (migration, tableMethods, up, tableName, first, second, third) => {
 	let options;
 	let fn;
@@ -428,7 +456,8 @@ const createTable$1 = async (migration, tableMethods, up, tableName, first, seco
 	let shape;
 	let tableData;
 	if (fn) {
-		shape = getColumnTypes(types, fn, migration.options.baseTable?.nowSQL, language);
+		const tableFactory = getTableFactoryConfig(migration.options);
+		shape = getColumnTypes(types, fn, tableFactory?.nowSQL, language);
 		tableData = parseTableData(dataFn);
 		tableData.constraints?.forEach((x, i) => {
 			if (x.name || !x.check) return;
@@ -465,7 +494,7 @@ const makeAst$5 = (schema, up, tableName, shape, tableData, options, noPrimaryKe
 		...tableData,
 		primaryKey: shapePKeys.length <= 1 ? primaryKey : primaryKey ? {
 			...primaryKey,
-			columns: [...new Set([...shapePKeys, ...primaryKey.columns])]
+			columns: [.../* @__PURE__ */ new Set([...shapePKeys, ...primaryKey.columns])]
 		} : { columns: shapePKeys },
 		...options,
 		noPrimaryKey: options.noPrimaryKey ? "ignore" : noPrimaryKey || "error"
@@ -851,6 +880,25 @@ const makeTableChangeMethods = (tableMethods) => ({
 			to: { comment }
 		};
 	},
+	/**
+	* Rename a column:
+	*
+	* ```ts
+	* import { change } from '../dbScript';
+	*
+	* change(async (db) => {
+	*   await db.changeTable('table', (t) => ({
+	*     oldColumnName: t.rename('newColumnName'),
+	*   }));
+	* });
+	* ```
+	*
+	* Note that the renaming `ALTER TABLE` is executed before the rest of alterations,
+	* so if you're also adding a new constraint on this column inside the same `changeTable`,
+	* refer to it with a new name.
+	*
+	* @param name
+	*/
 	rename(name) {
 		return {
 			type: "rename",
@@ -869,7 +917,8 @@ const changeTable = async (migration, tableChangeMethods, up, tableName, options
 	standaloneCheckChanges.length = 0;
 	const changeData = fn?.(tableChanger) || {};
 	const schema = migration.adapter.getSchema();
-	const queries = astToQueries(schema, makeAst$4(schema, up, tableName, changeData, changeTableData, options), snakeCase, language);
+	const ast = makeAst$4(schema, up, tableName, changeData, changeTableData, options);
+	const queries = astToQueries(schema, ast, snakeCase, language);
 	for (const query of queries) {
 		const result = await migration.adapter.arrays(interpolateSqlValues(query));
 		query.then?.(result);
@@ -1148,7 +1197,9 @@ const renameColumnSql = (from, to) => {
 	return `RENAME COLUMN "${from}" TO "${to}"`;
 };
 const createView = async (migration, up, name, options, sql) => {
-	const query = astToQuery$2(makeAst$3(migration.adapter.getSchema(), up, name, options, sql));
+	const schema = migration.adapter.getSchema();
+	const ast = makeAst$3(schema, up, name, options, sql);
+	const query = astToQuery$2(ast);
 	await migration.adapter.arrays(interpolateSqlValues(query));
 };
 const makeAst$3 = (schema, up, fullName, options, sql) => {
@@ -1195,12 +1246,15 @@ const astToQuery$2 = (ast) => {
 	};
 };
 const createMaterializedView = async (migration, up, name, options, sql) => {
-	const query = astToQuery$1(makeAst$2(migration.adapter.getSchema(), up, name, options, sql));
+	const schema = migration.adapter.getSchema();
+	const ast = makeAst$2(schema, up, name, options, sql);
+	const query = astToQuery$1(ast);
 	await migration.adapter.arrays(interpolateSqlValues(query));
 };
 const refreshMaterializedView = async (migration, name, options = {}) => {
 	if (options.concurrently && options.withData === false) throw new Error("Cannot refresh a materialized view concurrently with WITH NO DATA");
-	const [s, viewName] = getSchemaAndTableFromName(migration.adapter.getSchema(), name);
+	const schema = migration.adapter.getSchema();
+	const [s, viewName] = getSchemaAndTableFromName(schema, name);
 	const sql = ["REFRESH MATERIALIZED VIEW"];
 	if (options.concurrently) sql.push("CONCURRENTLY");
 	sql.push(`${s ? `"${s}".` : ""}"${viewName}"`);
@@ -1258,7 +1312,8 @@ const serializers = {
 	validUntil: (value) => `VALID UNTIL '${value === void 0 ? "infinity" : value}'`
 };
 const createOrDropRole = async (migration, up, name, params) => {
-	const sql = astToQuery(makeAst$1(up, name, params));
+	const ast = makeAst$1(up, name, params);
+	const sql = astToQuery(ast);
 	await migration.adapter.arrays(sql);
 };
 const makeAst$1 = (up, name, params) => {
@@ -1310,7 +1365,8 @@ const changeRole = async (migration, up, name, from, to) => {
 			for (const key in from.config) if (!(key in config)) config[key] = void 0;
 		}
 	}
-	const sql = changeAstToQuery(makeChangeAst(name, from, to));
+	const ast = makeChangeAst(name, from, to);
+	const sql = changeAstToQuery(ast);
 	if (sql) await migration.adapter.arrays(sql);
 };
 const makeChangeAst = (name, from, to) => {
@@ -1349,7 +1405,8 @@ const renameRole = async (migration, up, from, to) => {
 		from = to;
 		to = f;
 	}
-	const sql = renameAstToQuery(makeRenameAst(from, to));
+	const ast = makeRenameAst(from, to);
+	const sql = renameAstToQuery(ast);
 	if (sql) await migration.adapter.arrays(sql);
 };
 const makeRenameAst = (from, to) => ({
@@ -1401,7 +1458,8 @@ const filterAndTransformConfig = (config, schema) => {
 	return Object.keys(result).length ? result : void 0;
 };
 const changeDefaultPrivileges = async (migration, up, arg) => {
-	const sql = astToSql(makeAst(up, arg));
+	const ast = makeAst(up, arg);
+	const sql = astToSql(ast);
 	if (sql.length) await migration.adapter.arrays(sql.join(";\n"));
 };
 const makeAst = (up, arg) => {
@@ -1554,7 +1612,9 @@ const recreatePolicy = async (migration, tableName, policyName, from, to) => {
 	const fromTable = from.table ?? tableName;
 	const fromName = from.name ?? policyName;
 	await migration.adapter.arrays(dropPolicySql(migration, fromTable, fromName));
-	const { text, values } = createPolicySql(migration, to.table ?? tableName, to.name ?? policyName, to);
+	const toTable = to.table ?? tableName;
+	const toName = to.name ?? policyName;
+	const { text, values } = createPolicySql(migration, toTable, toName, to);
 	await migration.adapter.arrays(text, values);
 };
 const changePolicy = async (migration, up, tableName, policyName, params) => {
@@ -1582,18 +1642,19 @@ const schemaOrDatabaseTargetKeyToSql = {
 	schemas: "SCHEMA",
 	databases: "DATABASE"
 };
-const specialRoleSpecs = new Set([
+const specialRoleSpecs = /* @__PURE__ */ new Set([
 	"PUBLIC",
 	"CURRENT_ROLE",
 	"CURRENT_USER",
 	"SESSION_USER"
 ]);
 const changeGrant = async (migration, up, params) => {
-	const sql = privilegeToSql(migration, {
+	const ast = {
 		...params,
 		to: typeof params.to === "string" ? [params.to] : params.to,
 		action: up ? "grant" : "revoke"
-	});
+	};
+	const sql = privilegeToSql(migration, ast);
 	if (sql.length) await migration.adapter.arrays(sql.join(";\n"));
 };
 const privilegeToSql = (migration, ast) => {
@@ -1718,7 +1779,10 @@ const createMigrationInterface = (tx, up, config) => {
 var Migration = class {
 	getTableMethods() {
 		let { tableMethods } = this;
-		if (!tableMethods) tableMethods = makeTableMethods(defaultSchemaConfig());
+		if (!tableMethods) {
+			const schemaConfig = defaultSchemaConfig();
+			tableMethods = makeTableMethods(schemaConfig);
+		}
 		return tableMethods;
 	}
 	getTableChangeMethods() {
@@ -2799,7 +2863,8 @@ const addOrDropEnumValues = async (migration, up, enumName, values, options) =>
 		return;
 	}
 	const { rows: valuesRows } = await migration.adapter.query(`SELECT unnest(enum_range(NULL::${quotedName}))::text value`);
-	await recreateEnum(migration, ast, valuesRows.map((r) => r.value).filter((v) => !ast.values.includes(v)), (quotedName, table, column) => `Cannot drop ${quotedName} enum values [${ast.values.map(singleQuote).join(", ")}]: table ${table} has a row with such value in the column "${column}"`);
+	const existingValues = valuesRows.map((r) => r.value);
+	await recreateEnum(migration, ast, existingValues.filter((v) => !ast.values.includes(v)), (quotedName, table, column) => `Cannot drop ${quotedName} enum values [${ast.values.map(singleQuote).join(", ")}]: table ${table} has a row with such value in the column "${column}"`);
 };
 const changeEnumValues = async (migration, enumName, fromValues, toValues) => {
 	const [schema, name] = getSchemaAndTableFromName(migration.adapter.getSchema(), enumName);
@@ -2856,11 +2921,13 @@ GROUP BY n.nspname, c.relname`);
 const writeMigrationFile = async (config, version, name, migrationCode) => {
 	await mkdir(config.migrationsPath, { recursive: true });
 	const filePath = path.resolve(config.migrationsPath, `${version}_${name.replaceAll(" ", "-")}.ts`);
-	await writeFile(filePath, `import { change } from '${getImportPath(filePath, path.join(config.basePath, config.dbScript))}';\n${migrationCode}`);
+	const importPath = getImportPath(filePath, path.join(config.basePath, config.dbScript));
+	await writeFile(filePath, `import { change } from '${importPath}';\n${migrationCode}`);
 	config.logger?.log(`Created ${pathToLog(filePath)}`);
 };
 const newMigration = async (config, name) => {
-	await writeMigrationFile(config, await makeFileVersion({}, config), name, makeContent(name));
+	const version = await makeFileVersion({}, config);
+	await writeMigrationFile(config, version, name, makeContent(name));
 };
 const makeFileVersion = async (ctx, config) => {
 	if (config.migrationId === "timestamp") return generateTimeStamp();
@@ -3175,7 +3242,8 @@ const saveMigratedVersion = async (db, version, name, config) => {
 	await db.silentArrays(`INSERT INTO ${migrationsSchemaTableSql(db, config)}(version, name) VALUES ($1, $2)`, [version, name]);
 };
 const createMigrationsSchemaAndTable = async (db, config) => {
-	const { schema, table } = getMigrationsSchemaAndTable(getMaybeTransactionAdapter(db), config);
+	const adapter = getMaybeTransactionAdapter(db);
+	const { schema, table } = getMigrationsSchemaAndTable(adapter, config);
 	if (schema) {
 		if (await createSchema(db, schema) === "done") config.logger?.log(`Created schema "${schema}"`);
 	}
@@ -3267,10 +3335,10 @@ const processMigrateConfig = (config, db) => {
 		migrationsPath,
 		...handleConfigLogger(config, db)
 	};
-	if ("baseTable" in config && config.baseTable) {
-		const { snakeCase, language } = config.baseTable.prototype;
-		if (snakeCase) result.snakeCase = true;
-		if (language) result.language = language;
+	const tableFactory = getTableFactoryConfig(config);
+	if (tableFactory) {
+		if (tableFactory.snakeCase) result.snakeCase = true;
+		if (tableFactory.language) result.language = tableFactory.language;
 	}
 	return result;
 };
@@ -3288,12 +3356,14 @@ function makeMigrateFn(up, defaultCount, fn) {
 		let migrations;
 		try {
 			await transactionIfSingle(adapter, config, async (trx) => {
-				migrations = await fn(trx, config, set, await getMigratedVersionsMap(ctx, trx, config, set.renameTo), count, force);
+				const versions = await getMigratedVersionsMap(ctx, trx, config, set.renameTo);
+				migrations = await fn(trx, config, set, versions, count, force);
 			});
 		} catch (err) {
 			if (err instanceof NoMigrationsTableError) await transactionIfSingle(adapter, config, async (trx) => {
 				await createMigrationsSchemaAndTable(trx, config);
-				migrations = await fn(trx, config, set, await getMigratedVersionsMap(ctx, trx, config, set.renameTo), count, force);
+				const versions = await getMigratedVersionsMap(ctx, trx, config, set.renameTo);
+				migrations = await fn(trx, config, set, versions, count, force);
 			});
 			else throw err;
 		}
@@ -3329,9 +3399,11 @@ async function runMigration(db, ...args) {
 		...rawConfig,
 		...handleConfigLogger(rawConfig)
 	};
-	await transaction(getMaybeTransactionAdapter(db), config, async (trx) => {
+	const adapter = getMaybeTransactionAdapter(db);
+	await transaction(adapter, config, async (trx) => {
 		clearChanges();
-		await applyMigration(trx, true, await getChanges({ load: migration }), config);
+		const changes = await getChanges({ load: migration });
+		await applyMigration(trx, true, changes, config);
 	});
 }
 /**
@@ -3414,7 +3486,8 @@ const migrateOrRollback = async (trx, config, set, versions, count, up, redo, fo
 			loggedAboutStarting = true;
 			config.logger?.log(`${redo ? "Reapplying migrations for" : up ? "Migrating" : "Rolling back"} database ${getAdapterDatabase$1(trx)}\n`);
 		}
-		await changeMigratedVersion(await migrationRunner(trx, up, await getChanges(file, config), config), up, file, config);
+		const adapter = await migrationRunner(trx, up, await getChanges(file, config), config);
+		await changeMigratedVersion(adapter, up, file, config);
 		(migrations ??= []).push(file);
 		if (up) {
 			const name = path.basename(file.path);
@@ -3795,11 +3868,12 @@ const astToGenerateItem = (config, ast, currentSchema) => {
 				const keys = ast.action === "create" ? add : drop;
 				keys.push(table);
 				deps.push(schema);
-				analyzeTableColumns(config, currentSchema, schema, table, deps, resolveType, Object.entries(ast.shape).map(([name, column]) => [
+				const columns = Object.entries(ast.shape).map(([name, column]) => [
 					keys,
 					name,
 					{ column }
-				]));
+				]);
+				analyzeTableColumns(config, currentSchema, schema, table, deps, resolveType, columns);
 				if (ast.type === "table") analyzeTableData(config, currentSchema, schema, table, keys, deps, ast);
 				else deps.push(...ast.deps.map(({ schemaName, name }) => `${schemaName}.${name}`));
 			} else {
@@ -5659,9 +5733,7 @@ const viewToAst = (ctx, data, domains, view) => {
 			case "securityBarrier":
 				options.securityBarrier = value === "true";
 				break;
-			case "securityInvoker":
-				options.securityInvoker = value === "true";
-				break;
+			case "securityInvoker": options.securityInvoker = value === "true";
 		}
 	}
 	return {
@@ -5809,14 +5881,16 @@ const checkIfIsOuterRecursiveFkey = (data, table, references) => {
 const pullDbStructure = async (adapter, config) => {
 	const currentSchema = adapter.getSearchPath?.() ?? adapter.searchPath ?? "public";
 	const ctx = makeStructureToAstCtx(config, currentSchema);
-	const result = astToMigration(currentSchema, config, await structureToAst(ctx, adapter, config));
+	const ast = await structureToAst(ctx, adapter, config);
+	const result = astToMigration(currentSchema, config, ast);
 	if (!result) return;
 	const version = await makeFileVersion({}, config);
 	await writeMigrationFile(config, version, "pull", result);
-	await saveMigratedVersion(Object.assign(adapter, {
+	const silentQueries = Object.assign(adapter, {
 		silentQuery: adapter.query,
 		silentArrays: adapter.arrays
-	}), version, "pull", config);
+	});
+	await saveMigratedVersion(silentQueries, version, "pull", config);
 	const unsupportedEntries = Object.entries(ctx.unsupportedTypes);
 	if (unsupportedEntries.length) {
 		let count = 0;
@@ -6066,7 +6140,8 @@ const rakeDbCommands = {
 	},
 	status: {
 		run(adapters, config, args) {
-			return listMigrationsStatuses(adapters, config, { showUrl: args.includes("p") || args.includes("path") });
+			const showUrl = args.includes("p") || args.includes("path");
+			return listMigrationsStatuses(adapters, config, { showUrl });
 		},
 		help: "list migrations statuses",
 		helpArguments: {
@@ -6125,6 +6200,7 @@ const ensureBasePathAndDbScript = (config, intermediateCallers = 0) => {
 const makeRakeDbConfig = (config, args) => {
 	const ic = intermediateCallers;
 	intermediateCallers = 0;
+	const tableFactory = getTableFactoryConfig(config);
 	const result = {
 		...rakeDbConfigDefaults,
 		...config,
@@ -6134,10 +6210,8 @@ const makeRakeDbConfig = (config, args) => {
 	Object.assign(result, processMigrateConfig(result));
 	if (!result.recurrentPath && result.migrationsPath) result.recurrentPath = path.join(result.migrationsPath, "recurrent");
 	if (result.recurrentPath && !path.isAbsolute(result.recurrentPath)) result.recurrentPath = path.resolve(result.basePath, result.recurrentPath);
-	if ("baseTable" in config && config.baseTable) {
-		const { types } = config.baseTable.prototype;
-		result.columnTypes = types || makeColumnTypes(defaultSchemaConfig());
-	} else {
+	if (tableFactory) result.columnTypes = tableFactory.columnTypes || makeColumnTypes(defaultSchemaConfig());
+	else {
 		const ct = "columnTypes" in config && config.columnTypes;
 		result.columnTypes = (typeof ct === "function" ? ct(makeColumnTypes(defaultSchemaConfig())) : ct) || makeColumnTypes(defaultSchemaConfig());
 	}
@@ -6245,6 +6319,6 @@ ${commandsHelp.map(([key, help, helpArguments]) => {
 `);
 	}
 };
-export { RakeDbError, astToMigration, concatSchemaAndName, createDatabase, createMigrationChangeFn, createMigrationInterface, createMigrationsSchemaAndTable, createSchema, createTable, dbColumnToAst, dropDatabase, dropSchema, dropTable, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, incrementIntermediateCaller, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, promptSelect, rakeDbCliWithAdapter, rakeDbCommands, rakeDbConfigDefaults, redo, rollback, runMigration, saveMigratedVersion, setRakeDbCliRunFn, structureToAst, tableToAst, writeMigrationFile };
+export { RakeDbError, astToMigration, concatSchemaAndName, createDatabase, createMigrationChangeFn, createMigrationInterface, createMigrationsSchemaAndTable, createSchema, createTable, dbColumnToAst, dropDatabase, dropSchema, dropTable, encodeColumnDefault, getConstraintName, getDbStructureTableData, getDbTableColumnsChecks, getDbVersion, getExcludeName, getIndexName, getMigrationsSchemaAndTable, getSchemaAndTableFromName, getTableFactoryConfig, incrementIntermediateCaller, instantiateDbColumn, introspectDbSchema, makeDomainsMap, makeFileVersion, makeStructureToAstCtx, migrate, migrateAndClose, promptSelect, rakeDbCliWithAdapter, rakeDbCommands, rakeDbConfigDefaults, redo, rollback, runMigration, saveMigratedVersion, setRakeDbCliRunFn, structureToAst, tableToAst, writeMigrationFile };
 
 //# sourceMappingURL=index.mjs.map