@netlify/spark-ui 1.31.0-alpha.2 → 1.31.0-alpha.4

package/packages/components/preact/DropZone/drop-core/authedDropClient.ts

@@ -1,185 +0,0 @@
-import { apiError, type DropClient } from './client';
-import type { BuildSite } from './buildClient';
-import type { Digest, DropResponse } from './types';
-import { NotAuthenticatedError, SiteCreateError } from './errors';
-
-export interface AuthenticatedDropClientConfig {
-  /**
-   * API base for every call. Requests go straight to `api.netlify.com`, whose
-   * `/api/*` CORS policy allows any origin, rather than through a consumer's
-   * access-control rewrite — that proxy allowlists paths per origin, and site
-   * and deploy creation are not on the list for netlify.com (they 400 with
-   * `x-debug: request origin not allowed to call endpoint`).
-   */
-  apiBase?: string;
-  /**
-   * Mint a short-lived bearer token authorizing the calls. On netlify.com this
-   * is `GET /access-control/generate-access-control-token`, whose
-   * `accessControlToken` the API decrypts back into the user's access token.
-   * Resolving `null` means "no session" and surfaces as `NotAuthenticatedError`.
-   */
-  getUploadToken: () => Promise<string | null>;
-  /** Create the site in this account. Omit to use the user's default account. */
-  accountSlug?: string;
-  /** How often to re-read the deploy while waiting. Default 1s. */
-  pollIntervalMs?: number;
-  /** How long to wait before giving up on the deploy. Default 10 minutes. */
-  timeoutMs?: number;
-}
-
-// Same defaults as AuthenticatedBuildClient — the ~15 lines shared with it
-// (constants + site create) are deliberately duplicated rather than extracted,
-// to avoid churn on the in-review build-client branch. Worth unifying once both
-// have landed.
-const API_BASE = 'https://api.netlify.com/api/v1';
-const POLL_INTERVAL_MS = 1000;
-const TIMEOUT_MS = 10 * 60 * 1000;
-
-/** Deploy states that end the wait — `ready` succeeds, the rest are failures. */
-const TERMINAL_STATES = new Set(['ready', 'error', 'rejected']);
-
-interface DeployState {
-  state?: string;
-  error_message?: string;
-}
-
-/** Response body of `POST /sites/{id}/deploys` — the slice the drop flow needs. */
-interface SiteDeployResponse {
-  /** deploy id (BSON) */
-  id: string;
-  /** SHAs the backend does NOT yet have — only these get uploaded */
-  required?: string[];
-}
-
-/**
- * Authenticated drop client for logged-in visitors. Unlike `AnonymousDropClient`
- * — which creates an account-less site the visitor must later claim — this
- * deploys straight into the visitor's account via the sites/deploys API,
- * mirroring what app.netlify.com does for a logged-in drag-and-drop deploy.
- * There is no claim step, so the caller should hand off to the site's dashboard
- * page rather than the claim page.
- *
- * Every request goes direct to `api.netlify.com` with the short-lived bearer
- * from `getUploadToken()`. Routing the JSON calls through a consumer's
- * access-control rewrite instead (cookie session, no token in the browser)
- * would be the tighter design, but that proxy allowlists paths per origin and
- * site/deploy creation isn't allowed from netlify.com — it 400s before
- * reaching the API. Revisit if that allowlist gains these paths.
- *
- * Error-mapping invariant: only pre-mutation failures — a null upload token, or
- * a 401/403 creating the site — throw `NotAuthenticatedError`, which is the
- * signal the drop flow may safely retry anonymously. Once the site exists, an
- * auth failure throws a plain status-carrying error instead: falling back at
- * that point would strand an empty site in the account *and* deploy a duplicate
- * anonymously.
- */
-export class AuthenticatedDropClient implements DropClient {
-  private apiBase: string;
-  private getUploadToken: () => Promise<string | null>;
-  private accountSlug?: string;
-  private pollIntervalMs: number;
-  private timeoutMs: number;
-
-  constructor({
-    apiBase = API_BASE,
-    getUploadToken,
-    accountSlug,
-    pollIntervalMs = POLL_INTERVAL_MS,
-    timeoutMs = TIMEOUT_MS,
-  }: AuthenticatedDropClientConfig) {
-    this.apiBase = apiBase;
-    this.getUploadToken = getUploadToken;
-    this.accountSlug = accountSlug;
-    this.pollIntervalMs = pollIntervalMs;
-    this.timeoutMs = timeoutMs;
-  }
-
-  /**
-   * The token here is the upload bearer, not a drop token — it authorizes every
-   * call this client makes. Minted once per deploy, before anything is created,
-   * so a missing session fails the whole attempt cleanly.
-   */
-  async getToken(): Promise<string> {
-    const token = await this.getUploadToken();
-    if (!token) throw new NotAuthenticatedError();
-    return token;
-  }
-
-  /**
-   * Two calls: create the site in the visitor's account, then the deploy on it.
-   * Mapped into the anonymous `DropResponse` shape so `deployFiles` runs
-   * unchanged over either client.
-   */
-  async createDeploy(files: Digest, token: string): Promise<DropResponse> {
-    const path = this.accountSlug ? `/${this.accountSlug}/sites` : '/sites';
-    const siteRes = await fetch(`${this.apiBase}${path}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
-      body: JSON.stringify({ created_via: 'drop' }),
-    });
-    // A logged-out visitor 401s here, before anything is created — the one
-    // point an anonymous fallback is still safe (see the class doc).
-    if (siteRes.status === 401 || siteRes.status === 403) throw new NotAuthenticatedError();
-    if (!siteRes.ok) throw new SiteCreateError(siteRes.status);
-    const site: BuildSite = await siteRes.json();
-
-    const deployRes = await fetch(`${this.apiBase}/sites/${site.id}/deploys`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
-      body: JSON.stringify({ files, deploy_source: 'drop' }),
-    });
-    if (!deployRes.ok) throw apiError('deploy create', deployRes.status);
-    const deploy: SiteDeployResponse = await deployRes.json();
-
-    return {
-      id: site.id,
-      deploy_id: deploy.id,
-      subdomain: site.name,
-      required: deploy.required ?? [],
-    };
-  }
-
-  async uploadFile(
-    deployId: string,
-    path: string,
-    content: ArrayBuffer,
-    token: string
-  ): Promise<void> {
-    // PUT (not POST) so paths with "&" etc. work.
-    const res = await fetch(`${this.apiBase}/deploys/${deployId}/files${path}`, {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/octet-stream', Authorization: `Bearer ${token}` },
-      body: content,
-    });
-    if (!res.ok) throw apiError(`upload ${path}`, res.status);
-  }
-
-  /**
-   * Poll until the deploy settles: resolve on `ready`, throw on
-   * `error`/`rejected`, throw on timeout. Reuses the bearer minted at the start
-   * of the deploy, so a deploy that outlives the token's TTL will start seeing
-   * 401s here — those are ignored like any other non-ok read and the loop runs
-   * to its timeout rather than failing fast. Acceptable while static deploys
-   * finish in seconds; re-mint per poll if that stops being true.
-   */
-  async waitUntilReady(deploy: DropResponse, token: string): Promise<void> {
-    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) {
-        const state: DeployState = await res.json();
-        if (state.state && TERMINAL_STATES.has(state.state)) {
-          if (state.state === 'ready') return;
-          throw new Error(
-            state.error_message ? `deploy failed: ${state.error_message}` : 'deploy failed'
-          );
-        }
-      }
-      await new Promise(r => setTimeout(r, this.pollIntervalMs));
-    }
-    // Same message the anonymous client uses, so humanizeDropError maps it.
-    throw new Error('Deploy did not become ready in time');
-  }
-}