alchemy 0.7.3 → 0.8.1

package/lib/esbuild/bundle.d.ts

@@ -94,14 +94,21 @@ export interface Bundle extends Resource<"esbuild::Bundle"> {
  */
 export declare const Bundle: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>);
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
-    bundle: boolean;
+    entryPoints: string[];
+    outfile: string;
+    bundle: true;
+    format: "iife" | "cjs" | "esm" | undefined;
+    target: string | string[] | undefined;
+    minify: boolean | undefined;
+    sourcemap: boolean | "inline" | "external" | "both" | undefined;
+    external: string[];
+    platform: "browser" | "node" | "neutral" | undefined;
+    metafile: true;
+    write: true;
     splitting?: boolean;
     preserveSymlinks?: boolean;
-    outfile: string;
-    metafile: boolean;
     outdir?: string;
     outbase?: string;
-    external: string[];
     packages?: "bundle" | "external";
     alias?: Record<string, string>;
     loader?: {
@@ -110,7 +117,6 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     resolveExtensions?: string[];
     mainFields?: string[];
     conditions?: string[];
-    write: boolean;
     allowOverwrite?: boolean;
     tsconfig?: string;
     outExtension?: {
@@ -127,30 +133,21 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     footer?: {
         [type: string]: string;
     };
-    entryPoints: string[] | Record<string, string> | {
-        in: string;
-        out: string;
-    }[];
     stdin?: esbuild.StdinOptions;
     plugins?: esbuild.Plugin[];
     absWorkingDir?: string;
     nodePaths?: string[];
-    sourcemap: boolean | "linked" | "inline" | "external" | "both";
     legalComments?: "none" | "inline" | "eof" | "linked" | "external";
     sourceRoot?: string;
     sourcesContent?: boolean;
-    format: esbuild.Format;
     globalName?: string;
-    target: string | string[];
     supported?: Record<string, boolean>;
-    platform: esbuild.Platform;
     mangleProps?: RegExp;
     reserveProps?: RegExp;
     mangleQuoted?: boolean;
     mangleCache?: Record<string, string | false>;
     drop?: esbuild.Drop[];
     dropLabels?: string[];
-    minify: boolean;
     minifyWhitespace?: boolean;
     minifyIdentifiers?: boolean;
     minifySyntax?: boolean;

package/lib/esbuild/bundle.js

@@ -47,8 +47,8 @@ export const Bundle = Resource("esbuild::Bundle", {
 });
 export async function bundle(props) {
     const outputPath = getOutputPath(props);
-    // Build the bundle
     return await esbuild.build({
+        ...props.options,
         entryPoints: [props.entryPoint],
         outfile: outputPath,
         bundle: true,
@@ -56,11 +56,14 @@ export async function bundle(props) {
         target: props.target,
         minify: props.minify,
         sourcemap: props.sourcemap,
-        external: props.external,
+        external: [
+            "node:async_hooks",
+            ...(props.external ?? []),
+            ...(props.options?.external ?? []),
+        ],
         platform: props.platform,
         metafile: true,
         write: true,
-        ...props.options,
     });
 }
 function getOutputPath(props) {

package/lib/test/bun.js

@@ -79,6 +79,9 @@ export function test(meta, defaultOptions) {
     function test(...args) {
         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]
+            : 120000;
         const spread = (obj) => obj && typeof obj === "object"
             ? Object.fromEntries(Object.entries(obj).flatMap(([k, v]) => v !== undefined ? [[k, v]] : []))
             : {};
@@ -110,7 +113,7 @@ export function test(meta, defaultOptions) {
                         await destroy(scope);
                     }
                 }
-            });
+            }, timeout);
         });
     }
 }

package/lib/web/vitepress/process-front-matter-files.js

@@ -35,7 +35,7 @@ export async function processFrontmatterFiles(directoryPath, linkPrefix) {
             const frontmatter = frontmatterMatch[1];
             const orderMatch = frontmatter.match(/order:\s*(\d+)/);
             if (orderMatch) {
-                order = parseInt(orderMatch[1]);
+                order = parseFloat(orderMatch[1]);
             }
             const titleMatch = frontmatter.match(/title:\s*(.+)/);
             if (titleMatch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {

package/src/aws/table.ts

@@ -143,7 +143,7 @@ export const Table = Resource(
   async function (
     this: Context<Table>,
     id: string,
-    props: TableProps,
+    props: TableProps
   ): Promise<Table> {
     const client = new DynamoDBClient({});
 
@@ -154,15 +154,13 @@ export const Table = Resource(
             client.send(
               new DeleteTableCommand({
                 TableName: props.tableName,
-              }),
-            ),
+              })
+            )
           );
         },
-        (error) =>
-          error instanceof ResourceInUseException ||
-          error instanceof InternalServerError,
+        isRetryableError,
         10, // Max attempts
-        200, // Initial delay in ms
+        200 // Initial delay in ms
       );
 
       // Wait for table to be deleted
@@ -175,7 +173,7 @@ export const Table = Resource(
           await client.send(
             new DescribeTableCommand({
               TableName: props.tableName,
-            }),
+            })
           );
           // If we get here, table still exists
           retryCount++;
@@ -193,7 +191,7 @@ export const Table = Resource(
 
       if (!tableDeleted) {
         throw new Error(
-          `Timed out waiting for table ${props.tableName} to be deleted`,
+          `Timed out waiting for table ${props.tableName} to be deleted`
         );
       }
 
@@ -233,7 +231,7 @@ export const Table = Resource(
             const describeResponse = await client.send(
               new DescribeTableCommand({
                 TableName: props.tableName,
-              }),
+              })
             );
 
             // If table exists and is ACTIVE, no need to create it
@@ -267,16 +265,16 @@ export const Table = Resource(
                         Value,
                       }))
                     : undefined,
-                }),
+                })
               );
             } else {
               throw error;
             }
           }
         },
-        (error) => error instanceof ResourceInUseException,
+        isRetryableError,
         10, // Max attempts
-        200, // Initial delay in ms
+        200 // Initial delay in ms
       );
 
       // Wait for table to be active with timeout
@@ -290,7 +288,7 @@ export const Table = Resource(
           const response = await client.send(
             new DescribeTableCommand({
               TableName: props.tableName,
-            }),
+            })
           );
 
           tableActive = response.Table?.TableStatus === "ACTIVE";
@@ -313,7 +311,7 @@ export const Table = Resource(
 
       if (!tableActive) {
         throw new Error(
-          `Timed out waiting for table ${props.tableName} to become active`,
+          `Timed out waiting for table ${props.tableName} to become active`
         );
       }
 
@@ -324,5 +322,25 @@ export const Table = Resource(
         tableId: tableDescription!.TableId!,
       });
     }
-  },
+  }
 );
+
+const retryableErrors = [
+  "ResourceInUseException",
+  "ResourceNotFoundException",
+  "InternalServerError",
+  "ThrottlingException",
+  "ProvisionedThroughputExceededException",
+  "LimitExceededException",
+  "RequestLimitExceeded",
+];
+
+function isRetryableError(error: any) {
+  return (
+    error instanceof ResourceInUseException ||
+    error instanceof InternalServerError ||
+    retryableErrors.includes(error?.name) ||
+    retryableErrors.includes(error?.code) ||
+    error?.$metadata?.httpStatusCode === 500
+  );
+}

package/src/cloudflare/api-error.ts

@@ -49,7 +49,7 @@ export async function handleApiError(
   resourceName: string
 ): Promise<never> {
   const json: any = await response.json();
-  const errors: { message: string }[] = json.errors || [
+  const errors: { message: string }[] = json?.errors || [
     { message: response.statusText },
   ];
   const errorMessage = `Error ${action} ${resourceType} '${resourceName}': ${errors[0]?.message || response.statusText}`;

package/src/cloudflare/bindings.ts

@@ -11,6 +11,7 @@ import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
 import type { Pipeline } from "./pipeline";
 import type { Queue } from "./queue";
+import type { VectorizeIndex } from "./vectorize-index";
 import type { Worker } from "./worker";
 import type { Workflow } from "./workflow";
 
@@ -31,6 +32,7 @@ export type Binding =
   | R2Bucket
   | Secret
   | string
+  | VectorizeIndex
   | Worker
   | Workflow;
 

package/src/cloudflare/bound.ts

@@ -8,6 +8,7 @@ import type { DurableObjectNamespace as _DurableObjectNamespace } from "./durabl
 import type { KVNamespace as _KVNamespace } from "./kv-namespace";
 import type { Pipeline as _Pipeline } from "./pipeline";
 import type { Queue as _Queue } from "./queue";
+import type { VectorizeIndex as _VectorizeIndex } from "./vectorize-index";
 import type { Worker as _Worker } from "./worker";
 import type { Workflow as _Workflow } from "./workflow";
 
@@ -27,8 +28,10 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace
               ? Workflow<P>
               : T extends _D1Database
                 ? D1Database
-                : T extends _Queue
-                  ? Queue
-                  : T extends _Pipeline<infer R>
-                    ? Pipeline<R>
-                    : Service;
+                : T extends _VectorizeIndex
+                  ? VectorizeIndex
+                  : T extends _Queue
+                    ? Queue
+                    : T extends _Pipeline<infer R>
+                      ? Pipeline<R>
+                      : Service;

package/src/cloudflare/index.ts

@@ -13,6 +13,8 @@ export * from "./permission-groups";
 export * from "./pipeline";
 export * from "./queue";
 export * from "./r2-rest-state-store";
+export * from "./vectorize-index";
+export * from "./vectorize-metadata-index";
 export * from "./worker";
 export { Workflow } from "./workflow";
 export * from "./wrangler.json";

package/src/cloudflare/vectorize-index.ts

@@ -0,0 +1,331 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import {
+  CloudflareApi,
+  createCloudflareApi,
+  type CloudflareApiOptions,
+} from "./api";
+import { CloudflareApiError, handleApiError } from "./api-error";
+
+/**
+ * Properties for creating or updating a Vectorize Index
+ */
+export interface VectorizeIndexProps extends CloudflareApiOptions {
+  /**
+   * Name of the index
+   */
+  name: string;
+
+  /**
+   * Optional description of the index
+   */
+  description?: string;
+
+  /**
+   * Dimensions of the vectors
+   */
+  dimensions: number;
+
+  /**
+   * Distance metric used for vector similarity
+   */
+  metric: "cosine" | "euclidean" | "dot_product";
+
+  /**
+   * Whether to delete the index if removed
+   * If set to false, the index will remain but the resource will be removed from state
+   *
+   * @default true
+   */
+  delete?: boolean;
+
+  /**
+   * Whether to adopt an existing index with the same name if it exists
+   * If true and an index with the same name exists, it will be adopted rather than creating a new one
+   *
+   * @default false
+   */
+  adopt?: boolean;
+}
+
+/**
+ * Output returned after Vectorize Index creation/update
+ */
+export interface VectorizeIndex
+  extends Resource<"cloudflare::VectorizeIndex">,
+    VectorizeIndexProps {
+  type: "vectorize";
+
+  /**
+   * The unique identifier for the index (same as name)
+   */
+  id: string;
+
+  /**
+   * Time at which the index was created
+   */
+  createdAt?: number;
+}
+
+/**
+ * Creates and manages Cloudflare Vectorize Indexes.
+ *
+ * Vectorize is Cloudflare's vector database that enables vector search within Cloudflare Workers.
+ *
+ * @example
+ * // Create a basic vector index for text embeddings
+ * const basicIndex = await VectorizeIndex("text-embeddings", {
+ *   name: "text-embeddings",
+ *   config: {
+ *     dimensions: 768,
+ *     metric: "cosine"
+ *   }
+ * });
+ *
+ * @example
+ * // Create a vector index with a description
+ * const descIndex = await VectorizeIndex("image-embeddings", {
+ *   name: "image-embeddings",
+ *   description: "Vector index for image embeddings using CLIP model",
+ *   config: {
+ *     dimensions: 512,
+ *     metric: "cosine"
+ *   }
+ * });
+ *
+ * @example
+ * // Adopt an existing index if it already exists instead of failing
+ * const existingIndex = await VectorizeIndex("existing-index", {
+ *   name: "existing-index",
+ *   adopt: true,
+ *   config: {
+ *     dimensions: 1024,
+ *     metric: "euclidean"
+ *   }
+ * });
+ *
+ * @see https://developers.cloudflare.com/vectorize/
+ */
+export const VectorizeIndex = Resource(
+  "cloudflare::VectorizeIndex",
+  async function (
+    this: Context<VectorizeIndex>,
+    id: string,
+    props: VectorizeIndexProps
+  ): Promise<VectorizeIndex> {
+    const api = await createCloudflareApi(props);
+    const indexName = props.name || id;
+
+    if (this.phase === "delete") {
+      console.log("Deleting Vectorize index:", indexName);
+      if (props.delete !== false) {
+        // Delete Vectorize index
+        await deleteIndex(api, indexName);
+      }
+
+      // Return void (a deleted index has no content)
+      return this.destroy();
+    } else {
+      let indexData: CloudflareVectorizeResponse;
+
+      if (this.phase === "create") {
+        console.log("Creating Vectorize index:", indexName);
+        try {
+          indexData = await createIndex(api, indexName, {
+            ...props,
+            name: indexName,
+          });
+        } catch (error) {
+          // Check if this is a "index already exists" error and adopt is enabled
+          if (
+            props.adopt &&
+            error instanceof CloudflareApiError &&
+            error.message.includes("already exists")
+          ) {
+            console.log(`Index ${indexName} already exists, adopting it`);
+            // Find the existing index
+            indexData = await getIndex(api, indexName);
+          } else {
+            // Re-throw the error if adopt is false or it's not a "index already exists" error
+            throw error;
+          }
+        }
+      } else {
+        // Update operation is not supported by Vectorize API
+        throw new Error(
+          "Updating Vectorize indexes is not supported by the Cloudflare API. " +
+            "To change an index, delete it and create a new one with the desired configuration."
+        );
+      }
+
+      return this({
+        type: "vectorize",
+        id: indexName,
+        name: indexName,
+        description: props.description,
+        dimensions: indexData.result.config.dimensions,
+        metric: indexData.result.config.metric as
+          | "cosine"
+          | "euclidean"
+          | "dot_product",
+        accountId: api.accountId,
+        createdAt: indexData.result.created_on
+          ? new Date(indexData.result.created_on).getTime()
+          : undefined,
+      });
+    }
+  }
+);
+
+interface CloudflareVectorizeResponse {
+  result: {
+    name: string;
+    description?: string;
+    created_on?: string;
+    config: {
+      dimensions: number;
+      metric: string;
+    };
+  };
+  success: boolean;
+  errors: Array<{ code: number; message: string }>;
+  messages: string[];
+}
+
+/**
+ * Create a new Vectorize index
+ */
+export async function createIndex(
+  api: CloudflareApi,
+  indexName: string,
+  props: VectorizeIndexProps
+): Promise<CloudflareVectorizeResponse> {
+  // Create new Vectorize index
+  const createPayload: any = {
+    name: indexName,
+    config: {
+      dimensions: props.dimensions,
+      metric: props.metric,
+    },
+  };
+
+  if (props.description) {
+    createPayload.description = props.description;
+  }
+
+  const createResponse = await api.post(
+    `/accounts/${api.accountId}/vectorize/v2/indexes`,
+    createPayload
+  );
+
+  if (!createResponse.ok) {
+    return await handleApiError(
+      createResponse,
+      "creating",
+      "Vectorize index",
+      indexName
+    );
+  }
+
+  return (await createResponse.json()) as CloudflareVectorizeResponse;
+}
+
+/**
+ * Get a Vectorize index
+ */
+export async function getIndex(
+  api: CloudflareApi,
+  indexName: string
+): Promise<CloudflareVectorizeResponse> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}`
+  );
+
+  if (!response.ok) {
+    return await handleApiError(
+      response,
+      "getting",
+      "Vectorize index",
+      indexName
+    );
+  }
+
+  return (await response.json()) as CloudflareVectorizeResponse;
+}
+
+/**
+ * Delete a Vectorize index
+ */
+export async function deleteIndex(
+  api: CloudflareApi,
+  indexName: string
+): Promise<void> {
+  // Delete Vectorize index
+  const deleteResponse = await api.delete(
+    `/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}`
+  );
+
+  if (!deleteResponse.ok && deleteResponse.status !== 404) {
+    const errorData: any = await deleteResponse.json().catch(() => ({
+      errors: [{ message: deleteResponse.statusText }],
+    }));
+    throw new CloudflareApiError(
+      `Error deleting Vectorize index '${indexName}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
+      deleteResponse
+    );
+  }
+}
+
+/**
+ * List all Vectorize indexes in an account
+ */
+export async function listIndexes(
+  api: CloudflareApi
+): Promise<{ name: string; description?: string }[]> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/vectorize/v2/indexes`
+  );
+
+  if (!response.ok) {
+    throw new CloudflareApiError(
+      `Failed to list indexes: ${response.statusText}`,
+      response
+    );
+  }
+
+  const data = (await response.json()) as {
+    success: boolean;
+    errors?: Array<{ code: number; message: string }>;
+    result?: Array<{
+      name: string;
+      description?: string;
+    }>;
+  };
+
+  if (!data.success) {
+    const errorMessage = data.errors?.[0]?.message || "Unknown error";
+    throw new Error(`Failed to list indexes: ${errorMessage}`);
+  }
+
+  // Transform API response
+  return (data.result || []).map((index) => ({
+    name: index.name,
+    description: index.description,
+  }));
+}
+
+/**
+ * Update a Vectorize index
+ *
+ * Note: The Cloudflare Vectorize API does not support updating indexes.
+ * This function will always throw an error.
+ */
+export async function updateIndex(
+  api: CloudflareApi,
+  indexName: string,
+  props: VectorizeIndexProps
+): Promise<CloudflareVectorizeResponse> {
+  throw new Error(
+    "Updating Vectorize indexes is not supported by the Cloudflare API. To change an index, delete it and create a new one."
+  );
+}