@netlify/spark-ui 1.31.0-alpha.6 → 1.31.0-alpha.8

package/packages/drop-core/client.test.ts

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { AnonymousDropClient } from './client';
+import { DeployFailedError } from './errors';
+import type { DropResponse } from './types';
+
+const deploy: DropResponse = { id: 'site', deploy_id: 'd', subdomain: 'x', required: [] };
+const client = () => new AnonymousDropClient('https://api', 1, 50);
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe('AnonymousDropClient.waitUntilReady', () => {
+  it('resolves once the deploy is ready', async () => {
+    vi.stubGlobal('fetch', async () => ({ ok: true, json: async () => ({ state: 'ready' }) }));
+    await expect(client().waitUntilReady(deploy, 'tok')).resolves.toBeUndefined();
+  });
+
+  // Regression: a failed anonymous deploy used to poll to the full timeout.
+  it('fails fast on a failed deploy instead of timing out', async () => {
+    vi.stubGlobal('fetch', async () => ({
+      ok: true,
+      json: async () => ({ state: 'error', error_message: 'nope' }),
+    }));
+    const err = await client()
+      .waitUntilReady(deploy, 'tok')
+      .catch(e => e);
+    expect(err).toBeInstanceOf(DeployFailedError);
+    expect(err.reason).toBe('nope');
+  });
+});

package/packages/drop-core/client.ts

@@ -3,7 +3,8 @@
  * interface, so `deployFiles` runs the same pipeline anonymous or authenticated.
  */
 import { DEFAULT_API_BASE, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS } from './constants';
-import { DeployTimeoutError } from './errors';
+import { DeployFailedError, DeployTimeoutError } from './errors';
+import { pollUntilSettled } from './pollDeploy';
 import type { DropResponse, Digest } from './types';
 
 /** A normal Error with the response's HTTP status attached, so callers can branch on it directly. */
@@ -61,17 +62,24 @@ export class AnonymousDropClient implements DropClient {
   }
 
   async waitUntilReady(deploy: DropResponse, token: string): Promise<void> {
-    // `/deploys/{id}` expects the deploy_id (BSON), not the site id (UUID) that
-    // lives at `deploy.id`. See drop_controller.rb; Deploy.find(uuid) is nil and
-    // the request 401s misleadingly via require_current_actor!.
-    const deadline = this.timeoutMs / this.pollIntervalMs;
-    for (let i = 0; i < deadline; i++) {
-      const res = await fetch(`${this.apiBase}/deploys/${deploy.deploy_id}`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      if (res.ok && (await res.json()).state === 'ready') return;
-      await new Promise(r => setTimeout(r, this.pollIntervalMs));
-    }
+    const settled = await pollUntilSettled({
+      deployId: deploy.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs,
+      // `/deploys/{id}` expects the deploy_id (BSON), not the site id (UUID) that
+      // lives at `deploy.id`. See drop_controller.rb; Deploy.find(uuid) is nil and
+      // the request 401s misleadingly via require_current_actor!.
+      readState: async id => {
+        const res = await fetch(`${this.apiBase}/deploys/${id}`, {
+          headers: { Authorization: `Bearer ${token}` },
+        });
+        return res.ok ? res.json() : null;
+      },
+    });
+    if (settled.outcome === 'ready') return;
+    // A failed deploy now surfaces immediately instead of waiting out the full
+    // timeout, matching the authenticated path.
+    if (settled.outcome === 'failed') throw new DeployFailedError(settled.errorMessage);
     throw new DeployTimeoutError();
   }
 }

package/packages/drop-core/constants.ts

@@ -13,7 +13,7 @@ export const DEFAULT_POLL_INTERVAL_MS = 1000;
 // How long to keep polling before giving up: 10 minutes
 export const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 
-// Concurrent file uploads (matches netlify-cli's deploy engine)
+// Concurrent file uploads
 export const MAX_CONCURRENT_UPLOADS = 5;
 
 // Reuse window for a minted upload token: 20s (server TTL is 30s; the gap is

package/packages/drop-core/pollDeploy.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { pollUntilSettled } from './pollDeploy';
+
+const base = { deployId: 'd', pollIntervalMs: 1, timeoutMs: 50 };
+
+describe('pollUntilSettled', () => {
+  it('resolves ready when the deploy reaches ready', async () => {
+    const settled = await pollUntilSettled({ ...base, readState: async () => ({ state: 'ready' }) });
+    expect(settled).toEqual({ outcome: 'ready' });
+  });
+
+  it('reports failure with the API message on error/rejected', async () => {
+    for (const state of ['error', 'rejected']) {
+      const settled = await pollUntilSettled({
+        ...base,
+        readState: async () => ({ state, error_message: 'boom' }),
+      });
+      expect(settled).toEqual({ outcome: 'failed', errorMessage: 'boom' });
+    }
+  });
+
+  it('times out when the deploy never settles (does not hang on failure states either)', async () => {
+    const settled = await pollUntilSettled({
+      ...base,
+      timeoutMs: 3,
+      readState: async () => ({ state: 'building' }),
+    });
+    expect(settled).toEqual({ outcome: 'timed-out' });
+  });
+
+  it('skips a null read without settling, then resolves', async () => {
+    let calls = 0;
+    const settled = await pollUntilSettled({
+      ...base,
+      readState: async () => (++calls < 3 ? null : { state: 'ready' }),
+    });
+    expect(settled).toEqual({ outcome: 'ready' });
+    expect(calls).toBeGreaterThanOrEqual(3);
+  });
+
+  it('waits through non-terminal states then settles on the terminal one', async () => {
+    const states = ['uploading', 'processing', 'ready'];
+    let i = 0;
+    const settled = await pollUntilSettled({
+      ...base,
+      readState: async () => ({ state: states[Math.min(i++, states.length - 1)] }),
+    });
+    expect(settled).toEqual({ outcome: 'ready' });
+  });
+});

package/packages/drop-core/pollDeploy.ts

@@ -0,0 +1,46 @@
+/**
+ * The single deploy poller both drop clients share. The loop and its
+ * terminal-state policy live here once; transport (cookie proxy vs bearer) is
+ * injected via `readState`, so the anonymous and authenticated paths can't
+ * drift on what "done" means.
+ */
+
+/** How a watched deploy ended. `errorMessage` is the API's own explanation, when it gave one. */
+export type SettledDeploy =
+  | { outcome: 'ready' }
+  | { outcome: 'failed'; errorMessage?: string }
+  | { outcome: 'timed-out' };
+
+/** The slice of a deploy record the poller reads; `null` = a read that failed and should be skipped. */
+export interface DeployState {
+  state?: string;
+  error_message?: string;
+}
+
+/** `ready` succeeds; `error`/`rejected` are failures; anything else keeps waiting. */
+const TERMINAL_STATES = new Set(['ready', 'error', 'rejected']);
+
+/**
+ * Poll until the deploy reaches a terminal state or the timeout elapses.
+ * A `null` read is skipped, not fatal — a transient hiccup shouldn't kill a
+ * progressing deploy. Callers map the outcome onto their own error vocabulary.
+ */
+export async function pollUntilSettled(options: {
+  deployId: string;
+  pollIntervalMs: number;
+  timeoutMs: number;
+  readState: (deployId: string) => Promise<DeployState | null>;
+}): Promise<SettledDeploy> {
+  const { deployId, pollIntervalMs, timeoutMs, readState } = options;
+  const deadline = timeoutMs / pollIntervalMs;
+  for (let i = 0; i < deadline; i++) {
+    const deploy = await readState(deployId);
+    if (deploy?.state && TERMINAL_STATES.has(deploy.state)) {
+      return deploy.state === 'ready'
+        ? { outcome: 'ready' }
+        : { outcome: 'failed', errorMessage: deploy.error_message };
+    }
+    await new Promise(r => setTimeout(r, pollIntervalMs));
+  }
+  return { outcome: 'timed-out' };
+}