alchemy 0.22.3 → 0.23.0

package/src/test/vitest.ts

@@ -0,0 +1,209 @@
+import path from "node:path";
+import { afterAll, beforeAll, it } from "vitest";
+import { alchemy } from "../alchemy.ts";
+import { R2RestStateStore } from "../cloudflare/r2-rest-state-store.ts";
+import { Scope } from "../scope.ts";
+import type { StateStoreType } from "../state.ts";
+
+/**
+ * Extend the Alchemy interface to include test functionality
+ */
+declare module "../alchemy.ts" {
+  interface Alchemy {
+    test: typeof test;
+  }
+}
+
+/**
+ * Add test functionality to alchemy instance
+ */
+alchemy.test = test;
+
+/**
+ * Options for configuring test behavior
+ */
+export interface TestOptions {
+  /**
+   * Whether to suppress logging output.
+   * @default false.
+   */
+  quiet?: boolean;
+
+  /**
+   * Password to use for test resources.
+   * @default "test-password".
+   */
+  password?: string;
+
+  /**
+   * Override the default state store for the test.
+   */
+  stateStore?: StateStoreType;
+
+  /**
+   * Prefix to use for the scope to isolate tests and environments.
+   */
+  prefix?: string;
+}
+
+/**
+ * Test function type definition with overloads
+ */
+type test = {
+  /**
+   * Create a test with default options
+   * @param name Test name
+   * @param fn Test function
+   * @param timeout Optional timeout in milliseconds
+   */
+  (name: string, fn: (scope: Scope) => Promise<any>, timeout?: number): void;
+
+  /**
+   * Create a test with custom options
+   * @param name Test name
+   * @param options Test configuration options
+   * @param fn Test function
+   * @param timeout Optional timeout in milliseconds
+   */
+  (
+    name: string,
+    options: TestOptions,
+    fn: (scope: Scope) => Promise<any>,
+    timeout?: number,
+  ): void;
+
+  /**
+   * Skip test conditionally
+   * @param condition If true, test will be skipped
+   */
+  skipIf(condition: boolean): test;
+
+  beforeAll(fn: (scope: Scope) => Promise<void>): void;
+
+  afterAll(fn: (scope: Scope) => Promise<void>): void;
+
+  /**
+   * Current test scope
+   */
+  scope: Scope;
+};
+
+/**
+ * Creates a test helper function that provides scoped resource management
+ *
+ * @param meta Import meta object from the test file
+ * @param defaultOptions Default options to apply to all tests
+ * @returns Test function with scope management
+ *
+ * @example
+ * ```typescript
+ * const test = alchemy.test(import.meta, {
+  prefix: BRANCH_PREFIX
+});
+ *
+ * describe("My Resource", () => {
+ *   test("create and delete", async (scope) => {
+ *     try {
+ *       const resource = await MyResource("test", { ... });
+ *       expect(resource.id).toBeTruthy();
+ *     } finally {
+ *       await alchemy.destroy(scope);
+ *     }
+ *   });
+ * });
+ * ```
+ */
+export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
+  defaultOptions = defaultOptions ?? {};
+  if (
+    defaultOptions.stateStore === undefined &&
+    process.env.ALCHEMY_STATE_STORE === "cloudflare"
+  ) {
+    defaultOptions.stateStore = (scope) =>
+      new R2RestStateStore(scope, {
+        apiKey: alchemy.secret(process.env.CLOUDFLARE_API_KEY),
+        email: process.env.CLOUDFLARE_EMAIL,
+        bucketName: process.env.CLOUDFLARE_BUCKET_NAME!,
+      });
+  }
+
+  test.skipIf = (condition: boolean) => {
+    if (condition) {
+      return (..._args: any[]) => {};
+    }
+    return test;
+  };
+
+  const scope = new Scope({
+    scopeName: `${defaultOptions.prefix ? `${defaultOptions.prefix}-` : ""}${path.basename(meta.filename)}`,
+    stateStore: defaultOptions?.stateStore,
+    phase: "up",
+  });
+
+  test.beforeAll = (fn: (scope: Scope) => Promise<void>) => {
+    return beforeAll(() => scope.run(() => fn(scope)));
+  };
+
+  test.afterAll = (fn: (scope: Scope) => Promise<void>) => {
+    return afterAll(() => scope.run(() => fn(scope)));
+  };
+
+  return test as test;
+
+  function test(
+    ...args:
+      | [
+          name: string,
+          options: TestOptions,
+          fn: (scope: Scope) => Promise<void>,
+        ]
+      | [name: string, fn: (scope: Scope) => Promise<void>]
+  ) {
+    const testName = args[0];
+    const _options = typeof args[1] === "object" ? args[1] : undefined;
+    const timeout =
+      typeof args[args.length - 1] === "number"
+        ? (args[args.length - 1] as number)
+        : 120000;
+    const spread = (obj: any) =>
+      obj && typeof obj === "object"
+        ? Object.fromEntries(
+            Object.entries(obj).flatMap(([k, v]) =>
+              v !== undefined ? [[k, v]] : [],
+            ),
+          )
+        : {};
+
+    const options: TestOptions = {
+      quiet: false,
+      password: "test-password",
+      ...spread(defaultOptions),
+      ...spread(_options),
+    };
+
+    const fn = typeof args[1] === "function" ? args[1] : args[2]!;
+
+    return it(
+      testName,
+      (ctx) => {
+        // Get the current describe block name from the test context
+        let describeBlockName = "";
+        if (ctx.task.suite?.name) {
+          describeBlockName = `${ctx.task.suite.name}/`;
+        }
+
+        return alchemy.run(
+          `${describeBlockName}${testName}`,
+          {
+            ...options,
+            parent: scope,
+          },
+          async (scope) => {
+            await scope.run(() => fn(scope));
+          },
+        );
+      },
+      timeout,
+    );
+  }
+}

package/src/upstash/api.ts

@@ -1,4 +1,5 @@
 import type { Secret } from "../secret.ts";
+import { safeFetch } from "../util/safe-fetch.ts";
 
 /**
  * Options for Upstash API requests
@@ -68,7 +69,7 @@ export class UpstashApi {
       });
     }
 
-    return fetch(`${this.baseUrl}${path}`, {
+    return safeFetch(`${this.baseUrl}${path}`, {
       ...init,
       headers,
     });

package/src/util/retry.ts

@@ -21,11 +21,10 @@ export async function withExponentialBackoff<T>(
   while (true) {
     try {
       return await operation();
-    } catch (error) {
-      console.log("error", error);
+    } catch (error: any) {
+      console.log(error.message);
       attempt++;
       if (attempt >= maxAttempts || !isRetryable(error)) {
-        console.warn("Failed after ", attempt, " attempts");
         throw error;
       }
 
@@ -33,6 +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
     }
   }
 }

package/src/util/safe-fetch.ts

@@ -0,0 +1,61 @@
+import type { Agent } from "undici";
+
+export async function safeFetch(
+  url: string | URL | Request,
+  options: RequestInit = {},
+  retries = 3,
+) {
+  let latestErr: any;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await fetch(url, {
+        ...options,
+        // Type assertion to work around Cloudflare Workers type definitions
+        dispatcher: await dispatcher(),
+      } as RequestInit);
+    } catch (err: any) {
+      latestErr = err;
+      const shouldRetry =
+        err?.code === "UND_ERR_SOCKET" ||
+        err?.code === "ECONNRESET" ||
+        err?.name === "FetchError";
+
+      if (!shouldRetry || attempt === retries) {
+        throw err;
+      }
+
+      console.warn(`Retry ${attempt}/${retries} for ${url}: ${err.code}`);
+      await new Promise((r) => setTimeout(r, 250 * attempt)); // exponential backoff
+    }
+  }
+  throw latestErr;
+}
+
+let agent:
+  | {
+      value: Agent | undefined;
+    }
+  | undefined;
+
+async function dispatcher() {
+  if (agent) {
+    return agent.value;
+  }
+  try {
+    // undici not available in all runtimes
+    const { Agent } = await import("undici");
+
+    if (!agent) {
+      // Configure agent with connection limits to avoid socket errors
+      agent = {
+        value: new Agent({
+          pipelining: 0, // Disable pipelining to avoid connection issues
+          // connections: 5, // Limit concurrent connections per host
+        }),
+      };
+    }
+  } catch {
+    agent = { value: undefined };
+  }
+  return agent.value;
+}

package/src/vercel/api.ts

@@ -1,5 +1,6 @@
 import { alchemy } from "../alchemy.ts";
 import type { Secret } from "../secret.ts";
+import { safeFetch } from "../util/safe-fetch.ts";
 
 /**
  * Options for Vercel API requests
@@ -85,7 +86,7 @@ export class VercelApi {
       delete headers["Content-Type"];
     }
 
-    const response = await fetch(`${this.baseUrl}${path}`, {
+    const response = await safeFetch(`${this.baseUrl}${path}`, {
       ...init,
       headers,
     });

package/src/web/vitepress/process-front-matter-files.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { parse as parseYaml } from "yaml";
 
 /**
  * Process markdown files with frontmatter to generate navigation items
@@ -56,14 +57,21 @@ export async function processFrontmatterFiles(
         let title;
 
         if (frontmatterMatch) {
-          const frontmatter = frontmatterMatch[1];
-          const orderMatch = frontmatter.match(/order:\s*(\d+)/);
-          if (orderMatch) {
-            order = Number.parseFloat(orderMatch[1]);
+          const frontmatter = parseYaml(frontmatterMatch[1]);
+
+          // Parse order as a number (supports both integers and floats)
+          if (frontmatter.order !== undefined) {
+            if (typeof frontmatter.order !== "number") {
+              throw new Error(
+                `Invalid order field in ${fullPath}: expected number, got ${typeof frontmatter.order}`,
+              );
+            }
+            order = frontmatter.order;
           }
-          const titleMatch = frontmatter.match(/title:\s*(.+)/);
-          if (titleMatch) {
-            title = titleMatch[1].trim();
+
+          // Get title from frontmatter
+          if (frontmatter.title) {
+            title = String(frontmatter.title).trim();
           }
         }