alchemy 0.70.2 → 0.71.1

package/src/util/cli-args.ts

@@ -0,0 +1,11 @@
+export const cliArgs = process.argv.slice(2);
+
+export function parseOption<D extends string | undefined>(
+  option: string,
+  defaultValue?: D,
+): D {
+  const i = cliArgs.indexOf(option);
+  return (
+    i !== -1 && i + 1 < cliArgs.length ? cliArgs[i + 1] : defaultValue
+  ) as D;
+}

package/src/util/retry.ts

@@ -14,6 +14,7 @@ export async function withExponentialBackoff<T>(
   isRetryable: (error: any) => any,
   maxAttempts = 5,
   initialDelayMs = 100,
+  maxDelayMs = 10000,
 ): Promise<T> {
   let attempt = 0;
   let delay = initialDelayMs;
@@ -31,7 +32,7 @@ export async function withExponentialBackoff<T>(
       const jitter = Math.random() * 0.1 * delay;
       await new Promise((resolve) => setTimeout(resolve, delay + jitter));
       delay *= 2; // Double the delay for next attempt
-      delay = Math.min(delay, 10000); // Cap at 10 seconds
+      delay = Math.min(delay, maxDelayMs); // Cap at 10 seconds
     }
   }
 }

package/src/util/telemetry.ts

@@ -1,11 +1,15 @@
 import envPaths from "env-paths";
 import { exec } from "node:child_process";
 import fs from "node:fs/promises";
+import http from "node:http";
+import https from "node:https";
 import os from "node:os";
+import { URL } from "node:url";
 import path from "pathe";
 import pkg from "../../package.json" with { type: "json" };
 import type { Phase } from "../alchemy.ts";
 import { Scope } from "../scope.ts";
+import { parseOption } from "./cli-args.ts";
 import { logger } from "./logger.ts";
 import { memoize } from "./memoize.ts";
 
@@ -170,9 +174,25 @@ export const collectData = memoize(async (): Promise<GenericTelemetryData> => {
     getRuntime(),
     getEnvironment(),
   ]);
+
+  const sessionId =
+    parseOption("--telemetry-session-id") ??
+    process.env.ALCHEMY_TELEMETRY_SESSION_ID ??
+    //@ts-expect-error
+    globalThis.ALCHEMY_TELEMETRY_SESSION_ID ??
+    crypto.randomUUID();
+
+  const referrer =
+    parseOption("--telemetry-ref") ??
+    process.env.ALCHEMY_TELEMETRY_REF ??
+    //@ts-expect-error
+    globalThis.ALCHEMY_TELEMETRY_REF ??
+    "";
+
   return {
     userId: userId ?? "",
-    sessionId: crypto.randomUUID(),
+    sessionId,
+    referrer,
     platform: os.platform(),
     osVersion: os.release(),
     arch: os.arch(),
@@ -192,6 +212,7 @@ export const collectData = memoize(async (): Promise<GenericTelemetryData> => {
 export type GenericTelemetryData = {
   userId: string;
   sessionId: string;
+  referrer: string;
   platform: string;
   osVersion: string;
   arch: string;
@@ -287,7 +308,7 @@ export async function createAndSendEvent(
       ...(await collectData()),
       ...serializeError(error),
     };
-    await fetch(TELEMETRY_API_URL, {
+    await fetchNoResponse(TELEMETRY_API_URL, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -326,3 +347,48 @@ function serializeError(error: Error | undefined) {
     errorStack: "",
   };
 }
+
+async function fetchNoResponse(
+  url: string,
+  options: {
+    body?: string;
+    headers?: Record<string, string>;
+    method?: string;
+  } = {},
+) {
+  const parsedUrl = new URL(url);
+  const isHttps = parsedUrl.protocol === "https:";
+  const client = isHttps ? https : http;
+
+  const body = options.body || "";
+  const headers = {
+    ...options.headers,
+    "Content-Length": Buffer.byteLength(body),
+  };
+
+  const requestOptions = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || (isHttps ? 443 : 80),
+    path: parsedUrl.pathname + parsedUrl.search,
+    method: options.method || "GET",
+    headers,
+  };
+
+  await new Promise<void>((resolve, reject) => {
+    const req = client.request(requestOptions);
+
+    req.on("error", (error) => {
+      reject(error);
+    });
+
+    if (body) {
+      req.write(body);
+    }
+
+    req.once("finish", () => {
+      resolve(void 0);
+    });
+
+    req.end();
+  });
+}

package/src/util/validate-resource-id.ts

@@ -0,0 +1,10 @@
+export function validateResourceID(id: string, qualifier = "Resource"): void {
+  //todo(sam): during effect rewrite, this should be much more limiting
+  //todo:      its hard to undo the flexibility we've offered to users now
+  if (!id) {
+    throw new Error(`${qualifier} ID cannot be an empty string: "${id}"`);
+  }
+  if (id.includes(":")) {
+    throw new Error(`${qualifier} ID cannot include colons: "${id}"`);
+  }
+}

package/workers/tunnel-proxy.js

@@ -34,7 +34,7 @@ var h={async fetch(e,r){let n=new URL(e.url);n.host=r.TUNNEL_HOST;let l=new Head
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.70.2</p>
+        <p class="text-sm text-slate-500">Alchemy 0.71.1</p>
       </div>
     </div>
   </body>