@supabase/pg-delta 1.0.0-alpha.25 → 1.0.0-alpha.27

package/src/core/objects/type/range/changes/range.base.ts

@@ -8,7 +8,7 @@ abstract class BaseRangeChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "range" = "range";
+  readonly objectType = "range" as const;
 }
 
 export abstract class CreateRangeChange extends BaseRangeChange {

package/src/core/objects/view/changes/view.base.ts

@@ -8,7 +8,7 @@ abstract class BaseViewChange extends BaseChange {
     | "comment"
     | "privilege"
     | "security_label";
-  readonly objectType: "view" = "view";
+  readonly objectType = "view" as const;
 }
 
 export abstract class CreateViewChange extends BaseViewChange {

package/src/core/plan/hierarchy.ts

@@ -322,7 +322,7 @@ function addClusterChange(cluster: ClusterGroup, change: Change): void {
       break;
     default: {
       const _exhaustive: never = objectType;
-      throw new Error(`Unhandled object type: ${_exhaustive}`);
+      throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }
@@ -366,7 +366,7 @@ function addChildChange(schema: SchemaGroup, change: Change): void {
       break;
     default: {
       const _exhaustive: never = parentType;
-      throw new Error(`Unhandled parent type: ${_exhaustive}`);
+      throw new Error(`Unhandled parent type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 
@@ -416,7 +416,7 @@ function addChildChange(schema: SchemaGroup, change: Change): void {
       break;
     default: {
       const _exhaustive: never = objectType;
-      throw new Error(`Unhandled object type: ${_exhaustive}`);
+      throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }
@@ -568,7 +568,7 @@ function addSchemaLevelChange(
       break;
     default: {
       const _exhaustive: never = objectType;
-      throw new Error(`Unhandled object type: ${_exhaustive}`);
+      throw new Error(`Unhandled object type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }

package/src/core/postgres-config.test.ts

@@ -1,6 +1,7 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import {
   connectWithRetry,
+  connectWithTimeout,
   isRetryableConnectError,
   poolConfigFromUrl,
 } from "./postgres-config.ts";
@@ -241,6 +242,43 @@ describe("connectWithRetry", () => {
   });
 });
 
+describe("connectWithTimeout", () => {
+  test("clears the timer when connect resolves before it fires", async () => {
+    const clearSpy = spyOn(globalThis, "clearTimeout");
+    try {
+      const sentinel = { client: true };
+      const result = await connectWithTimeout(
+        () => Promise.resolve(sentinel),
+        60_000,
+        "source",
+      );
+      expect(result).toBe(sentinel);
+      expect(clearSpy).toHaveBeenCalled();
+    } finally {
+      clearSpy.mockRestore();
+    }
+  });
+
+  test("rejects with a timeout error when connect is too slow", async () => {
+    await expect(
+      connectWithTimeout(() => new Promise<never>(() => {}), 5, "target"),
+    ).rejects.toThrow(/timed out after 5ms/);
+  });
+
+  test("clears the timer even when connect rejects", async () => {
+    const clearSpy = spyOn(globalThis, "clearTimeout");
+    try {
+      const boom = new Error("connect ECONNREFUSED");
+      await expect(
+        connectWithTimeout(() => Promise.reject(boom), 60_000, "target"),
+      ).rejects.toBe(boom);
+      expect(clearSpy).toHaveBeenCalled();
+    } finally {
+      clearSpy.mockRestore();
+    }
+  });
+});
+
 describe("poolConfigFromUrl", () => {
   describe("non-IPv6 URLs pass through as connectionString", () => {
     test("DNS hostname", () => {

package/src/core/postgres-config.ts

@@ -209,6 +209,37 @@ export async function connectWithRetry<T>(opts: {
   throw lastError;
 }
 
+/**
+ * Race `connect()` against a `timeoutMs` rejection and clear the timer when
+ * either side wins. If the timer is left running after a fast connect, the
+ * pending `setTimeout` keeps the event loop alive and the process hangs for
+ * the rest of `timeoutMs`.
+ */
+export function connectWithTimeout<T>(
+  connect: () => Promise<T>,
+  timeoutMs: number,
+  label: "source" | "target",
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout>;
+  return Promise.race([
+    connect(),
+    new Promise<never>((_, reject) => {
+      timer = setTimeout(
+        () =>
+          reject(
+            new Error(
+              `Connection to ${label} database timed out after ${timeoutMs}ms. ` +
+                `The server may require SSL, use an invalid certificate, or be unreachable.`,
+            ),
+          ),
+        timeoutMs,
+      );
+    }),
+  ]).finally(() => {
+    clearTimeout(timer);
+  });
+}
+
 /**
  * Options for creating a Pool with event listeners.
  */
@@ -412,22 +443,7 @@ export async function createManagedPool(
   const timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS;
   try {
     const client = await connectWithRetry({
-      connect: () =>
-        Promise.race([
-          pool.connect(),
-          new Promise<never>((_, reject) =>
-            setTimeout(
-              () =>
-                reject(
-                  new Error(
-                    `Connection to ${label} database timed out after ${timeoutMs}ms. ` +
-                      `The server may require SSL, use an invalid certificate, or be unreachable.`,
-                  ),
-                ),
-              timeoutMs,
-            ),
-          ),
-        ]),
+      connect: () => connectWithTimeout(() => pool.connect(), timeoutMs, label),
     });
     client.release();
   } catch (err) {

package/src/core/sort/debug-visualization.ts

@@ -233,7 +233,7 @@ export function printDebugGraph(
       "\n==== Mermaid (cycle detected) ====\n%s\n==== end ====",
       mermaidDiagram,
     );
-  } catch (_error) {
+  } catch {
     // ignore debug printing errors
   }
 }

package/src/core/sort/sort-changes.test.ts

@@ -144,6 +144,7 @@ function table(
 
 async function catalogWithDepends(depends: PgDepend[]) {
   const base = await createEmptyCatalog(170000, "postgres");
+  // oxlint-disable-next-line typescript/no-misused-spread
   return new Catalog({ ...base, depends });
 }
 

package/src/core/sort/topological-sort.ts

@@ -14,7 +14,7 @@ export function performStableTopologicalSort(
     { length: nodeCount },
     () => new Set<number>(),
   );
-  const inDegreeCounts = new Array<number>(nodeCount).fill(0);
+  const inDegreeCounts: number[] = Array.from({ length: nodeCount }, () => 0);
 
   for (const [sourceIndex, targetIndex] of edges) {
     if (!adjacencyList[sourceIndex].has(targetIndex)) {
@@ -73,7 +73,7 @@ export function findCycle(
   }
 
   // 0 = unvisited, 1 = visiting, 2 = completed
-  const visitState = new Array<number>(nodeCount).fill(0);
+  const visitState: number[] = Array.from({ length: nodeCount }, () => 0);
   const pathStack: number[] = [];
   let cycleNodeIndexes: number[] | null = null;