alchemy 0.0.8 → 0.1.2

package/src/components/aws/table.ts

@@ -0,0 +1,172 @@
+import {
+  CreateTableCommand,
+  DeleteTableCommand,
+  DescribeTableCommand,
+  DynamoDBClient,
+  type KeySchemaElement,
+  ResourceInUseException,
+  ResourceNotFoundException,
+} from "@aws-sdk/client-dynamodb";
+import { ignore } from "../../error";
+import { type Context, Resource } from "../../resource";
+
+export interface TableProps {
+  tableName: string;
+  partitionKey: {
+    name: string;
+    type: "S" | "N" | "B";
+  };
+  sortKey?: {
+    name: string;
+    type: "S" | "N" | "B";
+  };
+  billingMode?: "PROVISIONED" | "PAY_PER_REQUEST";
+  readCapacity?: number;
+  writeCapacity?: number;
+  tags?: Record<string, string>;
+}
+
+export interface TableOutput extends TableProps {
+  id: string; // Same as tableName
+  arn: string;
+  streamArn?: string;
+  tableId: string;
+}
+
+export class Table extends Resource(
+  "dynamo::Table",
+  async (
+    ctx: Context<TableOutput>,
+    props: TableProps,
+  ): Promise<TableOutput> => {
+    const client = new DynamoDBClient({});
+
+    if (ctx.event === "delete") {
+      await ignore(ResourceNotFoundException.name, () =>
+        client.send(
+          new DeleteTableCommand({
+            TableName: props.tableName,
+          }),
+        ),
+      );
+
+      // Wait for table to be deleted
+      let tableDeleted = false;
+      while (!tableDeleted) {
+        try {
+          await client.send(
+            new DescribeTableCommand({
+              TableName: props.tableName,
+            }),
+          );
+          // If we get here, table still exists
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        } catch (error) {
+          if (error instanceof ResourceNotFoundException) {
+            tableDeleted = true;
+          } else {
+            throw error;
+          }
+        }
+      }
+
+      return {
+        ...props,
+        id: props.tableName,
+        arn: `arn:aws:dynamodb:${client.config.region}:${process.env.AWS_ACCOUNT_ID}:table/${props.tableName}`,
+        tableId: "",
+      };
+    } else {
+      try {
+        const attributeDefinitions = [
+          {
+            AttributeName: props.partitionKey.name,
+            AttributeType: props.partitionKey.type,
+          },
+        ];
+
+        const keySchema: KeySchemaElement[] = [
+          {
+            AttributeName: props.partitionKey.name,
+            KeyType: "HASH",
+          },
+        ];
+
+        if (props.sortKey) {
+          attributeDefinitions.push({
+            AttributeName: props.sortKey.name,
+            AttributeType: props.sortKey.type,
+          });
+          keySchema.push({
+            AttributeName: props.sortKey.name,
+            KeyType: "RANGE",
+          });
+        }
+
+        await client.send(
+          new CreateTableCommand({
+            TableName: props.tableName,
+            AttributeDefinitions: attributeDefinitions,
+            KeySchema: keySchema,
+            BillingMode: props.billingMode || "PAY_PER_REQUEST",
+            ProvisionedThroughput:
+              props.billingMode === "PROVISIONED"
+                ? {
+                    ReadCapacityUnits: props.readCapacity || 5,
+                    WriteCapacityUnits: props.writeCapacity || 5,
+                  }
+                : undefined,
+            Tags: props.tags
+              ? Object.entries(props.tags).map(([Key, Value]) => ({
+                  Key,
+                  Value,
+                }))
+              : undefined,
+          }),
+        );
+
+        // Wait for table to be active
+        let tableActive = false;
+        let tableDescription;
+        while (!tableActive) {
+          const response = await client.send(
+            new DescribeTableCommand({
+              TableName: props.tableName,
+            }),
+          );
+          tableActive = response.Table?.TableStatus === "ACTIVE";
+          if (tableActive) {
+            tableDescription = response.Table;
+          } else {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          }
+        }
+
+        return {
+          ...props,
+          id: props.tableName,
+          arn: tableDescription!.TableArn!,
+          streamArn: tableDescription!.LatestStreamArn,
+          tableId: tableDescription!.TableId!,
+        };
+      } catch (error) {
+        if (error instanceof ResourceInUseException) {
+          // Table already exists, get its details
+          const response = await client.send(
+            new DescribeTableCommand({
+              TableName: props.tableName,
+            }),
+          );
+          return {
+            ...props,
+            id: props.tableName,
+            arn: response.Table!.TableArn!,
+            streamArn: response.Table!.LatestStreamArn,
+            tableId: response.Table!.TableId!,
+          };
+        }
+        throw error;
+      }
+    }
+  },
+) {}

package/src/components/esbuild.ts

@@ -0,0 +1,128 @@
+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 interface BundleProps {
+  /**
+   * Entry point for the bundle
+   */
+  entryPoint: string;
+  /**
+   * Output directory for the bundle
+   */
+  outdir?: string;
+  /**
+   * Output filename for the bundle
+   */
+  outfile?: string;
+  /**
+   * Bundle format (iife, cjs, esm)
+   */
+  format?: "iife" | "cjs" | "esm";
+  /**
+   * Target environment (e.g., 'node16', 'es2020')
+   */
+  target?: string | string[];
+  /**
+   * Whether to minify the output
+   */
+  minify?: boolean;
+  /**
+   * Whether to generate sourcemaps
+   */
+  sourcemap?: boolean | "inline" | "external" | "both";
+  /**
+   * External packages to exclude from bundle
+   */
+  external?: string[];
+  /**
+   * Platform to target (browser, node, neutral)
+   */
+  platform?: "browser" | "node" | "neutral";
+  /**
+   * Additional esbuild options
+   */
+  options?: Partial<esbuild.BuildOptions>;
+}
+
+export interface BundleOutput {
+  /**
+   * Path to the bundled file
+   */
+  path: string;
+  /**
+   * SHA-256 hash of the bundle contents
+   */
+  hash: string;
+}
+
+export class Bundle extends Resource(
+  "esbuild::Bundle",
+  async (ctx, props: BundleProps): Promise<BundleOutput> => {
+    // Determine output path
+    const outputPath =
+      props.outfile ||
+      path.join(
+        props.outdir || "dist",
+        path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js",
+      );
+
+    // Ensure output directory exists
+    await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+
+    if (ctx.event === "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: "" };
+    }
+
+    // Build the bundle
+    const result = await esbuild.build({
+      entryPoints: [props.entryPoint],
+      outfile: outputPath,
+      bundle: true,
+      format: props.format,
+      target: props.target,
+      minify: props.minify,
+      sourcemap: props.sourcemap,
+      external: props.external,
+      platform: props.platform,
+      metafile: true,
+      write: true,
+      ...props.options,
+    });
+
+    // 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);
+
+    // Return output info
+    return {
+      path: outputPath,
+      hash,
+    };
+  },
+) {
+  /**
+   * Get the metafile from the last build
+   */
+  public async getMetafile(ctx: {
+    get<T>(key: string): Promise<T | undefined>;
+  }) {
+    return ctx.get<esbuild.Metafile>("metafile");
+  }
+
+  /**
+   * Get the hash from the last build
+   */
+  public async getHash(ctx: { get<T>(key: string): Promise<T | undefined> }) {
+    return ctx.get<string>("hash");
+  }
+}

package/src/components/fs.ts

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ignore } from "../error";
+import { Resource } from "../resource";
+
+export class File extends Resource(
+  "fs::File",
+  async (ctx, filePath: string, content: string) => {
+    if (ctx.event === "delete") {
+      await ignore("ENOENT", () => fs.promises.unlink(filePath));
+    } else {
+      await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+      await fs.promises.writeFile(filePath, content);
+    }
+    return filePath;
+  },
+) {}
+
+export class Folder extends Resource(
+  "fs::Folder",
+  async (ctx, dirPath: string) => {
+    if (ctx.event === "delete") {
+      if (await ctx.get("isOwned")) {
+        // only delete the folder if we own it (we created it)
+        await ignore("ENOENT", () => fs.promises.rmdir(dirPath));
+      }
+    } else {
+      try {
+        await fs.promises.mkdir(dirPath, { recursive: true });
+      } catch (error: any) {
+        if (error.code === "EEXIST") {
+          // record that we own the directory
+          await ctx.set("isOwned", true);
+        } else {
+          throw error;
+        }
+      }
+    }
+    return dirPath;
+  },
+) {
+  public file(filePath: string, content: string) {
+    return new File(path.basename(filePath), filePath, content);
+  }
+}

package/src/destroy.ts

@@ -0,0 +1,63 @@
+import { defaultStage, stateStore } from "./global";
+import type { Output } from "./output";
+import { Provider, ResourceID, isResource } from "./resource";
+import type { State } from "./state";
+
+interface DestroyOptions {
+  stage?: string;
+}
+
+/**
+ * Prune all resources from an Output and "down", i.e. that branches from it.
+ */
+export async function destroy<T>(
+  output: Output<T>,
+  options?: DestroyOptions,
+): Promise<void>;
+
+/**
+ * @internal
+ */
+export async function destroy<T>(
+  stage: string,
+  resourceID: ResourceID,
+  resourceState: State,
+  resourceProvider: Provider,
+): Promise<void>;
+
+export async function destroy<T>(
+  ...args: [Output<T>, DestroyOptions?] | [string, ResourceID, State, Provider]
+): Promise<void> {
+  let resourceID: ResourceID;
+  let resourceState: State;
+  let resourceProvider: Provider;
+  let stage: string;
+
+  if (args.length === 4) {
+    stage = args[0];
+    resourceID = args[1];
+    resourceState = args[2];
+    resourceProvider = args[3];
+  } else if (isResource(args[0])) {
+    const resource = args[0];
+    stage = args[1]?.stage ?? defaultStage;
+    resourceID = resource[ResourceID];
+    // First destroy all dependencies
+    const _resourceState = await stateStore.get(stage, resourceID);
+    if (_resourceState === undefined) {
+      // we have no record of this resource, we must assume it's already deleted
+      return;
+    }
+    resourceState = _resourceState;
+    resourceProvider = resource[Provider];
+  } else {
+    throw new Error("Not implemented: must handle destroy a Output chain");
+  }
+  await resourceProvider.delete(
+    stage,
+    resourceID,
+    resourceState,
+    resourceState.inputs as [],
+  );
+  await stateStore.delete(stage, resourceID);
+}

package/src/error.ts

@@ -0,0 +1,16 @@
+export async function ignore<T>(
+  codes: string | string[],
+  fn: () => Promise<T>,
+): Promise<T | undefined> {
+  try {
+    return await fn();
+  } catch (error: any) {
+    const errorCode = error.code || error.name;
+    if (
+      Array.isArray(codes) ? codes.includes(errorCode) : errorCode === codes
+    ) {
+      return undefined;
+    }
+    throw error;
+  }
+}

package/src/global.ts

@@ -0,0 +1,72 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Provider, Resource, ResourceID, ResourceType } from "./resource";
+import { defaultStore, type StateStore } from "./state";
+
+export interface Config {
+  defaultStage?: string;
+  stateStore?: StateStore;
+}
+
+const alchemy = path.resolve(process.cwd(), "alchemy.ts");
+
+let _config: Config | undefined;
+
+const exists =
+  fs.promises.exists ??
+  async function exists(path: string): Promise<boolean> {
+    try {
+      await fs.promises.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+if (await exists(alchemy)) {
+  const mod = await import(alchemy);
+  if (mod) {
+    const config = mod.default as Config | undefined;
+    if (config) {
+      if (typeof config !== "object") {
+        throw new Error("Config is not an object");
+      }
+      if (typeof config.defaultStage !== "string") {
+        throw new Error("Config.stage is not a string");
+      }
+      _config = config;
+    }
+  }
+}
+
+const _stage = process.env.ALCHEMY_STAGE ?? process.env.USER ?? "dev";
+
+export const config: Config = _config ?? {
+  defaultStage: _stage,
+  stateStore: defaultStore,
+};
+
+export const defaultStage = config.defaultStage ?? _stage;
+
+export const stateStore = config.stateStore ?? defaultStore;
+
+export const nodes = new Map<
+  ResourceID,
+  {
+    provider: Provider<any, any[], any>;
+    resource: Resource<any, any>;
+  }
+>();
+
+export const providers = new Map<
+  ResourceType,
+  Provider<ResourceType, any[], any>
+>();
+
+export const deletions: {
+  id: string;
+  data: Record<string, any>;
+  inputs: any[];
+}[] = [];
+
+await stateStore.init?.();

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from "./alchemize";
+export * from "./global";
+export * from "./output";
+export * from "./resource";
+
+export type { StateStore } from "./state";

package/src/input.ts

@@ -0,0 +1,16 @@
+import type { Output } from "./output";
+
+export type Inputs<P extends any[]> = P extends [infer First, ...infer Rest]
+  ? [Input<First>, ...Inputs<Rest>]
+  : [];
+
+export type Input<T> =
+  | T
+  | Output<T>
+  | (T extends any[] ? Inputs<T> : never)
+  | (T extends string | number | boolean ? Output<T> : never)
+  | (T extends object
+      ? {
+          [k in keyof T]: Input<T[k]>;
+        }
+      : never);

package/src/main.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+import { parseArgs } from "util";
+
+const { values, positionals } = parseArgs({
+  args: Bun.argv.slice(2),
+  options: {
+    help: {
+      type: "boolean",
+      short: "h",
+    },
+  },
+  strict: true,
+  allowPositionals: true,
+});
+
+if (values.help || positionals.length === 0) {
+  console.error("Usage: iac <command> [args]");
+  console.error("\nCommands:");
+  console.error("  destroy [stack names]  Delete the specified stacks");
+  process.exit(1);
+}
+
+const [command, ...restArgs] = positionals;
+
+if (command.toLowerCase() === "destroy") {
+  if (restArgs.length === 0) {
+    console.error("Error: Please specify at least one stack name to destroy");
+    process.exit(1);
+  }
+  console.log("Deleting stacks:", restArgs);
+} else {
+  console.error(`Unknown command: ${command}`);
+  process.exit(1);
+}

package/src/output.ts

@@ -0,0 +1,49 @@
+export type Eval<U> = U extends Output<infer V> ? Eval<V> : U;
+
+export type Outputs<P extends readonly any[]> = P extends [
+  infer First,
+  ...infer Rest,
+]
+  ? [Output<First>, ...Outputs<Rest>]
+  : [];
+
+export type Output<T> = {
+  apply<U>(fn: (value: T) => U): Output<Eval<U>>;
+} & (T extends string
+  ? {
+      [k in keyof typeof String.prototype]: Output<
+        (typeof String.prototype)[k]
+      >;
+    }
+  : T extends number
+    ? {
+        [K in keyof typeof Number.prototype]: Output<
+          (typeof Number.prototype)[K]
+        >;
+      }
+    : T extends boolean
+      ? {
+          [K in keyof typeof Boolean.prototype]: Output<
+            (typeof Boolean.prototype)[K]
+          >;
+        }
+      : T extends any[]
+        ? Outputs<T>
+        : {
+            [k in keyof T]: Output<T[k]>;
+          });
+
+export const Output = class<T, U> {
+  constructor(
+    public readonly parent: Output<T>,
+    public readonly fn: (value: T) => U,
+  ) {}
+
+  public apply<V>(fn: (value: U) => V): Output<V> {
+    // @ts-expect-error - we know we are an "Output"
+    return new Output(this, fn);
+  }
+} as new <T, U>(
+  parent: Output<T>,
+  fn: (value: T) => U,
+) => Output<U>;