alchemy 0.16.10 → 0.17.0

package/src/cloudflare/vectorize-index.ts

@@ -1,11 +1,13 @@
 import type { Context } from "../context.js";
-import { Resource } from "../resource.js";
+import { Resource, ResourceKind } from "../resource.js";
+import { bind } from "../runtime/bind.js";
 import { CloudflareApiError, handleApiError } from "./api-error.js";
 import {
   createCloudflareApi,
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.js";
+import type { Bound } from "./bound.js";
 
 /**
  * Properties for creating or updating a Vectorize Index
@@ -48,10 +50,16 @@ export interface VectorizeIndexProps extends CloudflareApiOptions {
   adopt?: boolean;
 }
 
+export function isVectorizeIndex(
+  resource: Resource,
+): resource is VectorizeIndexResource {
+  return resource[ResourceKind] === "cloudflare::VectorizeIndex";
+}
+
 /**
  * Output returned after Vectorize Index creation/update
  */
-export interface VectorizeIndex
+export interface VectorizeIndexResource
   extends Resource<"cloudflare::VectorizeIndex">,
     VectorizeIndexProps {
   type: "vectorize";
@@ -67,6 +75,9 @@ export interface VectorizeIndex
   createdAt?: number;
 }
 
+export type VectorizeIndex = VectorizeIndexResource &
+  Bound<VectorizeIndexResource>;
+
 /**
  * Creates and manages Cloudflare Vectorize Indexes.
  *
@@ -106,13 +117,30 @@ export interface VectorizeIndex
  *
  * @see https://developers.cloudflare.com/vectorize/
  */
-export const VectorizeIndex = Resource(
+export async function VectorizeIndex(
+  name: string,
+  props: VectorizeIndexProps,
+): Promise<VectorizeIndex> {
+  const index = await _VectorizeIndex(name, props);
+  const binding = await bind(index);
+  return {
+    ...index,
+    describe: binding.describe,
+    query: binding.query,
+    insert: binding.insert,
+    upsert: binding.upsert,
+    deleteByIds: binding.deleteByIds,
+    getByIds: binding.getByIds,
+  };
+}
+
+const _VectorizeIndex = Resource(
   "cloudflare::VectorizeIndex",
   async function (
-    this: Context<VectorizeIndex>,
+    this: Context<VectorizeIndexResource>,
     id: string,
     props: VectorizeIndexProps,
-  ): Promise<VectorizeIndex> {
+  ): Promise<VectorizeIndexResource> {
     const api = await createCloudflareApi(props);
     const indexName = props.name || id;
 
@@ -348,9 +376,9 @@ export async function listIndexes(
  * This function will always throw an error.
  */
 export async function updateIndex(
-  api: CloudflareApi,
-  indexName: string,
-  props: VectorizeIndexProps,
+  _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.",

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

@@ -1,12 +1,12 @@
 import type { Context } from "../context.js";
-import { Resource } from "../resource.js";
+import { Resource, ResourceKind } from "../resource.js";
 import { CloudflareApiError, handleApiError } from "./api-error.js";
 import {
   createCloudflareApi,
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.js";
-import type { VectorizeIndex } from "./vectorize-index.js";
+import type { VectorizeIndexResource } from "./vectorize-index.js";
 
 /**
  * Properties for creating or deleting a Vectorize Metadata Index
@@ -15,7 +15,7 @@ export interface VectorizeMetadataIndexProps extends CloudflareApiOptions {
   /**
    * Parent Vectorize Index
    */
-  index: VectorizeIndex;
+  index: VectorizeIndexResource;
 
   /**
    * Name of the property in the metadata to create an index for
@@ -28,6 +28,12 @@ export interface VectorizeMetadataIndexProps extends CloudflareApiOptions {
   indexType: "string" | "number" | "boolean";
 }
 
+export function isVectorizeMetadataIndex(
+  resource: Resource,
+): resource is VectorizeMetadataIndex {
+  return resource[ResourceKind] === "cloudflare::VectorizeMetadataIndex";
+}
+
 /**
  * Output returned after Vectorize Metadata Index creation/deletion
  */
@@ -82,7 +88,7 @@ export const VectorizeMetadataIndex = Resource(
   "cloudflare::VectorizeMetadataIndex",
   async function (
     this: Context<VectorizeMetadataIndex>,
-    id: string,
+    _id: string,
     props: VectorizeMetadataIndexProps,
   ): Promise<VectorizeMetadataIndex> {
     const api = await createCloudflareApi(props);

package/src/cloudflare/website.ts

@@ -61,7 +61,7 @@ export type Website<B extends Bindings> = B extends { ASSETS: any }
 
 export async function Website<B extends Bindings>(
   id: string,
-  props: WebsiteProps<B>
+  props: WebsiteProps<B>,
 ): Promise<Website<B>> {
   if (props.bindings?.ASSETS) {
     throw new Error("ASSETS binding is reserved for internal use");
@@ -99,8 +99,8 @@ export async function Website<B extends Bindings>(
               compatibility_flags: props.compatibilityFlags ?? [],
             },
             null,
-            2
-          )
+            2,
+          ),
         );
       }
     }
@@ -110,6 +110,7 @@ export async function Website<B extends Bindings>(
       command: props.command,
     });
 
+    // @ts-expect-error - the WorkerProps union type not happy
     const worker = await Worker("worker", {
       ...props,
       name: props.name ?? id,

package/src/cloudflare/worker-assets.ts

@@ -0,0 +1,237 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getContentType } from "../util/content-type.js";
+import type { CloudflareApi } from "./api.js";
+import type { Assets } from "./assets.js";
+import type { AssetsConfig, WorkerProps } from "./worker.js";
+
+export interface AssetUploadResult {
+  completionToken: string;
+  assetConfig?: AssetsConfig;
+}
+
+/**
+ * Interface for a file's metadata to be uploaded
+ */
+interface FileMetadata {
+  hash: string;
+  size: number;
+}
+
+/**
+ * Response from the assets upload session API
+ */
+interface UploadSessionResponse {
+  result: {
+    jwt: string;
+    buckets: string[][];
+  };
+  success: boolean;
+  errors: any[];
+  messages: any[];
+}
+
+/**
+ * Response from the file upload API
+ */
+interface UploadResponse {
+  result: {
+    jwt: string;
+    buckets?: string[][];
+  };
+  success: boolean;
+  errors: any[];
+  messages: any[];
+}
+
+/**
+ * Uploads assets to Cloudflare and returns a completion token
+ *
+ * @param api CloudflareApi instance
+ * @param workerName Name of the worker
+ * @param assets Assets resource containing files to upload
+ * @param assetConfig Configuration for the assets
+ * @returns Completion token for the assets upload
+ */
+export async function uploadAssets(
+  api: CloudflareApi,
+  workerName: string,
+  assets: Assets,
+  assetConfig?: WorkerProps["assets"],
+): Promise<AssetUploadResult> {
+  // Process the assets configuration once at the beginning
+  const processedConfig = createAssetConfig(assetConfig);
+
+  // Generate the file manifest
+  const fileMetadata: Record<string, FileMetadata> = {};
+
+  // Process each file in the assets
+  for (const file of assets.files) {
+    const { hash, size } = await calculateFileMetadata(file.filePath);
+    // Use the relative path as the key, ensuring it starts with a slash
+    const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
+    fileMetadata[key] = { hash, size };
+  }
+
+  // Start the upload session
+  const uploadSessionUrl = `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`;
+  const uploadSessionResponse = await api.post(
+    uploadSessionUrl,
+    JSON.stringify({ manifest: fileMetadata }),
+    {
+      headers: { "Content-Type": "application/json" },
+    },
+  );
+
+  if (!uploadSessionResponse.ok) {
+    throw new Error(
+      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText}`,
+    );
+  }
+
+  const sessionData =
+    (await uploadSessionResponse.json()) as UploadSessionResponse;
+
+  // If there are no buckets, assets are already uploaded or empty
+  if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+    return {
+      completionToken: sessionData.result.jwt,
+      assetConfig: processedConfig,
+    };
+  }
+
+  // Upload the files in batches as specified by the API
+  let completionToken = sessionData.result.jwt;
+  const buckets = sessionData.result.buckets;
+
+  // Process each bucket of files
+  for (const bucket of buckets) {
+    const formData = new FormData();
+
+    // Add each file in the bucket to the form
+    for (const fileHash of bucket) {
+      // Find the file with this hash
+      const file = assets.files.find((f) => {
+        const filePath = f.path.startsWith("/") ? f.path : `/${f.path}`;
+        return fileMetadata[filePath]?.hash === fileHash;
+      });
+
+      if (!file) {
+        throw new Error(`Could not find file with hash ${fileHash}`);
+      }
+
+      // Read the file content
+      const fileContent = await fs.readFile(file.filePath);
+
+      // Convert to base64 as required by the API when using base64=true
+      const base64Content = fileContent.toString("base64");
+
+      // Add the file to the form with the hash as the key and set the correct content type
+      const blob = new Blob([base64Content], {
+        // if you set application/octet-stream, you get weird `-1` errors with a message to contact support
+        type: getContentType(file.filePath) ?? "application/null",
+      });
+      formData.append(fileHash, blob, fileHash);
+    }
+
+    // Upload this batch of files
+    const uploadResponse = await api.post(
+      `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
+      formData,
+      {
+        headers: {
+          Authorization: `Bearer ${completionToken}`,
+          "Content-Type": "multipart/form-data",
+        },
+      },
+    );
+
+    if (!uploadResponse.ok) {
+      throw new Error(
+        `Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`,
+      );
+    }
+
+    const uploadData = (await uploadResponse.json()) as UploadResponse;
+    if (!uploadData.success) {
+      const error = uploadData.errors[0];
+      const message = error.message;
+      const code = error.code;
+      throw new Error(
+        `Failed to upload asset files: ${message} (Code: ${code})`,
+      );
+    }
+
+    // Update the completion token for the next batch
+    if (uploadData.result.jwt) {
+      completionToken = uploadData.result.jwt;
+    }
+  }
+
+  // Return the final completion token with asset configuration
+  return {
+    completionToken,
+    assetConfig: processedConfig,
+  };
+}
+
+/**
+ * Creates asset configuration object from provided config or defaults
+ */
+export function createAssetConfig(config?: AssetsConfig): AssetsConfig {
+  const assetConfig: AssetsConfig = {
+    html_handling: "auto-trailing-slash",
+  };
+
+  if (config) {
+    if (config._headers !== undefined) {
+      assetConfig._headers = config._headers;
+    }
+
+    if (config._redirects !== undefined) {
+      assetConfig._redirects = config._redirects;
+    }
+
+    if (config.html_handling !== undefined) {
+      assetConfig.html_handling = config.html_handling;
+    }
+
+    if (config.not_found_handling !== undefined) {
+      assetConfig.not_found_handling = config.not_found_handling;
+    }
+
+    if (config.run_worker_first !== undefined) {
+      assetConfig.run_worker_first = config.run_worker_first;
+    }
+
+    if (config.serve_directly !== undefined) {
+      assetConfig.serve_directly = config.serve_directly;
+    }
+  }
+
+  return assetConfig;
+}
+
+/**
+ * Calculate the SHA-256 hash and size of a file
+ *
+ * @param filePath Path to the file
+ * @returns Hash (first 32 chars of SHA-256) and size of the file
+ */
+export async function calculateFileMetadata(
+  filePath: string,
+): Promise<{ hash: string; size: number }> {
+  const contents = await fs.readFile(filePath);
+
+  const hash = crypto.createHash("sha256");
+  hash.update(contents);
+
+  const extension = path.extname(filePath).substring(1);
+  hash.update(extension);
+
+  return {
+    hash: hash.digest("hex").slice(0, 32),
+    size: contents.length,
+  };
+}

package/src/cloudflare/worker-metadata.ts

@@ -1,3 +1,12 @@
+import type { Context } from "../context.js";
+import { slugify } from "../util/slugify.js";
+import { Self, type Bindings, type WorkerBindingSpec } from "./bindings.js";
+import type { DurableObjectNamespace } from "./durable-object-namespace.js";
+import { createAssetConfig, type AssetUploadResult } from "./worker-assets.js";
+import type { SingleStepMigration } from "./worker-migration.js";
+import type { AssetsConfig, Worker, WorkerProps } from "./worker.js";
+import type { Workflow } from "./workflow.js";
+
 /**
  * Metadata returned by Cloudflare API for a worker script
  */
@@ -152,3 +161,281 @@ export interface WorkerDefaultEnvironment extends WorkerEnvironment {
    */
   script: WorkerScriptInfo;
 }
+
+export interface WorkerMetadata {
+  compatibility_date: string;
+  compatibility_flags?: string[];
+  bindings: WorkerBindingSpec[];
+  observability: {
+    enabled: boolean;
+  };
+  migrations?: SingleStepMigration;
+  main_module?: string;
+  body_part?: string;
+  tags?: string[];
+  assets?: {
+    jwt?: string;
+    keep_assets?: boolean;
+    config?: AssetsConfig;
+  };
+  cron_triggers?: {
+    cron: string;
+    suspended: boolean;
+  }[];
+}
+
+export async function prepareWorkerMetadata<B extends Bindings>(
+  ctx: Context<Worker<B>>,
+  oldBindings: Bindings | undefined,
+  props: WorkerProps & {
+    compatibilityDate: string;
+    compatibilityFlags: string[];
+    workerName: string;
+  },
+  assetUploadResult?: AssetUploadResult,
+): Promise<WorkerMetadata> {
+  const deletedClasses = Object.entries(oldBindings ?? {})
+    .filter(([key]) => !props.bindings?.[key])
+    .flatMap(([_, binding]) => {
+      if (
+        binding &&
+        typeof binding === "object" &&
+        binding.type === "durable_object_namespace"
+      ) {
+        return [binding.className];
+      }
+      return [];
+    });
+
+  // Prepare metadata with bindings
+  const meta: WorkerMetadata = {
+    compatibility_date: props.compatibilityDate,
+    compatibility_flags: props.compatibilityFlags,
+    bindings: [],
+    observability: {
+      enabled: props.observability?.enabled !== false,
+    },
+    // TODO(sam): base64 encode instead? 0 collision risk vs readability.
+    tags: [`alchemy:id:${slugify(ctx.fqn)}`],
+    migrations: {
+      new_classes: props.migrations?.new_classes ?? [],
+      deleted_classes: [
+        ...deletedClasses,
+        ...(props.migrations?.deleted_classes ?? []),
+      ],
+      renamed_classes: props.migrations?.renamed_classes ?? [],
+      transferred_classes: props.migrations?.transferred_classes ?? [],
+      new_sqlite_classes: props.migrations?.new_sqlite_classes ?? [],
+    },
+  };
+
+  // If we have asset upload results, add them to the metadata
+  if (assetUploadResult) {
+    meta.assets = {
+      jwt: assetUploadResult.completionToken,
+    };
+
+    // Initialize config from assetUploadResult if it exists
+    if (assetUploadResult.assetConfig) {
+      meta.assets.config = {
+        ...assetUploadResult.assetConfig,
+      };
+    }
+
+    // If there's no config from assetUploadResult but we have props.assets,
+    // we need to create the config ourselves (this handles the case when no assets were uploaded)
+    if (!meta.assets.config && props.assets) {
+      meta.assets.config = createAssetConfig(props.assets);
+    }
+  }
+
+  const bindings = (props.bindings ?? {}) as Bindings;
+
+  // Convert bindings to the format expected by the API
+  for (const [bindingName, binding] of Object.entries(bindings)) {
+    // Create a copy of the binding to avoid modifying the original
+
+    if (typeof binding === "string") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: binding,
+      });
+    } else if (binding === Self) {
+      meta.bindings.push({
+        type: "service",
+        name: bindingName,
+        service: props.workerName,
+      });
+    } else if (binding.type === "d1") {
+      meta.bindings.push({
+        type: "d1",
+        name: bindingName,
+        id: binding.id,
+      });
+    } else if (binding.type === "kv_namespace") {
+      meta.bindings.push({
+        type: "kv_namespace",
+        name: bindingName,
+        namespace_id:
+          "namespaceId" in binding ? binding.namespaceId : binding.id,
+      });
+    } else if (binding.type === "service") {
+      meta.bindings.push({
+        type: "service",
+        name: bindingName,
+        service: binding.name,
+      });
+    } else if (binding.type === "durable_object_namespace") {
+      meta.bindings.push({
+        type: "durable_object_namespace",
+        name: bindingName,
+        class_name: binding.className,
+        script_name: binding.scriptName,
+        environment: binding.environment,
+        namespace_id: binding.namespaceId,
+      });
+      configureClassMigration(binding, binding.id, binding.className);
+    } else if (binding.type === "r2_bucket") {
+      meta.bindings.push({
+        type: "r2_bucket",
+        name: bindingName,
+        bucket_name: binding.name,
+      });
+    } else if (binding.type === "assets") {
+      meta.bindings.push({
+        type: "assets",
+        name: bindingName,
+      });
+    } else if (binding.type === "secret") {
+      meta.bindings.push({
+        type: "secret_text",
+        name: bindingName,
+        text: binding.unencrypted,
+      });
+    } else if (binding.type === "workflow") {
+      meta.bindings.push({
+        type: "workflow",
+        name: bindingName,
+        workflow_name: binding.workflowName,
+        class_name: binding.className,
+        // this should be set if the Workflow is in another script ...
+        // script_name: ??,
+      });
+      // it's unclear whether this is needed, but it works both ways
+      // configureClassMigration(binding, binding.id, binding.className);
+    } else if (binding.type === "queue") {
+      meta.bindings.push({
+        type: "queue",
+        name: bindingName,
+        queue_name: binding.name,
+      });
+    } else if (binding.type === "pipeline") {
+      meta.bindings.push({
+        type: "pipelines",
+        name: bindingName,
+        pipeline: binding.name,
+      });
+    } else if (binding.type === "vectorize") {
+      meta.bindings.push({
+        type: "vectorize",
+        name: bindingName,
+        index_name: binding.name,
+      });
+    } else if (binding.type === "ai_gateway") {
+      // AI Gateway binding - just needs the name property
+      meta.bindings.push({
+        type: "ai",
+        name: bindingName,
+      });
+    } else if (binding.type === "hyperdrive") {
+      // Hyperdrive binding
+      meta.bindings.push({
+        type: "hyperdrive",
+        name: bindingName,
+        id: binding.hyperdriveId,
+      });
+    } else if (binding.type === "browser") {
+      meta.bindings.push({
+        type: "browser",
+        name: bindingName,
+      });
+    } else if (binding.type === "ai") {
+      meta.bindings.push({
+        type: "ai",
+        name: bindingName,
+      });
+    } else if (binding.type === "json") {
+      meta.bindings.push({
+        type: "json",
+        name: bindingName,
+        json: JSON.stringify(binding.json),
+      });
+    } else if (binding.type === "analytics_engine") {
+      meta.bindings.push({
+        type: "analytics_engine",
+        name: bindingName,
+        dataset: binding.dataset,
+      });
+    } else {
+      // @ts-expect-error - we should never reach here
+      throw new Error(`Unsupported binding type: ${binding.type}`);
+    }
+  }
+
+  function configureClassMigration(
+    binding: DurableObjectNamespace | Workflow,
+    stableId: string,
+    className: string,
+  ) {
+    const oldBinding: DurableObjectNamespace | Workflow | undefined =
+      Object.values(oldBindings ?? {})
+        ?.filter(
+          (b) =>
+            typeof b === "object" &&
+            (b.type === "durable_object_namespace" || b.type === "workflow"),
+        )
+        ?.find((b) => b.id === stableId);
+
+    if (!oldBinding) {
+      if (binding.type === "durable_object_namespace" && binding.sqlite) {
+        meta.migrations!.new_sqlite_classes!.push(className);
+      } else {
+        meta.migrations!.new_classes!.push(className);
+      }
+    } else if (oldBinding.className !== className) {
+      meta.migrations!.renamed_classes!.push({
+        from: oldBinding.className,
+        to: className,
+      });
+    }
+  }
+
+  // Convert env variables to plain_text bindings
+  // TODO(sam): remove Worker.env in favor of always bindings
+  if (props.env) {
+    for (const [key, value] of Object.entries(props.env)) {
+      meta.bindings.push({
+        name: key,
+        type: "plain_text",
+        text: value,
+      });
+    }
+  }
+
+  // Determine if we're using ESM or service worker format
+  const isEsModule = props.format !== "cjs"; // Default to ESM unless CJS is specified
+  const scriptName = isEsModule ? "worker.js" : "script";
+
+  if (isEsModule) {
+    // For ES modules format
+    meta.main_module = scriptName;
+  } else {
+    // For service worker format (CJS)
+    meta.body_part = scriptName;
+  }
+  if (process.env.DEBUG) {
+    console.log(meta);
+  }
+  return meta;
+}