alchemy 0.1.18 → 0.2.1

package/src/destroy.ts

@@ -1,92 +1,143 @@
-import { defaultStage, defaultStateStore } from "./global";
-import type { Output } from "./output";
-import { Provider, ResourceID, isResource } from "./resource";
-import { type Scope, rootScope } from "./scope";
-import type { State, StateStore } from "./state";
+import { alchemy } from "./alchemy";
+import { context } from "./context";
+import { PROVIDERS, type Provider, type Resource } from "./resource";
+import { Scope } from "./scope";
+
+export class DestroyedSignal extends Error {}
 
 export interface DestroyOptions {
-  stage?: string;
-  stateStore?: StateStore;
-  scope?: Scope;
   quiet?: boolean;
+  strategy?: "sequential" | "parallel";
 }
 
-/**
- * Prune all resources from an Output and "down", i.e. that branches from it.
- */
-export async function destroy<T>(
-  output: Output<T>,
-  options?: DestroyOptions,
-): Promise<void>;
+function isScopeArgs(a: any): a is [scope: Scope, options?: DestroyOptions] {
+  return a[0] instanceof Scope;
+}
 
 /**
- * @internal
+ * Prune all resources from an Output and "down", i.e. that branches from it.
  */
-export async function destroy<T>(
-  stage: string,
-  scope: Scope,
-  resourceID: ResourceID,
-  resourceState: State,
-  resourceProvider: Provider,
-  stateStore: StateStore,
-  options: DestroyOptions,
-): Promise<void>;
-
-export async function destroy<T>(
+export async function destroy<Type extends string>(
   ...args:
-    | [Output<T>, DestroyOptions?]
-    | [string, Scope, ResourceID, State, Provider, StateStore, DestroyOptions]
+    | [scope: Scope, options?: DestroyOptions]
+    | [resource: Resource<Type> | undefined | null, options?: DestroyOptions]
 ): Promise<void> {
-  let resourceID: ResourceID;
-  let resourceState: State;
-  let resourceProvider: Provider;
-  let stage: string;
-  let stateStore: StateStore;
-  let scope: Scope | undefined = undefined;
-  let options: DestroyOptions | undefined = undefined;
-  if (args.length === 7) {
-    stage = args[0];
-    scope = args[1];
-    resourceID = args[2];
-    resourceState = args[3];
-    resourceProvider = args[4];
-    stateStore = args[5];
-    options = args[6];
-  } else if (isResource(args[0])) {
-    const resource = args[0];
-    // stage = args[1]?.stage ?? defaultStage;
-    resourceID = resource[ResourceID];
-    stage = args[1]?.stage ?? defaultStage;
-    scope = args[1]?.scope ?? rootScope;
-    const statePath = scope.getScopePath(stage);
-    stateStore = args[1]?.stateStore ?? new defaultStateStore(statePath);
-    // First destroy all dependencies
-    const _resourceState = await stateStore.get(resourceID);
-    if (_resourceState === undefined) {
-      // we have no record of this resource, we must assume it's already deleted
-      return;
-    }
-    resourceState = _resourceState;
-    resourceProvider = resource[Provider];
-    options = args[1];
-  } else {
-    console.log(args[0]);
-    throw new Error("Not implemented: must handle destroy a Output chain");
+  if (isScopeArgs(args)) {
+    const [scope, options] = args;
+    const strategy = options?.strategy ?? "sequential";
+    // destroy all active resources
+    await destroy.all(Array.from(scope.resources.values()), {
+      strategy,
+    });
+    // then detect orphans and destroy them
+    const orphans = await scope.state.all();
+    await destroy.all(
+      Object.values(orphans).map((orphan) => ({
+        ...orphan.output,
+        Scope: scope,
+      })),
+      options,
+    );
+    // finally, destroy the scope container
+    await scope.deinit();
+    return;
+  }
+
+  const [instance, options] = args;
+
+  if (!instance) {
+    return;
+  }
+
+  const Provider: Provider<Type> | undefined = PROVIDERS.get(instance.Kind);
+  if (!Provider) {
+    throw new Error(
+      `Cannot destroy resource type ${instance.Kind} - no provider found. You may need to import the provider in your alchemy.config.ts.`,
+    );
   }
+
+  const scope = instance.Scope;
+  if (!scope) {
+    console.warn(`Resource "${instance.FQN}" has no scope`);
+  }
+  const quiet = options?.quiet ?? scope.quiet;
+
   try {
-    await resourceProvider.delete(
-      stage,
+    if (!quiet) {
+      console.log(`Delete:  "${instance.FQN}"`);
+    }
+
+    const state = (await scope.state.get(instance.ID))!;
+
+    if (state === undefined) {
+      console.warn(`Resource "${instance.FQN}" not found`);
+      return;
+    }
+
+    const ctx = context({
       scope,
-      resourceID,
-      resourceState,
-      resourceState.inputs as [],
-      options ?? {
-        quiet: false,
+      phase: "delete",
+      kind: instance.Kind,
+      id: instance.ID,
+      fqn: instance.FQN,
+      seq: instance.Seq,
+      state,
+      replace: () => {
+        throw new Error("Cannot replace a resource that is being deleted");
       },
-    );
+    });
+
+    let nestedScope: Scope | undefined;
+    try {
+      // BUG: this does not restore persisted scope
+      await alchemy.run(instance.ID, async (scope) => {
+        nestedScope = scope;
+        return await Provider.handler.bind(ctx)(instance.ID, state.props);
+      });
+    } catch (err) {
+      if (err instanceof DestroyedSignal) {
+        // TODO: should we fail if the DestroyedSignal is not thrown?
+      } else {
+        throw err;
+      }
+    }
+
+    if (nestedScope) {
+      await destroy(nestedScope, options);
+    }
+
+    await scope.delete(instance.ID);
+
+    if (!quiet) {
+      console.log(`Deleted: "${instance.FQN}"`);
+    }
   } catch (error) {
     console.error(error);
     throw error;
   }
-  await stateStore.delete(resourceID);
+}
+
+export namespace destroy {
+  export async function all(resources: Resource[], options?: DestroyOptions) {
+    if (options?.strategy !== "parallel") {
+      const sorted = resources.sort((a, b) => b.Seq - a.Seq);
+      for (const resource of sorted) {
+        await destroy(resource);
+      }
+    } else {
+      await Promise.all(
+        resources.map((resource) => destroy(resource, options)),
+      );
+    }
+  }
+
+  export async function sequentially(
+    ...resources: (Resource<string> | undefined | null)[]
+  ) {
+    for (const resource of resources) {
+      if (resource) {
+        await destroy(resource);
+      }
+    }
+  }
 }

package/src/{esbuild.ts → esbuild/bundle.ts}

@@ -2,8 +2,8 @@ import * as esbuild from "esbuild";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { Resource } from "./resource";
-
+import type { Context } from "../context";
+import { Resource } from "../resource";
 export interface BundleProps {
   /**
    * Entry point for the bundle
@@ -47,7 +47,7 @@ export interface BundleProps {
   options?: Partial<esbuild.BuildOptions>;
 }
 
-export interface BundleOutput {
+export interface Bundle extends Resource<"esbuild::Bundle"> {
   /**
    * Path to the bundled file
    */
@@ -58,23 +58,27 @@ export interface BundleOutput {
   hash: string;
 }
 
-export class Bundle extends Resource(
+export const Bundle = Resource(
   "esbuild::Bundle",
   {
     alwaysUpdate: true,
   },
-  async (ctx, props: BundleProps): Promise<BundleOutput> => {
+  async function (
+    this: Context<Bundle>,
+    id: string,
+    props: BundleProps,
+  ): Promise<Bundle> {
     // Determine output path
     const outputPath = getOutputPath(props);
 
     // Ensure output directory exists
     await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
 
-    if (ctx.event === "delete") {
+    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 { path: outputPath, hash: "" };
+      return this.destroy();
     }
 
     const result = await bundle(props);
@@ -83,32 +87,16 @@ export class Bundle extends Resource(
     const hash = crypto.createHash("sha256").update(contents).digest("hex");
 
     // Store metadata in context
-    await ctx.set("metafile", result.metafile);
-    await ctx.set("hash", hash);
+    await this.set("metafile", result.metafile);
+    await this.set("hash", hash);
 
     // Return output info
-    return {
+    return this({
       path: outputPath,
       hash,
-    };
+    });
   },
-) {
-  /**
-   * Get the metafile from the last build
-   */
-  public async getMetafile(ctx: {
-    get<T>(key: string): Promise<T | undefined>;
-  }) {
-    return ctx.get<esbuild.Metafile>("metafile");
-  }
-
-  /**
-   * Get the hash from the last build
-   */
-  public async getHash(ctx: { get<T>(key: string): Promise<T | undefined> }) {
-    return ctx.get<string>("hash");
-  }
-}
+);
 
 export async function bundle(props: BundleProps) {
   const outputPath = getOutputPath(props);

package/src/esbuild/index.ts

@@ -0,0 +1 @@
+export * from "./bundle";

package/src/fs/file.ts

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
+
+export interface File extends Resource<"fs::File"> {
+  path: string;
+  content: string;
+}
+
+export const File = Resource(
+  "fs::File",
+  async function (
+    this: Context<File>,
+    id: string,
+    {
+      path: filePath,
+      content,
+    }: {
+      path: string;
+      content: string;
+    },
+  ): Promise<File> {
+    if (this.phase === "delete") {
+      await ignore("ENOENT", async () => fs.promises.unlink(filePath));
+      return this.destroy();
+    } else {
+      await fs.promises.mkdir(path.dirname(filePath), {
+        recursive: true,
+      });
+      await fs.promises.writeFile(filePath, content);
+    }
+    return this({
+      path: filePath,
+      content,
+    });
+  },
+);

package/src/fs/folder.ts

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
+
+export interface Folder extends Resource<"fs::Folder"> {
+  path: string;
+}
+
+export const Folder = Resource(
+  "fs::Folder",
+  async function (
+    this: Context<Folder>,
+    id: string,
+    { path: dirPath }: { path: string },
+  ): Promise<Folder> {
+    if (this.phase === "delete") {
+      // we just do a best effort attempt
+      await ignore(["ENOENT", "ENOTEMPTY"], async () =>
+        fs.promises.rmdir(dirPath),
+      );
+      return this.destroy();
+    } else {
+      await ignore("EEXIST", async () =>
+        fs.promises.mkdir(dirPath, { recursive: true }),
+      );
+    }
+    return this({
+      path: dirPath,
+    });
+  },
+);

package/src/fs/index.ts

@@ -0,0 +1,2 @@
+export * from "./file";
+export * from "./folder";

package/src/github/secret.ts

@@ -1,5 +1,6 @@
 import sodium from "libsodium-wrappers";
-import { type Context, Resource } from "../resource";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 import type { Secret } from "../secret";
 import { createGitHubClient, verifyGitHubAuth } from "./client";
 /**
@@ -35,7 +36,9 @@ export interface GitHubSecretProps {
 /**
  * Output returned after Secret creation/update
  */
-export interface GitHubSecretOutput extends Omit<GitHubSecretProps, "value"> {
+export interface GitHubSecretOutput
+  extends Resource<"github::Secret">,
+    Omit<GitHubSecretProps, "value"> {
   /**
    * The ID of the resource
    */
@@ -50,22 +53,24 @@ export interface GitHubSecretOutput extends Omit<GitHubSecretProps, "value"> {
 /**
  * Resource for managing GitHub repository secrets
  */
-export class GitHubSecret extends Resource(
+export const GitHubSecret = Resource(
   "github::Secret",
-  async (
-    ctx: Context<GitHubSecretOutput>,
+  async function (
+    this: Context<GitHubSecretOutput>,
+    id: string,
     props: GitHubSecretProps,
-  ): Promise<GitHubSecretOutput | void> => {
+  ): Promise<GitHubSecretOutput> {
     // Create authenticated Octokit client - will automatically handle token resolution
+    /// TODO: use fetch
     const octokit = await createGitHubClient({ token: props.token });
 
     // Verify authentication and permissions
-    if (!ctx.quiet) {
+    if (!this.quiet) {
       await verifyGitHubAuth(octokit, props.owner, props.repository);
     }
 
-    if (ctx.event === "delete") {
-      if (ctx.output?.id) {
+    if (this.phase === "delete") {
+      if (this.output?.id) {
         try {
           // Delete the secret
           await octokit.rest.actions.deleteRepoSecret({
@@ -84,7 +89,7 @@ export class GitHubSecret extends Resource(
       }
 
       // Return void (a deleted resource has no content)
-      return undefined;
+      return this.destroy();
     } else {
       try {
         // Get the repository's public key for encrypting secrets
@@ -102,7 +107,7 @@ export class GitHubSecret extends Resource(
         );
 
         // Create or update the secret with the encrypted value and key_id
-        const response = await octokit.rest.actions.createOrUpdateRepoSecret({
+        await octokit.rest.actions.createOrUpdateRepoSecret({
           owner: props.owner,
           repo: props.repository,
           secret_name: props.name,
@@ -111,16 +116,14 @@ export class GitHubSecret extends Resource(
         });
 
         // GitHub doesn't return the secret details on create/update, so we need to construct it
-        const output: GitHubSecretOutput = {
+        return this({
           id: `${props.owner}/${props.repository}/${props.name}`,
           owner: props.owner,
           repository: props.repository,
           name: props.name,
           token: props.token,
           updatedAt: new Date().toISOString(),
-        };
-
-        return output;
+        });
       } catch (error: any) {
         if (
           error.status === 403 &&
@@ -142,7 +145,7 @@ export class GitHubSecret extends Resource(
       }
     }
   },
-) {}
+);
 
 /**
  * Encrypt a value for GitHub using libsodium

package/src/index.ts

@@ -1,16 +1,8 @@
-export * from "./$";
-export * from "./alchemize";
-export * from "./error";
-export * from "./global";
-export * from "./input";
-export * from "./output";
-export * from "./print";
-export {
-  Resource,
-  type Context,
-  type CreateContext,
-  type DeleteContext,
-  type UpdateContext,
-} from "./resource";
+export type * from "./context";
+export * from "./resource";
 export * from "./secret";
-export type { FileSystemStateStore as StateStore } from "./state";
+export * from "./state";
+export * from "./util/ignore";
+
+import { alchemy } from "./alchemy";
+export default alchemy;

package/src/project/index.ts

@@ -0,0 +1 @@
+export * from "./vite";

package/src/project/vite.ts

@@ -0,0 +1,152 @@
+import { exec } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { rm } from "../util/rm";
+const execAsync = promisify(exec);
+
+type ViteTemplate =
+  | "vanilla"
+  | "vanilla-ts"
+  | "vue"
+  | "vue-ts"
+  | "react"
+  | "react-ts"
+  | "react-swc"
+  | "react-swc-ts"
+  | "preact"
+  | "preact-ts"
+  | "lit"
+  | "lit-ts"
+  | "svelte"
+  | "svelte-ts"
+  | "solid"
+  | "solid-ts"
+  | "qwik"
+  | "qwik-ts";
+
+export interface ViteProjectProps {
+  /**
+   * The name/path of the project
+   */
+  name: string;
+  /**
+   * The Vite template to use
+   */
+  template: ViteTemplate;
+  /**
+   * The extends to add to the tsconfig.json file
+   */
+  extends?: string;
+  /**
+   * The references to add to the tsconfig.json file
+   */
+  references?: string[];
+  /**
+   * @default false
+   */
+  tailwind?: boolean;
+  /**
+   * Force overwrite the project config tfiles during the update phase
+   *
+   * @default false
+   */
+  overwrite?: boolean;
+}
+
+export interface ViteProject extends ViteProjectProps, Resource {
+  /**
+   * The name/path of the project
+   */
+  name: string;
+}
+
+export const ViteProject = Resource(
+  "project::ViteProject",
+  async function (
+    this: Context<ViteProject>,
+    id: string,
+    props: ViteProjectProps,
+  ): Promise<ViteProject> {
+    if (this.phase === "delete") {
+      try {
+        if (await fs.exists(props.name)) {
+          // TODO: OS agnostic - fs.rm is slow to delete node_modules/
+          await execAsync("rm -rf " + props.name);
+        }
+      } catch (error) {
+        console.error(`Error deleting project ${id}:`, error);
+      }
+      return this.destroy();
+    }
+
+    if (this.phase === "update") {
+      if (props.overwrite) {
+        await modifyConfig(props);
+      } else {
+        console.warn(
+          "ViteProject does not support updates - the project must be recreated to change the template",
+        );
+      }
+    } else {
+      // Create phase
+      await execAsync(`bun create vite ${id} --template ${props.template}`);
+
+      await modifyConfig(props);
+    }
+
+    return this(props);
+  },
+);
+
+async function modifyConfig(props: ViteProjectProps) {
+  if (props.tailwind) {
+    await execAsync(`bun add tailwindcss @tailwindcss/vite`);
+
+    await fs.writeFile(
+      path.join(props.name, "vite.config.ts"),
+      `import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+});`,
+    );
+
+    // Add Tailwind CSS import to index.css
+    const indexCssPath = path.join(props.name, "src", "index.css");
+    const currentCss = await fs.readFile(indexCssPath, "utf-8");
+    if (!currentCss.includes('@import "tailwindcss";')) {
+      await fs.writeFile(
+        indexCssPath,
+        '@import "tailwindcss";\n\n' + currentCss,
+      );
+    }
+  }
+
+  await Promise.all([
+    rm(path.join(props.name, "tsconfig.app.json")),
+    rm(path.join(props.name, "tsconfig.node.json")),
+    fs.writeFile(
+      path.join(props.name, "tsconfig.json"),
+      JSON.stringify(
+        {
+          extends: props.extends,
+          compilerOptions: {
+            types: ["@cloudflare/workers-types"],
+            allowImportingTsExtensions: true,
+            jsx: "react-jsx",
+          },
+          include: ["vite/*.ts", "src/**/*.ts", "src/**/*.tsx", "src/env.d.ts"],
+          references: props.references?.map((path) => ({ path })),
+        },
+        null,
+        2,
+      ),
+    ),
+  ]);
+}