alchemy 0.1.17 → 0.2.0

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 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 = {}));

package/lib/{esbuild.d.ts → esbuild/bundle.d.ts}

@@ -1,4 +1,6 @@
 import * as esbuild from "esbuild";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 export interface BundleProps {
     /**
      * Entry point for the bundle
@@ -41,7 +43,7 @@ export interface BundleProps {
      */
     options?: Partial<esbuild.BuildOptions>;
 }
-export interface BundleOutput {
+export interface Bundle extends Resource<"esbuild::Bundle"> {
     /**
      * Path to the bundled file
      */
@@ -51,21 +53,7 @@ export interface BundleOutput {
      */
     hash: string;
 }
-declare const Bundle_base: import("./resource").Provider<string, [props: BundleProps], BundleOutput>;
-export declare class Bundle extends Bundle_base {
-    /**
-     * Get the metafile from the last build
-     */
-    getMetafile(ctx: {
-        get<T>(key: string): Promise<T | undefined>;
-    }): Promise<esbuild.Metafile | undefined>;
-    /**
-     * Get the hash from the last build
-     */
-    getHash(ctx: {
-        get<T>(key: string): Promise<T | undefined>;
-    }): Promise<string | undefined>;
-}
+export declare const Bundle: ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>) | (((this: any, id: string, props: BundleProps) => never) & (new (_: never) => never));
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
     bundle: boolean;
     splitting?: boolean;
@@ -148,5 +136,3 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     logOverride?: Record<string, esbuild.LogLevel>;
     tsconfigRaw?: string | esbuild.TsconfigRaw;
 }>>;
-export {};
-//# sourceMappingURL=esbuild.d.ts.map

package/lib/{esbuild.js → esbuild/bundle.js}

@@ -2,46 +2,33 @@ import * as esbuild from "esbuild";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { Resource } from "./resource";
-export class Bundle extends Resource("esbuild::Bundle", {
+import { Resource } from "../resource";
+export const Bundle = Resource("esbuild::Bundle", {
     alwaysUpdate: true,
-}, async (ctx, props) => {
+}, async function (id, props) {
     // Determine output path
     const outputPath = getOutputPath(props);
     // Ensure output directory exists
     await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         await fs.promises.unlink(outputPath).catch(() => { });
         // Also clean up sourcemap if it exists
         await fs.promises.unlink(outputPath + ".map").catch(() => { });
-        return { path: outputPath, hash: "" };
+        return this.destroy();
     }
     const result = await bundle(props);
     // Calculate hash of the output
     const contents = await fs.promises.readFile(outputPath);
     const hash = crypto.createHash("sha256").update(contents).digest("hex");
     // Store metadata in context
-    await ctx.set("metafile", result.metafile);
-    await ctx.set("hash", hash);
+    await this.set("metafile", result.metafile);
+    await this.set("hash", hash);
     // Return output info
-    return {
+    return this({
         path: outputPath,
         hash,
-    };
-}) {
-    /**
-     * Get the metafile from the last build
-     */
-    async getMetafile(ctx) {
-        return ctx.get("metafile");
-    }
-    /**
-     * Get the hash from the last build
-     */
-    async getHash(ctx) {
-        return ctx.get("hash");
-    }
-}
+    });
+});
 export async function bundle(props) {
     const outputPath = getOutputPath(props);
     // Build the bundle
@@ -64,4 +51,3 @@ function getOutputPath(props) {
     return (props.outfile ||
         path.join(props.outdir || "dist", path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js"));
 }
-//# sourceMappingURL=esbuild.js.map

package/lib/esbuild/index.d.ts

@@ -0,0 +1 @@
+export * from "./bundle";

package/lib/esbuild/index.js

@@ -0,0 +1 @@
+export * from "./bundle";

package/lib/fs/file.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+export interface File extends Resource<"fs::File"> {
+    path: string;
+    content: string;
+}
+export declare const File: ((this: Context<File>, id: string, { path: filePath, content, }: {
+    path: string;
+    content: string;
+}) => Promise<File>) | (((this: any, id: string, props: {
+    path: string;
+    content: string;
+}) => never) & (new (_: never) => never));

package/lib/fs/file.js

@@ -0,0 +1,20 @@
+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, }) {
+    if (this.phase === "delete") {
+        await ignore("ENOENT", async () => fs.promises.unlink(filePath));
+        return this.destroy();
+    }
+    else {
+        await fs.promises.mkdir(path.dirname(filePath), {
+            recursive: true,
+        });
+        await fs.promises.writeFile(filePath, content);
+    }
+    return this({
+        path: filePath,
+        content,
+    });
+});

package/lib/fs/folder.d.ts

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

package/lib/fs/folder.js

@@ -0,0 +1,16 @@
+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 }) {
+    if (this.phase === "delete") {
+        // we just do a best effort attempt
+        await ignore(["ENOENT", "ENOTEMPTY"], async () => fs.promises.rmdir(dirPath));
+        return this.destroy();
+    }
+    else {
+        await ignore("EEXIST", async () => fs.promises.mkdir(dirPath, { recursive: true }));
+    }
+    return this({
+        path: dirPath,
+    });
+});

package/lib/fs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./file";
+export * from "./folder";

package/lib/fs/index.js

@@ -0,0 +1,2 @@
+export * from "./file";
+export * from "./folder";

package/lib/github/client.d.ts

@@ -31,4 +31,3 @@ export declare function createGitHubClient(options?: {
  * @param repo Repository name
  */
 export declare function verifyGitHubAuth(octokit: Octokit, owner: string, repo: string): Promise<void>;
-//# sourceMappingURL=client.d.ts.map

package/lib/github/client.js

@@ -88,4 +88,3 @@ export async function verifyGitHubAuth(octokit, owner, repo) {
         }
     }
 }
-//# sourceMappingURL=client.js.map

package/lib/github/index.d.ts

@@ -1,2 +1 @@
 export * from "./secret";
-//# sourceMappingURL=index.d.ts.map

package/lib/github/index.js

@@ -1,2 +1 @@
 export * from "./secret";
-//# sourceMappingURL=index.js.map

package/lib/github/secret.d.ts

@@ -1,3 +1,6 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import type { Secret } from "../secret";
 /**
  * Properties for creating or updating a GitHub Secret
  */
@@ -17,7 +20,7 @@ export interface GitHubSecretProps {
     /**
      * Secret value (will be stored securely on GitHub)
      */
-    value: string;
+    value: Secret;
     /**
      * Optional GitHub API token (overrides environment variable)
      */
@@ -26,7 +29,7 @@ export interface GitHubSecretProps {
 /**
  * Output returned after Secret creation/update
  */
-export interface GitHubSecretOutput extends Omit<GitHubSecretProps, "value"> {
+export interface GitHubSecretOutput extends Resource<"github::Secret">, Omit<GitHubSecretProps, "value"> {
     /**
      * The ID of the resource
      */
@@ -36,11 +39,7 @@ export interface GitHubSecretOutput extends Omit<GitHubSecretProps, "value"> {
      */
     updatedAt: string;
 }
-declare const GitHubSecret_base: import("../resource").Provider<"github::Secret", [props: GitHubSecretProps], GitHubSecretOutput>;
 /**
  * Resource for managing GitHub repository secrets
  */
-export declare class GitHubSecret extends GitHubSecret_base {
-}
-export {};
-//# sourceMappingURL=secret.d.ts.map
+export declare const GitHubSecret: ((this: Context<GitHubSecretOutput>, id: string, props: GitHubSecretProps) => Promise<GitHubSecretOutput>) | (((this: any, id: string, props: GitHubSecretProps) => never) & (new (_: never) => never));

package/lib/github/secret.js

@@ -1,38 +1,19 @@
 import sodium from "libsodium-wrappers";
 import { Resource } from "../resource";
 import { createGitHubClient, verifyGitHubAuth } from "./client";
-/**
- * Encrypt a value for GitHub using libsodium
- * Based on GitHub's documentation for encrypting secrets
- *
- * @param value - The secret value to encrypt
- * @param publicKey - The base64-encoded public key from GitHub
- * @returns The base64-encoded encrypted value
- */
-async function encryptValue(value, publicKey) {
-    // Initialize libsodium
-    await sodium.ready;
-    // Convert the public key from base64 to binary
-    const binKey = sodium.from_base64(publicKey, sodium.base64_variants.ORIGINAL);
-    // Convert the message to a Uint8Array
-    const binMessage = sodium.from_string(value);
-    // Encrypt the message with the public key using libsodium's sealed box
-    const encryptedBin = sodium.crypto_box_seal(binMessage, binKey);
-    // Convert the encrypted message to base64
-    return sodium.to_base64(encryptedBin, sodium.base64_variants.ORIGINAL);
-}
 /**
  * Resource for managing GitHub repository secrets
  */
-export class GitHubSecret extends Resource("github::Secret", async (ctx, props) => {
+export const GitHubSecret = Resource("github::Secret", async function (id, props) {
     // Create authenticated Octokit client - will automatically handle token resolution
+    /// TODO: use fetch
     const octokit = await createGitHubClient({ token: props.token });
     // Verify authentication and permissions
-    if (!ctx.quiet) {
+    if (!this.quiet) {
         await verifyGitHubAuth(octokit, props.owner, props.repository);
     }
-    if (ctx.event === "delete") {
-        if (ctx.output?.id) {
+    if (this.phase === "delete") {
+        if (this.output?.id) {
             try {
                 // Delete the secret
                 await octokit.rest.actions.deleteRepoSecret({
@@ -52,7 +33,7 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
             }
         }
         // Return void (a deleted resource has no content)
-        return undefined;
+        return this.destroy();
     }
     else {
         try {
@@ -62,29 +43,24 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
                 repo: props.repository,
             });
             // Encrypt the secret value using libsodium
-            const encryptedValue = await encryptValue(props.value, publicKey.key);
+            const encryptedValue = await encryptString(props.value.unencrypted, publicKey.key);
             // Create or update the secret with the encrypted value and key_id
-            const response = await octokit.rest.actions.createOrUpdateRepoSecret({
+            await octokit.rest.actions.createOrUpdateRepoSecret({
                 owner: props.owner,
                 repo: props.repository,
                 secret_name: props.name,
                 encrypted_value: encryptedValue,
                 key_id: publicKey.key_id,
             });
-            // Log success
-            if (!ctx.quiet) {
-                console.log(`Successfully created/updated secret: ${props.name}`);
-            }
             // GitHub doesn't return the secret details on create/update, so we need to construct it
-            const output = {
+            return this({
                 id: `${props.owner}/${props.repository}/${props.name}`,
                 owner: props.owner,
                 repository: props.repository,
                 name: props.name,
                 token: props.token,
                 updatedAt: new Date().toISOString(),
-            };
-            return output;
+            });
         }
         catch (error) {
             if (error.status === 403 &&
@@ -98,6 +74,24 @@ export class GitHubSecret extends Resource("github::Secret", async (ctx, props)
             throw error;
         }
     }
-}) {
+});
+/**
+ * Encrypt a value for GitHub using libsodium
+ * Based on GitHub's documentation for encrypting secrets
+ *
+ * @param value - The secret value to encrypt
+ * @param publicKey - The base64-encoded public key from GitHub
+ * @returns The base64-encoded encrypted value
+ */
+async function encryptString(value, publicKey) {
+    // Initialize libsodium
+    await sodium.ready;
+    // Convert the public key from base64 to binary
+    const binKey = sodium.from_base64(publicKey, sodium.base64_variants.ORIGINAL);
+    // Convert the message to a Uint8Array
+    const binMessage = sodium.from_string(value);
+    // Encrypt the message with the public key using libsodium's sealed box
+    const encryptedBin = sodium.crypto_box_seal(binMessage, binKey);
+    // Convert the encrypted message to base64
+    return sodium.to_base64(encryptedBin, sodium.base64_variants.ORIGINAL);
 }
-//# sourceMappingURL=secret.js.map

package/lib/index.d.ts

@@ -1,10 +1,7 @@
-export * from "./$";
-export * from "./alchemize";
-export * from "./error";
-export * from "./global";
-export * from "./input";
-export * from "./output";
-export * from "./print";
-export { Resource, type Context, type CreateContext, type DeleteContext, type UpdateContext, } from "./resource";
-export type { FileSystemStateStore as StateStore } from "./state";
-//# sourceMappingURL=index.d.ts.map
+export type * from "./context";
+export * from "./resource";
+export * from "./secret";
+export * from "./state";
+export * from "./util/ignore";
+import { alchemy } from "./alchemy";
+export default alchemy;

package/lib/index.js

@@ -1,9 +1,6 @@
-export * from "./$";
-export * from "./alchemize";
-export * from "./error";
-export * from "./global";
-export * from "./input";
-export * from "./output";
-export * from "./print";
-export { Resource, } from "./resource";
-//# sourceMappingURL=index.js.map
+export * from "./resource";
+export * from "./secret";
+export * from "./state";
+export * from "./util/ignore";
+import { alchemy } from "./alchemy";
+export default alchemy;