alchemy 0.2.5 → 0.3.0

package/lib/state.d.ts

@@ -11,7 +11,7 @@ export interface State<Kind extends string = string, Props extends ResourceProps
     oldProps?: Props;
     output: Out;
 }
-export type StateStoreType = new (scope: Scope) => StateStore;
+export type StateStoreType = (scope: Scope) => StateStore;
 export interface StateStore {
     /** Initialize the state container if one is required */
     init?(): Promise<void>;
@@ -27,18 +27,3 @@ export interface StateStore {
     set(key: string, value: State): Promise<void>;
     delete(key: string): Promise<void>;
 }
-export declare class FileSystemStateStore implements StateStore {
-    readonly scope: Scope;
-    readonly dir: string;
-    constructor(scope: Scope);
-    init(): Promise<void>;
-    deinit(): Promise<void>;
-    count(): Promise<number>;
-    list(): Promise<string[]>;
-    get(key: string): Promise<State | undefined>;
-    set(key: string, value: State): Promise<void>;
-    delete(key: string): Promise<void>;
-    all(): Promise<Record<string, State>>;
-    getBatch(ids: string[]): Promise<Record<string, State>>;
-    private getPath;
-}

package/lib/state.js

@@ -1,87 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { ignore } from "./util/ignore";
-import { deserialize, serialize } from "./util/serde";
-const stateRootDir = path.join(process.cwd(), ".alchemy");
-export class FileSystemStateStore {
-    scope;
-    dir;
-    constructor(scope) {
-        this.scope = scope;
-        this.dir = path.join(stateRootDir, ...scope.chain);
-    }
-    async init() {
-        await fs.promises.mkdir(stateRootDir, { recursive: true });
-        await fs.promises.mkdir(this.dir, { recursive: true });
-    }
-    async deinit() {
-        await ignore("ENOENT", () => fs.promises.rmdir(this.dir));
-    }
-    async count() {
-        return Object.keys(await this.list()).length;
-    }
-    async list() {
-        try {
-            const files = await fs.promises.readdir(this.dir, {
-                withFileTypes: true,
-            });
-            return files
-                .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".json"))
-                .map((dirent) => dirent.name.replace(/\.json$/, ""))
-                .map((key) => key.replaceAll(":", "/"));
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return [];
-            }
-            throw error;
-        }
-    }
-    async get(key) {
-        try {
-            const content = await fs.promises.readFile(await this.getPath(key), "utf8");
-            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") {
-                return undefined;
-            }
-            throw error;
-        }
-    }
-    async set(key, value) {
-        return fs.promises.writeFile(await this.getPath(key), JSON.stringify(await serialize(this.scope, value), null, 2));
-    }
-    async delete(key) {
-        return fs.promises.unlink(await this.getPath(key));
-    }
-    async all() {
-        return this.getBatch(await this.list());
-    }
-    async getBatch(ids) {
-        return Object.fromEntries((await Promise.all(Array.from(ids).flatMap(async (id) => {
-            const s = await this.get(id);
-            if (s === undefined) {
-                return [];
-            }
-            return [[id, s]];
-        }))).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 });
-        return file;
-    }
-}

package/lib/test/bun.d.ts

@@ -1,4 +1,5 @@
 import type { Scope } from "../scope";
+import type { StateStoreType } from "../state";
 /**
  * Extend the Alchemy interface to include test functionality
  */
@@ -26,6 +27,14 @@ export interface TestOptions {
      * @default "test-password".
      */
     password?: string;
+    /**
+     * Override the default state store for the test.
+     */
+    stateStore?: StateStoreType;
+    /**
+     * Prefix to use for the scope to isolate tests and environments.
+     */
+    prefix?: string;
 }
 /**
  * Test function type definition with overloads
@@ -51,6 +60,8 @@ type test = {
      * @param condition If true, test will be skipped
      */
     skipIf(condition: boolean): test;
+    beforeAll(fn: (scope: Scope) => Promise<void>): void;
+    afterAll(fn: (scope: Scope) => Promise<void>): void;
     /**
      * Current test scope
      */

package/lib/test/bun.js

@@ -1,16 +1,13 @@
 /// <reference types="bun" />
-import { afterAll, it } from "bun:test";
+import { afterAll, beforeAll, it } from "bun:test";
 import path from "node:path";
 import { alchemy } from "../alchemy";
+import { R2RestStateStore } from "../cloudflare";
 import { destroy } from "../destroy";
 /**
  * Add test functionality to alchemy instance
  */
 alchemy.test = test;
-/**
- * Global test scope for all tests
- */
-const globalTestScope = alchemy.scope("test");
 /**
  * Creates a test helper function that provides scoped resource management
  *
@@ -35,6 +32,16 @@ const globalTestScope = alchemy.scope("test");
  * ```
  */
 export function test(meta, defaultOptions) {
+    defaultOptions = defaultOptions ?? {};
+    if (defaultOptions.stateStore === undefined &&
+        // process.env.CI &&
+        process.env.ALCHEMY_STATE_STORE === "cloudflare") {
+        defaultOptions.stateStore = (scope) => new R2RestStateStore(scope, {
+            apiKey: process.env.CLOUDFLARE_API_KEY,
+            email: process.env.CLOUDFLARE_EMAIL,
+            bucketName: process.env.CLOUDFLARE_BUCKET_NAME,
+        });
+    }
     // Add skipIf functionality
     test.skipIf = (condition) => {
         if (condition) {
@@ -44,12 +51,29 @@ export function test(meta, defaultOptions) {
         return test;
     };
     // Create local test scope based on filename
-    const localTestScope = alchemy.scope(path.basename(meta.filename), {
-        parent: globalTestScope,
+    const localTestScope = alchemy.scope(`${defaultOptions.prefix ? `${defaultOptions.prefix}-` : ""}${path.basename(meta.filename)}`, {
+        // parent: globalTestScope,
+        stateStore: defaultOptions?.stateStore,
     });
     test.scope = localTestScope;
+    test.beforeAll = (fn) => {
+        return beforeAll(async () => {
+            test.scope.enter();
+            await fn(test.scope);
+        });
+    };
+    test.afterAll = (fn) => {
+        return afterAll(async () => {
+            test.scope.enter();
+            await fn(test.scope);
+        });
+    };
     // Clean up test scope after all tests complete
-    afterAll(() => alchemy.destroy(test.scope));
+    afterAll(async () => {
+        if (defaultOptions?.destroy !== false) {
+            await alchemy.destroy(test.scope);
+        }
+    });
     return test;
     function test(...args) {
         const testName = args[0];
@@ -76,6 +100,10 @@ export function test(meta, defaultOptions) {
                 try {
                     await fn(scope);
                 }
+                catch (err) {
+                    console.error(err);
+                    throw err;
+                }
                 finally {
                     if (options.destroy !== false) {
                         await destroy(scope);

package/lib/web/astro.d.ts

@@ -0,0 +1,147 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+/**
+ * Type of integrations that can be added to an Astro project
+ */
+export type AstroIntegration = "react" | "preact" | "vue" | "svelte" | "solid" | "lit" | "tailwind" | "mdx" | "sitemap" | "partytown" | "markdoc";
+/**
+ * Properties for creating an Astro project
+ */
+export interface AstroProjectProps {
+    /**
+     * The name/path of the project
+     */
+    name: string;
+    /**
+     * The title of the site
+     * @default "Astro Site"
+     */
+    title?: string;
+    /**
+     * The description of the site
+     * @default "Welcome to my Astro site"
+     */
+    description?: string;
+    /**
+     * The directory to initialize the project in.
+     * @default {@link name}
+     */
+    dir?: string;
+    /**
+     * The integrations to add to the project
+     * @default []
+     */
+    integrations?: AstroIntegration[];
+    /**
+     * The TypeScript configuration
+     */
+    tsconfig?: {
+        /**
+         * Extends from this TypeScript configuration
+         */
+        extends?: string;
+        /**
+         * References to add to the tsconfig
+         */
+        references?: string[];
+        /**
+         * Compiler options to add to the tsconfig
+         */
+        compilerOptions?: Record<string, any>;
+    };
+    /**
+     * Whether to delete the project folder during the delete phase
+     * @default true
+     */
+    delete?: 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;
+        /**
+         * Mute output
+         * @default false
+         */
+        silent?: boolean;
+        /**
+         * Use the src directory when creating a new project
+         * @default true
+         */
+        srcDir?: boolean;
+        /**
+         * Use css variables for theming
+         * @default true
+         */
+        cssVariables?: boolean;
+        /**
+         * The components to add
+         */
+        components?: string[];
+    };
+    /**
+     * The dependencies to install
+     */
+    dependencies?: Record<string, string>;
+    /**
+     * The dev dependencies to install
+     */
+    devDependencies?: Record<string, string>;
+    /**
+     * Additional scripts to add to package.json
+     */
+    scripts?: Record<string, string>;
+}
+/**
+ * Astro project resource
+ */
+export interface AstroProject extends AstroProjectProps, Resource {
+    /**
+     * The name/path of the project
+     */
+    name: string;
+}
+/**
+ * Creates a new Astro project
+ *
+ * @example
+ * // Create a basic Astro project
+ * const basicProject = await AstroProject("my-astro-app", {
+ *   title: "My Astro Site",
+ *   description: "Built with Alchemy"
+ * });
+ *
+ * @example
+ * // Create an Astro project with React and Tailwind
+ * const reactProject = await AstroProject("astro-react", {
+ *   title: "Astro + React",
+ *   integrations: ["react", "tailwind"]
+ * });
+ *
+ * @example
+ * // Create an Astro project with Shadcn UI
+ * const shadcnProject = await AstroProject("astro-shadcn", {
+ *   title: "Astro with Shadcn UI",
+ *   integrations: ["react", "tailwind"],
+ *   shadcn: {
+ *     baseColor: "zinc",
+ *     components: ["button", "card", "input"]
+ *   }
+ * });
+ */
+export declare const AstroProject: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<AstroProject>, id: string, props: AstroProjectProps) => Promise<AstroProject>);