alchemy 0.2.1 → 0.2.3

package/lib/fs/file.d.ts

@@ -1,13 +1,40 @@
 import type { Context } from "../context";
 import { Resource } from "../resource";
+declare module "../alchemy" {
+    interface Alchemy {
+        file(path: string): Promise<FileRef>;
+        files(paths: string[]): Promise<FileCollection>;
+        files(path: string, ...paths: string[]): Promise<FileCollection>;
+    }
+}
+export type FileRef = {
+    kind: "fs::FileRef";
+    path: string;
+};
+export declare function isFileRef(value: unknown): value is FileRef;
+export type FileCollection = {
+    type: "fs::FileCollection";
+    files: {
+        [relativePath: string]: string;
+    };
+};
+export declare function isFileCollection(value: unknown): value is FileCollection;
 export interface File extends Resource<"fs::File"> {
     path: string;
     content: string;
 }
-export declare const File: ((this: Context<File>, id: string, { path: filePath, content, }: {
+export declare const File: ((this: Context<File>, id: string, props: {
     path: string;
     content: string;
-}) => Promise<File>) | (((this: any, id: string, props: {
+}) => Promise<File>) | (((this: any, id: string, props?: {
     path: string;
     content: string;
-}) => never) & (new (_: never) => never));
+} | undefined) => never) & (new (_: never) => never));
+export type JsonFile = File;
+export declare function JsonFile(id: string, content: any): Promise<JsonFile>;
+export type TextFile = File;
+export declare function TextFile(id: string, content: string): Promise<TextFile>;
+export type YamlFile = File;
+export declare function YamlFile(id: string, content: any): Promise<YamlFile>;
+export type TypeScriptFile = File;
+export declare function TypeScriptFile(id: string, content: string): Promise<TypeScriptFile>;

package/lib/fs/file.js

@@ -2,7 +2,35 @@ 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, }) {
+import { alchemy } from "../alchemy";
+export function isFileRef(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "kind" in value &&
+        value.kind === "fs::FileRef");
+}
+export function isFileCollection(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        value.type === "fs::FileCollection");
+}
+alchemy.file = async (path) => ({
+    kind: "fs::FileRef",
+    path,
+});
+alchemy.files = async (...args) => {
+    const paths = typeof args[0] === "string" ? args : args[0];
+    return {
+        type: "fs::FileCollection",
+        files: Object.fromEntries(await Promise.all(paths.map(async (path) => [
+            path,
+            await fs.promises.readFile(path, "utf-8"),
+        ]))),
+    };
+};
+export const File = Resource("fs::File", async function (id, props) {
+    const filePath = props?.path ?? id;
     if (this.phase === "delete") {
         await ignore("ENOENT", async () => fs.promises.unlink(filePath));
         return this.destroy();
@@ -11,10 +39,42 @@ export const File = Resource("fs::File", async function (id, { path: filePath, c
         await fs.promises.mkdir(path.dirname(filePath), {
             recursive: true,
         });
-        await fs.promises.writeFile(filePath, content);
+        await fs.promises.writeFile(filePath, props.content);
     }
     return this({
         path: filePath,
-        content,
+        content: props.content,
     });
 });
+export function JsonFile(id, content) {
+    return File(id, {
+        path: id,
+        content: JSON.stringify(content, null, 2),
+    });
+}
+export function TextFile(id, content) {
+    return File(id, {
+        path: id,
+        content,
+    });
+}
+export async function YamlFile(id, content) {
+    const yaml = await import("yaml");
+    return File(id, {
+        path: id,
+        content: yaml.stringify(content),
+    });
+}
+export async function TypeScriptFile(id, content) {
+    const prettier = await import("prettier");
+    return File(id, {
+        path: id,
+        content: await prettier.format(content, {
+            parser: "typescript",
+            editor: {
+                tabWidth: 2,
+                indentWidth: 2,
+            },
+        }),
+    });
+}

package/lib/fs/folder.d.ts

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

package/lib/fs/folder.js

@@ -1,7 +1,8 @@
 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 }) {
+export const Folder = Resource("fs::Folder", async function (id, props) {
+    const dirPath = props?.path ?? id;
     if (this.phase === "delete") {
         // we just do a best effort attempt
         await ignore(["ENOENT", "ENOTEMPTY"], async () => fs.promises.rmdir(dirPath));

package/lib/github/secret.d.ts

@@ -42,4 +42,4 @@ export interface GitHubSecretOutput extends Resource<"github::Secret">, Omit<Git
 /**
  * Resource for managing GitHub repository secrets
  */
-export declare const GitHubSecret: ((this: Context<GitHubSecretOutput>, id: string, props: GitHubSecretProps) => Promise<GitHubSecretOutput>) | (((this: any, id: string, props: GitHubSecretProps) => never) & (new (_: never) => never));
+export declare const GitHubSecret: ((this: Context<GitHubSecretOutput>, id: string, props: GitHubSecretProps) => Promise<GitHubSecretOutput>) | (((this: any, id: string, props?: GitHubSecretProps | undefined) => never) & (new (_: never) => never));

package/lib/resource.d.ts

@@ -36,8 +36,8 @@ export interface Resource<Kind extends ResourceKind = ResourceKind, ID extends R
 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);
+type ResourceLifecycleHandler = (this: Context<any, 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 {};

package/lib/resource.js

@@ -8,6 +8,10 @@ export function Resource(type, ...args) {
     const [options, handler] = args.length === 2 ? args : [undefined, args[0]];
     const provider = ((resourceID, props) => {
         const scope = _Scope.current;
+        if (resourceID.includes(":")) {
+            // we want to use : as an internal separator for resources
+            throw new Error(`ID cannot include colons: ${resourceID}`);
+        }
         if (scope.resources.has(resourceID)) {
             // TODO(sam): do we want to throw?
             // it's kind of awesome that you can re-create a resource and call apply

package/lib/scope.d.ts

@@ -31,9 +31,9 @@ export declare class Scope {
     init(): Promise<void>;
     deinit(): Promise<void>;
     fqn(resourceID: ResourceID): string;
-    finalize(): Promise<void>;
     run<T>(fn: (scope: Scope) => Promise<T>): Promise<T>;
     [Symbol.asyncDispose](): Promise<void>;
+    finalize(): Promise<void>;
     /**
      * Returns a string representation of the scope.
      */

package/lib/scope.js

@@ -68,6 +68,12 @@ export class Scope {
     fqn(resourceID) {
         return [...this.chain, resourceID].join("/");
     }
+    async run(fn) {
+        return scopeStorage.run(this, () => fn(this));
+    }
+    [Symbol.asyncDispose]() {
+        return this.finalize();
+    }
     async finalize() {
         if (!this.isErrored) {
             // TODO: need to detect if it is in error
@@ -84,12 +90,6 @@ export class Scope {
             console.warn("Scope is in error, skipping finalize");
         }
     }
-    async run(fn) {
-        return scopeStorage.run(this, () => fn(this));
-    }
-    [Symbol.asyncDispose]() {
-        return this.finalize();
-    }
     /**
      * Returns a string representation of the scope.
      */

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 | undefined) => 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.d.ts

@@ -1,6 +1,6 @@
 import type { Resource, ResourceProps } from "./resource";
 import type { Scope } from "./scope";
-export interface State<Kind extends string = string, Props extends ResourceProps = ResourceProps, Out extends Resource = Resource> {
+export interface State<Kind extends string = string, Props extends ResourceProps | undefined = ResourceProps | undefined, Out extends Resource = Resource> {
     status: `creating` | `created` | `updating` | `updated` | `deleting` | `deleted`;
     kind: Kind;
     id: string;

package/lib/state.js

@@ -27,7 +27,8 @@ export class FileSystemStateStore {
             });
             return files
                 .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".json"))
-                .map((dirent) => dirent.name.replace(/\.json$/, ""));
+                .map((dirent) => dirent.name.replace(/\.json$/, ""))
+                .map((key) => key.replaceAll(":", "/"));
         }
         catch (error) {
             if (error.code === "ENOENT") {
@@ -72,6 +73,12 @@ export class FileSystemStateStore {
         }))).flat());
     }
     async getPath(key) {
+        if (key.includes(":")) {
+            throw new Error(`ID cannot include colons: ${key}`);
+        }
+        if (key.includes("/")) {
+            key = key.replaceAll("/", ":");
+        }
         const file = path.join(this.dir, `${key}.json`);
         const dir = path.dirname(file);
         await fs.promises.mkdir(dir, { recursive: true });

package/lib/stripe/price.d.ts

@@ -104,5 +104,5 @@ export interface Price extends Resource<"stripe::Price">, PriceProps {
      */
     lookupKey?: string;
 }
-export declare const Price: ((this: Context<Price>, id: string, props: PriceProps) => Promise<Price>) | (((this: any, id: string, props: PriceProps) => never) & (new (_: never) => never));
+export declare const Price: ((this: Context<Price>, id: string, props: PriceProps) => Promise<Price>) | (((this: any, id: string, props?: PriceProps | undefined) => never) & (new (_: never) => never));
 export {};

package/lib/stripe/product.d.ts

@@ -81,5 +81,5 @@ export interface Product extends Resource<"stripe::Product">, ProductProps {
         width: number;
     };
 }
-export declare const Product: ((this: Context<Product>, id: string, props: ProductProps) => Promise<Product>) | (((this: any, id: string, props: ProductProps) => never) & (new (_: never) => never));
+export declare const Product: ((this: Context<Product>, id: string, props: ProductProps) => Promise<Product>) | (((this: any, id: string, props?: ProductProps | undefined) => never) & (new (_: never) => never));
 export {};

package/lib/stripe/webhook.d.ts

@@ -68,4 +68,4 @@ export interface WebhookEndpoint extends Resource<"stripe::WebhookEndpoint">, We
      */
     status: string;
 }
-export declare const WebhookEndpoint: ((this: Context<WebhookEndpoint>, id: string, props: WebhookEndpointProps) => Promise<WebhookEndpoint>) | (((this: any, id: string, props: WebhookEndpointProps) => never) & (new (_: never) => never));
+export declare const WebhookEndpoint: ((this: Context<WebhookEndpoint>, id: string, props: WebhookEndpointProps) => Promise<WebhookEndpoint>) | (((this: any, id: string, props?: WebhookEndpointProps | undefined) => never) & (new (_: never) => never));

package/lib/util/serde.d.ts

@@ -1,3 +1,5 @@
 import { Scope } from "../scope";
-export declare function serialize(scope: Scope, value: any): Promise<any>;
+export declare function serialize(scope: Scope, value: any, options?: {
+    encrypt?: boolean;
+}): Promise<any>;
 export declare function deserialize(scope: Scope, value: any): Promise<any>;

package/lib/util/serde.js

@@ -1,16 +1,18 @@
 import { Scope } from "../scope";
 import { Secret } from "../secret";
 import { decryptWithKey, encryptWithKey } from "./encrypt";
-export async function serialize(scope, value) {
+export async function serialize(scope, value, options) {
     if (Array.isArray(value)) {
-        return Promise.all(value.map((value) => serialize(scope, value)));
+        return Promise.all(value.map((value) => serialize(scope, value, options)));
     }
     else if (value instanceof Secret) {
         if (!scope.password) {
             throw new Error("Cannot serialize secret without password");
         }
         return {
-            "@secret": await encryptWithKey(value.unencrypted, scope.password),
+            "@secret": options?.encrypt !== false
+                ? await encryptWithKey(value.unencrypted, scope.password)
+                : value.unencrypted,
         };
     }
     else if (value instanceof Scope) {
@@ -19,7 +21,7 @@ export async function serialize(scope, value) {
     else if (value && typeof value === "object") {
         return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, value]) => [
             key,
-            await serialize(scope, value),
+            await serialize(scope, value, options),
         ])));
     }
     return value;

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 | undefined) => never) & (new (_: never) => never));
+export {};