alchemy 0.1.18 → 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/context.d.ts

@@ -0,0 +1,58 @@
+import type { Resource, ResourceFQN, ResourceID, ResourceKind, ResourceProps } from "./resource";
+import type { Scope } from "./scope";
+import type { State } from "./state";
+export type Context<Out extends Resource> = CreateContext<Out> | UpdateContext<Out> | DeleteContext<Out>;
+export interface CreateContext<Out extends Resource> extends BaseContext<Out> {
+    phase: "create";
+    output?: undefined;
+}
+export interface UpdateContext<Out extends Resource> extends BaseContext<Out> {
+    phase: "update";
+    output: Out;
+}
+export interface DeleteContext<Out extends Resource> extends BaseContext<Out> {
+    phase: "delete";
+    output: Out;
+}
+export interface BaseContext<Out extends Resource> {
+    quiet: boolean;
+    stage: string;
+    id: ResourceID;
+    fqn: ResourceFQN;
+    scope: Scope;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete<T>(key: string): Promise<T | undefined>;
+    /**
+     * Indicate that this resource is being replaced.
+     * This will cause the resource to be deleted at the end of the stack's CREATE phase.
+     */
+    replace(): void;
+    /**
+     * Terminate the resource lifecycle handler and destroy the resource.
+     *
+     * This is the final operation performed during a delete operation.
+     *
+     * It is so that the resource lifecycle handler can "return never" instead of
+     * "return undefined" so that `await MyResource()` always returns a value.
+     */
+    destroy(): never;
+    /**
+     * Create the Resource envelope (with Alchemy + User properties)
+     */
+    create(props: Omit<Out, keyof Resource>): Out;
+    /**
+     * Create the Resource envelope (with Alchemy + User properties)
+     */
+    (props: Omit<Out, keyof Resource>): Out;
+}
+export declare function context<Kind extends string, Props extends ResourceProps, Out extends Resource>({ scope, phase, kind, id, fqn, seq, state, replace, }: {
+    scope: Scope;
+    phase: "create" | "update" | "delete";
+    kind: ResourceKind;
+    id: ResourceID;
+    fqn: ResourceFQN;
+    seq: number;
+    state: State<Kind, Props, Out>;
+    replace: () => void;
+}): Context<Out>;

package/lib/context.js

@@ -0,0 +1,36 @@
+import { DestroyedSignal } from "./destroy";
+export function context({ scope, phase, kind, id, fqn, seq, state, replace, }) {
+    function create(props) {
+        return {
+            ...props,
+            Kind: kind,
+            ID: id,
+            FQN: fqn,
+            Scope: scope,
+            Seq: seq,
+        };
+    }
+    return Object.assign(create, {
+        stage: scope.stage,
+        scope,
+        id: id,
+        fqn: fqn,
+        phase,
+        output: state.output,
+        replace,
+        get: (key) => state.data[key],
+        set: async (key, value) => {
+            state.data[key] = value;
+        },
+        delete: async (key) => {
+            const value = state.data[key];
+            delete state.data[key];
+            return value;
+        },
+        quiet: scope.quiet,
+        destroy: () => {
+            throw new DestroyedSignal();
+        },
+        create,
+    });
+}

package/lib/destroy.d.ts

@@ -1,19 +1,16 @@
-import type { Output } from "./output";
-import { Provider, ResourceID } from "./resource";
-import { type Scope } from "./scope";
-import type { State, StateStore } from "./state";
+import { type Resource } from "./resource";
+import { Scope } from "./scope";
+export declare class DestroyedSignal extends Error {
+}
 export interface DestroyOptions {
-    stage?: string;
-    stateStore?: StateStore;
-    scope?: Scope;
     quiet?: boolean;
+    strategy?: "sequential" | "parallel";
 }
 /**
  * Prune all resources from an Output and "down", i.e. that branches from it.
  */
-export declare function destroy<T>(output: Output<T>, options?: DestroyOptions): Promise<void>;
-/**
- * @internal
- */
-export declare function destroy<T>(stage: string, scope: Scope, resourceID: ResourceID, resourceState: State, resourceProvider: Provider, stateStore: StateStore, options: DestroyOptions): Promise<void>;
-//# sourceMappingURL=destroy.d.ts.map
+export declare function destroy<Type extends string>(...args: [scope: Scope, options?: DestroyOptions] | [resource: Resource<Type> | undefined | null, options?: DestroyOptions]): Promise<void>;
+export declare namespace destroy {
+    function all(resources: Resource[], options?: DestroyOptions): Promise<void>;
+    function sequentially(...resources: (Resource<string> | undefined | null)[]): Promise<void>;
+}

package/lib/destroy.js

@@ -1,54 +1,115 @@
-import { defaultStage, defaultStateStore } from "./global";
-import { Provider, ResourceID, isResource } from "./resource";
-import { rootScope } from "./scope";
+import { alchemy } from "./alchemy";
+import { context } from "./context";
+import { PROVIDERS } from "./resource";
+import { Scope } from "./scope";
+export class DestroyedSignal extends Error {
+}
+function isScopeArgs(a) {
+    return a[0] instanceof Scope;
+}
+/**
+ * Prune all resources from an Output and "down", i.e. that branches from it.
+ */
 export async function destroy(...args) {
-    let resourceID;
-    let resourceState;
-    let resourceProvider;
-    let stage;
-    let stateStore;
-    let scope = undefined;
-    let options = undefined;
-    if (args.length === 7) {
-        stage = args[0];
-        scope = args[1];
-        resourceID = args[2];
-        resourceState = args[3];
-        resourceProvider = args[4];
-        stateStore = args[5];
-        options = args[6];
-    }
-    else if (isResource(args[0])) {
-        const resource = args[0];
-        // stage = args[1]?.stage ?? defaultStage;
-        resourceID = resource[ResourceID];
-        stage = args[1]?.stage ?? defaultStage;
-        scope = args[1]?.scope ?? rootScope;
-        const statePath = scope.getScopePath(stage);
-        stateStore = args[1]?.stateStore ?? new defaultStateStore(statePath);
-        // First destroy all dependencies
-        const _resourceState = await stateStore.get(resourceID);
-        if (_resourceState === undefined) {
-            // we have no record of this resource, we must assume it's already deleted
-            return;
-        }
-        resourceState = _resourceState;
-        resourceProvider = resource[Provider];
-        options = args[1];
+    if (isScopeArgs(args)) {
+        const [scope, options] = args;
+        const strategy = options?.strategy ?? "sequential";
+        // destroy all active resources
+        await destroy.all(Array.from(scope.resources.values()), {
+            strategy,
+        });
+        // then detect orphans and destroy them
+        const orphans = await scope.state.all();
+        await destroy.all(Object.values(orphans).map((orphan) => ({
+            ...orphan.output,
+            Scope: scope,
+        })), options);
+        // finally, destroy the scope container
+        await scope.deinit();
+        return;
     }
-    else {
-        console.log(args[0]);
-        throw new Error("Not implemented: must handle destroy a Output chain");
+    const [instance, options] = args;
+    if (!instance) {
+        return;
     }
+    const Provider = PROVIDERS.get(instance.Kind);
+    if (!Provider) {
+        throw new Error(`Cannot destroy resource type ${instance.Kind} - no provider found. You may need to import the provider in your alchemy.config.ts.`);
+    }
+    const scope = instance.Scope;
+    if (!scope) {
+        console.warn(`Resource "${instance.FQN}" has no scope`);
+    }
+    const quiet = options?.quiet ?? scope.quiet;
     try {
-        await resourceProvider.delete(stage, scope, resourceID, resourceState, resourceState.inputs, options ?? {
-            quiet: false,
+        if (!quiet) {
+            console.log(`Delete:  "${instance.FQN}"`);
+        }
+        const state = (await scope.state.get(instance.ID));
+        if (state === undefined) {
+            console.warn(`Resource "${instance.FQN}" not found`);
+            return;
+        }
+        const ctx = context({
+            scope,
+            phase: "delete",
+            kind: instance.Kind,
+            id: instance.ID,
+            fqn: instance.FQN,
+            seq: instance.Seq,
+            state,
+            replace: () => {
+                throw new Error("Cannot replace a resource that is being deleted");
+            },
         });
+        let nestedScope;
+        try {
+            // BUG: this does not restore persisted scope
+            await alchemy.run(instance.ID, async (scope) => {
+                nestedScope = scope;
+                return await Provider.handler.bind(ctx)(instance.ID, state.props);
+            });
+        }
+        catch (err) {
+            if (err instanceof DestroyedSignal) {
+                // TODO: should we fail if the DestroyedSignal is not thrown?
+            }
+            else {
+                throw err;
+            }
+        }
+        if (nestedScope) {
+            await destroy(nestedScope, options);
+        }
+        await scope.delete(instance.ID);
+        if (!quiet) {
+            console.log(`Deleted: "${instance.FQN}"`);
+        }
     }
     catch (error) {
         console.error(error);
         throw error;
     }
-    await stateStore.delete(resourceID);
 }
-//# sourceMappingURL=destroy.js.map
+(function (destroy) {
+    async function all(resources, options) {
+        if (options?.strategy !== "parallel") {
+            const sorted = resources.sort((a, b) => b.Seq - a.Seq);
+            for (const resource of sorted) {
+                await destroy(resource);
+            }
+        }
+        else {
+            await Promise.all(resources.map((resource) => destroy(resource, options)));
+        }
+    }
+    destroy.all = all;
+    async function sequentially(...resources) {
+        for (const resource of resources) {
+            if (resource) {
+                await destroy(resource);
+            }
+        }
+    }
+    destroy.sequentially = sequentially;
+})(destroy || (destroy = {}));