rake-db 2.33.12 → 2.34.0

package/dist/index.d.ts

@@ -263,6 +263,7 @@ declare namespace RakeDbAst {
     comment?: string | null;
     compression?: string;
     primaryKey?: boolean;
+    primaryKeyName?: string;
     checks?: Column$1.Data.Check[];
     foreignKeys?: TableData.ColumnReferences[];
     indexes?: TableData.ColumnIndex[];
@@ -466,14 +467,38 @@ interface OneWayChange {
 interface ColumnForeignKeyChangeInput {
   columnForeignKey: TableData.ColumnReferences;
 }
-interface NoForeignKeyChangeInput {
-  noForeignKey: true;
+interface ColumnPrimaryKeyChangeInput {
+  columnPrimaryKey: {
+    name?: string;
+  };
+}
+interface ColumnIndexChangeInput {
+  columnIndex: TableData.ColumnIndex;
+}
+interface ColumnExcludeChangeInput {
+  columnExclude: TableData.ColumnExclude;
 }
-type ChangeInput = Column$1 | OneWayChange | NonUniqDataItem | ColumnForeignKeyChangeInput | NoForeignKeyChangeInput;
+type ChangeInput = Column$1 | OneWayChange | NonUniqDataItem | ColumnForeignKeyChangeInput | ColumnPrimaryKeyChangeInput | ColumnIndexChangeInput | ColumnExcludeChangeInput;
 interface TableChangeMethods extends TableMethods, TableDataMethods<string> {
   name(name: string): TableChangeMethods;
   add: Add;
   drop: Add;
+  primaryKey<Columns extends [string, ...string[]], Name extends string>(columns: Columns, name?: Name): {
+    tableDataItem: true;
+    columns: Columns;
+    name: string extends Name ? never : Name;
+  };
+  primaryKey(name?: string): ColumnPrimaryKeyChangeInput;
+  index(columns: (string | TableData.Index.ColumnOrExpressionOptions)[], options?: TableData.Index.OptionsArg): NonUniqDataItem;
+  index(options?: TableData.Index.ColumnArg): ColumnIndexChangeInput;
+  unique<Columns extends [string | TableData.Index.ColumnOrExpressionOptions, ...(string | TableData.Index.ColumnOrExpressionOptions)[]], Name extends string>(columns: Columns, options?: TableData.Index.UniqueOptionsArg<Name>): {
+    tableDataItem: true;
+    columns: Columns extends (string | TableData.Index.ColumnOptionsForColumn<string>)[] ? { [I in keyof Columns]: 'column' extends keyof Columns[I] ? Columns[I]['column'] : Columns[I] } : never;
+    name: string extends Name ? never : Name;
+  };
+  unique(options?: TableData.Index.UniqueColumnArg): ColumnIndexChangeInput;
+  exclude(columns: TableData.Exclude.ColumnOrExpressionOptions[], options?: TableData.Exclude.Options): NonUniqDataItem;
+  exclude(with_: string, options?: TableData.Exclude.ColumnArg): ColumnExcludeChangeInput;
   foreignKey<Shape>(columns: [string, ...string[]], fnOrTable: () => new () => {
     columns: {
       shape: Shape;
@@ -481,7 +506,6 @@ interface TableChangeMethods extends TableMethods, TableDataMethods<string> {
   }, foreignColumns: [keyof Shape, ...(keyof Shape)[]], options?: TableData.References.Options): NonUniqDataItem;
   foreignKey(columns: [string, ...string[]], fnOrTable: string, foreignColumns: [string, ...string[]], options?: TableData.References.Options): NonUniqDataItem;
   foreignKey(fnOrTable: string, foreignColumn: string, options?: TableData.References.Options): ColumnForeignKeyChangeInput;
-  noForeignKey(): NoForeignKeyChangeInput;
   change(from: ChangeInput, to: ChangeInput, using?: ChangeOptions): Change;
   default(value: unknown | RawSqlBase): OneWayChange;
   nullable(): OneWayChange;

package/dist/index.js

@@ -541,14 +541,34 @@ const resetChangeTableData = () => {
 	changeTableData = newChangeTableData();
 };
 const addOrDropChanges = [];
+const standaloneCheckChanges = [];
 function add(item, options) {
 	(0, pqb_internal.consumeColumnName)();
 	setName(this, item);
-	if (isNoForeignKeyChangeInput(item)) throw new Error("t.noForeignKey() is only supported in t.change(...)");
 	if (item instanceof pqb_internal.Column) {
 		const result = addOrDrop("add", item, options);
-		if (result.type === "change") return result;
+		if (result.type === "change") {
+			result.name ??= getName(this);
+			return result;
+		}
+		addOrDropChanges.push(result);
+		return addOrDropChanges.length - 1;
+	}
+	if (isStandaloneAddOrDropInput(item)) {
+		const result = standaloneAddOrDropToChange("add", item);
+		result.name ??= getName(this);
+		addOrDropChanges.push(result);
+		return addOrDropChanges.length - 1;
+	}
+	if (isStandaloneCheckAddOrDropInput(item)) {
+		const result = standaloneAddOrDropToChange("add", item);
+		result.name ??= getName(this);
 		addOrDropChanges.push(result);
+		standaloneCheckChanges.push({
+			index: addOrDropChanges.length - 1,
+			type: "add",
+			item
+		});
 		return addOrDropChanges.length - 1;
 	}
 	for (const key in item) {
@@ -568,13 +588,32 @@ function add(item, options) {
 const drop = function(item, options) {
 	(0, pqb_internal.consumeColumnName)();
 	setName(this, item);
-	if (isNoForeignKeyChangeInput(item)) throw new Error("t.noForeignKey() is only supported in t.change(...)");
 	if (item instanceof pqb_internal.Column) {
 		const result = addOrDrop("drop", item, options);
-		if (result.type === "change") return result;
+		if (result.type === "change") {
+			result.name ??= getName(this);
+			return result;
+		}
 		addOrDropChanges.push(result);
 		return addOrDropChanges.length - 1;
 	}
+	if (isStandaloneAddOrDropInput(item)) {
+		const result = standaloneAddOrDropToChange("drop", item);
+		result.name ??= getName(this);
+		addOrDropChanges.push(result);
+		return addOrDropChanges.length - 1;
+	}
+	if (isStandaloneCheckAddOrDropInput(item)) {
+		const result = standaloneAddOrDropToChange("drop", item);
+		result.name ??= getName(this);
+		addOrDropChanges.push(result);
+		standaloneCheckChanges.push({
+			index: addOrDropChanges.length - 1,
+			type: "drop",
+			item
+		});
+		return addOrDropChanges.length - 1;
+	}
 	for (const key in item) {
 		if (item[key] instanceof pqb_internal.Column) {
 			const result = {};
@@ -612,22 +651,48 @@ const addOrDrop = (type, item, options) => {
 		dropMode: options?.dropMode
 	};
 };
+const standaloneAddOrDropToChange = (type, item) => {
+	const empty = columnTypeToColumnChange({
+		type: "change",
+		to: {}
+	});
+	const change = changeInputToColumnChange(item);
+	return {
+		type: "change",
+		from: type === "add" ? empty : change,
+		to: type === "add" ? change : empty
+	};
+};
 const isColumnForeignKeyChangeInput = (item) => {
 	return "columnForeignKey" in item;
 };
-const isNoForeignKeyChangeInput = (item) => {
-	return "noForeignKey" in item;
+const isColumnPrimaryKeyChangeInput = (item) => {
+	return "columnPrimaryKey" in item;
+};
+const isColumnIndexChangeInput = (item) => {
+	return "columnIndex" in item;
+};
+const isColumnExcludeChangeInput = (item) => {
+	return "columnExclude" in item;
+};
+const isStandaloneAddOrDropInput = (item) => {
+	return isColumnForeignKeyChangeInput(item) || isColumnPrimaryKeyChangeInput(item) || isColumnIndexChangeInput(item) || isColumnExcludeChangeInput(item);
+};
+const isStandaloneCheckAddOrDropInput = (item) => {
+	return isCheckConstraintItem(item);
 };
 const isCheckConstraintItem = (item) => {
 	return !!item.constraint?.check;
 };
-const changeInputToColumnChange = (item, opposite) => {
+const changeInputToColumnChange = (item) => {
 	if (item instanceof pqb_internal.Column || "type" in item) return columnTypeToColumnChange(item);
+	if (isColumnPrimaryKeyChangeInput(item)) return {
+		primaryKey: true,
+		primaryKeyName: item.columnPrimaryKey.name
+	};
+	if (isColumnIndexChangeInput(item)) return { indexes: [item.columnIndex] };
+	if (isColumnExcludeChangeInput(item)) return { excludes: [item.columnExclude] };
 	if (isColumnForeignKeyChangeInput(item)) return { foreignKeys: [item.columnForeignKey] };
-	if (isNoForeignKeyChangeInput(item)) {
-		if (!isColumnForeignKeyChangeInput(opposite)) throw new Error("t.noForeignKey() in t.change(...) must be paired with t.foreignKey(...)");
-		return { foreignKeys: [] };
-	}
 	if (isCheckConstraintItem(item)) return { checks: [{
 		sql: item.constraint.check,
 		name: item.constraint.name
@@ -658,6 +723,9 @@ const columnTypeToColumnChange = (item, name) => {
 	return item.to;
 };
 const nameKey = Symbol("name");
+const getName = (self) => {
+	return self[nameKey];
+};
 const setName = (self, item) => {
 	const name = self[nameKey];
 	if (!name) return;
@@ -677,6 +745,47 @@ function foreignKey(...args) {
 		options
 	} };
 }
+function primaryKey(...args) {
+	if (Array.isArray(args[0])) {
+		const [columns, name] = args;
+		return pqb_internal.tableDataMethods.primaryKey(columns, name);
+	}
+	const [name] = args;
+	return { columnPrimaryKey: { name } };
+}
+function index(...args) {
+	if (Array.isArray(args[0])) {
+		const [columns, first, second] = args;
+		if (typeof first === "string") return pqb_internal.tableDataMethods.index(columns, first, second);
+		return pqb_internal.tableDataMethods.index(columns, first);
+	}
+	const [options] = args;
+	return { columnIndex: { options: { ...options } } };
+}
+function unique(...args) {
+	if (Array.isArray(args[0])) {
+		const [columns, first, second] = args;
+		if (typeof first === "string") return pqb_internal.tableDataMethods.unique(columns, first, second);
+		return pqb_internal.tableDataMethods.unique(columns, first);
+	}
+	const [options] = args;
+	return { columnIndex: { options: {
+		...options,
+		unique: true
+	} } };
+}
+function exclude(...args) {
+	if (Array.isArray(args[0])) {
+		const [columns, first, second] = args;
+		if (typeof first === "string") return pqb_internal.tableDataMethods.exclude(columns, first, second);
+		return pqb_internal.tableDataMethods.exclude(columns, first);
+	}
+	const [with_, options] = args;
+	return { columnExclude: {
+		with: with_,
+		options: { ...options }
+	} };
+}
 const tableChangeMethods = {
 	...tableMethods,
 	...pqb_internal.tableDataMethods,
@@ -688,14 +797,15 @@ const tableChangeMethods = {
 	},
 	add,
 	drop,
+	primaryKey,
+	index,
+	unique,
+	exclude,
 	foreignKey,
-	noForeignKey() {
-		return { noForeignKey: true };
-	},
 	change(from, to, using) {
 		(0, pqb_internal.consumeColumnName)();
-		const f = changeInputToColumnChange(from, to);
-		const t = changeInputToColumnChange(to, from);
+		const f = changeInputToColumnChange(from);
+		const t = changeInputToColumnChange(to);
 		setName(this, f);
 		setName(this, t);
 		return {
@@ -745,6 +855,7 @@ const changeTable = async (migration, up, tableName, options, fn) => {
 	const tableChanger = Object.create(migration.columnTypes);
 	Object.assign(tableChanger, tableChangeMethods);
 	addOrDropChanges.length = 0;
+	standaloneCheckChanges.length = 0;
 	const changeData = fn?.(tableChanger) || {};
 	const schema = migration.adapter.getSchema();
 	const queries = astToQueries(schema, makeAst$3(schema, up, tableName, changeData, changeTableData, options), snakeCase, language);
@@ -759,6 +870,7 @@ const makeAst$3 = (schema, up, name, changeData, changeTableData, options) => {
 	const consumedChanges = {};
 	for (const key in changeData) {
 		let item = changeData[key];
+		if (item === void 0) continue;
 		if (typeof item === "number") {
 			consumedChanges[item] = true;
 			item = addOrDropChanges[item];
@@ -784,9 +896,15 @@ const makeAst$3 = (schema, up, name, changeData, changeTableData, options) => {
 			}
 		} : item;
 	}
+	for (const checkChange of standaloneCheckChanges) {
+		if (consumedChanges[checkChange.index]) continue;
+		(0, pqb_internal.parseTableDataInput)(changeTableData[checkChange.type], checkChange.item);
+		consumedChanges[checkChange.index] = true;
+	}
 	for (let i = 0; i < addOrDropChanges.length; i++) {
 		if (consumedChanges[i]) continue;
 		const change = addOrDropChanges[i];
+		if (change.type === "change") throw new Error("Standalone helper add/drop changes must be assigned to a column key");
 		const name = change.item.data.name;
 		if (!name) throw new Error(`Column in ...t.${change.type}() must have a name`);
 		const arr = shape[name] ? (0, pqb_internal.toArray)(shape[name]) : [];
@@ -882,6 +1000,11 @@ const alterTableSql = (tableName, lines, values) => ({
   ${lines.join(",\n  ")}`,
 	values
 });
+const setPrimaryKeyName = (key, primaryKey, name) => {
+	if (!name) return;
+	if (primaryKey.name && primaryKey.name !== name) throw new Error(`Cannot use different primary key names in standalone changes for column ${key}`);
+	primaryKey.name = name;
+};
 const handlePrerequisitesForTableItem = (schema, key, item, queries, addPrimaryKeys, dropPrimaryKeys, snakeCase) => {
 	if ("item" in item) {
 		const { item: column } = item;
@@ -895,10 +1018,12 @@ const handlePrerequisitesForTableItem = (schema, key, item, queries, addPrimaryK
 		if (item.from.column instanceof pqb_internal.EnumColumn) queries.push(makePopulateEnumQuery(schema, item.from.column));
 		if (item.to.column instanceof pqb_internal.EnumColumn) queries.push(makePopulateEnumQuery(schema, item.to.column));
 		if (item.from.primaryKey) {
+			setPrimaryKeyName(key, dropPrimaryKeys, item.from.primaryKeyName);
 			dropPrimaryKeys.columns.push(item.from.column ? getColumnName(item.from.column, key, snakeCase) : snakeCase ? (0, pqb_internal.toSnakeCase)(key) : key);
 			dropPrimaryKeys.change = true;
 		}
 		if (item.to.primaryKey) {
+			setPrimaryKeyName(key, addPrimaryKeys, item.to.primaryKeyName);
 			addPrimaryKeys.columns.push(item.to.column ? getColumnName(item.to.column, key, snakeCase) : snakeCase ? (0, pqb_internal.toSnakeCase)(key) : key);
 			addPrimaryKeys.change = true;
 		}