alchemy 0.10.1 → 0.10.3

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/bound.ts

@@ -34,4 +34,6 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace
                     ? Queue
                     : T extends _Pipeline<infer R>
                       ? Pipeline<R>
-                      : Service;
+                      : T extends string
+                        ? string
+                        : Service;

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/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 {

package/src/web/astro.ts

@@ -1,14 +1,12 @@
 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 type { Context } from "../context";
-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 { ShadcnUI } from "./shadcn";
 
@@ -198,7 +196,7 @@ export const AstroProject = Resource(
   async function (
     this: Context<AstroProject>,
     id: string,
-    props: AstroProjectProps,
+    props: AstroProjectProps
   ): Promise<AstroProject> {
     const dir = props.dir ?? props.name;
 
@@ -396,7 +394,7 @@ export const AstroProject = Resource(
 export default defineConfig({${integrationsStr}${vitePluginsStr}
   site: "https://example.com",
   output: "static"
-});`,
+});`
       );
     }
 
@@ -427,14 +425,14 @@ pnpm-debug.log*
 # macOS-specific files
 .DS_Store
 .astro/
-`,
+`
       );
 
       // Create .env.d.ts
       await StaticTextFile(
         path.join(dir, "src", "env.d.ts"),
         `/// <reference types="astro/client" />
-`,
+`
       );
 
       // Create a basic layout
@@ -478,7 +476,7 @@ const { title, description = "Welcome to my Astro site" } = Astro.props;
       Bitstream Vera Sans Mono, Courier New, monospace;
   }
 </style>
-`,
+`
       );
 
       // Create a basic index page
@@ -532,7 +530,7 @@ import Layout from '../layouts/Layout.astro';
     padding: 0.3em 0.45em;
   }
 </style>
-`,
+`
       );
 
       // Create public/favicon.svg
@@ -548,7 +546,7 @@ import Layout from '../layouts/Layout.astro';
     </linearGradient>
   </defs>
 </svg>
-`,
+`
       );
     }
 
@@ -590,7 +588,7 @@ import Layout from '../layouts/Layout.astro';
               `@tailwind base;
 @tailwind components;
 @tailwind utilities;
-`,
+`
             );
             break;
           case "mdx":
@@ -640,5 +638,5 @@ import Layout from '../layouts/Layout.astro';
         await exec(`bun add ${depsArg}`);
       }
     }
-  },
+  }
 );

package/src/web/shadcn-component.ts

@@ -1,6 +1,6 @@
 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 type { Context } from "../context";
 import { Resource } from "../resource";
@@ -44,13 +44,13 @@ export const ShadcnComponent = Resource(
   async function (
     this: Context<ShadcnComponent>,
     id: string,
-    props: ShadcnComponentProps,
+    props: ShadcnComponentProps
   ): Promise<ShadcnComponent> {
     if (this.phase === "delete") {
       await ignore("ENOENT", () =>
         fs.unlink(
-          path.join(props.cwd, "src", "components", "ui", `${props.name}.tsx`),
-        ),
+          path.join(props.cwd, "src", "components", "ui", `${props.name}.tsx`)
+        )
       );
       return this.destroy();
     }
@@ -68,5 +68,5 @@ export const ShadcnComponent = Resource(
     await execAsync(addCommand, { cwd: props.cwd });
 
     return this(props);
-  },
+  }
 );

package/src/web/shadcn.ts

@@ -1,8 +1,9 @@
 import { exec } from "child_process";
-import path from "path";
+import path from "node:path";
 import { promisify } from "util";
 import type { Context } from "../context";
-import { Folder, StaticJsonFile } from "../fs";
+import { Folder } from "../fs/folder";
+import { StaticJsonFile } from "../fs/static-json-file";
 import { StaticTypeScriptFile } from "../fs/static-typescript-file";
 import { Resource } from "../resource";
 import { ShadcnComponent } from "./shadcn-component";
@@ -120,14 +121,14 @@ export const ShadcnUI = Resource(
   async function (
     this: Context<ShadcnUI>,
     id: string,
-    props: ShadcnUIProps,
+    props: ShadcnUIProps
   ): Promise<ShadcnUI> {
     if (this.phase === "delete") {
       // For a delete phase, we don't perform any action
       // as removing Shadcn UI would require removing many files
       // which could be destructive to the project
       console.log(
-        "Note: ShadcnUI delete phase does not remove installed components",
+        "Note: ShadcnUI delete phase does not remove installed components"
       );
 
       return this.destroy();
@@ -171,15 +172,15 @@ export const ShadcnUI = Resource(
         props.cwd,
         props.srcDir !== false ? "src" : "",
         "components",
-        "ui",
-      ),
+        "ui"
+      )
     );
 
     // Create lib directory
     const libPath = path.join(
       props.cwd,
       props.srcDir !== false ? "src" : "",
-      "lib",
+      "lib"
     );
     const lib = await Folder(libPath);
 
@@ -215,5 +216,5 @@ export const ShadcnUI = Resource(
       ui,
       lib,
     });
-  },
+  }
 );