alchemy 0.2.2 → 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

@@ -26,4 +26,4 @@ export interface ShadcnComponent extends ShadcnComponentProps, Resource {
      */
     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));
+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/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

@@ -86,5 +86,5 @@ export interface ViteProject extends ViteProjectProps, Resource {
      */
     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 declare const ViteProject: ((this: Context<ViteProject>, id: string, props: ViteProjectProps) => Promise<ViteProject>) | (((this: any, id: string, props?: ViteProjectProps | undefined) => never) & (new (_: never) => never));
 export {};

package/lib/vitepress/dependencies.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+export type InstallDependencies = Resource<"project::InstallDependencies">;
+export declare const InstallDependencies: ((this: Context<InstallDependencies>, id: string, { cwd, dependencies, devDependencies, }: {
+    cwd: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}) => Promise<InstallDependencies>) | (((this: any, id: string, props?: {
+    cwd: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+} | undefined) => never) & (new (_: never) => never));
+export declare function fixedDependencies(dependencies?: Record<string, string>): {
+    [k: string]: string;
+};
+export declare function installDependencies(cwd: string, dependencies: Record<string, string> | undefined, ...args: string[]): Promise<void>;

package/lib/vitepress/dependencies.js

@@ -0,0 +1,35 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { Resource } from "../resource";
+const execAsync = promisify(exec);
+export const InstallDependencies = Resource("project::InstallDependencies", {
+    alwaysUpdate: true,
+}, async function (id, { cwd, dependencies, devDependencies, }) {
+    if (this.phase === "delete") {
+        return this.destroy();
+    }
+    await installDependencies(cwd, dependencies);
+    await installDependencies(cwd, devDependencies, "-D");
+    await execAsync("bun install", { cwd });
+    return this({});
+});
+function isInstallableVersion(version) {
+    // TODO: file:// ?
+    return !version.startsWith("workspace:");
+}
+export function fixedDependencies(dependencies) {
+    if (!dependencies)
+        return {};
+    return Object.fromEntries(Object.entries(dependencies).filter(([, value]) => !isInstallableVersion(value)));
+}
+export async function installDependencies(cwd, dependencies, ...args) {
+    if (!dependencies)
+        return;
+    const deps = Object.entries(dependencies)
+        .filter(([, value]) => isInstallableVersion(value))
+        .map(([pkg, version]) => `${pkg}@${version}`)
+        .join(" ");
+    const cmd = `bun add ${args.join(" ")} ${deps}`;
+    console.log(cmd);
+    await execAsync(cmd, { cwd });
+}

package/lib/vitepress/home-page.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Image that can be themed for light/dark mode
+ */
+export interface ThemeableImage {
+    /**
+     * Image source URL
+     */
+    src?: string;
+    /**
+     * Image alt text
+     */
+    alt?: string;
+    /**
+     * Light theme image URL
+     */
+    light?: string;
+    /**
+     * Dark theme image URL
+     */
+    dark?: string;
+}
+/**
+ * Hero action button configuration
+ */
+export interface HeroAction {
+    /**
+     * Color theme of the button
+     * @default "brand"
+     */
+    theme?: "brand" | "alt";
+    /**
+     * Label of the button
+     */
+    text: string;
+    /**
+     * Destination link of the button
+     */
+    link: string;
+    /**
+     * Link target attribute
+     */
+    target?: string;
+    /**
+     * Link rel attribute
+     */
+    rel?: string;
+}
+/**
+ * Hero section configuration
+ */
+export interface Hero {
+    /**
+     * The string shown top of text. Comes with brand color
+     * and expected to be short, such as product name.
+     */
+    name?: string;
+    /**
+     * The main text for the hero section. This will be defined
+     * as h1 tag.
+     */
+    text: string;
+    /**
+     * Tagline displayed below text
+     */
+    tagline?: string;
+    /**
+     * The image displayed next to the text and tagline area
+     */
+    image?: string | ThemeableImage;
+    /**
+     * Action buttons to display in home hero section
+     */
+    actions?: HeroAction[];
+}
+/**
+ * Feature item configuration
+ */
+export interface Feature {
+    /**
+     * Show icon on each feature box
+     */
+    icon?: string | ThemeableImage;
+    /**
+     * Title of the feature
+     */
+    title: string;
+    /**
+     * Details of the feature
+     */
+    details: string;
+    /**
+     * Link when clicked on feature component
+     */
+    link?: string;
+    /**
+     * Link text to be shown inside feature component
+     */
+    linkText?: string;
+    /**
+     * Link rel attribute
+     */
+    rel?: string;
+    /**
+     * Link target attribute
+     */
+    target?: string;
+}
+/**
+ * VitePress home page configuration
+ */
+export interface HomePage {
+    /**
+     * Use home page layout
+     */
+    layout: "home";
+    /**
+     * Hero section configuration
+     */
+    hero?: Hero;
+    /**
+     * Features section configuration
+     */
+    features?: Feature[];
+    /**
+     * Whether to apply default markdown styles
+     * @default true
+     */
+    markdownStyles?: boolean;
+}
+/**
+ * Parse YAML frontmatter to home page config
+ */
+export declare function parseHomePage(content: string): HomePage;

package/lib/vitepress/home-page.js

@@ -0,0 +1,11 @@
+import yaml from "yaml";
+/**
+ * Parse YAML frontmatter to home page config
+ */
+export function parseHomePage(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) {
+        throw new Error("Invalid frontmatter format");
+    }
+    return yaml.parse(match[1]);
+}

package/lib/vitepress/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./home-page";
+export * from "./vitepress";

package/lib/vitepress/index.js

@@ -0,0 +1,2 @@
+export * from "./home-page";
+export * from "./vitepress";

package/lib/vitepress/vitepress.d.ts

@@ -0,0 +1,60 @@
+import type { DefaultTheme, ThemeOptions } from "vitepress";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import type { HomePage } from "./home-page";
+export interface VitePressProjectProps {
+    /**
+     * The name/path of the project
+     */
+    name: string;
+    /**
+     * The title of the documentation site
+     */
+    title?: string;
+    /**
+     * The description of the documentation site
+     */
+    description?: string;
+    /**
+     * Whether to use TypeScript for config and theme files
+     * @default true
+     */
+    typescript?: boolean;
+    tsconfig?: {
+        extends?: string;
+        references?: string[];
+        compilerOptions?: Record<string, any>;
+    };
+    /**
+     * Force overwrite the project config files during the update phase
+     * @default false
+     */
+    overwrite?: boolean;
+    /**
+     * The dependencies to install
+     */
+    dependencies?: Record<string, string>;
+    /**
+     * The dev dependencies to install
+     */
+    devDependencies?: Record<string, string>;
+    /**
+     * The theme options to use
+     */
+    theme?: ThemeOptions;
+    /**
+     * The theme config to use
+     */
+    themeConfig: DefaultTheme.Config;
+    /**
+     * The home page configuration
+     */
+    home: HomePage;
+}
+export interface VitePressProject extends VitePressProjectProps, Resource {
+    /**
+     * The name/path of the project
+     */
+    name: string;
+}
+export declare const VitePressProject: ((this: Context<VitePressProject>, id: string, props: VitePressProjectProps) => Promise<VitePressProject>) | (((this: any, id: string, props?: VitePressProjectProps | undefined) => never) & (new (_: never) => never));