alchemy 0.3.0 → 0.4.0

package/src/ai/json-file.ts

@@ -1,11 +1,9 @@
 import { generateObject, generateText } from "ai";
 import type { JsonSchema, Type, type } from "arktype";
-import fs from "node:fs/promises";
-import path from "node:path";
 import type { Context } from "../context";
+import { StaticJsonFile } from "../fs/static-json-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
 import { ark } from "./ark";
 import { type ModelConfig, createModel } from "./client";
 
@@ -193,25 +191,11 @@ export const JSONFile = Resource("ai::JSONFile", async function <
 >(this: Context<JSONFile<T extends Type<any, any> ? type.infer<T> : any>>, id: string, props: JSONFileProps<T>): Promise<
   JSONFile<T extends Type<any, any> ? type.infer<T> : any>
 > {
-  // Ensure directory exists
-  await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+  // Handle deletion phase
   if (this.phase === "delete") {
-    try {
-      await fs.unlink(props.path);
-    } catch (error: any) {
-      // Ignore if file doesn't exist
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
     return this.destroy();
   }
 
-  // Determine if we should use pretty printing
-  const pretty = props.pretty !== false;
-  const indent = props.indent ?? 2;
-
   let jsonContent: string;
   let jsonObject: any;
 
@@ -232,9 +216,10 @@ export const JSONFile = Resource("ai::JSONFile", async function <
     });
 
     jsonObject = object;
-    jsonContent = pretty
-      ? JSON.stringify(jsonObject, null, indent)
-      : JSON.stringify(jsonObject);
+
+    // Use StaticJsonFile to create the file
+    const file = await StaticJsonFile("file", props.path, jsonObject);
+    jsonContent = file.content;
   } else {
     // Use fence-based extraction
     // Use provided system prompt or default
@@ -277,31 +262,22 @@ export const JSONFile = Resource("ai::JSONFile", async function <
       content = retryResult.content;
     }
 
-    // Parse JSON
+    // Parse JSON to get the object representation
     jsonObject = JSON.parse(content);
 
-    // Format with or without indentation based on pretty option
-    jsonContent = pretty ? JSON.stringify(jsonObject, null, indent) : content;
+    // Use StaticJsonFile to create the file
+    const file = await StaticJsonFile("file", props.path, jsonObject);
+    jsonContent = file.content;
   }
 
-  if (this.phase === "update" && props.path !== this.props.path) {
-    await ignore("ENOENT", () => fs.unlink(this.props.path));
-  }
-
-  // Write content to file
-  await fs.writeFile(props.path, jsonContent);
-
-  // Get file stats for timestamps
-  const stats = await fs.stat(props.path);
-
   // Return the resource
   return this({
     ...props,
     schema: props.schema,
     content: jsonContent,
     json: jsonObject,
-    createdAt: stats.birthtimeMs,
-    updatedAt: stats.mtimeMs,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   });
 });
 
@@ -313,7 +289,7 @@ export const JSONFile = Resource("ai::JSONFile", async function <
  * @returns The extracted JSON or error message
  */
 async function extractJSONContent(
-  text: string,
+  text: string
 ): Promise<{ content: string; error?: string }> {
   const jsonCodeRegex = /```json\s*([\s\S]*?)```/g;
   const matches = Array.from(text.matchAll(jsonCodeRegex));

package/src/ai/typescript-file.ts

@@ -1,12 +1,9 @@
 import { generateText } from "ai";
-import fs from "node:fs/promises";
-import path from "node:path";
-import prettier from "prettier";
 import type { Context } from "../context";
+import { StaticTypeScriptFile } from "../fs/static-typescript-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
-import { type ModelConfig, createModel } from "./client";
+import { createModel, type ModelConfig } from "./client";
 
 /**
  * Properties for creating or updating a TypeScriptFile
@@ -65,7 +62,7 @@ export interface TypeScriptFileProps {
    * Prettier configuration to use for formatting the TypeScript code
    * If not provided, will use the default Prettier configuration
    */
-  prettierConfig?: prettier.Options;
+  prettierConfig?: object;
 }
 
 /**
@@ -166,20 +163,11 @@ export const TypeScriptFile = Resource(
   async function (
     this: Context<TypeScriptFile>,
     id: string,
-    props: TypeScriptFileProps,
+    props: TypeScriptFileProps
   ): Promise<TypeScriptFile> {
-    // Ensure directory exists
-    await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+    // Handle delete phase
     if (this.phase === "delete") {
-      try {
-        await fs.unlink(props.path);
-      } catch (error: any) {
-        // Ignore if file doesn't exist
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
+      // StaticTypeScriptFile will handle the deletion
       return this.destroy();
     }
 
@@ -218,46 +206,24 @@ export const TypeScriptFile = Resource(
 
       if (retryResult.error) {
         throw new Error(
-          `Failed to generate valid TypeScript code: ${retryResult.error}`,
+          `Failed to generate valid TypeScript code: ${retryResult.error}`
         );
       }
 
       code = retryResult.code;
     }
 
-    // Format the code with Prettier
-    try {
-      // Set default parser to typescript
-      const prettierOptions: prettier.Options = {
-        parser: "typescript",
-        ...props.prettierConfig,
-      };
-
-      // Format the code
-      code = await prettier.format(code, prettierOptions);
-    } catch (error) {
-      // If Prettier formatting fails, just use the unformatted code
-      console.warn("Failed to format TypeScript code with Prettier:", error);
-    }
-
-    if (this.phase === "update" && props.path !== this.props.path) {
-      await ignore("ENOENT", () => fs.unlink(this.props.path));
-    }
-
-    // Write content to file
-    await fs.writeFile(props.path, code);
-
-    // Get file stats for timestamps
-    const stats = await fs.stat(props.path);
+    // Use StaticTypeScriptFile to create/update the file
+    const file = await StaticTypeScriptFile("file", props.path, code);
 
     // Return the resource
     return this({
       ...props,
-      content: code,
-      createdAt: stats.birthtimeMs,
-      updatedAt: stats.mtimeMs,
+      content: file.content,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
     });
-  },
+  }
 );
 
 /**
@@ -268,7 +234,7 @@ export const TypeScriptFile = Resource(
  * @returns The extracted TypeScript code or error message
  */
 async function extractTypeScriptCode(
-  text: string,
+  text: string
 ): Promise<{ code: string; error?: string }> {
   const tsCodeRegex = /```ts\s*([\s\S]*?)```/g;
   const matches = Array.from(text.matchAll(tsCodeRegex));

package/src/ai/vue-file.ts

@@ -1,10 +1,8 @@
 import { generateText } from "ai";
-import fs from "node:fs/promises";
-import path from "node:path";
 import type { Context } from "../context";
+import { StaticVueFile } from "../fs/static-vue-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
 import { type ModelConfig, createModel } from "./client";
 
 /**
@@ -149,20 +147,10 @@ export const VueFile = Resource(
   async function (
     this: Context<VueFile>,
     id: string,
-    props: VueFileProps,
+    props: VueFileProps
   ): Promise<VueFile> {
-    // Ensure directory exists
-    await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+    // Handle deletion phase
     if (this.phase === "delete") {
-      try {
-        await fs.unlink(props.path);
-      } catch (error: any) {
-        // Ignore if file doesn't exist
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
       return this.destroy();
     }
 
@@ -201,31 +189,24 @@ export const VueFile = Resource(
 
       if (retryResult.error) {
         throw new Error(
-          `Failed to generate valid Vue code: ${retryResult.error}`,
+          `Failed to generate valid Vue code: ${retryResult.error}`
         );
       }
 
       code = retryResult.code;
     }
 
-    if (this.phase === "update" && props.path !== this.props.path) {
-      await ignore("ENOENT", () => fs.unlink(this.props.path));
-    }
-
-    // Write content to file
-    await fs.writeFile(props.path, code);
-
-    // Get file stats for timestamps
-    const stats = await fs.stat(props.path);
+    // Use StaticVueFile to create/update the file
+    const file = await StaticVueFile("file", props.path, code);
 
     // Return the resource
     return this({
       ...props,
-      content: code,
-      createdAt: stats.birthtimeMs,
-      updatedAt: stats.mtimeMs,
+      content: file.content,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
     });
-  },
+  }
 );
 
 /**
@@ -236,7 +217,7 @@ export const VueFile = Resource(
  * @returns The extracted Vue code or error message
  */
 async function extractVueCode(
-  text: string,
+  text: string
 ): Promise<{ code: string; error?: string }> {
   const vueCodeRegex = /```vue\s*([\s\S]*?)```/g;
   const matches = Array.from(text.matchAll(vueCodeRegex));

package/src/ai/yaml-file.ts

@@ -1,11 +1,9 @@
 import { generateObject, generateText } from "ai";
 import type { JsonSchema, Type, type } from "arktype";
-import fs from "node:fs/promises";
-import path from "node:path";
 import type { Context } from "../context";
+import { StaticYamlFile } from "../fs/static-yaml-file";
 import { Resource } from "../resource";
 import type { Secret } from "../secret";
-import { ignore } from "../util/ignore";
 import { ark } from "./ark";
 import { type ModelConfig, createModel } from "./client";
 
@@ -200,32 +198,11 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
 >(this: Context<YAMLFile<T extends Type<any, any> ? type.infer<T> : any>>, id: string, props: YAMLFileProps<T>): Promise<
   YAMLFile<T extends Type<any, any> ? type.infer<T> : any>
 > {
-  // Ensure directory exists
-  await fs.mkdir(path.dirname(props.path), { recursive: true });
-
+  // Handle deletion phase
   if (this.phase === "delete") {
-    try {
-      await fs.unlink(props.path);
-    } catch (error: any) {
-      // Ignore if file doesn't exist
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
     return this.destroy();
   }
 
-  // Dynamic import js-yaml to avoid dependency issues
-  // This allows the code to work even if js-yaml is not installed
-  let yaml: typeof import("yaml");
-  try {
-    yaml = await import("yaml");
-  } catch (err) {
-    throw new Error(
-      "The 'yaml' package is required for the YAMLFile resource. Please install it with: bun add yaml",
-    );
-  }
-
   let yamlContent: string;
   let yamlObject: any;
 
@@ -247,16 +224,9 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
 
     yamlObject = object;
 
-    // Convert object to YAML
-    try {
-      yamlContent = yaml.stringify(yamlObject, {
-        indent: 2,
-      });
-    } catch (error) {
-      throw new Error(
-        `Failed to convert object to YAML: ${(error as Error).message}`,
-      );
-    }
+    // Let StaticYamlFile handle the YAML conversion
+    const file = await StaticYamlFile("file", props.path, yamlObject);
+    yamlContent = file.content;
   } else {
     // Use fence-based extraction
     // Use provided system prompt or default
@@ -301,32 +271,22 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
 
     yamlContent = content;
 
-    // Parse YAML to validate and get object representation
-    try {
-      yamlObject = yaml.parse(yamlContent);
-    } catch (error) {
-      throw new Error(`Failed to parse YAML: ${(error as Error).message}`);
-    }
-  }
+    // Create the file with the string content
+    const file = await StaticYamlFile("file", props.path, yamlContent);
 
-  if (this.phase === "update" && props.path !== this.props.path) {
-    await ignore("ENOENT", () => fs.unlink(this.props.path));
+    // We need to parse the YAML to get the object representation
+    const yaml = await import("yaml");
+    yamlObject = yaml.parse(yamlContent);
   }
 
-  // Write content to file
-  await fs.writeFile(props.path, yamlContent);
-
-  // Get file stats for timestamps
-  const stats = await fs.stat(props.path);
-
   // Return the resource
   return this({
     ...props,
     schema: props.schema,
     content: yamlContent,
     yaml: yamlObject,
-    createdAt: stats.birthtimeMs,
-    updatedAt: stats.mtimeMs,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   });
 });
 
@@ -338,7 +298,7 @@ export const YAMLFile = Resource("ai::YAMLFile", async function <
  * @returns The extracted YAML or error message
  */
 async function extractYAMLContent(
-  text: string,
+  text: string
 ): Promise<{ content: string; error?: string }> {
   // Check for yaml or yml fence blocks
   const yamlCodeRegex = /```(yaml|yml)\s*([\s\S]*?)```/g;

package/src/alchemy.ts

@@ -40,6 +40,12 @@ export interface Alchemy {
   scope: typeof scope;
   run: typeof run;
   destroy: typeof destroy;
+
+  /**
+   * Get an environment variable and error if it's not set.
+   */
+  env: typeof env;
+
   /**
    * Creates an encrypted secret that can be safely stored in state files.
    * Requires a password to be set either globally in the application options
@@ -88,12 +94,18 @@ function _alchemy(
     | [appName: string, options?: Omit<AlchemyOptions, "appName">]
 ): any {
   if (typeof args[0] === "string") {
-    const [appName, options] = args;
-    return scope(undefined, {
+    const [appName, options] = args as [string, AlchemyOptions?];
+    const root = scope(undefined, {
       ...options,
       appName,
       stage: options?.stage,
     });
+    if (options?.phase === "destroy") {
+      return destroy(root).finally(() => {
+        process.exit(0);
+      });
+    }
+    return root;
   } else {
     const [template, ...values] = args;
     const [, secondLine] = template[0].split("\n");
@@ -111,6 +123,16 @@ function _alchemy(
         values.map(async function resolve(value): Promise<string> {
           if (typeof value === "string") {
             return indent + value;
+          } else if (value === null) {
+            return "null";
+          } else if (value === undefined) {
+            return "undefined";
+          } else if (
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            typeof value === "bigint"
+          ) {
+            return value.toString();
           } else if (value instanceof Promise) {
             return resolve(await value);
           } else if (isFileRef(value)) {
@@ -128,14 +150,34 @@ function _alchemy(
           } else if (Array.isArray(value)) {
             return (
               await Promise.all(
-                value.map(async (value, i) => `${i}. ${await resolve(value)}`),
+                value.map(async (value, i) => `${i}. ${await resolve(value)}`)
+              )
+            ).join("\n");
+          } else if (
+            typeof value === "object" &&
+            typeof value.path === "string"
+          ) {
+            if (typeof value.content === "string") {
+              appendices[value.path] = value.content;
+              return `[${path.basename(value.path)}](${value.path})`;
+            } else {
+              appendices[value.path] = await fs.readFile(value.path, "utf-8");
+              return `[${path.basename(value.path)}](${value.path})`;
+            }
+          } else if (typeof value === "object") {
+            return (
+              await Promise.all(
+                Object.entries(value).map(async ([key, value]) => {
+                  return `* ${key}: ${await resolve(value)}`;
+                })
               )
             ).join("\n");
           } else {
             // TODO: support other types
-            throw new Error(`Unsupported value type: ${JSON.stringify(value)}`);
+            console.log(value);
+            throw new Error(`Unsupported value type: ${value}`);
           }
-        }),
+        })
       );
 
       // Construct the string template by joining template parts with interpolated values
@@ -144,12 +186,12 @@ function _alchemy(
           part
             .split("\n")
             .map((line) =>
-              line.startsWith(indent) ? line.slice(indent.length) : line,
+              line.startsWith(indent) ? line.slice(indent.length) : line
             )
-            .join("\n"),
+            .join("\n")
         )
         .flatMap((part, i) =>
-          i < stringValues.length ? [part, stringValues[i] ?? ""] : [part],
+          i < stringValues.length ? [part, stringValues[i] ?? ""] : [part]
         )
         .join("")
         .split("\n");
@@ -178,6 +220,7 @@ _alchemy.destroy = destroy;
 _alchemy.run = run;
 _alchemy.scope = scope;
 _alchemy.secret = secret;
+_alchemy.env = env;
 
 export interface AlchemyOptions {
   /**
@@ -240,7 +283,7 @@ export interface AlchemyOptions {
  */
 function scope(
   id: string | undefined,
-  options?: AlchemyOptions,
+  options?: AlchemyOptions
   // TODO: maybe we want to allow using _ = await alchemy.scope(import.meta)
   // | [meta: ImportMeta]
 ): Scope {
@@ -300,3 +343,25 @@ async function run<T>(
     await scope.finalize();
   }
 }
+
+export async function env<T = string>(
+  name: string,
+  value?: T | undefined,
+  error?: string
+): Promise<T> {
+  if (value !== undefined) {
+    return value;
+  } else if (typeof process !== undefined) {
+    // we are in a node environment
+    return process.env[name]! as T;
+  } else {
+    // we are in a browser environment
+    try {
+      const { env } = await import("cloudflare:workers");
+      if (name in env) {
+        return env[name as keyof typeof env];
+      }
+    } catch (error) {}
+  }
+  throw new Error(error ?? `Environment variable ${name} is not set`);
+}

package/src/apply.ts

@@ -7,9 +7,8 @@ import {
   type Resource,
   type ResourceProps,
 } from "./resource";
-import { Secret } from "./secret";
+import { serialize } from "./serde";
 import type { State } from "./state";
-import { serialize } from "./util/serde";
 
 export interface ApplyOptions {
   quiet?: boolean;
@@ -19,7 +18,7 @@ export interface ApplyOptions {
 export async function apply<Out extends Resource>(
   resource: PendingResource<Out>,
   props: ResourceProps | undefined,
-  options?: ApplyOptions,
+  options?: ApplyOptions
 ): Promise<Awaited<Out>> {
   const scope = resource.Scope;
   try {
@@ -56,29 +55,30 @@ export async function apply<Out extends Resource>(
 
     // Skip update if inputs haven't changed and resource is in a stable state
     if (state.status === "created" || state.status === "updated") {
-      const oldProps = JSON.stringify(
-        state.props,
-        (_, value) =>
-          value instanceof Secret
-            ? {
-                "@secret": value.unencrypted,
-              }
-            : value,
-        2,
-      );
-      const newProps = JSON.stringify(
-        await serialize(scope, props, {
-          encrypt: false,
-        }),
-        null,
-        2,
-      );
-      if (oldProps === newProps && alwaysUpdate !== true) {
+      const oldProps = await serialize(scope, state.props, {
+        encrypt: false,
+      });
+      const newProps = await serialize(scope, props, {
+        encrypt: false,
+      });
+      if (
+        JSON.stringify(oldProps) === JSON.stringify(newProps) &&
+        alwaysUpdate !== true
+      ) {
         if (!quiet) {
-          console.log(`Skip:    "${resource.FQN}" (no changes)`);
+          // console.log(`Skip:    "${resource.FQN}" (no changes)`);
         }
         return state.output as Awaited<Out>;
       }
+
+      const diff = await import("diff");
+      const yaml = await import("yaml");
+      const old = yaml.stringify(oldProps);
+      const news = yaml.stringify(newProps);
+      const patch = diff.createPatch(resource.ID, old, news);
+      // console.log(patch);
+      // if (resource.ID === "what-is-alchemy") {
+      // }
     }
 
     const phase = state.status === "creating" ? "create" : "update";
@@ -88,7 +88,7 @@ export async function apply<Out extends Resource>(
 
     if (!quiet) {
       console.log(
-        `${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`,
+        `${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`
       );
     }
 
@@ -108,7 +108,7 @@ export async function apply<Out extends Resource>(
       replace: () => {
         if (isReplaced) {
           console.warn(
-            `Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`,
+            `Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`
           );
           return;
         }
@@ -117,11 +117,11 @@ export async function apply<Out extends Resource>(
     });
 
     const output = await alchemy.run(resource.ID, async () =>
-      provider.handler.bind(ctx)(resource.ID, props),
+      provider.handler.bind(ctx)(resource.ID, props)
     );
     if (!quiet) {
       console.log(
-        `${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`,
+        `${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`
       );
     }
 
@@ -141,6 +141,7 @@ export async function apply<Out extends Resource>(
     // }
     return output as any;
   } catch (error) {
+    console.error(new Error().stack);
     scope.fail();
     throw error;
   }

package/src/aws/account-id.ts

@@ -2,10 +2,14 @@ import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
 
 const sts = new STSClient({});
 
+export type AccountId = string & {
+  readonly __brand: "AccountId";
+};
+
 /**
  * Helper to get the current AWS account ID
  */
-export async function getAccountId(): Promise<string> {
+export async function AccountId(): Promise<AccountId> {
   const identity = await sts.send(new GetCallerIdentityCommand({}));
-  return identity.Account!;
+  return identity.Account! as AccountId;
 }

package/src/aws/credentials.ts

@@ -0,0 +1,6 @@
+import type { Secret } from "../secret";
+
+export interface AwsCredentials {
+  accessKeyId: Secret;
+  secretAccessKey: Secret;
+}