@atscript/db-postgres 0.1.128 → 0.1.129

package/dist/index.cjs

@@ -300,6 +300,40 @@ function parseCount(value) {
 * const users = space.getTable(UsersType)
 * ```
 */
+/** The suffix PostgreSQL gives an auto-named constraint of each `pg_constraint.contype`. */
+const PG_CONSTRAINT_LABELS = {
+	p: "pkey",
+	u: "key",
+	f: "fkey",
+	n: "not_null"
+};
+/** UTF-8 byte length of `s`. */
+function byteLength(s) {
+	return Buffer.byteLength(s, "utf8");
+}
+/** Cuts `s` to at most `bytes` UTF-8 bytes (whole characters only). */
+function truncateBytes(s, bytes) {
+	let out = s;
+	while (byteLength(out) > bytes) out = out.slice(0, -1);
+	return out;
+}
+/**
+* The name PostgreSQL generates for an unnamed constraint (`makeObjectName`):
+* `<table>_<columns joined by _>_<label>`, with the table and column parts
+* shortened — the longer one first — until the whole fits 63 bytes
+* (`NAMEDATALEN - 1`). Used to recognise and to rename the recreated table's
+* constraints. Ignores the `1`, `2`, … suffix PostgreSQL appends on a clash.
+*/
+function pgObjectName(table, columns, label) {
+	const name2 = columns.join("_");
+	const avail = 63 - (label.length + 1 + (name2 ? 1 : 0));
+	let n1 = byteLength(table);
+	let n2 = byteLength(name2);
+	while (n1 + n2 > avail) if (n1 > n2) n1--;
+	else n2--;
+	const head = truncateBytes(table, n1);
+	return name2 ? `${head}_${truncateBytes(name2, n2)}_${label}` : `${head}_${label}`;
+}
 var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 	driver;
 	supportsColumnModify = true;
@@ -869,14 +903,18 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
            ON kcu.constraint_name = tc.constraint_name AND kcu.table_schema = tc.table_schema
          JOIN information_schema.key_column_usage kcur
            ON kcur.constraint_name = rc.unique_constraint_name AND kcur.table_schema = rc.unique_constraint_schema
-              AND kcur.ordinal_position = kcu.ordinal_position
+              AND kcur.ordinal_position = kcu.position_in_unique_constraint
          WHERE rc.unique_constraint_schema = COALESCE($1, 'public')
            AND rc.unique_constraint_name IN (
              SELECT constraint_name FROM information_schema.table_constraints
-             WHERE table_name = $2 AND table_schema = COALESCE($1, 'public') AND constraint_type = 'PRIMARY KEY'
-           )`, [schema, this._table.tableName]);
+             WHERE table_name = $2 AND table_schema = COALESCE($1, 'public')
+               AND constraint_type IN ('PRIMARY KEY', 'UNIQUE')
+           )
+         ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema, this._table.tableName]);
 			const fkByName = /* @__PURE__ */ new Map();
+			const ownSchema = schema ?? "public";
 			for (const fk of fkRefs) {
+				if (fk.table_schema === ownSchema && fk.table_name === this._table.tableName) continue;
 				let entry = fkByName.get(fk.constraint_name);
 				if (!entry) {
 					entry = {
@@ -900,7 +938,8 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 			const createSql = buildCreateTable(tempName, this._table.fieldDescriptors, this._table.foreignKeys, {
 				incrementFields: this._incrementFields,
 				autoIncrementStart: this._autoIncrementStart,
-				typeMapper: (field) => this.typeMapper(field)
+				typeMapper: (field) => this.typeMapper(field),
+				deferForeignKeysTo: new Set([this._table.tableName])
 			});
 			this._log(createSql);
 			await conn.exec(createSql);
@@ -925,13 +964,16 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 				this._log(copySql);
 				await conn.exec(copySql);
 			}
-			await conn.exec(`DROP TABLE IF EXISTS ${quoteTableName(tableName)} CASCADE`);
+			const dropSql = `DROP TABLE IF EXISTS ${quoteTableName(tableName)}`;
+			this._log(dropSql);
+			await conn.exec(dropSql);
 			await conn.exec(`ALTER TABLE ${quoteTableName(tempName)} RENAME TO ${qi(this._table.tableName)}`);
+			await this._renameTempConstraints(conn, baseTempName);
 			const resolvedTable = this.resolveTableName();
-			for (const [, fk] of fkByName) {
+			for (const [name, fk] of fkByName) {
 				const localCols = fk.cols.map((c) => qi(c)).join(", ");
 				const refCols = fk.refCols.map((c) => qi(c)).join(", ");
-				let ddl = `ALTER TABLE ${qi(fk.schema)}.${qi(fk.table)} ADD FOREIGN KEY (${localCols}) REFERENCES ${quoteTableName(resolvedTable)} (${refCols})`;
+				let ddl = `ALTER TABLE ${qi(fk.schema)}.${qi(fk.table)} ADD CONSTRAINT ${qi(name)} FOREIGN KEY (${localCols}) REFERENCES ${quoteTableName(resolvedTable)} (${refCols})`;
 				if (fk.onDelete !== "NO ACTION") ddl += ` ON DELETE ${fk.onDelete}`;
 				if (fk.onUpdate !== "NO ACTION") ddl += ` ON UPDATE ${fk.onUpdate}`;
 				this._log(ddl);
@@ -941,11 +983,59 @@ var PostgresAdapter = class PostgresAdapter extends _atscript_db.BaseDbAdapter {
 			await this._resetIdentitySequences();
 		} catch (err) {
 			await conn.exec("ROLLBACK").catch(() => {});
+			const detail = err.detail;
+			if (err instanceof Error && typeof detail === "string" && detail.length > 0) err.message = `${err.message} — ${detail}`;
 			throw err;
 		} finally {
 			conn.release();
 		}
 	}
+	/**
+	* Renames the recreated table's auto-named constraints from the temp
+	* table's names to the final table's: `<tmp>_pkey` → `<table>_pkey`,
+	* `<tmp>_<cols>_fkey` → `<table>_<cols>_fkey`, and so on. Runs inside the
+	* recreate transaction, after the RENAME. A constraint is recognised by
+	* its kind and columns — its name equals the one PostgreSQL generates for
+	* the temp table ({@link pgObjectName}, 63-byte truncation included) — so
+	* a long table name matches too. A target name already taken (a primary /
+	* unique constraint's index shares its name with every relation in the
+	* schema; other kinds with the table's constraints) is skipped and logged.
+	*/
+	async _renameTempConstraints(conn, baseTempName) {
+		const table = this._table.tableName;
+		const rows = await conn.all(`SELECT c.conname, c.contype,
+              (SELECT array_agg(a.attname::text ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS columns
+       FROM pg_constraint c
+       JOIN pg_class cl ON cl.oid = c.conrelid
+       JOIN pg_namespace n ON n.oid = cl.relnamespace
+       WHERE cl.relname = $1 AND n.nspname = COALESCE($2, 'public')
+       ORDER BY c.conname`, [table, this._schema]);
+		const taken = new Set(rows.map((r) => r.conname));
+		for (const { conname, contype, columns } of rows) {
+			const label = PG_CONSTRAINT_LABELS[contype];
+			if (!label) continue;
+			const cols = contype === "p" ? [] : columns ?? [];
+			if (conname !== pgObjectName(baseTempName, cols, label)) continue;
+			const target = pgObjectName(table, cols, label);
+			if (target === conname) continue;
+			if (contype === "p" || contype === "u" ? await this._relationExists(conn, target) : taken.has(target)) {
+				this._log(`-- constraint "${conname}" keeps its name: "${target}" already exists`);
+				continue;
+			}
+			const ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} RENAME CONSTRAINT ${qi(conname)} TO ${qi(target)}`;
+			this._log(ddl);
+			await conn.exec(ddl);
+			taken.add(target);
+		}
+	}
+	/** Whether a relation (table, index, view, …) named `name` exists in this adapter's schema. */
+	async _relationExists(conn, name) {
+		return (await conn.get(`SELECT true AS present FROM pg_class c
+       JOIN pg_namespace n ON n.oid = c.relnamespace
+       WHERE c.relname = $1 AND n.nspname = COALESCE($2, 'public')`, [name, this._schema]))?.present ?? false;
+	}
 	async afterSyncTable() {
 		await this._resetIdentitySequences();
 	}

package/dist/index.d.cts

@@ -69,22 +69,6 @@ interface TPgConnection {
 }
 //#endregion
 //#region src/postgres-adapter.d.ts
-/**
- * PostgreSQL adapter for {@link AtscriptDbTable}.
- *
- * Accepts any {@link TPgDriver} implementation — the actual PostgreSQL driver
- * is fully swappable (pg Pool, custom implementations, etc.).
- *
- * Usage:
- * ```typescript
- * import { PgDriver, PostgresAdapter } from '@atscript/db-postgres'
- * import { DbSpace } from '@atscript/db'
- *
- * const driver = new PgDriver('postgresql://user@localhost:5432/mydb')
- * const space = new DbSpace(() => new PostgresAdapter(driver))
- * const users = space.getTable(UsersType)
- * ```
- */
 declare class PostgresAdapter extends BaseDbAdapter {
   protected readonly driver: TPgDriver;
   supportsColumnModify: boolean;
@@ -191,6 +175,20 @@ declare class PostgresAdapter extends BaseDbAdapter {
   getExistingColumnsForTable(tableName: string): Promise<TExistingColumn[]>;
   syncColumns(diff: TColumnDiff): Promise<TSyncColumnResult>;
   recreateTable(): Promise<void>;
+  /**
+   * Renames the recreated table's auto-named constraints from the temp
+   * table's names to the final table's: `<tmp>_pkey` → `<table>_pkey`,
+   * `<tmp>_<cols>_fkey` → `<table>_<cols>_fkey`, and so on. Runs inside the
+   * recreate transaction, after the RENAME. A constraint is recognised by
+   * its kind and columns — its name equals the one PostgreSQL generates for
+   * the temp table ({@link pgObjectName}, 63-byte truncation included) — so
+   * a long table name matches too. A target name already taken (a primary /
+   * unique constraint's index shares its name with every relation in the
+   * schema; other kinds with the table's constraints) is skipped and logged.
+   */
+  private _renameTempConstraints;
+  /** Whether a relation (table, index, view, …) named `name` exists in this adapter's schema. */
+  private _relationExists;
   afterSyncTable(): Promise<void>;
   /**
    * Resets IDENTITY sequences to MAX(column) so that the next auto-generated

package/dist/index.d.mts

@@ -69,22 +69,6 @@ interface TPgConnection {
 }
 //#endregion
 //#region src/postgres-adapter.d.ts
-/**
- * PostgreSQL adapter for {@link AtscriptDbTable}.
- *
- * Accepts any {@link TPgDriver} implementation — the actual PostgreSQL driver
- * is fully swappable (pg Pool, custom implementations, etc.).
- *
- * Usage:
- * ```typescript
- * import { PgDriver, PostgresAdapter } from '@atscript/db-postgres'
- * import { DbSpace } from '@atscript/db'
- *
- * const driver = new PgDriver('postgresql://user@localhost:5432/mydb')
- * const space = new DbSpace(() => new PostgresAdapter(driver))
- * const users = space.getTable(UsersType)
- * ```
- */
 declare class PostgresAdapter extends BaseDbAdapter {
   protected readonly driver: TPgDriver;
   supportsColumnModify: boolean;
@@ -191,6 +175,20 @@ declare class PostgresAdapter extends BaseDbAdapter {
   getExistingColumnsForTable(tableName: string): Promise<TExistingColumn[]>;
   syncColumns(diff: TColumnDiff): Promise<TSyncColumnResult>;
   recreateTable(): Promise<void>;
+  /**
+   * Renames the recreated table's auto-named constraints from the temp
+   * table's names to the final table's: `<tmp>_pkey` → `<table>_pkey`,
+   * `<tmp>_<cols>_fkey` → `<table>_<cols>_fkey`, and so on. Runs inside the
+   * recreate transaction, after the RENAME. A constraint is recognised by
+   * its kind and columns — its name equals the one PostgreSQL generates for
+   * the temp table ({@link pgObjectName}, 63-byte truncation included) — so
+   * a long table name matches too. A target name already taken (a primary /
+   * unique constraint's index shares its name with every relation in the
+   * schema; other kinds with the table's constraints) is skipped and logged.
+   */
+  private _renameTempConstraints;
+  /** Whether a relation (table, index, view, …) named `name` exists in this adapter's schema. */
+  private _relationExists;
   afterSyncTable(): Promise<void>;
   /**
    * Resets IDENTITY sequences to MAX(column) so that the next auto-generated

package/dist/index.mjs

@@ -299,6 +299,40 @@ function parseCount(value) {
 * const users = space.getTable(UsersType)
 * ```
 */
+/** The suffix PostgreSQL gives an auto-named constraint of each `pg_constraint.contype`. */
+const PG_CONSTRAINT_LABELS = {
+	p: "pkey",
+	u: "key",
+	f: "fkey",
+	n: "not_null"
+};
+/** UTF-8 byte length of `s`. */
+function byteLength(s) {
+	return Buffer.byteLength(s, "utf8");
+}
+/** Cuts `s` to at most `bytes` UTF-8 bytes (whole characters only). */
+function truncateBytes(s, bytes) {
+	let out = s;
+	while (byteLength(out) > bytes) out = out.slice(0, -1);
+	return out;
+}
+/**
+* The name PostgreSQL generates for an unnamed constraint (`makeObjectName`):
+* `<table>_<columns joined by _>_<label>`, with the table and column parts
+* shortened — the longer one first — until the whole fits 63 bytes
+* (`NAMEDATALEN - 1`). Used to recognise and to rename the recreated table's
+* constraints. Ignores the `1`, `2`, … suffix PostgreSQL appends on a clash.
+*/
+function pgObjectName(table, columns, label) {
+	const name2 = columns.join("_");
+	const avail = 63 - (label.length + 1 + (name2 ? 1 : 0));
+	let n1 = byteLength(table);
+	let n2 = byteLength(name2);
+	while (n1 + n2 > avail) if (n1 > n2) n1--;
+	else n2--;
+	const head = truncateBytes(table, n1);
+	return name2 ? `${head}_${truncateBytes(name2, n2)}_${label}` : `${head}_${label}`;
+}
 var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 	driver;
 	supportsColumnModify = true;
@@ -868,14 +902,18 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
            ON kcu.constraint_name = tc.constraint_name AND kcu.table_schema = tc.table_schema
          JOIN information_schema.key_column_usage kcur
            ON kcur.constraint_name = rc.unique_constraint_name AND kcur.table_schema = rc.unique_constraint_schema
-              AND kcur.ordinal_position = kcu.ordinal_position
+              AND kcur.ordinal_position = kcu.position_in_unique_constraint
          WHERE rc.unique_constraint_schema = COALESCE($1, 'public')
            AND rc.unique_constraint_name IN (
              SELECT constraint_name FROM information_schema.table_constraints
-             WHERE table_name = $2 AND table_schema = COALESCE($1, 'public') AND constraint_type = 'PRIMARY KEY'
-           )`, [schema, this._table.tableName]);
+             WHERE table_name = $2 AND table_schema = COALESCE($1, 'public')
+               AND constraint_type IN ('PRIMARY KEY', 'UNIQUE')
+           )
+         ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema, this._table.tableName]);
 			const fkByName = /* @__PURE__ */ new Map();
+			const ownSchema = schema ?? "public";
 			for (const fk of fkRefs) {
+				if (fk.table_schema === ownSchema && fk.table_name === this._table.tableName) continue;
 				let entry = fkByName.get(fk.constraint_name);
 				if (!entry) {
 					entry = {
@@ -899,7 +937,8 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			const createSql = buildCreateTable(tempName, this._table.fieldDescriptors, this._table.foreignKeys, {
 				incrementFields: this._incrementFields,
 				autoIncrementStart: this._autoIncrementStart,
-				typeMapper: (field) => this.typeMapper(field)
+				typeMapper: (field) => this.typeMapper(field),
+				deferForeignKeysTo: new Set([this._table.tableName])
 			});
 			this._log(createSql);
 			await conn.exec(createSql);
@@ -924,13 +963,16 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 				this._log(copySql);
 				await conn.exec(copySql);
 			}
-			await conn.exec(`DROP TABLE IF EXISTS ${quoteTableName(tableName)} CASCADE`);
+			const dropSql = `DROP TABLE IF EXISTS ${quoteTableName(tableName)}`;
+			this._log(dropSql);
+			await conn.exec(dropSql);
 			await conn.exec(`ALTER TABLE ${quoteTableName(tempName)} RENAME TO ${qi(this._table.tableName)}`);
+			await this._renameTempConstraints(conn, baseTempName);
 			const resolvedTable = this.resolveTableName();
-			for (const [, fk] of fkByName) {
+			for (const [name, fk] of fkByName) {
 				const localCols = fk.cols.map((c) => qi(c)).join(", ");
 				const refCols = fk.refCols.map((c) => qi(c)).join(", ");
-				let ddl = `ALTER TABLE ${qi(fk.schema)}.${qi(fk.table)} ADD FOREIGN KEY (${localCols}) REFERENCES ${quoteTableName(resolvedTable)} (${refCols})`;
+				let ddl = `ALTER TABLE ${qi(fk.schema)}.${qi(fk.table)} ADD CONSTRAINT ${qi(name)} FOREIGN KEY (${localCols}) REFERENCES ${quoteTableName(resolvedTable)} (${refCols})`;
 				if (fk.onDelete !== "NO ACTION") ddl += ` ON DELETE ${fk.onDelete}`;
 				if (fk.onUpdate !== "NO ACTION") ddl += ` ON UPDATE ${fk.onUpdate}`;
 				this._log(ddl);
@@ -940,11 +982,59 @@ var PostgresAdapter = class PostgresAdapter extends BaseDbAdapter {
 			await this._resetIdentitySequences();
 		} catch (err) {
 			await conn.exec("ROLLBACK").catch(() => {});
+			const detail = err.detail;
+			if (err instanceof Error && typeof detail === "string" && detail.length > 0) err.message = `${err.message} — ${detail}`;
 			throw err;
 		} finally {
 			conn.release();
 		}
 	}
+	/**
+	* Renames the recreated table's auto-named constraints from the temp
+	* table's names to the final table's: `<tmp>_pkey` → `<table>_pkey`,
+	* `<tmp>_<cols>_fkey` → `<table>_<cols>_fkey`, and so on. Runs inside the
+	* recreate transaction, after the RENAME. A constraint is recognised by
+	* its kind and columns — its name equals the one PostgreSQL generates for
+	* the temp table ({@link pgObjectName}, 63-byte truncation included) — so
+	* a long table name matches too. A target name already taken (a primary /
+	* unique constraint's index shares its name with every relation in the
+	* schema; other kinds with the table's constraints) is skipped and logged.
+	*/
+	async _renameTempConstraints(conn, baseTempName) {
+		const table = this._table.tableName;
+		const rows = await conn.all(`SELECT c.conname, c.contype,
+              (SELECT array_agg(a.attname::text ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS columns
+       FROM pg_constraint c
+       JOIN pg_class cl ON cl.oid = c.conrelid
+       JOIN pg_namespace n ON n.oid = cl.relnamespace
+       WHERE cl.relname = $1 AND n.nspname = COALESCE($2, 'public')
+       ORDER BY c.conname`, [table, this._schema]);
+		const taken = new Set(rows.map((r) => r.conname));
+		for (const { conname, contype, columns } of rows) {
+			const label = PG_CONSTRAINT_LABELS[contype];
+			if (!label) continue;
+			const cols = contype === "p" ? [] : columns ?? [];
+			if (conname !== pgObjectName(baseTempName, cols, label)) continue;
+			const target = pgObjectName(table, cols, label);
+			if (target === conname) continue;
+			if (contype === "p" || contype === "u" ? await this._relationExists(conn, target) : taken.has(target)) {
+				this._log(`-- constraint "${conname}" keeps its name: "${target}" already exists`);
+				continue;
+			}
+			const ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} RENAME CONSTRAINT ${qi(conname)} TO ${qi(target)}`;
+			this._log(ddl);
+			await conn.exec(ddl);
+			taken.add(target);
+		}
+	}
+	/** Whether a relation (table, index, view, …) named `name` exists in this adapter's schema. */
+	async _relationExists(conn, name) {
+		return (await conn.get(`SELECT true AS present FROM pg_class c
+       JOIN pg_namespace n ON n.oid = c.relnamespace
+       WHERE c.relname = $1 AND n.nspname = COALESCE($2, 'public')`, [name, this._schema]))?.present ?? false;
+	}
 	async afterSyncTable() {
 		await this._resetIdentitySequences();
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db-postgres",
-  "version": "0.1.128",
+  "version": "0.1.129",
   "description": "PostgreSQL adapter for @atscript/db with pg (node-postgres) driver support.",
   "keywords": [
     "atscript",
@@ -55,8 +55,8 @@
     "@atscript/typescript": "^0.1.92",
     "@uniqu/core": "^0.1.8",
     "pg": ">=8.0.0",
-    "@atscript/db-sql-tools": "^0.1.128",
-    "@atscript/db": "^0.1.128"
+    "@atscript/db": "^0.1.129",
+    "@atscript/db-sql-tools": "^0.1.129"
   },
   "peerDependenciesMeta": {
     "pg": {