alchemy 0.1.18 → 0.2.0

package/lib/alchemy.d.ts

@@ -0,0 +1,67 @@
+import { destroy } from "./destroy";
+import { Scope } from "./scope";
+import { secret } from "./secret";
+import type { StateStoreType } from "./state";
+export type alchemy = Alchemy;
+export declare const alchemy: Alchemy;
+export interface Alchemy {
+    scope: typeof scope;
+    run: typeof run;
+    destroy: typeof destroy;
+    secret: typeof secret;
+    (...parameters: Parameters<typeof scope>): ReturnType<typeof scope>;
+}
+export interface AlchemyOptions {
+    /**
+     * The name of the application.
+     */
+    appName?: string;
+    /**
+     * Determines whether the resources will be created/updated or deleted.
+     *
+     * @default "up"
+     */
+    phase?: "up" | "destroy";
+    /**
+     * Name to scope the resource state under (e.g. `.alchemy/{stage}/..`).
+     *
+     * @default - your POSIX username
+     */
+    stage?: string;
+    /**
+     * If true, will not prune resources that were dropped from the root stack.
+     *
+     * @default true
+     */
+    destroyOrphans?: boolean;
+    /**
+     * A custom state store to use instead of the default file system store.
+     */
+    stateStore?: StateStoreType;
+    /**
+     * A custom scope to use as a parent.
+     */
+    parent?: Scope;
+    /**
+     * If true, will not print any Create/Update/Delete messages.
+     *
+     * @default false
+     */
+    quiet?: boolean;
+    /**
+     * A passphrase to use to encrypt/decrypt secrets.
+     */
+    password?: string;
+}
+/**
+ * Enter a new scope synchronously.
+ * @param options
+ * @returns
+ */
+declare function scope(id: string | undefined, options?: AlchemyOptions): Scope;
+declare function run<T>(...args: [id: string, fn: (this: Scope, scope: Scope) => Promise<T>] | [
+    id: string,
+    options: AlchemyOptions,
+    fn: (this: Scope, scope: Scope) => Promise<T>
+]): Promise<T>;
+export {};

package/lib/alchemy.js

@@ -0,0 +1,40 @@
+import { destroy } from "./destroy";
+import { Scope } from "./scope";
+import { secret } from "./secret";
+// TODO: support browser
+const DEFAULT_STAGE = process.env.ALCHEMY_STAGE ?? process.env.USER ?? "dev";
+function _alchemy(appName, options) {
+    return scope(undefined, {
+        ...options,
+        appName,
+        stage: options.stage,
+    });
+}
+_alchemy.destroy = destroy;
+_alchemy.run = run;
+_alchemy.scope = scope;
+_alchemy.secret = secret;
+export const alchemy = _alchemy;
+/**
+ * Enter a new scope synchronously.
+ * @param options
+ * @returns
+ */
+function scope(id, options) {
+    const scope = new Scope({
+        ...options,
+        appName: options?.appName,
+        stage: options?.stage ?? DEFAULT_STAGE,
+        scopeName: id,
+        parent: options?.parent ?? Scope.get(),
+    });
+    scope.enter();
+    return scope;
+}
+async function run(...args) {
+    const [id, options, fn] = typeof args[1] === "function"
+        ? [args[0], undefined, args[1]]
+        : args;
+    await using scope = alchemy.scope(id, options);
+    return await fn.bind(scope)(scope);
+}

package/lib/apply.d.ts

@@ -1,23 +1,6 @@
-import { type Output, type Resolved } from "./output";
-import { type Scope as IScope } from "./scope";
-import type { StateStore } from "./state";
+import { type PendingResource, type Resource, type ResourceProps } from "./resource";
 export interface ApplyOptions {
-    stage: string;
-    scope: IScope;
-    stateStore: StateStore;
     quiet?: boolean;
+    alwaysUpdate?: boolean;
 }
-/**
- * Apply a sub-graph to produce a resource.
- * @param output A sub-graph that produces a resource.
- * @returns The resource properties.
- */
-export declare function apply<T>(output: T, options?: Partial<ApplyOptions>): Promise<Resolved<T>>;
-declare class Evaluated<T> {
-    readonly value: T;
-    readonly deps: string[];
-    constructor(value: T, deps?: string[]);
-}
-export declare function evaluate<T>(output: T | Output<T>, options: ApplyOptions): Promise<Evaluated<T>>;
-export {};
-//# sourceMappingURL=apply.d.ts.map
+export declare function apply<Out extends Resource>(resource: PendingResource<Out>, props: ResourceProps, options?: ApplyOptions): Promise<Awaited<Out>>;

package/lib/apply.js

@@ -1,88 +1,92 @@
-import { defaultStage, defaultStateStore } from "./global";
-import { OutputChain } from "./output";
-import { Input, Provider, ResourceID, isResource, } from "./resource";
-import { getScope } from "./scope";
-import { Secret } from "./secret";
-/**
- * Apply a sub-graph to produce a resource.
- * @param output A sub-graph that produces a resource.
- * @returns The resource properties.
- */
-export async function apply(output, options) {
-    const stage = options?.stage ?? defaultStage;
-    const scope = options?.scope ?? getScope();
-    const statePath = scope.getScopePath(stage);
-    const stateStore = options?.stateStore ?? new defaultStateStore(statePath);
-    return (await evaluate(output, { stage, scope, stateStore, quiet: options?.quiet })).value;
-}
-class Evaluated {
-    value;
-    deps;
-    constructor(value, deps = []) {
-        this.value = value;
-        this.deps = deps;
-    }
-}
-const cache = new WeakMap();
-export async function evaluate(output, options) {
-    const stage = options.stage;
-    const stateStore = options.stateStore;
-    if (isResource(output)) {
-        const resource = output;
-        const resourceID = resource[ResourceID];
-        const evaluated = await Promise.all(resource[Input].map((r) => evaluate(r, options)));
-        if (cache.has(resource)) {
-            return await cache.get(resource);
-        }
-        let resolve;
-        let reject;
-        const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        // set this eagerly to avoid double-apply (caused by recursive applies to inputs)
-        cache.set(resource, promise);
-        const deps = new Set(evaluated.flatMap((input) => input.deps));
-        const inputs = evaluated.map((input) => input.value);
-        try {
-            const result = await resource[Provider].update(stage, resource, deps, inputs, stateStore, options);
-            resolve(new Evaluated(result, [resourceID, ...deps]));
-        }
-        catch (error) {
-            console.error(error);
-            reject(error);
-        }
-        return promise;
+import { alchemy } from "./alchemy";
+import { context } from "./context";
+import { PROVIDERS, } from "./resource";
+import { serialize } from "./util/serde";
+export async function apply(resource, props, options) {
+    const scope = resource.Scope;
+    const quiet = props.quiet ?? scope.quiet;
+    await scope.init();
+    let state = (await scope.state.get(resource.ID));
+    const provider = PROVIDERS.get(resource.Kind);
+    if (provider === undefined) {
+        throw new Error(`Provider "${resource.Kind}" not found`);
     }
-    else if (output instanceof OutputChain) {
-        const inside = output;
-        const parent = await evaluate(inside.parent, options);
-        const ret = inside.fn(parent.value);
-        // the ret may be an Output (e.g. in the flatMap case), so we need to evaluate it and include its deps
-        const evaluated = await evaluate(ret, options);
-        return new Evaluated(evaluated.value, [
-            ...parent.deps,
-            ...evaluated.deps,
-        ]);
+    if (state === undefined) {
+        state = {
+            kind: resource.Kind,
+            id: resource.ID,
+            fqn: resource.FQN,
+            seq: resource.Seq,
+            status: "creating",
+            data: {},
+            output: {
+                ID: resource.ID,
+                FQN: resource.FQN,
+                Kind: resource.Kind,
+                Scope: scope,
+                Seq: resource.Seq,
+            },
+            // deps: [...deps],
+            props,
+        };
+        await scope.state.set(resource.ID, state);
     }
-    else if (Array.isArray(output)) {
-        const evaluatedItems = await Promise.all(output.map((item) => evaluate(item, options)));
-        return new Evaluated(evaluatedItems.map((e) => e.value), evaluatedItems.flatMap((e) => e.deps));
-    }
-    else if (output instanceof Date) {
-        return new Evaluated(output);
+    const alwaysUpdate = options?.alwaysUpdate ?? provider.options?.alwaysUpdate ?? false;
+    // Skip update if inputs haven't changed and resource is in a stable state
+    if (state.status === "created" || state.status === "updated") {
+        if (JSON.stringify(state.props) === JSON.stringify(serialize(scope, props)) &&
+            alwaysUpdate !== true) {
+            if (!quiet) {
+                console.log(`Skip:    "${resource.FQN}" (no changes)`);
+            }
+            // if (resourceState.output !== undefined) {
+            //   resource[Provide](resourceState.output);
+            // }
+            return state.output;
+        }
     }
-    else if (output instanceof Secret) {
-        return new Evaluated(output);
+    const phase = state.status === "creating" ? "create" : "update";
+    state.status = phase === "create" ? "creating" : "updating";
+    state.oldProps = state.props;
+    state.props = props;
+    if (!quiet) {
+        console.log(`${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`);
     }
-    else if (output && typeof output === "object") {
-        const entries = Object.entries(output);
-        const evaluatedEntries = await Promise.all(entries.map(async ([key, value]) => [key, await evaluate(value, options)]));
-        const result = Object.fromEntries(evaluatedEntries.map(([key, evaluated]) => [key, evaluated.value]));
-        const deps = evaluatedEntries.flatMap(([_, evaluated]) => evaluated.deps);
-        return new Evaluated(result, deps);
+    await scope.state.set(resource.ID, state);
+    let isReplaced = false;
+    const ctx = context({
+        scope,
+        phase,
+        kind: resource.Kind,
+        id: resource.ID,
+        fqn: resource.FQN,
+        seq: resource.Seq,
+        state,
+        replace: () => {
+            if (isReplaced) {
+                console.warn(`Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`);
+                return;
+            }
+            isReplaced = true;
+        },
+    });
+    const output = await alchemy.run(resource.ID, async () => provider.handler.bind(ctx)(resource.ID, props));
+    if (!quiet) {
+        console.log(`${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`);
     }
-    // Base case: primitive value
-    return new Evaluated(output);
+    await scope.state.set(resource.ID, {
+        kind: resource.Kind,
+        id: resource.ID,
+        fqn: resource.FQN,
+        seq: resource.Seq,
+        data: state.data,
+        status: phase === "create" ? "created" : "updated",
+        output,
+        props,
+        // deps: [...deps],
+    });
+    // if (output !== undefined) {
+    //   resource[Provide](output as Out);
+    // }
+    return output;
 }
-//# sourceMappingURL=apply.js.map

package/lib/aws/account-id.d.ts

@@ -2,4 +2,3 @@
  * Helper to get the current AWS account ID
  */
 export declare function getAccountId(): Promise<string>;
-//# sourceMappingURL=account-id.d.ts.map

package/lib/aws/account-id.js

@@ -7,4 +7,3 @@ export async function getAccountId() {
     const identity = await sts.send(new GetCallerIdentityCommand({}));
     return identity.Account;
 }
-//# sourceMappingURL=account-id.js.map

package/lib/aws/bucket.d.ts

@@ -1,9 +1,10 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
 export interface BucketProps {
     bucketName: string;
     tags?: Record<string, string>;
 }
-export interface BucketOutput extends BucketProps {
-    id: string;
+export interface Bucket extends Resource<"s3::Bucket">, BucketProps {
     arn: string;
     bucketDomainName: string;
     bucketRegionalDomainName?: string;
@@ -14,8 +15,4 @@ export interface BucketOutput extends BucketProps {
     versioningEnabled?: boolean;
     acl?: string;
 }
-declare const Bucket_base: import("../resource").Provider<"s3::Bucket", [props: BucketProps], BucketProps>;
-export declare class Bucket extends Bucket_base {
-}
-export {};
-//# sourceMappingURL=bucket.d.ts.map
+export declare const Bucket: ((this: Context<Bucket>, id: string, props: BucketProps) => Promise<Bucket>) | (((this: any, id: string, props: BucketProps) => never) & (new (_: never) => never));

package/lib/aws/bucket.js

@@ -1,13 +1,13 @@
 import { CreateBucketCommand, DeleteBucketCommand, GetBucketAclCommand, GetBucketLocationCommand, GetBucketTaggingCommand, GetBucketVersioningCommand, HeadBucketCommand, NoSuchBucket, PutBucketTaggingCommand, S3Client, } from "@aws-sdk/client-s3";
-import { ignore } from "../error";
 import { Resource } from "../resource";
-export class Bucket extends Resource("s3::Bucket", async (ctx, props) => {
+import { ignore } from "../util/ignore";
+export const Bucket = Resource("s3::Bucket", async function (id, props) {
     const client = new S3Client({});
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         await ignore(NoSuchBucket.name, () => client.send(new DeleteBucketCommand({
             Bucket: props.bucketName,
         })));
-        return props;
+        return this.destroy();
     }
     else {
         try {
@@ -16,7 +16,7 @@ export class Bucket extends Resource("s3::Bucket", async (ctx, props) => {
                 Bucket: props.bucketName,
             }));
             // Update tags if they changed and bucket exists
-            if (ctx.event === "update" && props.tags) {
+            if (this.phase === "update" && props.tags) {
                 await client.send(new PutBucketTaggingCommand({
                     Bucket: props.bucketName,
                     Tagging: {
@@ -68,9 +68,8 @@ export class Bucket extends Resource("s3::Bucket", async (ctx, props) => {
                 }
             }
         }
-        const output = {
+        return this({
             bucketName: props.bucketName,
-            id: props.bucketName,
             arn: `arn:aws:s3:::${props.bucketName}`,
             bucketDomainName: `${props.bucketName}.s3.amazonaws.com`,
             bucketRegionalDomainName: `${props.bucketName}.s3.${region}.amazonaws.com`,
@@ -79,11 +78,9 @@ export class Bucket extends Resource("s3::Bucket", async (ctx, props) => {
             versioningEnabled: versioningResponse.Status === "Enabled",
             acl: aclResponse.Grants?.[0]?.Permission?.toLowerCase(),
             ...(tags && { tags }),
-        };
-        return output;
+        });
     }
-}) {
-}
+});
 // Helper function to get S3 hosted zone IDs by region
 function getHostedZoneId(region) {
     const hostedZoneIds = {
@@ -111,4 +108,3 @@ function getHostedZoneId(region) {
     };
     return hostedZoneIds[region] || "Z3AQBSTGFYJSTF"; // Default to us-east-1 if region not found
 }
-//# sourceMappingURL=bucket.js.map

package/lib/aws/function.d.ts

@@ -1,4 +1,6 @@
 import { Architecture, Runtime } from "@aws-sdk/client-lambda";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 export interface FunctionProps {
     functionName: string;
     zipPath: string;
@@ -23,8 +25,7 @@ export interface FunctionProps {
         };
     };
 }
-export interface FunctionOutput extends FunctionProps {
-    id: string;
+export interface Function extends Resource<"lambda::Function">, FunctionProps {
     arn: string;
     lastModified: string;
     version: string;
@@ -46,8 +47,4 @@ export interface FunctionOutput extends FunctionProps {
     signingProfileVersionArn?: string;
     signingJobArn?: string;
 }
-declare const Function_base: import("../resource").Provider<"lambda::Function", [props: FunctionProps], FunctionOutput>;
-export declare class Function extends Function_base {
-}
-export {};
-//# sourceMappingURL=function.d.ts.map
+export declare const Function: ((this: Context<Function>, id: string, props: FunctionProps) => Promise<Function>) | (((this: any, id: string, props: FunctionProps) => never) & (new (_: never) => never));

package/lib/aws/function.js

@@ -1,8 +1,8 @@
 import { Architecture, CreateFunctionCommand, DeleteFunctionCommand, GetFunctionCommand, GetFunctionConfigurationCommand, LambdaClient, ResourceNotFoundException, Runtime, UpdateFunctionCodeCommand, UpdateFunctionConfigurationCommand, } from "@aws-sdk/client-lambda";
 import fs from "node:fs";
 import path from "node:path";
-import { ignore } from "../error";
 import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
 async function resolveRegion(client) {
     const region = client.config.region;
     if (typeof region === "string")
@@ -11,40 +11,23 @@ async function resolveRegion(client) {
         return region();
     throw new Error("Could not resolve AWS region");
 }
-export class Function extends Resource("lambda::Function", async (ctx, props) => {
+export const Function = Resource("lambda::Function", async function (id, props) {
     const client = new LambdaClient({});
     const region = await resolveRegion(client);
     const code = await zipCode(props.zipPath);
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         await ignore(ResourceNotFoundException.name, () => client.send(new DeleteFunctionCommand({
             FunctionName: props.functionName,
         })));
-        // Return a minimal FunctionOutput for deleted state
-        return {
-            ...props,
-            id: props.functionName,
-            arn: `arn:aws:lambda:${region}:${process.env.AWS_ACCOUNT_ID}:function:${props.functionName}`,
-            lastModified: new Date().toISOString(),
-            version: "$LATEST",
-            qualifiedArn: `arn:aws:lambda:${region}:${process.env.AWS_ACCOUNT_ID}:function:${props.functionName}:$LATEST`,
-            invokeArn: `arn:aws:apigateway:${region}:lambda:path/2015-03-31/functions/arn:aws:lambda:${region}:${process.env.AWS_ACCOUNT_ID}:function:${props.functionName}/invocations`,
-            sourceCodeHash: "",
-            sourceCodeSize: 0,
-            architectures: props.architecture
-                ? [props.architecture]
-                : [Architecture.x86_64],
-            revisionId: "",
-            state: "Inactive",
-            packageType: "Zip",
-        };
+        return this.destroy();
     }
     else {
         try {
             // Check if function exists
-            const func = await client.send(new GetFunctionCommand({
+            await client.send(new GetFunctionCommand({
                 FunctionName: props.functionName,
             }));
-            if (ctx.event === "update") {
+            if (this.phase === "update") {
                 // Wait for function to stabilize
                 await waitForFunctionStabilization(client, props.functionName);
                 // Update function code
@@ -134,9 +117,8 @@ export class Function extends Resource("lambda::Function", async (ctx, props) =>
                 FunctionName: props.functionName,
             })),
         ]);
-        const output = {
+        return this({
             ...props,
-            id: props.functionName,
             arn: config.FunctionArn,
             lastModified: config.LastModified,
             version: config.Version,
@@ -157,11 +139,9 @@ export class Function extends Resource("lambda::Function", async (ctx, props) =>
             packageType: config.PackageType,
             signingProfileVersionArn: config.SigningProfileVersionArn,
             signingJobArn: config.SigningJobArn,
-        };
-        return output;
+        });
     }
-}) {
-}
+});
 // Helper to wait for function to stabilize
 async function waitForFunctionStabilization(client, functionName) {
     while (true) {
@@ -192,4 +172,3 @@ async function zipCode(filePath) {
         platform: "UNIX",
     });
 }
-//# sourceMappingURL=function.js.map

package/lib/aws/index.d.ts

@@ -2,8 +2,8 @@ export * from "./account-id";
 export * from "./bucket";
 export * from "./function";
 export * from "./policy";
+export * from "./policy-attachment";
 export * from "./queue";
 export * from "./role";
 export * from "./ses";
 export * from "./table";
-//# sourceMappingURL=index.d.ts.map

package/lib/aws/index.js

@@ -2,8 +2,8 @@ export * from "./account-id";
 export * from "./bucket";
 export * from "./function";
 export * from "./policy";
+export * from "./policy-attachment";
 export * from "./queue";
 export * from "./role";
 export * from "./ses";
 export * from "./table";
-//# sourceMappingURL=index.js.map

package/lib/aws/oidc/github-oidc-provider.d.ts

@@ -1,11 +1,7 @@
-import type { Input } from "../../input";
 import { OIDCProvider, type OIDCProviderProps } from "./oidc-provider";
 export interface GitHubOIDCProviderProps extends Omit<OIDCProviderProps, "thumbprint"> {
     owner: string;
     repository: string;
-    thumbprint?: string;
 }
-export declare class GitHubOIDCProvider extends OIDCProvider {
-    constructor(id: string, props: Input<GitHubOIDCProviderProps>);
-}
-//# sourceMappingURL=github-oidc-provider.d.ts.map
+export type GitHubOIDCProvider = ReturnType<typeof GitHubOIDCProvider>;
+export declare const GitHubOIDCProvider: (id: string, props: GitHubOIDCProviderProps) => Promise<OIDCProvider>;

package/lib/aws/oidc/github-oidc-provider.js

@@ -1,4 +1,3 @@
-import { isOutput } from "../../output";
 import { OIDCProvider } from "./oidc-provider";
 /**
  * Default thumbprint for GitHub's OIDC provider
@@ -6,17 +5,13 @@ import { OIDCProvider } from "./oidc-provider";
  * @see https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services#adding-the-identity-provider-to-aws
  */
 const DEFAULT_GITHUB_THUMBPRINT = "6938fd4d98bab03faadb97b34396831e3780aea1";
-export class GitHubOIDCProvider extends OIDCProvider {
-    constructor(id, props) {
-        super(id, isOutput(props)
-            ? props.apply((props) => ({
-                ...props,
-                thumbprint: props.thumbprint ?? DEFAULT_GITHUB_THUMBPRINT,
-            }))
-            : {
-                ...props,
-                thumbprint: props.thumbprint ?? DEFAULT_GITHUB_THUMBPRINT,
-            });
-    }
-}
-//# sourceMappingURL=github-oidc-provider.js.map
+export const GitHubOIDCProvider = async (id, props) => {
+    return OIDCProvider(id, {
+        owner: props.owner,
+        repository: props.repository,
+        roleArn: props.roleArn,
+        branches: props.branches,
+        environments: props.environments,
+        thumbprint: DEFAULT_GITHUB_THUMBPRINT,
+    });
+};

package/lib/aws/oidc/index.d.ts

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

package/lib/aws/oidc/index.js

@@ -1,3 +1,2 @@
 export * from "./github-oidc-provider";
 export * from "./oidc-provider";
-//# sourceMappingURL=index.js.map

package/lib/aws/oidc/oidc-provider.d.ts

@@ -1,3 +1,5 @@
+import type { Context } from "../../context";
+import { Resource } from "../../resource";
 /**
  * Properties for configuring an AWS OIDC provider for GitHub Actions
  */
@@ -40,7 +42,7 @@ export interface OIDCProviderProps {
 /**
  * Output returned after OIDC provider configuration
  */
-export interface OIDCProviderOutput extends OIDCProviderProps {
+export interface OIDCProvider extends Resource<"aws::OIDCProvider">, OIDCProviderProps {
     /**
      * The ARN of the OIDC provider
      */
@@ -50,11 +52,7 @@ export interface OIDCProviderOutput extends OIDCProviderProps {
      */
     createdAt: number;
 }
-declare const OIDCProvider_base: import("../../resource").Provider<"aws::OIDCProvider", [props: OIDCProviderProps], OIDCProviderOutput>;
 /**
  * Resource for configuring AWS OIDC provider for GitHub Actions
  */
-export declare class OIDCProvider extends OIDCProvider_base {
-}
-export {};
-//# sourceMappingURL=oidc-provider.d.ts.map
+export declare const OIDCProvider: ((this: Context<OIDCProvider>, id: string, props: OIDCProviderProps) => Promise<OIDCProvider>) | (((this: any, id: string, props: OIDCProviderProps) => never) & (new (_: never) => never));