alchemy 0.1.18 → 0.2.1

package/lib/{esbuild.d.ts → esbuild/bundle.d.ts}

@@ -1,4 +1,6 @@
 import * as esbuild from "esbuild";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 export interface BundleProps {
     /**
      * Entry point for the bundle
@@ -41,7 +43,7 @@ export interface BundleProps {
      */
     options?: Partial<esbuild.BuildOptions>;
 }
-export interface BundleOutput {
+export interface Bundle extends Resource<"esbuild::Bundle"> {
     /**
      * Path to the bundled file
      */
@@ -51,21 +53,7 @@ export interface BundleOutput {
      */
     hash: string;
 }
-declare const Bundle_base: import("./resource").Provider<string, [props: BundleProps], BundleOutput>;
-export declare class Bundle extends Bundle_base {
-    /**
-     * Get the metafile from the last build
-     */
-    getMetafile(ctx: {
-        get<T>(key: string): Promise<T | undefined>;
-    }): Promise<esbuild.Metafile | undefined>;
-    /**
-     * Get the hash from the last build
-     */
-    getHash(ctx: {
-        get<T>(key: string): Promise<T | undefined>;
-    }): Promise<string | undefined>;
-}
+export declare const Bundle: ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>) | (((this: any, id: string, props: BundleProps) => never) & (new (_: never) => never));
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
     bundle: boolean;
     splitting?: boolean;
@@ -148,5 +136,3 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     logOverride?: Record<string, esbuild.LogLevel>;
     tsconfigRaw?: string | esbuild.TsconfigRaw;
 }>>;
-export {};
-//# sourceMappingURL=esbuild.d.ts.map

package/lib/{esbuild.js → esbuild/bundle.js}

@@ -2,46 +2,33 @@ import * as esbuild from "esbuild";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { Resource } from "./resource";
-export class Bundle extends Resource("esbuild::Bundle", {
+import { Resource } from "../resource";
+export const Bundle = Resource("esbuild::Bundle", {
     alwaysUpdate: true,
-}, async (ctx, props) => {
+}, async function (id, props) {
     // 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);
     // Calculate hash of the output
     const contents = await fs.promises.readFile(outputPath);
     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
-     */
-    async getMetafile(ctx) {
-        return ctx.get("metafile");
-    }
-    /**
-     * Get the hash from the last build
-     */
-    async getHash(ctx) {
-        return ctx.get("hash");
-    }
-}
+    });
+});
 export async function bundle(props) {
     const outputPath = getOutputPath(props);
     // Build the bundle
@@ -64,4 +51,3 @@ function getOutputPath(props) {
     return (props.outfile ||
         path.join(props.outdir || "dist", path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js"));
 }
-//# sourceMappingURL=esbuild.js.map

package/lib/esbuild/index.d.ts

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

package/lib/esbuild/index.js

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

package/lib/fs/file.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+export interface File extends Resource<"fs::File"> {
+    path: string;
+    content: string;
+}
+export declare const File: ((this: Context<File>, id: string, { path: filePath, content, }: {
+    path: string;
+    content: string;
+}) => Promise<File>) | (((this: any, id: string, props: {
+    path: string;
+    content: string;
+}) => never) & (new (_: never) => never));

package/lib/fs/file.js

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
+export const File = Resource("fs::File", async function (id, { path: filePath, content, }) {
+    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/lib/fs/folder.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+export interface Folder extends Resource<"fs::Folder"> {
+    path: string;
+}
+export declare const Folder: ((this: Context<Folder>, id: string, { path: dirPath }: {
+    path: string;
+}) => Promise<Folder>) | (((this: any, id: string, props: {
+    path: string;
+}) => never) & (new (_: never) => never));

package/lib/fs/folder.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
+export const Folder = Resource("fs::Folder", async function (id, { path: dirPath }) {
+    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/lib/fs/index.d.ts

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

package/lib/fs/index.js

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

package/lib/github/client.d.ts

@@ -31,4 +31,3 @@ export declare function createGitHubClient(options?: {
  * @param repo Repository name
  */
 export declare function verifyGitHubAuth(octokit: Octokit, owner: string, repo: string): Promise<void>;
-//# sourceMappingURL=client.d.ts.map

package/lib/github/client.js

@@ -88,4 +88,3 @@ export async function verifyGitHubAuth(octokit, owner, repo) {
         }
     }
 }
-//# sourceMappingURL=client.js.map

package/lib/github/index.d.ts

@@ -1,2 +1 @@
 export * from "./secret";
-//# sourceMappingURL=index.d.ts.map

package/lib/github/index.js

@@ -1,2 +1 @@
 export * from "./secret";
-//# sourceMappingURL=index.js.map

package/lib/github/secret.d.ts

@@ -1,3 +1,5 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
 import type { Secret } from "../secret";
 /**
  * Properties for creating or updating a GitHub Secret
@@ -27,7 +29,7 @@ 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
      */
@@ -37,11 +39,7 @@ export interface GitHubSecretOutput extends Omit<GitHubSecretProps, "value"> {
      */
     updatedAt: string;
 }
-declare const GitHubSecret_base: import("../resource").Provider<"github::Secret", [props: GitHubSecretProps], GitHubSecretOutput>;
 /**
  * Resource for managing GitHub repository secrets
  */
-export declare class GitHubSecret extends GitHubSecret_base {
-}
-export {};
-//# sourceMappingURL=secret.d.ts.map
+export declare const GitHubSecret: ((this: Context<GitHubSecretOutput>, id: string, props: GitHubSecretProps) => Promise<GitHubSecretOutput>) | (((this: any, id: string, props: GitHubSecretProps) => never) & (new (_: never) => never));

package/lib/github/secret.js

@@ -4,15 +4,16 @@ import { createGitHubClient, verifyGitHubAuth } from "./client";
 /**
  * Resource for managing GitHub repository secrets
  */
-export class GitHubSecret extends Resource("github::Secret", async (ctx, props) => {
+export const GitHubSecret = Resource("github::Secret", async function (id, props) {
     // 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({
@@ -32,7 +33,7 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
             }
         }
         // Return void (a deleted resource has no content)
-        return undefined;
+        return this.destroy();
     }
     else {
         try {
@@ -44,7 +45,7 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
             // Encrypt the secret value using libsodium
             const encryptedValue = await encryptString(props.value.unencrypted, publicKey.key);
             // 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,
@@ -52,15 +53,14 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
                 key_id: publicKey.key_id,
             });
             // GitHub doesn't return the secret details on create/update, so we need to construct it
-            const output = {
+            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) {
             if (error.status === 403 &&
@@ -74,8 +74,7 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
             throw error;
         }
     }
-}) {
-}
+});
 /**
  * Encrypt a value for GitHub using libsodium
  * Based on GitHub's documentation for encrypting secrets
@@ -96,4 +95,3 @@ async function encryptString(value, publicKey) {
     // Convert the encrypted message to base64
     return sodium.to_base64(encryptedBin, sodium.base64_variants.ORIGINAL);
 }
-//# sourceMappingURL=secret.js.map

package/lib/index.d.ts

@@ -1,11 +1,7 @@
-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";
-//# sourceMappingURL=index.d.ts.map
+export * from "./state";
+export * from "./util/ignore";
+import { alchemy } from "./alchemy";
+export default alchemy;

package/lib/index.js

@@ -1,10 +1,6 @@
-export * from "./$";
-export * from "./alchemize";
-export * from "./error";
-export * from "./global";
-export * from "./input";
-export * from "./output";
-export * from "./print";
-export { Resource, } from "./resource";
+export * from "./resource";
 export * from "./secret";
-//# sourceMappingURL=index.js.map
+export * from "./state";
+export * from "./util/ignore";
+import { alchemy } from "./alchemy";
+export default alchemy;

package/lib/project/index.d.ts

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

package/lib/project/index.js

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

package/lib/project/vite.d.ts

@@ -0,0 +1,39 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+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 declare const ViteProject: ((this: Context<ViteProject>, id: string, props: ViteProjectProps) => Promise<ViteProject>) | (((this: any, id: string, props: ViteProjectProps) => never) & (new (_: never) => never));
+export {};

package/lib/project/vite.js

@@ -0,0 +1,68 @@
+import { exec } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import { Resource } from "../resource";
+import { rm } from "../util/rm";
+const execAsync = promisify(exec);
+export const ViteProject = Resource("project::ViteProject", async function (id, props) {
+    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) {
+    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)),
+    ]);
+}

package/lib/resource.d.ts

@@ -1,71 +1,43 @@
-import { type ApplyOptions } from "./apply";
-import type { DestroyOptions } from "./destroy";
-import type { Inputs, Input as input } from "./input";
-import { type Export, type Output, type Resolved } from "./output";
-import { type Scope as IScope } from "./scope";
-import type { State, StateStore } from "./state";
+import type { Context } from "./context";
+import { Scope as _Scope } from "./scope";
+export declare const PROVIDERS: Map<string, any>;
 export type ResourceID = string;
 export type ResourceFQN = string;
-export type ResourceType = string;
-export declare const ResourceID: unique symbol;
-export declare const ResourceFQN: unique symbol;
-export declare const ResourceHandle: unique symbol;
-export declare const Provider: unique symbol;
-export declare const Input: unique symbol;
-export declare const Value: unique symbol;
-export declare const Apply: unique symbol;
-export declare const Provide: unique symbol;
-export declare const Scope: unique symbol;
-export declare const Options: unique symbol;
+export type ResourceKind = string;
 export interface ProviderOptions {
     /**
      * If true, the resource will be updated even if the inputs have not changed.
      */
     alwaysUpdate: boolean;
 }
-export type Resource<In extends any[] = any[], Out = any> = {
-    [ResourceID]: string;
-    [Provider]: Provider<any, any[], any>;
-    [Input]: Inputs<In>;
-    [Value]?: Out;
-    [Apply]: <O>(value: Out) => O;
-    [Provide]: (value: Out) => void;
-    [Options]: ProviderOptions;
-} & Output<Out> & Export<Resolved<Out>>;
-export interface BaseContext {
-    quiet: boolean;
-    stage: string;
-    resourceID: ResourceID;
-    resourceFQN: ResourceFQN;
-    scope: IScope;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T): Promise<void>;
-    delete<T>(key: string): Promise<T | undefined>;
-    /**
-     * Indicate that this resource is being replaced.
-     * This will cause the resource to be deleted at the end of the stack's CREATE phase.
-     */
-    replace(): void;
-}
-export interface CreateContext extends BaseContext {
-    event: "create";
-    output?: undefined;
-}
-export interface UpdateContext<Outputs> extends BaseContext {
-    event: "update";
-    output: Outputs;
-}
-export interface DeleteContext<Outputs> extends BaseContext {
-    event: "delete";
-    output: Outputs;
-}
-export type Context<Outputs> = CreateContext | UpdateContext<Outputs> | DeleteContext<Outputs>;
-export type Provider<Type extends ResourceType = ResourceType, In extends any[] = any[], Out = any> = {
+export type ResourceProps = {
+    [key: string]: any;
+};
+export type Provider<Type extends string = string, F extends ResourceLifecycleHandler = ResourceLifecycleHandler> = F & IsClass & {
     type: Type;
-    update(stage: string, resource: Resource, deps: Set<ResourceID>, inputs: Inputs<In>, stateStore: StateStore, options: ApplyOptions): Promise<Awaited<Out>>;
-    delete(stage: string, scope: IScope | undefined, resourceID: ResourceID, state: State, inputs: Inputs<In>, options: DestroyOptions): Promise<void>;
-} & (new (id: string, ...inputs: [...Inputs<In>, ...any[]]) => Resource<In, Out>);
-export declare function isResource(value: any): value is Resource;
-export declare function Resource<Args extends any[], Out>(type: string, options: Partial<ProviderOptions>, func: (ctx: Context<Out>, ...args: Args) => Promise<input<Out> | void> | input<Out> | void): Provider<string, Args, Awaited<Out>>;
-export declare function Resource<const Type extends ResourceType, Args extends any[], Out>(type: Type, func: (ctx: Context<Out>, ...args: Args) => Promise<input<Out> | void> | input<Out> | void): Provider<Type, Args, Awaited<Out>>;
-//# sourceMappingURL=resource.d.ts.map
+    options: Partial<ProviderOptions> | undefined;
+    handler: F;
+};
+export type PendingResource<Out = unknown, Kind extends ResourceKind = ResourceKind, ID extends ResourceID = ResourceID, FQN extends ResourceFQN = ResourceFQN, Scope extends _Scope = _Scope, Seq extends number = number> = Promise<Out> & {
+    Kind: Kind;
+    ID: ID;
+    FQN: FQN;
+    Seq: Seq;
+    Scope: Scope;
+    signal: () => void;
+};
+export interface Resource<Kind extends ResourceKind = ResourceKind, ID extends ResourceID = ResourceID, FQN extends ResourceFQN = ResourceFQN, Scope extends _Scope = _Scope, Seq extends number = number> {
+    Kind: Kind;
+    ID: ID;
+    FQN: FQN;
+    Scope: Scope;
+    Seq: Seq;
+}
+type IsClass = {
+    new (_: never): never;
+};
+type ResourceLifecycleHandler = (this: Context<any>, id: string, props: any) => Promise<Resource<string>>;
+type Handler<F extends (...args: any[]) => any> = F | (((this: any, id: string, props: Parameters<F>[1]) => never) & IsClass);
+export declare function Resource<const Type extends string, F extends ResourceLifecycleHandler>(type: Type, fn: F): Handler<F>;
+export declare function Resource<const Type extends string, F extends ResourceLifecycleHandler>(type: Type, options: Partial<ProviderOptions>, fn: F): Handler<F>;
+export {};