@happyvertical/sql 0.89.8 → 0.89.9

package/README.md

@@ -298,6 +298,11 @@ values so nullable composite keys update the existing row instead of inserting a
 duplicate. Pass `{ nullsDistinct: true }` as the fourth argument to preserve the
 database-native behavior where `NULL` conflict values are distinct.
 
+For PostgreSQL 15+, a matching `UNIQUE (...) NULLS NOT DISTINCT` index lets
+nullable upserts use one native `ON CONFLICT` statement. An ordinary `UNIQUE`
+constraint still treats `NULL` values as distinct, so the adapter retains its
+race-safe NULL-aware fallback for that schema.
+
 ### Transactions
 
 ```typescript
@@ -525,6 +530,17 @@ On PostgreSQL, `syncSchema()` recognizes `CREATE [UNIQUE] INDEX CONCURRENTLY
 [IF NOT EXISTS]` statements, including optional `USING` index methods, and
 skips indexes that already exist when a schema is applied again.
 
+PostgreSQL `tableExists()`, `getTableSchema()`, and `syncSchema()` resolve an
+unqualified table name through the executing connection's `search_path`, so a
+non-`public` schema can be used without changing the API. Root PostgreSQL
+helpers use a pool: do not issue `SET search_path` on one root call and assume
+later root helpers will use that same session. Configure the path for every
+pool connection, or keep transaction-scoped schema work on the supplied `tx`
+handle with `SET LOCAL search_path` before calling `tx.tableExists()` or
+`tx.syncSchema()`. `acquireSession()` pins raw PostgreSQL queries to one
+connection for session-scoped state; root metadata helpers are not part of
+that raw session handle.
+
 ### Vector Search (PostgreSQL)
 
 PostgreSQL adapters expose `db.vector` when pgvector is available:

package/dist/index.js

@@ -3089,7 +3089,18 @@ async function createDatabase(config) {
 		* @returns Promise resolving to boolean indicating if the table exists
 		*/
 		const tableExists = async (tableName) => {
-			return (await executor.query(`SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = 'public')`, [tableName])).rows[0].exists;
+			return (await executor.query(`SELECT EXISTS (
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_name = $1
+            AND table_schema = (
+              SELECT namespace.nspname
+              FROM pg_catalog.pg_class AS relation
+              JOIN pg_catalog.pg_namespace AS namespace
+                ON namespace.oid = relation.relnamespace
+              WHERE relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident($1))
+            )
+        )`, [tableName])).rows[0].exists;
 		};
 		/**
 		* Synchronizes database schema with provided SQL DDL
@@ -3138,16 +3149,25 @@ async function createDatabase(config) {
 					tableName
 				} : null;
 			};
-			const indexNames = [];
+			const indexTargets = [];
 			for (const command of commands) {
 				const indexMatch = parseCreateIndex(command.trim());
-				if (indexMatch) indexNames.push(indexMatch.indexName);
+				if (indexMatch) indexTargets.push(indexMatch);
 			}
 			const existingIndexes = /* @__PURE__ */ new Set();
-			if (indexNames.length > 0) {
-				const result = await executor.query(`SELECT indexname FROM pg_indexes
-           WHERE schemaname = 'public' AND indexname = ANY($1::text[])`, [indexNames]);
-				for (const row of result.rows) existingIndexes.add(row.indexname);
+			if (indexTargets.length > 0) {
+				const result = await executor.query(`SELECT target.table_name, target.index_name
+           FROM unnest($1::text[], $2::text[])
+             AS target(table_name, index_name)
+           JOIN pg_catalog.pg_class AS relation
+             ON relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident(target.table_name))
+           JOIN pg_catalog.pg_namespace AS namespace
+             ON namespace.oid = relation.relnamespace
+           JOIN pg_catalog.pg_indexes AS existing
+             ON existing.schemaname = namespace.nspname
+             AND existing.tablename = target.table_name
+             AND existing.indexname = target.index_name`, [indexTargets.map((target) => target.tableName), indexTargets.map((target) => target.indexName)]);
+				for (const row of result.rows) existingIndexes.add(`${row.table_name}\u0000${row.index_name}`);
 			}
 			for (const command of commands) {
 				const trimmedCommand = command.trim();
@@ -3170,7 +3190,13 @@ async function createDatabase(config) {
                         SELECT 1 FROM information_schema.columns
                         WHERE table_name = $1
                         AND column_name = $2
-                        AND table_schema = 'public'
+                        AND table_schema = (
+                          SELECT namespace.nspname
+                          FROM pg_catalog.pg_class AS relation
+                          JOIN pg_catalog.pg_namespace AS namespace
+                            ON namespace.oid = relation.relnamespace
+                          WHERE relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident($1))
+                        )
                       )`, [tableName, columnName])).rows[0].exists) {
 										const alterCommand = `ALTER TABLE "${tableName}" ADD COLUMN ${columnDef}`;
 										await executor.query(alterCommand);
@@ -3186,9 +3212,10 @@ async function createDatabase(config) {
 				const indexMatch = parseCreateIndex(trimmedCommand);
 				if (indexMatch) {
 					const { indexName, tableName: indexTableName } = indexMatch;
-					if (!existingIndexes.has(indexName)) try {
+					const indexKey = `${indexTableName}\u0000${indexName}`;
+					if (!existingIndexes.has(indexKey)) try {
 						await runTolerated(() => executor.query(trimmedCommand));
-						existingIndexes.add(indexName);
+						existingIndexes.add(indexKey);
 					} catch (error) {
 						console.warn(`Warning: Failed to create index ${indexName} on ${indexTableName}:`, error instanceof Error ? error.message : String(error));
 					}
@@ -3468,7 +3495,13 @@ async function createDatabase(config) {
           column_default
         FROM information_schema.columns
         WHERE table_name = ${table}
-          AND table_schema = 'public'
+          AND table_schema = (
+            SELECT namespace.nspname
+            FROM pg_catalog.pg_class AS relation
+            JOIN pg_catalog.pg_namespace AS namespace
+              ON namespace.oid = relation.relnamespace
+            WHERE relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident(${table}))
+          )
         ORDER BY ordinal_position
       `;
 			const pkRows = await many`
@@ -3478,7 +3511,13 @@ async function createDatabase(config) {
           ON tc.constraint_name = kcu.constraint_name
           AND tc.table_schema = kcu.table_schema
         WHERE tc.table_name = ${table}
-          AND tc.table_schema = 'public'
+          AND tc.table_schema = (
+            SELECT namespace.nspname
+            FROM pg_catalog.pg_class AS relation
+            JOIN pg_catalog.pg_namespace AS namespace
+              ON namespace.oid = relation.relnamespace
+            WHERE relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident(${table}))
+          )
           AND tc.constraint_type = 'PRIMARY KEY'
       `;
 			const pkColumns = new Set(pkRows.map((row) => row.column_name));
@@ -3498,7 +3537,13 @@ async function createDatabase(config) {
           indexdef
         FROM pg_indexes
         WHERE tablename = ${table}
-          AND schemaname = 'public'
+          AND schemaname = (
+            SELECT namespace.nspname
+            FROM pg_catalog.pg_class AS relation
+            JOIN pg_catalog.pg_namespace AS namespace
+              ON namespace.oid = relation.relnamespace
+            WHERE relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident(${table}))
+          )
           AND indexname NOT LIKE '%_pkey'
       `;
 			const indexes = [];
@@ -3533,7 +3578,13 @@ async function createDatabase(config) {
           AND rc.constraint_schema = tc.table_schema
         WHERE tc.constraint_type = 'FOREIGN KEY'
           AND tc.table_name = ${table}
-          AND tc.table_schema = 'public'
+          AND tc.table_schema = (
+            SELECT namespace.nspname
+            FROM pg_catalog.pg_class AS relation
+            JOIN pg_catalog.pg_namespace AS namespace
+              ON namespace.oid = relation.relnamespace
+            WHERE relation.oid = pg_catalog.to_regclass(pg_catalog.quote_ident(${table}))
+          )
       `;
 			const foreignKeys = [];
 			for (const fkRow of fkRows) foreignKeys.push({