veryfront 0.1.1186 → 0.1.1190

package/esm/src/proxy/routing-invalidation.js

@@ -1,6 +1,8 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { verifyDispatchJws } from "../channels/control-plane.js";
 import { getHostEnv } from "../platform/compat/process.js";
+import { isCanonicalOpaqueProjectIdentifier, isCanonicalProjectSlug, } from "../utils/project-identity.js";
+import { ProxyResponseBodyError, readProxyResponseText } from "./response-body.js";
 export const PROXY_ROUTING_INVALIDATION_PATH = "/_proxy/internal/routing-invalidation";
 export const PROXY_ROUTING_INVALIDATION_PLATFORM = "proxy-routing";
 export const PROXY_ROUTING_INVALIDATION_SUBJECT = "deployment-routing-invalidation";
@@ -8,49 +10,95 @@ const DISPATCH_JWS_HEADER = "x-veryfront-dispatch-jws";
 const PUBLIC_KEY_ENV_VAR = "CHANNEL_DISPATCH_SIGNING_PUBLIC_KEY";
 const MAX_SIGNATURE_AGE_SECONDS = 60;
 const MAX_REQUEST_BODY_BYTES = 16 * 1024;
+const DEFAULT_REQUEST_BODY_TIMEOUT_MS = 5_000;
+const MAX_REQUEST_BODY_TIMEOUT_MS = 60_000;
 function jsonResponse(status, body) {
     return Response.json(body, {
         status,
         headers: { "cache-control": "no-store" },
     });
 }
-function nonEmptyString(value) {
-    return typeof value === "string" && value.length > 0;
+function ownDataValue(descriptors, key) {
+    const descriptor = descriptors[key];
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
 }
-async function readBoundedRequestBody(req) {
-    if (!req.body)
-        return { body: "" };
-    const reader = req.body.getReader();
-    const chunks = [];
-    let totalBytes = 0;
+function isNonNegativeSafeInteger(value) {
+    return typeof value === "number" &&
+        Number.isSafeInteger(value) &&
+        value >= 0;
+}
+async function readBoundedRequestBody(req, timeoutMs) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const abortFromRequest = () => {
+        controller.abort(req.signal.reason);
+    };
+    if (req.signal.aborted)
+        abortFromRequest();
+    else
+        req.signal.addEventListener("abort", abortFromRequest, { once: true });
+    const timeoutId = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new DOMException("Routing invalidation request body timed out", "TimeoutError"));
+    }, timeoutMs);
     try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (!value)
-                continue;
-            totalBytes += value.byteLength;
-            if (totalBytes > MAX_REQUEST_BODY_BYTES) {
-                await reader.cancel("Request body is too large").catch(() => undefined);
-                return { error: "too-large" };
-            }
-            chunks.push(value);
+        const response = new Response(req.body, { headers: req.headers });
+        return {
+            body: await readProxyResponseText(response, MAX_REQUEST_BODY_BYTES, controller.signal),
+        };
+    }
+    catch (error) {
+        if (timedOut)
+            return { error: "timeout" };
+        if (error instanceof ProxyResponseBodyError &&
+            (error.failure === "too-large" ||
+                error.failure === "too-many-chunks")) {
+            return { error: "too-large" };
         }
-    }
-    catch {
         return { error: "unreadable" };
     }
     finally {
-        reader.releaseLock();
+        clearTimeout(timeoutId);
+        req.signal.removeEventListener("abort", abortFromRequest);
+    }
+}
+function snapshotProxyRoutingInvalidationRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    let descriptors;
+    try {
+        descriptors = Object.getOwnPropertyDescriptors(value);
+    }
+    catch {
+        return null;
     }
-    const bytes = new Uint8Array(totalBytes);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
+    const version = ownDataValue(descriptors, "version");
+    const projectId = ownDataValue(descriptors, "projectId");
+    const projectSlug = ownDataValue(descriptors, "projectSlug");
+    const deploymentId = ownDataValue(descriptors, "deploymentId");
+    const environmentId = ownDataValue(descriptors, "environmentId");
+    const environmentName = ownDataValue(descriptors, "environmentName");
+    const releaseId = ownDataValue(descriptors, "releaseId");
+    if (version !== 1 ||
+        !isCanonicalOpaqueProjectIdentifier(projectId) ||
+        typeof projectSlug !== "string" ||
+        !isCanonicalProjectSlug(projectSlug) ||
+        projectSlug !== projectSlug.toLowerCase() ||
+        !isCanonicalOpaqueProjectIdentifier(deploymentId) ||
+        !isCanonicalOpaqueProjectIdentifier(environmentId) ||
+        !isCanonicalOpaqueProjectIdentifier(environmentName) ||
+        !isCanonicalOpaqueProjectIdentifier(releaseId)) {
+        return null;
     }
-    return { body: new TextDecoder().decode(bytes) };
+    return Object.freeze({
+        version: 1,
+        projectId,
+        projectSlug,
+        deploymentId,
+        environmentId,
+        environmentName,
+        releaseId,
+    });
 }
 export function parseProxyRoutingInvalidationRequest(body) {
     let parsed;
@@ -60,27 +108,60 @@ export function parseProxyRoutingInvalidationRequest(body) {
     catch {
         return null;
     }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return snapshotProxyRoutingInvalidationRequest(parsed);
+}
+export function parseProxyRoutingInvalidationEvent(value) {
+    const request = snapshotProxyRoutingInvalidationRequest(value);
+    if (!request || !value || typeof value !== "object")
+        return null;
+    let eventId;
+    try {
+        eventId = ownDataValue(Object.getOwnPropertyDescriptors(value), "eventId");
+    }
+    catch {
+        return null;
+    }
+    if (!isCanonicalOpaqueProjectIdentifier(eventId))
         return null;
-    const input = parsed;
-    if (input.version !== 1 ||
-        !nonEmptyString(input.projectId) ||
-        !nonEmptyString(input.projectSlug) ||
-        !nonEmptyString(input.deploymentId) ||
-        !nonEmptyString(input.environmentId) ||
-        !nonEmptyString(input.environmentName) ||
-        !nonEmptyString(input.releaseId)) {
+    return Object.freeze({ eventId, ...request });
+}
+export function parseProxyRoutingInvalidationPublishResult(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
         return null;
+    let descriptors;
+    try {
+        descriptors = Object.getOwnPropertyDescriptors(value);
     }
-    return {
-        version: 1,
-        projectId: input.projectId,
-        projectSlug: input.projectSlug,
-        deploymentId: input.deploymentId,
-        environmentId: input.environmentId,
-        environmentName: input.environmentName,
-        releaseId: input.releaseId,
-    };
+    catch {
+        return null;
+    }
+    const acknowledged = ownDataValue(descriptors, "acknowledged");
+    const converged = ownDataValue(descriptors, "converged");
+    const recipients = ownDataValue(descriptors, "recipients");
+    if (!isNonNegativeSafeInteger(acknowledged) ||
+        !isNonNegativeSafeInteger(recipients) ||
+        acknowledged > recipients ||
+        typeof converged !== "boolean" ||
+        (converged &&
+            (recipients === 0 ||
+                acknowledged < recipients))) {
+        return null;
+    }
+    return Object.freeze({
+        acknowledged,
+        converged,
+        recipients,
+    });
+}
+function resolveBodyReadTimeout(value) {
+    if (value === undefined)
+        return DEFAULT_REQUEST_BODY_TIMEOUT_MS;
+    if (!Number.isSafeInteger(value) ||
+        value < 1 ||
+        value > MAX_REQUEST_BODY_TIMEOUT_MS) {
+        throw new RangeError(`Routing invalidation body timeout must be an integer between 1 and ${MAX_REQUEST_BODY_TIMEOUT_MS}`);
+    }
+    return value;
 }
 export async function handleProxyRoutingInvalidationRequest(req, options) {
     if (req.method !== "POST") {
@@ -90,14 +171,13 @@ export async function handleProxyRoutingInvalidationRequest(req, options) {
     if (!publicKeyPem || !options.publisher) {
         return jsonResponse(503, { error: "Routing invalidation is unavailable" });
     }
-    const declaredLength = Number(req.headers.get("content-length") ?? 0);
-    if (Number.isFinite(declaredLength) && declaredLength > MAX_REQUEST_BODY_BYTES) {
-        return jsonResponse(413, { error: "Request body is too large" });
-    }
-    const bodyResult = await readBoundedRequestBody(req);
+    const bodyResult = await readBoundedRequestBody(req, resolveBodyReadTimeout(options.bodyReadTimeoutMs));
     if ("error" in bodyResult && bodyResult.error === "too-large") {
         return jsonResponse(413, { error: "Request body is too large" });
     }
+    if ("error" in bodyResult && bodyResult.error === "timeout") {
+        return jsonResponse(408, { error: "Routing invalidation request timed out" });
+    }
     if ("error" in bodyResult) {
         return jsonResponse(400, { error: "Invalid routing invalidation request" });
     }
@@ -123,10 +203,16 @@ export async function handleProxyRoutingInvalidationRequest(req, options) {
     }
     try {
         const createEventId = options.createEventId ?? (() => dntShim.crypto.randomUUID());
-        const result = await options.publisher.publish({
+        const event = parseProxyRoutingInvalidationEvent({
             eventId: createEventId(),
             ...input,
         });
+        if (!event)
+            throw new TypeError("Routing invalidation event is invalid");
+        const result = parseProxyRoutingInvalidationPublishResult(await options.publisher.publish(event));
+        if (!result) {
+            throw new TypeError("Routing invalidation publisher returned an invalid result");
+        }
         return jsonResponse(result.converged ? 200 : 503, { ...result });
     }
     catch {

package/esm/src/proxy/server-resolver.d.ts

@@ -1,32 +1,45 @@
 /**
  * Dedicated Server Resolver
  *
- * Resolves an environment ID to a dedicated server hostname.
- * Used by the proxy to route traffic to dedicated servers instead of the shared pool.
- *
- * Caches results in memory with a short TTL to avoid hitting the API on every request.
- * A null result (no dedicated server) is also cached to prevent repeated lookups.
+ * Resolves an environment ID to a dedicated server origin. Control-plane
+ * failures deliberately fall back to the shared renderer pool, but malformed
+ * identifiers and construction policy fail at the local boundary.
  */
+export interface ServerResolverOptions {
+    maxEntries?: number;
+    maxInflight?: number;
+    requestTimeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}
 export declare class ServerResolver {
-    private apiInternalUrl;
-    private apiUser;
-    private apiPass;
-    private cacheTtlMs;
-    private cache;
-    private pending;
+    private readonly apiEndpointBase;
+    private readonly authorizationHeader;
+    private readonly cacheTtlMs;
+    private readonly maxEntries;
+    private readonly maxInflight;
+    private readonly requestTimeoutMs;
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly cache;
+    private readonly pending;
+    private readonly pendingControllers;
+    private readonly activeRequests;
     private cleanupTimer;
-    constructor(apiInternalUrl: string, apiUser: string, apiPass: string, cacheTtlMs?: number);
-    /**
-     * Resolve an environment ID to a dedicated server URL, or null for shared pool.
-     */
+    private generation;
+    private closed;
+    private capacityWarningEmitted;
+    constructor(apiInternalUrl: string, apiUser: string, apiPass: string, cacheTtlMs?: number, options?: ServerResolverOptions);
     resolve(environmentId: string | undefined): Promise<string | null>;
     close(): void;
-    /**
-     * Fetch dedicated server from API.
-     * Returns DedicatedServer | null on success (null = no dedicated server assigned).
-     * Throws ServerResolverError on transient failures (network, non-OK status).
-     */
+    private performLookup;
     private fetchServer;
+    private fetchServerWithinDeadline;
+    private remember;
     private cleanup;
+    private readClock;
+    private assertOpen;
+    private isAtCapacity;
+    private resetCapacityWarningIfAvailable;
 }
 //# sourceMappingURL=server-resolver.d.ts.map

package/esm/src/proxy/server-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-resolver.d.ts","sourceRoot":"","sources":["../../../src/src/proxy/server-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA2BH,qBAAa,cAAc;IAMvB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,UAAU;IARpB,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,OAAO,CAAsD;IACrE,OAAO,CAAC,YAAY,CAA+C;gBAGzD,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,MAAe;IAQrC;;OAEG;IACG,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAwCxE,KAAK,IAAI,IAAI;IAQb;;;;OAIG;YACW,WAAW;IAmCzB,OAAO,CAAC,OAAO;CAMhB"}
+{"version":3,"file":"server-resolver.d.ts","sourceRoot":"","sources":["../../../src/src/proxy/server-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqCH,MAAM,WAAW,qBAAqB;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAuND,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IACzC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA8B;IACjE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;IAChF,OAAO,CAAC,YAAY,CAA+C;IACnE,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,sBAAsB,CAAS;gBAGrC,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,MAA6B,EACzC,OAAO,GAAE,qBAA0B;IAwE/B,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgDxE,KAAK,IAAI,IAAI;YAkBC,aAAa;YAoBb,WAAW;YAmBX,yBAAyB;IA8EvC,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,+BAA+B;CAGxC"}