alchemy 0.7.3 → 0.8.1

package/src/cloudflare/vectorize-metadata-index.ts

@@ -0,0 +1,239 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import {
+  CloudflareApi,
+  createCloudflareApi,
+  type CloudflareApiOptions,
+} from "./api";
+import { CloudflareApiError, handleApiError } from "./api-error";
+import { VectorizeIndex } from "./vectorize-index";
+
+/**
+ * Properties for creating or deleting a Vectorize Metadata Index
+ */
+export interface VectorizeMetadataIndexProps extends CloudflareApiOptions {
+  /**
+   * Parent Vectorize Index
+   */
+  index: VectorizeIndex;
+
+  /**
+   * Name of the property in the metadata to create an index for
+   */
+  propertyName: string;
+
+  /**
+   * Type of the metadata index
+   */
+  indexType: "string" | "number" | "boolean";
+}
+
+/**
+ * Output returned after Vectorize Metadata Index creation/deletion
+ */
+export interface VectorizeMetadataIndex
+  extends Resource<"cloudflare::VectorizeMetadataIndex">,
+    VectorizeMetadataIndexProps {
+  /**
+   * ID of this metadata index (derived from propertyName)
+   */
+  id: string;
+
+  /**
+   * Mutation ID returned by the API after creation
+   */
+  mutationId?: string;
+}
+
+/**
+ * Creates and manages Cloudflare Vectorize Metadata Indexes.
+ *
+ * Vectorize Metadata Indexes enable filtering based on metadata properties when querying vectors.
+ * Each Vectorize Index can have up to 10 metadata indexes.
+ *
+ * @example
+ * // First create a Vectorize Index
+ * const vectorIndex = await VectorizeIndex("documents", {
+ *   name: "documents",
+ *   config: {
+ *     dimensions: 768,
+ *     metric: "cosine"
+ *   }
+ * });
+ *
+ * // Then create a metadata index for the "category" property
+ * const categoryIndex = await VectorizeMetadataIndex("category-index", {
+ *   index: vectorIndex,
+ *   propertyName: "category",
+ *   indexType: "string"
+ * });
+ *
+ * @example
+ * // Create a metadata index for a numeric property
+ * const yearIndex = await VectorizeMetadataIndex("year-index", {
+ *   index: vectorIndex,
+ *   propertyName: "year",
+ *   indexType: "number"
+ * });
+ *
+ * @see https://developers.cloudflare.com/vectorize/
+ */
+export const VectorizeMetadataIndex = Resource(
+  "cloudflare::VectorizeMetadataIndex",
+  async function (
+    this: Context<VectorizeMetadataIndex>,
+    id: string,
+    props: VectorizeMetadataIndexProps
+  ): Promise<VectorizeMetadataIndex> {
+    const api = await createCloudflareApi(props);
+    const indexName = props.index.name;
+    const propertyName = props.propertyName;
+
+    if (this.phase === "delete") {
+      // Delete metadata index
+      try {
+        await deleteMetadataIndex(api, indexName, propertyName);
+      } catch (error) {
+        if (
+          error instanceof CloudflareApiError &&
+          error.status === 400 &&
+          error.message.includes("does not exist")
+        ) {
+          // Index doesn't exist, which is what we want
+        } else {
+          throw error;
+        }
+      }
+      return this.destroy();
+    } else if (this.phase === "update") {
+      // Update operation is not supported
+      throw new Error(
+        "Updating Vectorize metadata indexes is not supported by the Cloudflare API. " +
+          "To change a metadata index, delete it and create a new one with the desired configuration."
+      );
+    } else {
+      const indexData = await createMetadataIndex(api, indexName, props);
+
+      return this({
+        id: propertyName, // Use propertyName as ID
+        index: props.index,
+        propertyName: props.propertyName,
+        indexType: props.indexType,
+        accountId: api.accountId,
+        mutationId: indexData.result.mutationId,
+      });
+    }
+  }
+);
+
+interface CloudflareMetadataIndexResponse {
+  result: {
+    mutationId: string;
+  };
+  success: boolean;
+  errors: Array<{ code: number; message: string }>;
+  messages: string[];
+}
+
+interface CloudflareMetadataIndexListResponse {
+  result: {
+    metadataIndexes: Array<{
+      propertyName: string;
+      indexType: "string" | "number" | "boolean";
+    }>;
+  };
+  success: boolean;
+  errors: Array<{ code: number; message: string }>;
+  messages: string[];
+}
+
+/**
+ * Create a new Vectorize metadata index
+ */
+export async function createMetadataIndex(
+  api: CloudflareApi,
+  indexName: string,
+  props: VectorizeMetadataIndexProps
+): Promise<CloudflareMetadataIndexResponse> {
+  // Create new metadata index
+  const createPayload = {
+    propertyName: props.propertyName,
+    indexType: props.indexType,
+  };
+
+  const createResponse = await api.post(
+    `/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}/metadata_index/create`,
+    createPayload
+  );
+
+  if (!createResponse.ok) {
+    return await handleApiError(
+      createResponse,
+      "creating",
+      "Vectorize metadata index",
+      props.propertyName
+    );
+  }
+
+  return (await createResponse.json()) as CloudflareMetadataIndexResponse;
+}
+
+/**
+ * Delete a Vectorize metadata index
+ */
+export async function deleteMetadataIndex(
+  api: CloudflareApi,
+  indexName: string,
+  propertyName: string
+): Promise<void> {
+  const deleteResponse = await api.post(
+    `/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}/metadata_index/delete`,
+    {
+      propertyName,
+    }
+  );
+
+  if (!deleteResponse.ok) {
+    await handleApiError(
+      deleteResponse,
+      "deleting",
+      "Vectorize metadata index",
+      propertyName
+    );
+  }
+}
+
+/**
+ * List all metadata indexes for a Vectorize index
+ */
+export async function listMetadataIndexes(
+  api: CloudflareApi,
+  indexName: string
+): Promise<
+  { propertyName: string; indexType: "string" | "number" | "boolean" }[]
+> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}/metadata_index/list`
+  );
+
+  if (response.status === 410) {
+    // Gone
+    return [];
+  }
+
+  if (!response.ok) {
+    throw new CloudflareApiError(
+      `Failed to list metadata indexes: ${response.statusText}`,
+      response
+    );
+  }
+
+  const data = (await response.json()) as CloudflareMetadataIndexListResponse;
+
+  if (!data.success) {
+    const errorMessage = data.errors?.[0]?.message || "Unknown error";
+    throw new Error(`Failed to list metadata indexes: ${errorMessage}`);
+  }
+
+  return data.result.metadataIndexes;
+}

package/src/cloudflare/worker.ts

@@ -611,6 +611,12 @@ async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         pipeline: binding.name,
       });
+    } else if (binding.type === "vectorize") {
+      meta.bindings.push({
+        type: "vectorize",
+        name: bindingName,
+        index_name: binding.name,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);

package/src/cloudflare/wrangler.json.ts

@@ -187,6 +187,14 @@ export interface WranglerJsonSpec {
     class_name: string;
   }[];
 
+  /**
+   * Vectorize index bindings
+   */
+  vectorize_indexes?: {
+    binding: string;
+    index_name: string;
+  }[];
+
   /**
    * Plain text bindings (vars)
    */
@@ -239,6 +247,7 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
     database_name: string;
   }[] = [];
   const queues: { binding: string; queue: string }[] = [];
+  const vectorizeIndexes: { binding: string; index_name: string }[] = [];
 
   // Process each binding
   for (const [bindingName, binding] of Object.entries(bindings)) {
@@ -302,6 +311,11 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
         binding: bindingName,
         queue: binding.name,
       });
+    } else if (binding.type === "vectorize") {
+      vectorizeIndexes.push({
+        binding: bindingName,
+        index_name: binding.name,
+      });
     }
   }
 
@@ -327,4 +341,8 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
   if (queues.length > 0) {
     spec.queues = queues;
   }
+
+  if (vectorizeIndexes.length > 0) {
+    spec.vectorize_indexes = vectorizeIndexes;
+  }
 }

package/src/esbuild/bundle.ts

@@ -150,8 +150,8 @@ export const Bundle = Resource(
 
 export async function bundle(props: BundleProps) {
   const outputPath = getOutputPath(props);
-  // Build the bundle
   return await esbuild.build({
+    ...props.options,
     entryPoints: [props.entryPoint],
     outfile: outputPath,
     bundle: true,
@@ -159,11 +159,14 @@ export async function bundle(props: BundleProps) {
     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,
   });
 }
 

package/src/test/bun.ts

@@ -189,6 +189,10 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
   ) {
     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(
@@ -199,7 +203,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
         : {};
 
     // Merge options with defaults
-    const options = {
+    const options: TestOptions = {
       destroy: true,
       quiet: false,
       password: "test-password",
@@ -216,20 +220,24 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
         parent: localTestScope,
       },
       async (scope) => {
-        return it(testName, async () => {
-          // Enter test scope since bun calls from different scope
-          scope.enter();
-          try {
-            await fn(scope);
-          } catch (err) {
-            console.error(err);
-            throw err;
-          } finally {
-            if (options.destroy !== false) {
-              await destroy(scope);
+        return it(
+          testName,
+          async () => {
+            // Enter test scope since bun calls from different scope
+            scope.enter();
+            try {
+              await fn(scope);
+            } catch (err) {
+              console.error(err);
+              throw err;
+            } finally {
+              if (options.destroy !== false) {
+                await destroy(scope);
+              }
             }
-          }
-        });
+          },
+          timeout
+        );
       }
     );
   }

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

@@ -58,7 +58,7 @@ export async function processFrontmatterFiles(
           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) {