alchemy 0.2.0 → 0.2.1

package/lib/cloudflare/zone.d.ts

@@ -0,0 +1,196 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import type { AlwaysUseHTTPSValue, AutomaticHTTPSRewritesValue, BrotliValue, DevelopmentModeValue, EarlyHintsValue, EmailObfuscationValue, HTTP2Value, HTTP3Value, HotlinkProtectionValue, IPv6Value, MinTLSVersionValue, SSLValue, TLS13Value, WebSocketsValue, ZeroRTTValue } from "./zone-settings";
+/**
+ * Properties for creating or updating a Zone
+ */
+export interface ZoneProps {
+    /**
+     * The domain name for the zone
+     */
+    name: string;
+    /**
+     * Account ID to use for the zone
+     * If not provided, will use the default account
+     */
+    accountId?: string;
+    /**
+     * The type of zone to create
+     * "full" - Full zone implies that DNS is hosted with Cloudflare
+     * "partial" - Partial zone is typically a partner-hosted zone or a CNAME setup
+     * "secondary" - Secondary zone is a zone that mirrors the primary zone
+     * @default "full"
+     */
+    type?: "full" | "partial" | "secondary";
+    /**
+     * Whether to jump start the zone
+     * When enabled, Cloudflare will attempt to fetch existing DNS records
+     * @default true
+     */
+    jumpStart?: boolean;
+    /**
+     * Settings to apply to the zone
+     */
+    settings?: {
+        /**
+         * Enable SSL/TLS encryption for the zone
+         * "off" - SSL disabled
+         * "flexible" - Encrypts traffic between browser and Cloudflare
+         * "full" - Encrypts traffic between browser and server, allows self-signed certs
+         * "strict" - Encrypts traffic between browser and server, requires valid cert
+         */
+        ssl?: SSLValue;
+        /**
+         * Enable Always Use HTTPS
+         * Redirects all HTTP traffic to HTTPS
+         * @default "off"
+         */
+        alwaysUseHttps?: AlwaysUseHTTPSValue;
+        /**
+         * Enable Automatic HTTPS Rewrites
+         * Automatically rewrites HTTP URLs to HTTPS
+         * @default "off"
+         */
+        automaticHttpsRewrites?: AutomaticHTTPSRewritesValue;
+        /**
+         * Enable TLS 1.3
+         * Enables the latest version of TLS encryption
+         * @default "off"
+         */
+        tls13?: TLS13Value;
+        /**
+         * Enable Early Hints
+         * Speeds up page loads by serving Link headers
+         * @default "off"
+         */
+        earlyHints?: EarlyHintsValue;
+        /**
+         * Enable Email Obfuscation
+         * Obfuscates email addresses on the site
+         * @default "off"
+         */
+        emailObfuscation?: EmailObfuscationValue;
+        /**
+         * Enable Browser Cache TTL
+         * Sets the browser cache TTL in seconds
+         */
+        browserCacheTtl?: number;
+        /**
+         * Enable Development Mode
+         * Disables caching and enables real-time updates
+         * @default "off"
+         */
+        developmentMode?: DevelopmentModeValue;
+        /**
+         * Enable HTTP/2
+         * @default "on"
+         */
+        http2?: HTTP2Value;
+        /**
+         * Enable HTTP/3
+         * @default "on"
+         */
+        http3?: HTTP3Value;
+        /**
+         * Enable IPv6
+         * @default "on"
+         */
+        ipv6?: IPv6Value;
+        /**
+         * Enable WebSockets
+         * @default "on"
+         */
+        websockets?: WebSocketsValue;
+        /**
+         * Enable Zero-RTT
+         * @default "off"
+         */
+        zeroRtt?: ZeroRTTValue;
+        /**
+         * Enable Brotli compression
+         * @default "on"
+         */
+        brotli?: BrotliValue;
+        /**
+         * Enable Hotlink Protection
+         * @default "off"
+         */
+        hotlinkProtection?: HotlinkProtectionValue;
+        /**
+         * Minimum TLS Version
+         * @default "1.0"
+         */
+        minTlsVersion?: MinTLSVersionValue;
+    };
+}
+/**
+ * Output returned after Zone creation/update
+ */
+export interface Zone extends Resource<"cloudflare::Zone"> {
+    /**
+     * The ID of the zone
+     */
+    id: string;
+    /**
+     * The domain name for the zone
+     */
+    name: string;
+    /**
+     * The type of zone
+     */
+    type: "full" | "partial" | "secondary";
+    /**
+     * The status of the zone
+     */
+    status: string;
+    /**
+     * Whether the zone is paused
+     */
+    paused: boolean;
+    /**
+     * The account ID the zone belongs to
+     */
+    accountId: string;
+    /**
+     * The nameservers assigned to the zone
+     */
+    nameservers: string[];
+    /**
+     * The original nameservers for the zone
+     */
+    originalNameservers: string[] | null;
+    /**
+     * Time at which the zone was created
+     */
+    createdAt: number;
+    /**
+     * Time at which the zone was last modified
+     */
+    modifiedAt: number;
+    /**
+     * Time at which the zone was activated
+     */
+    activatedAt: number | null;
+    /**
+     * The zone's current settings
+     */
+    settings: {
+        ssl: SSLValue;
+        alwaysUseHttps: AlwaysUseHTTPSValue;
+        automaticHttpsRewrites: AutomaticHTTPSRewritesValue;
+        tls13: TLS13Value;
+        earlyHints: EarlyHintsValue;
+        emailObfuscation: EmailObfuscationValue;
+        browserCacheTtl: number;
+        developmentMode: DevelopmentModeValue;
+        http2: HTTP2Value;
+        http3: HTTP3Value;
+        ipv6: IPv6Value;
+        websockets: WebSocketsValue;
+        zeroRtt: ZeroRTTValue;
+        brotli: BrotliValue;
+        hotlinkProtection: HotlinkProtectionValue;
+        minTlsVersion: MinTLSVersionValue;
+    };
+}
+export declare const Zone: ((this: Context<Zone>, id: string, props: ZoneProps) => Promise<Zone>) | (((this: any, id: string, props: ZoneProps) => never) & (new (_: never) => never));

package/lib/cloudflare/zone.js

@@ -0,0 +1,175 @@
+import { Resource } from "../resource";
+import { createCloudflareApi } from "./api";
+export const Zone = Resource("cloudflare::Zone", async function (id, props) {
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi({
+        accountId: props.accountId,
+    });
+    if (this.phase === "delete") {
+        if (this.output?.id) {
+            // Delete zone
+            const deleteResponse = await api.delete(`/zones/${this.output.id}`);
+            if (!deleteResponse.ok && deleteResponse.status !== 404) {
+                const errorData = await deleteResponse.json().catch(() => ({
+                    errors: [{ message: deleteResponse.statusText }],
+                }));
+                throw new Error(`Error deleting zone '${props.name}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`);
+            }
+        }
+        else {
+            console.warn(`Zone '${props.name}' not found, skipping delete`);
+        }
+        return this.destroy();
+    }
+    if (this.phase === "update" && this.output?.id) {
+        // Get zone details to verify it exists
+        const response = await api.get(`/zones/${this.output.id}`);
+        if (!response.ok) {
+            throw new Error(`Error getting zone '${props.name}': ${response.statusText}`);
+        }
+        const result = (await response.json());
+        const zoneData = result.result;
+        // Update zone settings if provided
+        if (props.settings) {
+            await updateZoneSettings(api, this.output.id, props.settings);
+            // Add a small delay to ensure settings are propagated
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        return this({
+            id: zoneData.id,
+            name: zoneData.name,
+            type: zoneData.type,
+            status: zoneData.status,
+            paused: zoneData.paused,
+            accountId: zoneData.account.id,
+            nameservers: zoneData.name_servers,
+            originalNameservers: zoneData.original_name_servers,
+            createdAt: new Date(zoneData.created_on).getTime(),
+            modifiedAt: new Date(zoneData.modified_on).getTime(),
+            activatedAt: zoneData.activated_on
+                ? new Date(zoneData.activated_on).getTime()
+                : null,
+            settings: await getZoneSettings(api, zoneData.id),
+        });
+    }
+    else {
+        // Create new zone
+        const response = await api.post("/zones", {
+            name: props.name,
+            type: props.type || "full",
+            jump_start: props.jumpStart !== false,
+            account: {
+                id: api.accountId,
+            },
+        });
+        const body = await response.text();
+        if (!response.ok) {
+            if (response.status === 400 && body.includes("already exists")) {
+                // TODO: should we error?
+            }
+            else {
+                throw new Error(`Error creating zone '${props.name}': ${response.statusText}\n${body}`);
+            }
+        }
+        const zoneData = JSON.parse(body).result;
+        // Update zone settings if provided
+        if (props.settings) {
+            await updateZoneSettings(api, zoneData.id, props.settings);
+            // Add a small delay to ensure settings are propagated
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        return this({
+            id: zoneData.id,
+            name: zoneData.name,
+            type: zoneData.type,
+            status: zoneData.status,
+            paused: zoneData.paused,
+            accountId: zoneData.account.id,
+            nameservers: zoneData.name_servers,
+            originalNameservers: zoneData.original_name_servers,
+            createdAt: new Date(zoneData.created_on).getTime(),
+            modifiedAt: new Date(zoneData.modified_on).getTime(),
+            activatedAt: zoneData.activated_on
+                ? new Date(zoneData.activated_on).getTime()
+                : null,
+            settings: await getZoneSettings(api, zoneData.id),
+        });
+    }
+});
+/**
+ * Helper function to update zone settings
+ */
+async function updateZoneSettings(api, zoneId, settings) {
+    if (!settings)
+        return;
+    const settingsMap = {
+        ssl: "ssl",
+        alwaysUseHttps: "always_use_https",
+        automaticHttpsRewrites: "automatic_https_rewrites",
+        tls13: "tls_1_3",
+        earlyHints: "early_hints",
+        emailObfuscation: "email_obfuscation",
+        browserCacheTtl: "browser_cache_ttl",
+        developmentMode: "development_mode",
+        http2: "http2",
+        http3: "http3",
+        ipv6: "ipv6",
+        websockets: "websockets",
+        zeroRtt: "0rtt",
+        brotli: "brotli",
+        hotlinkProtection: "hotlink_protection",
+        minTlsVersion: "min_tls_version",
+    };
+    await Promise.all(Object.entries(settings)
+        .filter(([_, value]) => value !== undefined)
+        .map(async ([key, value]) => {
+        const settingId = settingsMap[key];
+        if (!settingId)
+            return;
+        const response = await api.patch(`/zones/${zoneId}/settings/${settingId}`, {
+            value,
+        });
+        if (!response.ok) {
+            const data = await response.text();
+            if (response.status === 400 && data.includes("already enabled")) {
+                console.warn(`Warning: Setting '${key}' already enabled`);
+                return;
+            }
+            throw new Error(`Failed to update zone setting ${key}: ${response.statusText}`);
+        }
+    }));
+}
+/**
+ * Helper function to get current zone settings
+ */
+async function getZoneSettings(api, zoneId) {
+    const settingsResponse = await api.get(`/zones/${zoneId}/settings`);
+    if (!settingsResponse.ok) {
+        throw new Error(`Failed to fetch zone settings: ${settingsResponse.status} ${settingsResponse.statusText}`);
+    }
+    const result = (await settingsResponse.json());
+    const settingsData = result.result;
+    // Helper to get setting value with default
+    const getSetting = (id, defaultValue) => {
+        const setting = settingsData.find((s) => s.id === id);
+        return setting?.value ?? defaultValue;
+    };
+    return {
+        ssl: getSetting("ssl", "off"),
+        alwaysUseHttps: getSetting("always_use_https", "off"),
+        automaticHttpsRewrites: getSetting("automatic_https_rewrites", "off"),
+        tls13: getSetting("tls_1_3", "off"),
+        earlyHints: getSetting("early_hints", "off"),
+        emailObfuscation: getSetting("email_obfuscation", "off"),
+        browserCacheTtl: getSetting("browser_cache_ttl", 14400),
+        developmentMode: getSetting("development_mode", "off"),
+        http2: getSetting("http2", "on"),
+        http3: getSetting("http3", "on"),
+        ipv6: getSetting("ipv6", "on"),
+        websockets: getSetting("websockets", "on"),
+        zeroRtt: getSetting("0rtt", "off"),
+        brotli: getSetting("brotli", "on"),
+        hotlinkProtection: getSetting("hotlink_protection", "off"),
+        minTlsVersion: getSetting("min_tls_version", "1.0"),
+    };
+}

package/lib/destroy.js

@@ -67,7 +67,7 @@ export async function destroy(...args) {
             // BUG: this does not restore persisted scope
             await alchemy.run(instance.ID, async (scope) => {
                 nestedScope = scope;
-                return Provider.handler.bind(ctx)(instance.ID, state.props);
+                return await Provider.handler.bind(ctx)(instance.ID, state.props);
             });
         }
         catch (err) {

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/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/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/package.json

@@ -1,10 +1,10 @@
 {
   "name": "alchemy",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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,6 +15,7 @@
     "./esbuild": "./lib/esbuild/index.js",
     "./fs": "./lib/fs/index.js",
     "./github": "./lib/github/index.js",
+    "./project": "./lib/project/index.js",
     "./stripe": "./lib/stripe/index.js",
     "./test/bun": "./lib/test/bun.js"
   },

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;
+  }
 }