alchemy 0.2.0 → 0.2.2

package/lib/scope.d.ts

@@ -20,11 +20,13 @@ export declare class Scope {
     readonly password: string | undefined;
     readonly state: StateStore;
     readonly quiet: boolean;
+    private isErrored;
     constructor(options: ScopeOptions);
     delete(resourceID: ResourceID): Promise<void>;
     private _seq;
     seq(): number;
     get chain(): string[];
+    fail(): void;
     enter(): void;
     init(): Promise<void>;
     deinit(): Promise<void>;

package/lib/scope.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { destroy } from "./destroy";
 import { FileSystemStateStore, } from "./state";
 const scopeStorage = new AsyncLocalStorage();
 export class Scope {
@@ -20,6 +21,7 @@ export class Scope {
     password;
     state;
     quiet;
+    isErrored = false;
     constructor(options) {
         this.appName = options.appName;
         this.stage = options.stage;
@@ -50,6 +52,10 @@ export class Scope {
             return [...app, this.stage, ...thisScope];
         }
     }
+    fail() {
+        console.error("Scope failed", this.chain.join("/"));
+        this.isErrored = true;
+    }
     enter() {
         scopeStorage.enterWith(this);
     }
@@ -63,7 +69,20 @@ export class Scope {
         return [...this.chain, resourceID].join("/");
     }
     async finalize() {
-        // TODO
+        if (!this.isErrored) {
+            // TODO: need to detect if it is in error
+            const resourceIds = await this.state.list();
+            const aliveIds = new Set(this.resources.keys());
+            const orphanIds = Array.from(resourceIds.filter((id) => !aliveIds.has(id)));
+            const orphans = await Promise.all(orphanIds.map(async (id) => (await this.state.get(id)).output));
+            await destroy.all(orphans, {
+                quiet: this.quiet,
+                strategy: "sequential",
+            });
+        }
+        else {
+            console.warn("Scope is in error, skipping finalize");
+        }
     }
     async run(fn) {
         return scopeStorage.run(this, () => fn(this));

package/lib/shadcn/component.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+export interface ShadcnComponentProps {
+    /**
+     * The name of the component to install
+     */
+    name: string;
+    /**
+     * The working directory where the component should be installed
+     */
+    cwd: string;
+    /**
+     * Force overwrite of existing component
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * Mute output
+     * @default false
+     */
+    silent?: boolean;
+}
+export interface ShadcnComponent extends ShadcnComponentProps, Resource {
+    /**
+     * The name of the installed component
+     */
+    name: string;
+}
+export declare const ShadcnComponent: ((this: Context<ShadcnComponent>, id: string, props: ShadcnComponentProps) => Promise<ShadcnComponent>) | (((this: any, id: string, props: ShadcnComponentProps) => never) & (new (_: never) => never));

package/lib/shadcn/component.js

@@ -0,0 +1,31 @@
+import { exec } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import { Resource } from "../resource";
+const execAsync = promisify(exec);
+export const ShadcnComponent = Resource("project::ShadcnComponent", async function (id, props) {
+    if (this.phase === "delete") {
+        const componentPath = path.join(props.cwd, "src", "components", "ui", `${props.name}.tsx`);
+        try {
+            await fs.unlink(componentPath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        return this.destroy();
+    }
+    // Build the shadcn add command with options
+    const addCommand = [
+        "bunx --bun shadcn@latest add",
+        props.name,
+        props.silent && "-s",
+    ]
+        .filter(Boolean)
+        .join(" ");
+    // Execute the command in the specified directory
+    await execAsync(addCommand, { cwd: props.cwd });
+    return this(props);
+});

package/lib/shadcn/index.d.ts

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

package/lib/shadcn/index.js

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

package/lib/state.js

@@ -39,7 +39,12 @@ export class FileSystemStateStore {
     async get(key) {
         try {
             const content = await fs.promises.readFile(await this.getPath(key), "utf8");
-            return (await deserialize(this.scope, JSON.parse(content)));
+            const state = (await deserialize(this.scope, JSON.parse(content)));
+            if (state.output === undefined) {
+                state.output = {};
+            }
+            state.output.Scope = this.scope;
+            return state;
         }
         catch (error) {
             if (error.code === "ENOENT") {

package/lib/util/rm.d.ts

@@ -0,0 +1 @@
+export declare function rm(path: string): Promise<void>;

package/lib/util/rm.js

@@ -0,0 +1,11 @@
+import fs from "fs/promises";
+export async function rm(path) {
+    try {
+        await fs.rm(path, { recursive: true, force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}

package/lib/vite/index.d.ts

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

package/lib/vite/index.js

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

package/lib/vite/vite.d.ts

@@ -0,0 +1,90 @@
+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[];
+    /**
+     * Add Tailwind CSS to the project
+     * @default false
+     */
+    tailwind?: boolean;
+    /**
+     * Add Tanstack Router to the project
+     * @default false
+     */
+    tanstack?: boolean;
+    /**
+     * Add Shadcn UI to the project
+     * @default false
+     */
+    shadcn?: {
+        /**
+         * The base color to use
+         * @default "neutral"
+         */
+        baseColor?: "neutral" | "gray" | "zinc" | "stone" | "slate";
+        /**
+         * Use default configuration
+         * @default false
+         */
+        defaults?: boolean;
+        /**
+         * Force overwrite of existing configuration
+         * @default false
+         */
+        force?: boolean;
+        /**
+         * The working directory
+         * @default current directory
+         */
+        cwd?: string;
+        /**
+         * Mute output
+         * @default false
+         */
+        silent?: boolean;
+        /**
+         * Use the src directory when creating a new project
+         * @default false
+         */
+        srcDir?: boolean;
+        /**
+         * Use css variables for theming
+         * @default true
+         */
+        cssVariables?: boolean;
+        /**
+         * The components to add
+         */
+        components?: string[];
+    };
+    /**
+     * Force overwrite the project config files 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/vite/vite.js

@@ -0,0 +1,228 @@
+import { exec } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+import { Resource } from "../resource";
+import { ShadcnComponent } from "../shadcn/component";
+import { rm } from "../util/rm";
+const execAsync = promisify(exec);
+export const ViteProject = Resource("project::ViteProject", {
+    alwaysUpdate: true,
+}, async function (id, props) {
+    const phase = this.phase;
+    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 {
+        await execAsync(`bun create vite ${id} --template ${props.template}`);
+        await modifyConfig(props);
+    }
+    return this(props);
+    async function modifyConfig(props) {
+        const tailwind = props.tailwind ?? false;
+        const tanstack = props.tanstack ?? false;
+        const plugins = [
+            tailwind && "tailwindcss()",
+            tanstack &&
+                "TanStackRouterVite({ target: 'react', autoCodeSplitting: true })",
+            "react()",
+        ].filter((s) => typeof s === "string");
+        const cwd = path.resolve(process.cwd(), props.name);
+        const exec = (command) => execAsync(command, { cwd });
+        if (phase === "create" || props.overwrite) {
+            await removeUnnecessaryFiles();
+        }
+        await patchTsConfig();
+        if (props.tailwind) {
+            await installTailwind();
+        }
+        if (props.tanstack) {
+            await installTanstack();
+        }
+        if (props.shadcn !== undefined) {
+            await installShadcn();
+        }
+        await build();
+        async function build() {
+            // tsc -b will fail if we have not invoked tan stacks' code gen
+            await execAsync(`bun vite build`, { cwd: props.name });
+        }
+        async function installTailwind() {
+            await exec(`bun add tailwindcss @tailwindcss/vite`);
+            await fs.writeFile(path.join(props.name, "vite.config.ts"), `import path from "path";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+${tailwind ? "import tailwindcss from '@tailwindcss/vite';" : ""}
+${tanstack ? 'import { TanStackRouterVite } from "@tanstack/router-plugin/vite";' : ""}
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [${plugins.join(", ")}],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});`);
+            // 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);
+            }
+        }
+        async function installShadcn() {
+            await exec("bun add -D @types/node");
+            // Build the shadcn init command with all options
+            const shadcnOptions = props.shadcn;
+            const initCommand = [
+                "bunx --bun shadcn@latest init",
+                shadcnOptions?.baseColor && `-b ${shadcnOptions.baseColor}`,
+                shadcnOptions?.defaults && "-d",
+                shadcnOptions?.force && "-f",
+                shadcnOptions?.cwd && `-c ${shadcnOptions.cwd}`,
+                shadcnOptions?.silent && "-s",
+                shadcnOptions?.srcDir && "--src-dir",
+                shadcnOptions?.cssVariables === false && "--no-css-variables",
+            ]
+                .filter(Boolean)
+                .join(" ");
+            await exec(initCommand);
+            // Install requested components using the ShadcnComponent resource
+            for (const componentName of props.shadcn?.components ?? []) {
+                await ShadcnComponent(`shadcn-component-${componentName}`, {
+                    name: componentName,
+                    cwd: props.name,
+                    force: props.shadcn?.force,
+                    silent: props.shadcn?.silent,
+                });
+            }
+        }
+        async function installTanstack() {
+            await exec(`bun add @tanstack/react-router`);
+            await exec(`bun add -D @tanstack/router-plugin @tanstack/react-router-devtools`);
+            const src = path.join(props.name, "src");
+            const routes = path.join(src, "routes");
+            await fs.mkdir(routes, { recursive: true });
+            await fs.writeFile(path.join(routes, "__root.tsx"), `import { Link, Outlet, createRootRoute } from "@tanstack/react-router";
+import { TanStackRouterDevtools } from "@tanstack/react-router-devtools";
+
+export const Route = createRootRoute({
+  component: () => (
+    <div className="w-full min-h-screen flex flex-col">
+      <div className="p-2 flex gap-2">
+        <Link to="/" className="[&.active]:font-bold">
+          Home
+        </Link>{" "}
+        <Link to="/about" className="[&.active]:font-bold">
+          About
+        </Link>
+      </div>
+      <hr />
+      <Outlet />
+      <TanStackRouterDevtools />
+    </div>
+  ),
+});
+`);
+            await fs.writeFile(path.join(routes, "index.tsx"), `import { createLazyFileRoute } from '@tanstack/react-router'
+
+export const Route = createLazyFileRoute('/')({
+  component: Index,
+})
+
+function Index() {
+  return (
+    <div className="p-2">
+      <h3>Welcome Home!</h3>
+    </div>
+  )
+}`);
+            await fs.writeFile(path.join(routes, "about.tsx"), `import { createLazyFileRoute } from '@tanstack/react-router'
+
+export const Route = createLazyFileRoute('/about')({
+  component: About,
+})
+
+function About() {
+  return <div className="p-2">Hello from About!</div>
+}`);
+            await fs.writeFile(path.join(src, "main.tsx"), `import { StrictMode } from 'react'
+import ReactDOM from 'react-dom/client'
+import { RouterProvider, createRouter } from '@tanstack/react-router'
+import './index.css'
+
+// Import the generated route tree
+import { routeTree } from './routeTree.gen'
+
+// Create a new router instance
+const router = createRouter({ routeTree })
+
+// Register the router instance for type safety
+declare module '@tanstack/react-router' {
+  interface Register {
+    router: typeof router
+  }
+}
+
+// Render the app
+const rootElement = document.getElementById('root')!
+if (!rootElement.innerHTML) {
+  const root = ReactDOM.createRoot(rootElement)
+  root.render(
+    <StrictMode>
+      <RouterProvider router={router} />
+    </StrictMode>,
+  )
+}`);
+        }
+        async function removeUnnecessaryFiles() {
+            await Promise.all([
+                rm(path.join(props.name, "src", "App.tsx")),
+                rm(path.join(props.name, "src", "App.css")),
+            ]);
+        }
+        async function patchTsConfig() {
+            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: {
+                        baseUrl: ".",
+                        paths: {
+                            "@/*": ["./src/*"],
+                        },
+                        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/package.json

@@ -1,10 +1,10 @@
 {
   "name": "alchemy",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {
-    "publish:npm": "rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish"
+    "publish:npm": "cp ../README.md . && rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish && rm README.md"
   },
   "files": ["lib", "src"],
   "exports": {
@@ -15,8 +15,10 @@
     "./esbuild": "./lib/esbuild/index.js",
     "./fs": "./lib/fs/index.js",
     "./github": "./lib/github/index.js",
+    "./shadcn": "./lib/shadcn/index.js",
     "./stripe": "./lib/stripe/index.js",
-    "./test/bun": "./lib/test/bun.js"
+    "./test/bun": "./lib/test/bun.js",
+    "./vite": "./lib/vite/index.js"
   },
   "peerDependencies": {
     "@ai-sdk/openai": "^1.1.9",

package/src/alchemy.ts

@@ -1,4 +1,4 @@
-import { destroy } from "./destroy";
+import { DestroyedSignal, destroy } from "./destroy";
 import { Scope } from "./scope";
 import { secret } from "./secret";
 import type { StateStoreType } from "./state";
@@ -116,5 +116,12 @@ async function run<T>(
           (this: Scope, scope: Scope) => Promise<T>,
         ]);
   await using scope = alchemy.scope(id, options);
-  return await fn.bind(scope)(scope);
+  try {
+    return await fn.bind(scope)(scope);
+  } catch (error) {
+    if (!(error instanceof DestroyedSignal)) {
+      scope.fail();
+    }
+    throw error;
+  }
 }