alchemy 0.10.0 → 0.10.2

package/lib/web/vitepress/custom-theme.js

@@ -1,11 +1,11 @@
 import { type } from "arktype";
-import path from "path";
+import path from "node:path";
 import { CSSFile } from "../../ai/css-file";
 import { Data } from "../../ai/data";
 import { TypeScriptFile } from "../../ai/typescript-file";
 import { VueFile } from "../../ai/vue-file";
 import { alchemy } from "../../alchemy";
-import { Folder } from "../../fs";
+import { Folder } from "../../fs/folder";
 import { Resource } from "../../resource";
 /**
  * Resource for generating a custom VitePress theme using AI.

package/lib/web/vitepress/home-page.d.ts

@@ -1,5 +1,5 @@
 import { Document } from "../../ai/document";
-import { StaticTextFile } from "../../fs";
+import { StaticTextFile } from "../../fs/static-text-file";
 import type { Secret } from "../../secret";
 /**
  * Image that can be themed for light/dark mode

package/lib/web/vitepress/home-page.js

@@ -1,7 +1,7 @@
 import yaml from "yaml";
 import { Document } from "../../ai/document";
 import { alchemy } from "../../alchemy";
-import { StaticTextFile } from "../../fs";
+import { StaticTextFile } from "../../fs/static-text-file";
 /**
  * Parse YAML frontmatter to home page config
  */

package/lib/web/vitepress/vitepress.js

@@ -1,8 +1,11 @@
 import { exec } from "child_process";
-import fs from "fs/promises";
-import path from "path";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { promisify } from "util";
-import { Folder, StaticJsonFile, StaticTextFile, StaticTypeScriptFile, } from "../../fs";
+import { Folder } from "../../fs/folder";
+import { StaticJsonFile } from "../../fs/static-json-file";
+import { StaticTextFile } from "../../fs/static-text-file";
+import { StaticTypeScriptFile } from "../../fs/static-typescript-file";
 import { Resource } from "../../resource";
 import { InstallDependencies, fixedDependencies } from "./dependencies";
 const execAsync = promisify(exec);
@@ -75,7 +78,7 @@ export const VitepressProject = Resource("project::VitepressProject", {
         //         `import alchemy from "alchemy";
         // import { Folder } from "alchemy/fs";
         // import { Document } from "alchemy/docs";
-        // import path from "path";
+        // import path from "node:path";
         // const app = await alchemy("alchemy.run", {
         //   stage: "prod",
         //   phase: process.argv.includes("--destroy") ? "destroy" : "up",

package/package.json

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

package/src/alchemy.ts

@@ -111,7 +111,10 @@ async function _alchemy(
       : 0;
     const indent = " ".repeat(leadingSpaces);
 
-    const { isFileCollection, isFileRef } = await import("./fs");
+    const [{ isFileRef }, { isFileCollection }] = await Promise.all([
+      import("./fs/file-ref"),
+      import("./fs/file-collection"),
+    ]);
 
     const appendices: Record<string, string> = {};
 

package/src/cloudflare/api.ts

@@ -131,7 +131,7 @@ export class CloudflareApi {
           errorMsg.includes("ETIMEDOUT") ||
           errorMsg.includes("ECONNREFUSED");
 
-        return isNetworkError;
+        return isNetworkError || error.status?.toString().startsWith("5");
       },
       5, // Maximum 5 attempts (1 initial + 4 retries)
       1000 // Start with 1s delay, will exponentially increase

package/src/cloudflare/assets.ts

@@ -1,5 +1,5 @@
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import type { Context } from "../context";
 import { Resource } from "../resource";
 import { getContentType } from "../util/content-type";

package/src/cloudflare/d1-database.ts

@@ -6,6 +6,7 @@ import {
   type CloudflareApiOptions,
 } from "./api";
 import { CloudflareApiError, handleApiError } from "./api-error";
+import { applyMigrations, listMigrationsFiles } from "./d1-migrations";
 
 /**
  * Properties for creating or updating a D1 Database
@@ -57,6 +58,25 @@ export interface D1DatabaseProps extends CloudflareApiOptions {
    * @default false
    */
   adopt?: boolean;
+
+  /**
+   * These files will be generated internally with the D1Database wrapper function when migrationsDir is specified
+   *
+   * @private
+   */
+  migrationsFiles?: Array<{ id: string; sql: string }>;
+
+  /**
+   * Name of the table used to track migrations. Only used if migrationsDir is specified. Defaults to 'd1_migrations'
+   * This is analogous to wrangler's `migrations_table`.
+   */
+  migrationsTable?: string;
+
+  /**
+   * Directory containing migration SQL files. If not set, no migrations will be applied.
+   * This is analogous to wrangler's `migrations_dir`.
+   */
+  migrationsDir?: string;
 }
 
 /**
@@ -97,6 +117,20 @@ export interface D1Database
   };
 }
 
+export async function D1Database(
+  id: string,
+  props: Omit<D1DatabaseProps, "migrationsFiles">
+) {
+  const migrationsFiles = props.migrationsDir
+    ? await listMigrationsFiles(props.migrationsDir)
+    : [];
+
+  return D1DatabaseResource(id, {
+    ...props,
+    migrationsFiles,
+  });
+}
+
 /**
  * Creates and manages Cloudflare D1 Databases.
  *
@@ -126,9 +160,16 @@ export interface D1Database
  *   }
  * });
  *
+ * @example
+ * // Create a database with migrations
+ * const dbWithMigrations = await D1Database("mydb", {
+ *   name: "mydb",
+ *   migrationsDir: "./migrations",
+ * });
+ *
  * @see https://developers.cloudflare.com/d1/
  */
-export const D1Database = Resource(
+export const D1DatabaseResource = Resource(
   "cloudflare::D1Database",
   async function (
     this: Context<D1Database>,
@@ -204,6 +245,29 @@ export const D1Database = Resource(
         }
       }
 
+      // Run migrations if provided
+      if (props.migrationsFiles && props.migrationsFiles.length > 0) {
+        try {
+          const migrationsTable = props.migrationsTable || "d1_migrations";
+          const databaseId = dbData.result.uuid || this.output?.id;
+
+          if (!databaseId) {
+            throw new Error("Database ID not found for migrations");
+          }
+
+          await applyMigrations({
+            migrationsFiles: props.migrationsFiles,
+            migrationsTable,
+            accountId: api.accountId,
+            databaseId,
+            api,
+          });
+        } catch (migrationErr) {
+          console.error("Failed to apply D1 migrations:", migrationErr);
+          throw migrationErr;
+        }
+      }
+
       return this({
         type: "d1",
         id: dbData.result.uuid || "",

package/src/cloudflare/d1-migrations.ts

@@ -0,0 +1,137 @@
+import * as fs from "fs/promises";
+import * as path from "node:path";
+import { CloudflareApi } from "./api";
+import { handleApiError } from "./api-error";
+
+export interface D1MigrationOptions {
+  migrationsFiles: Array<{ id: string; sql: string }>;
+  migrationsTable: string;
+  accountId: string;
+  databaseId: string;
+  api: CloudflareApi;
+}
+
+const getPrefix = (name: string) => {
+  const prefix = name.split("_")[0];
+  const num = parseInt(prefix, 10);
+  return isNaN(num) ? null : num;
+};
+
+async function readMigrationFile(filePath: string): Promise<string> {
+  return fs.readFile(filePath, "utf-8");
+}
+
+/**
+ * Reads migration SQL files from the migrationsDir, sorted by filename.
+ * @param migrationsDir Directory containing .sql migration files
+ */
+export async function listMigrationsFiles(
+  migrationsDir: string
+): Promise<Array<{ id: string; sql: string }>> {
+  const entries = await fs.readdir(migrationsDir);
+
+  const sqlFiles = entries
+    .filter((f: string) => f.endsWith(".sql"))
+    .sort((a: string, b: string) => {
+      const aNum = getPrefix(a);
+      const bNum = getPrefix(b);
+
+      if (aNum !== null && bNum !== null) return aNum - bNum;
+      if (aNum !== null) return -1;
+      if (bNum !== null) return 1;
+
+      return a.localeCompare(b);
+    });
+
+  const files: Array<{ id: string; sql: string }> = [];
+  for (const file of sqlFiles) {
+    const sql = await readMigrationFile(path.join(migrationsDir, file));
+    files.push({ id: file, sql });
+  }
+
+  return files;
+}
+
+/**
+ * Ensures the migrations table exists in the D1 database.
+ */
+export async function ensureMigrationsTable(
+  options: D1MigrationOptions
+): Promise<void> {
+  const createTableSQL = `CREATE TABLE IF NOT EXISTS ${options.migrationsTable} (id TEXT PRIMARY KEY, applied_at TEXT);`;
+
+  await executeD1SQL(options, createTableSQL);
+}
+
+/**
+ * Gets the list of applied migration IDs from the migrations table.
+ */
+export async function getAppliedMigrations(
+  options: D1MigrationOptions
+): Promise<Set<string>> {
+  const sql = `SELECT id FROM ${options.migrationsTable};`;
+
+  const result = await executeD1SQL(options, sql);
+
+  const ids = (result?.result[0]?.results || []).map((row: any) => row.id);
+  return new Set(ids);
+}
+
+/**
+ * Executes a SQL statement against the D1 database using the HTTP API.
+ */
+export async function executeD1SQL(
+  options: D1MigrationOptions,
+  sql: string
+): Promise<{
+  result: [
+    {
+      results: Array<unknown>;
+      success: boolean;
+      meta: any;
+    },
+  ];
+  errors: Array<any>;
+  messages: Array<any>;
+  success: boolean;
+}> {
+  const response = await options.api.post(
+    `/accounts/${options.accountId}/d1/database/${options.databaseId}/query`,
+    { sql }
+  );
+
+  if (!response.ok) {
+    await handleApiError(
+      response,
+      "executing migration SQL",
+      "D1 database",
+      options.databaseId
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Applies all pending migrations from the provided files to the D1 database.
+ */
+export async function applyMigrations(
+  options: D1MigrationOptions
+): Promise<void> {
+  await ensureMigrationsTable(options);
+  const applied = await getAppliedMigrations(options);
+
+  for (const migration of options.migrationsFiles) {
+    const migrationId = migration.id;
+
+    if (applied.has(migrationId)) continue;
+
+    // Run the migration
+    await executeD1SQL(options, migration.sql);
+    // Record as applied
+    const insertSQL = `INSERT INTO ${options.migrationsTable} (id, applied_at) VALUES ('${migrationId.replace("'", "''")}', datetime('now'));`;
+    await executeD1SQL(options, insertSQL);
+
+    console.log(`Applied migration: ${migrationId}`);
+  }
+}

package/src/cloudflare/worker.ts

@@ -1,5 +1,5 @@
-import * as crypto from "crypto";
-import * as fs from "fs/promises";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs/promises";
 import type { Context } from "../context";
 import { Bundle, type BundleProps } from "../esbuild/bundle";
 import { Resource } from "../resource";

package/src/cloudflare/wrangler.json.ts

@@ -1,5 +1,5 @@
 import type { Context } from "../context";
-import { StaticJsonFile } from "../fs";
+import { StaticJsonFile } from "../fs/static-json-file";
 import { Resource } from "../resource";
 import type { Bindings } from "./bindings";
 import type { DurableObjectNamespace } from "./durable-object-namespace";

package/src/esbuild/bundle.ts

@@ -119,22 +119,54 @@ export const Bundle = Resource(
     props: BundleProps
   ): Promise<Bundle> {
     // Determine output path
-    const outputPath = getOutputPath(props);
+    const outDirPath =
+      props.outfile != null ? path.dirname(props.outfile) : props.outdir;
 
-    // Ensure output directory exists
-    await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+    if (outDirPath == null) {
+      throw new Error(
+        `You need to specify either outfile or outdir in your bundle configuration ${JSON.stringify(props)}`
+      );
+    }
 
+    // Ensure output directory exists
+    await fs.promises.mkdir(path.dirname(outDirPath), { recursive: true });
     if (this.phase === "delete") {
-      await fs.promises.unlink(outputPath).catch(() => {});
-      // Also clean up sourcemap if it exists
-      await fs.promises.unlink(outputPath + ".map").catch(() => {});
-      return this.destroy();
+      await fs.promises.rm(outDirPath, { recursive: true });
     }
 
     const result = await bundle(props);
+    // Check that bundle created output an file for the given entrypoint
+    // Use bundle metada data to retrieve its content
+    const bundleOutputPath = Object.entries(result.metafile.outputs).find(
+      ([file, output]) => {
+        if (output.entryPoint === undefined) {
+          return false;
+        }
+        // resolve to absolute and then relative to ensure consistent result (e.g. ./src/handler.ts instead of src/handler.ts)
+        const relativeOutput = path.relative(
+          process.cwd(),
+          path.resolve(output.entryPoint)
+        );
+        return (
+          relativeOutput ===
+          path.relative(
+            process.cwd(),
+            path.resolve(process.cwd(), props.entryPoint)
+          )
+        );
+      }
+    )?.[0];
+
+    if (!bundleOutputPath) {
+      throw new Error(`Unable to find a compiled file`);
+    }
+
     // Calculate hash of the output
-    const contents = await fs.promises.readFile(outputPath);
-    const hash = crypto.createHash("sha256").update(contents).digest("hex");
+    const bundleOutputContent = await fs.promises.readFile(bundleOutputPath);
+    const hash = crypto
+      .createHash("sha256")
+      .update(bundleOutputContent)
+      .digest("hex");
 
     // Store metadata in context
     await this.set("metafile", result.metafile);
@@ -142,18 +174,18 @@ export const Bundle = Resource(
 
     // Return output info
     return this({
-      path: outputPath,
+      path: bundleOutputPath,
       hash,
     });
   }
 );
 
 export async function bundle(props: BundleProps) {
-  const outputPath = getOutputPath(props);
   return await esbuild.build({
     ...props.options,
     entryPoints: [props.entryPoint],
-    outfile: outputPath,
+    outdir: props.outdir,
+    outfile: props.outfile,
     bundle: true,
     format: props.format,
     target: props.target,
@@ -169,13 +201,3 @@ export async function bundle(props: BundleProps) {
     write: true,
   });
 }
-
-function getOutputPath(props: BundleProps) {
-  return (
-    props.outfile ||
-    path.join(
-      props.outdir || "dist",
-      path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js"
-    )
-  );
-}

package/src/internal/docs/providers.ts

@@ -1,9 +1,10 @@
 import { type } from "arktype";
-import fs from "fs/promises";
-import path from "path";
-import { Data, Document } from "../../ai";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Data } from "../../ai/data";
+import { Document } from "../../ai/document";
 import { alchemy } from "../../alchemy";
-import { Folder } from "../../fs";
+import { Folder } from "../../fs/folder";
 
 export interface DocsProps {
   /**

package/src/test/bun.ts

@@ -3,7 +3,7 @@
 import { afterAll, beforeAll, it } from "bun:test";
 import path from "node:path";
 import { alchemy } from "../alchemy";
-import { R2RestStateStore } from "../cloudflare";
+import { R2RestStateStore } from "../cloudflare/r2-rest-state-store";
 import { Scope } from "../scope";
 import type { StateStoreType } from "../state";
 

package/src/test/prune.ts

@@ -0,0 +1,165 @@
+import { exec } from "child_process";
+import * as esbuild from "esbuild";
+import { glob } from "glob";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Runs only tests that have changed dependencies
+ * @param directory Directory to scan for test files
+ * @param baseCommit Optional base commit to compare against
+ */
+export async function runChangedTests(
+  directory: string,
+  baseCommit?: string
+): Promise<void> {
+  const changedTests = await findChangedTestFiles(directory, baseCommit);
+
+  if (changedTests.length === 0) {
+    console.log("No tests affected by recent changes.");
+    return;
+  }
+
+  // Run the tests with bun using spawn for stdio inheritance
+  return new Promise<void>((resolve, reject) => {
+    console.log(`bun test ${changedTests.join(" ")}`);
+    // resolve();
+    const child = spawn("bun", ["test", ...changedTests], { stdio: "inherit" });
+
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Tests exited with code ${code}`));
+    });
+
+    child.on("error", reject);
+  });
+}
+
+/**
+ * Identifies test files that have changed or depend on changed files
+ * @param directory Directory to scan for test files
+ * @param baseCommit Optional base commit to compare against (defaults to HEAD~1)
+ * @returns Array of changed test files
+ */
+export async function findChangedTestFiles(
+  directory: string,
+  baseCommit: string = "HEAD~1"
+): Promise<string[]> {
+  // 1. Find all test files
+  const testFiles = await findTestFiles(directory);
+
+  // 2. Get git changed files
+  const changedFiles = await getChangedFiles(baseCommit);
+
+  // 3. Process each test file
+  const changedTestFiles: string[] = [];
+
+  for (const testFile of testFiles) {
+    // Get dependency tree for the test file
+    const dependencies = await getDependencies(testFile);
+
+    // Check if any dependencies have changed
+    const changedDependencies = [...dependencies].filter((dep) =>
+      changedFiles.has(dep)
+    );
+
+    if (changedDependencies.length > 0) {
+      changedTestFiles.push(testFile);
+    }
+  }
+
+  return changedTestFiles.map((p) => path.relative(process.cwd(), p));
+}
+
+/**
+ * Finds all test files in a directory
+ * @param directory Directory to scan
+ * @returns Array of test file paths
+ */
+async function findTestFiles(directory: string): Promise<string[]> {
+  return await glob(path.join(directory, "**/*.test.ts"));
+}
+
+/**
+ * Gets list of files changed since a base commit
+ * @param baseCommit Base commit to compare against
+ * @returns Set of changed file paths
+ */
+async function getChangedFiles(baseCommit: string): Promise<Set<string>> {
+  // Get changed files from git
+  const { stdout: gitOutput } = await execAsync(
+    `git diff --name-only ${baseCommit}`
+  );
+
+  // Convert to set of absolute paths
+  const changedFiles = new Set<string>();
+  const { stdout: workDir } = await execAsync("git rev-parse --show-toplevel");
+  const rootDir = workDir.trim();
+
+  gitOutput
+    .split("\n")
+    .filter((line) => line.trim().length > 0)
+    .forEach((file) => {
+      changedFiles.add(path.resolve(rootDir, file));
+    });
+
+  return changedFiles;
+}
+
+/**
+ * Gets dependency tree for a test file
+ * @param testFile Path to test file
+ * @returns Set of dependency file paths
+ */
+async function getDependencies(testFile: string): Promise<Set<string>> {
+  const dependencies = new Set<string>();
+
+  // Add the test file itself to dependencies
+  const absTestPath = path.resolve(testFile);
+  dependencies.add(absTestPath);
+
+  try {
+    // Use esbuild with metafile to get dependencies
+    const result = await esbuild.build({
+      entryPoints: [testFile],
+      write: false,
+      platform: "node",
+      format: "esm",
+      bundle: true,
+      metafile: true,
+      external: ["@cloudflare/workers-types", "bun:test"],
+    });
+
+    if (!result.metafile) {
+      return dependencies;
+    }
+
+    // Function to normalize paths for comparison
+    const normalizePath = (p: string) => path.resolve(p).replace(/\\/g, "/");
+
+    // Process imports from the metafile
+    const { inputs } = result.metafile;
+    for (const filePath in inputs) {
+      // Skip node_modules and non-local imports
+      if (
+        filePath.includes("node_modules") ||
+        filePath.includes("bun:") ||
+        !filePath.endsWith(".ts")
+      ) {
+        continue;
+      }
+
+      const absolutePath = normalizePath(filePath);
+      dependencies.add(absolutePath);
+    }
+
+    return dependencies;
+  } catch (error) {
+    console.error(`Error analyzing dependencies for ${testFile}:`, error);
+    // Return at least the test file itself
+    return dependencies;
+  }
+}

package/src/util/content-type.ts

@@ -1,4 +1,4 @@
-import path from "path";
+import path from "node:path";
 
 // Common MIME types
 const mimeTypes: Record<string, string> = {

package/src/util/rm.ts

@@ -1,4 +1,4 @@
-import fs from "fs/promises";
+import fs from "node:fs/promises";
 
 export async function rm(path: string) {
   try {