rake-db 2.36.14 → 2.36.16

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Adapter, Column as Column$1, ColumnSchemaConfig, ColumnTypeSchemaArg, ColumnsByType, ColumnsShape, DbDomainArg, DbResult, DbStructureDomainsMap, DefaultColumnTypes, DefaultPrivileges, DefaultSchemaConfig, EmptyObject, EnumColumn, Grant, MaybeArray, MaybePromise, NoPrimaryKeyOption, NonUniqDataItem, PickQueryQ, QueryData, QueryLogObject, QueryLogOptions, QueryLogger, QuerySchema, RawSqlBase, RecordOptionalString, RecordString, RlsPolicy, SearchWeight, TableData, TableDataFn, TableDataItem, TableDataMethods, raw } from "pqb/internal";
+import { Adapter, Column as Column$1, ColumnSchemaConfig, ColumnsByType, ColumnsShape, DbDomainArg, DbResult, DbStructureDomainsMap, DefaultColumnTypes, DefaultPrivileges, DefaultSchemaConfig, EmptyObject, EnumColumn, Grant, MaybeArray, MaybePromise, NoPrimaryKeyOption, NonUniqDataItem, PickQueryQ, QueryData, QueryLogObject, QueryLogOptions, QueryLogger, QuerySchema, RawSqlBase, RecordOptionalString, RecordString, RlsPolicy, SearchWeight, TableData, TableDataFn, TableDataItem, TableDataMethods, raw } from "pqb/internal";
 import { Db } from "pqb";
 declare namespace DbStructure {
   interface TableNameAndSchemaName {
@@ -87,6 +87,8 @@ declare namespace DbStructure {
     name: string;
     using: string;
     unique: boolean;
+    /** Deferrability mode when the unique index is backed by a constraint. */
+    deferrable?: false | 'immediate' | 'deferred';
     columns: (({
       column: string;
     } | {
@@ -576,7 +578,7 @@ declare namespace RakeDbAst {
   export {};
 }
 interface TableMethods {
-  enum(name: string): EnumColumn<ColumnTypeSchemaArg, undefined, [string, ...string[]]>;
+  enum(name: string): EnumColumn<DefaultSchemaConfig, undefined, [string, ...string[]]>;
 }
 type Add = typeof add;
 declare function add(item: Column$1, options?: {
@@ -721,7 +723,7 @@ type TableOptions = {
   language?: string;
 };
 type MigrationColumnTypes<CT> = Omit<CT, 'enum'> & {
-  enum: (name: string) => EnumColumn<ColumnSchemaConfig, unknown, readonly string[]>;
+  enum: (name: string) => EnumColumn<DefaultSchemaConfig, unknown, readonly string[]>;
 };
 type ColumnsShapeCallback<CT, Shape extends ColumnsShape = ColumnsShape> = (t: MigrationColumnTypes<CT> & {
   raw: typeof raw;

package/dist/index.js

@@ -266,17 +266,20 @@ const getExcludeName = (table, columns) => getIndexOrExcludeName(table, columns,
 const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, language) => {
 	return indexes.map((index) => {
 		const { options } = index;
+		const isDeferrableUnique = isActiveUniqueDeferrable(options.deferrable);
+		if (isDeferrableUnique && !options.unique) throw new Error("Only unique indexes can be deferrable");
 		const { columns, include, name } = getIndexOrExcludeMainOptions(tableName, index, getIndexName, snakeCase);
-		if (!up) return { text: `DROP INDEX "${name}"${options.dropMode ? ` ${options.dropMode}` : ""}` };
+		if (!up) return { text: `${isDeferrableUnique ? `ALTER TABLE ${quoteTable(schema, tableName)} DROP CONSTRAINT "${name}"` : `DROP INDEX "${name}"`}${options.dropMode ? ` ${options.dropMode}` : ""}` };
+		if (isDeferrableUnique) validateDeferrableUnique(index);
 		const values = [];
-		const sql = ["CREATE"];
-		if (options.unique) sql.push("UNIQUE");
-		sql.push(`INDEX "${name}" ON ${quoteTable(schema, tableName)}`);
+		const sql = isDeferrableUnique ? [`ALTER TABLE ${quoteTable(schema, tableName)} ADD CONSTRAINT "${name}"`, `UNIQUE${options.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}`] : ["CREATE"];
+		if (!isDeferrableUnique && options.unique) sql.push("UNIQUE");
+		if (!isDeferrableUnique) sql.push(`INDEX "${name}" ON ${quoteTable(schema, tableName)}`);
 		const u = options.using || options.tsVector && "GIN";
-		if (u) sql.push(`USING ${u}`);
+		if (!isDeferrableUnique && u) sql.push(`USING ${u}`);
 		const lang = options.tsVector && options.languageColumn ? `"${options.languageColumn}"` : options.language ? `'${options.language}'` : `'${language || "english"}'`;
-		let hasWeight = options.tsVector && columns.some((column) => !!column.weight);
-		const columnsSql = columns.map((column) => {
+		let hasWeight = !isDeferrableUnique && options.tsVector && columns.some((column) => !!column.weight);
+		const columnsSql = isDeferrableUnique ? columns.map(uniqueConstraintColumnToSql) : columns.map((column) => {
 			let sql = [
 				"expression" in column ? `(${column.expression})` : `"${column.column}"`,
 				column.collate && `COLLATE ${quoteNameFromString(schema, column.collate)}`,
@@ -298,16 +301,45 @@ const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, lan
 		else columnList = columnsSql.join(", ");
 		sql.push(`(${columnList})`);
 		if (include && include.length) sql.push(`INCLUDE (${include.map((column) => `"${column}"`).join(", ")})`);
-		if (options.nullsNotDistinct) sql.push(`NULLS NOT DISTINCT`);
+		if (!isDeferrableUnique && options.nullsNotDistinct) sql.push(`NULLS NOT DISTINCT`);
 		if (options.with) sql.push(`WITH (${options.with})`);
-		if (options.tablespace) sql.push(`TABLESPACE ${options.tablespace}`);
-		if (options.where) sql.push(`WHERE ${(0, pqb_internal.isRawSQL)(options.where) ? options.where.toSQL({ values }) : options.where}`);
+		if (options.tablespace) sql.push(isDeferrableUnique ? `USING INDEX TABLESPACE ${options.tablespace}` : `TABLESPACE ${options.tablespace}`);
+		if (!isDeferrableUnique && options.where) sql.push(`WHERE ${(0, pqb_internal.isRawSQL)(options.where) ? options.where.toSQL({ values }) : options.where}`);
+		if (isDeferrableUnique) sql.push(`DEFERRABLE INITIALLY ${options.deferrable === "deferred" ? "DEFERRED" : "IMMEDIATE"}`);
 		return {
 			text: sql.join(" "),
 			values
 		};
 	});
 };
+const isActiveUniqueDeferrable = (deferrable) => deferrable === "immediate" || deferrable === "deferred";
+const uniqueConstraintColumnToSql = (column) => {
+	if ("expression" in column) throw new Error("Deferrable unique constraints do not support expression indexes");
+	return `"${column.column}"`;
+};
+const validateDeferrableUnique = (index) => {
+	const { options } = index;
+	if (options.where) throw new Error("Deferrable unique constraints do not support partial indexes");
+	const unsupportedOption = getUnsupportedDeferrableUniqueIndexOption(options);
+	if (unsupportedOption) throw new Error(`Deferrable unique constraints do not support index option: ${unsupportedOption}`);
+	for (const column of index.columns) {
+		if ("expression" in column) throw new Error("Deferrable unique constraints do not support expression indexes");
+		const unsupportedColumnOption = getUnsupportedDeferrableUniqueColumnOption(column);
+		if (unsupportedColumnOption) throw new Error(`Deferrable unique constraints do not support index column option: ${unsupportedColumnOption}`);
+	}
+};
+const getUnsupportedDeferrableUniqueIndexOption = (options) => {
+	if (options.using) return "using";
+	if (options.tsVector) return "tsVector";
+	if (options.language) return "language";
+	if (options.languageColumn) return "languageColumn";
+};
+const getUnsupportedDeferrableUniqueColumnOption = (column) => {
+	if (column.collate) return "collate";
+	if (column.opclass) return "opclass";
+	if (column.order) return "order";
+	if (column.weight) return "weight";
+};
 const excludesToQuery = (up, { schema, name: tableName }, excludes, snakeCase) => {
 	return excludes.map((exclude) => {
 		const { options } = exclude;
@@ -4769,6 +4801,10 @@ const indexesSql = `SELECT
   ic.relname "name",
   am.amname AS "using",
   i.indisunique "unique",
+  CASE
+    WHEN c.condeferrable AND c.condeferred THEN 'deferred'
+    WHEN c.condeferrable THEN 'immediate'
+  END AS "deferrable",
   (
     SELECT json_agg(
       (
@@ -4865,6 +4901,9 @@ JOIN pg_class t ON t.oid = i.indrelid
 JOIN pg_namespace n ON n.oid = t.relnamespace
 JOIN pg_class ic ON ic.oid = i.indexrelid
 JOIN pg_am am ON am.oid = ic.relam
+LEFT JOIN pg_constraint c
+  ON c.conindid = ic.oid
+ AND c.contype = 'u'
 LEFT JOIN pg_catalog.pg_class tc ON (ic.reltoastrelid = tc.oid)
 WHERE ${filterSchema("n.nspname")}
   AND NOT i.indisprimary
@@ -5218,6 +5257,7 @@ async function introspectDbSchema(db, params) {
 	const excludes = [];
 	for (const index of raw.indexes) {
 		nullsToUndefined(index);
+		if (!index.deferrable) index.deferrable = void 0;
 		for (const column of index.columns) {
 			if (!("expression" in column)) continue;
 			const s = column.expression;
@@ -5767,6 +5807,7 @@ const makeIndexOrExcludeOptions = (tableName, index, key) => {
 		name: index.name !== (key === "indexes" ? getIndexName : getExcludeName)(tableName, index.columns) ? index.name : void 0,
 		using: index.using === "btree" ? void 0 : index.using,
 		unique: index.unique || void 0,
+		deferrable: index.deferrable || void 0,
 		include: index.include,
 		nullsNotDistinct: index.nullsNotDistinct || void 0,
 		with: index.with,