alchemy 0.1.8 → 0.1.10

package/test/aws/role.test.ts

@@ -1,153 +0,0 @@
-import {
-  GetRoleCommand,
-  IAMClient,
-  NoSuchEntityException,
-} from "@aws-sdk/client-iam";
-import { describe, expect, test } from "bun:test";
-import { apply } from "../../src/apply";
-import type { PolicyDocument } from "../../src/aws/policy";
-import { Role, type RoleProps } from "../../src/aws/role";
-import { destroy } from "../../src/destroy";
-
-// Verify role was deleted
-const iam = new IAMClient({});
-
-describe("AWS Resources", () => {
-  describe("Role", () => {
-    const assumeRolePolicy: PolicyDocument = {
-      Version: "2012-10-17",
-      Statement: [
-        {
-          Effect: "Allow",
-          Principal: {
-            Service: "lambda.amazonaws.com",
-          },
-          Action: "sts:AssumeRole",
-        },
-      ],
-    };
-
-    const inlinePolicy: PolicyDocument = {
-      Version: "2012-10-17",
-      Statement: [
-        {
-          Effect: "Allow",
-          Action: [
-            "logs:CreateLogGroup",
-            "logs:CreateLogStream",
-            "logs:PutLogEvents",
-          ],
-          Resource: "*",
-        },
-      ],
-    };
-
-    test("create role", async () => {
-      const role = new Role("alchemy-test-create-role", {
-        roleName: "alchemy-test-create-role",
-        assumeRolePolicy,
-        description: "Test role for IAC",
-        tags: {
-          Environment: "test",
-        },
-        policies: [
-          {
-            policyName: "logs",
-            policyDocument: inlinePolicy,
-          },
-        ],
-      });
-
-      const output = await apply(role);
-      expect(output.id).toBe("alchemy-test-create-role");
-      expect(output.arn).toMatch(
-        /^arn:aws:iam::\d+:role\/alchemy-test-create-role$/,
-      );
-      expect(output.uniqueId).toBeTruthy();
-      expect(output.roleId).toBeTruthy();
-      expect(output.createDate).toBeInstanceOf(Date);
-
-      await destroy(role);
-
-      await assertRoleNotExists("alchemy-test-create-role");
-    });
-
-    test("update role", async () => {
-      const roleProps: RoleProps = {
-        roleName: "alchemy-test-update-role",
-        assumeRolePolicy,
-        description: "Updated test role for IAC",
-        maxSessionDuration: 7200,
-        tags: {
-          Environment: "test",
-          Updated: "true",
-        },
-        policies: [
-          {
-            policyName: "logs",
-            policyDocument: inlinePolicy,
-          },
-          {
-            policyName: "extra",
-            policyDocument: {
-              Version: "2012-10-17",
-              Statement: [
-                {
-                  Effect: "Allow",
-                  Action: "s3:ListBucket",
-                  Resource: "*",
-                },
-              ],
-            },
-          },
-        ],
-      };
-      let role = new Role("alchemy-test-update-role", roleProps);
-
-      let output = await apply(role);
-      expect(output.id).toBe("alchemy-test-update-role");
-      expect(output.description).toBe("Updated test role for IAC");
-      expect(output.maxSessionDuration).toBe(7200);
-      expect(output.tags).toEqual({
-        Environment: "test",
-        Updated: "true",
-      });
-
-      role = new Role("alchemy-test-update-role", {
-        ...roleProps,
-        description: "Updated test role for IAC",
-        policies: [
-          {
-            policyName: "logs",
-            policyDocument: inlinePolicy,
-          },
-          // 1 policy removed
-        ],
-      });
-
-      output = await apply(role);
-
-      expect(output.description).toBe("Updated test role for IAC");
-      expect(output.policies).toEqual([
-        {
-          policyName: "logs",
-          policyDocument: inlinePolicy,
-        },
-      ]);
-
-      await destroy(role);
-
-      await assertRoleNotExists("alchemy-test-update-role");
-    });
-  });
-});
-
-async function assertRoleNotExists(roleName: string) {
-  await expect(
-    iam.send(
-      new GetRoleCommand({
-        RoleName: "alchemy-test-create-role",
-      }),
-    ),
-  ).rejects.toThrow(NoSuchEntityException);
-}

package/test/aws/table.test.ts

@@ -1,73 +0,0 @@
-import {
-  DescribeTableCommand,
-  DynamoDBClient,
-  ResourceNotFoundException,
-} from "@aws-sdk/client-dynamodb";
-import { describe, expect, test } from "bun:test";
-import { apply } from "../../src/apply";
-import { Table } from "../../src/aws/table";
-import { destroy } from "../../src/destroy";
-
-const dynamo = new DynamoDBClient({});
-
-describe("AWS Resources", () => {
-  describe("Table", () => {
-    test("create table", async () => {
-      const table = new Table("alchemy-test-create-table", {
-        tableName: "alchemy-test-create-table",
-        partitionKey: {
-          name: "id",
-          type: "S",
-        },
-        sortKey: {
-          name: "timestamp",
-          type: "N",
-        },
-        tags: {
-          Environment: "test",
-        },
-      });
-
-      const output = await apply(table);
-      expect(output.id).toBe("alchemy-test-create-table");
-      expect(output.arn).toMatch(
-        /^arn:aws:dynamodb:[a-z0-9-]+:\d+:table\/alchemy-test-create-table$/,
-      );
-      expect(output.tableId).toBeTruthy();
-      expect(output.partitionKey).toEqual({
-        name: "id",
-        type: "S",
-      });
-      expect(output.sortKey).toEqual({
-        name: "timestamp",
-        type: "N",
-      });
-      expect(output.tags).toEqual({
-        Environment: "test",
-      });
-
-      // Verify table exists and is active
-      const describeResponse = await dynamo.send(
-        new DescribeTableCommand({
-          TableName: "alchemy-test-create-table",
-        }),
-      );
-      expect(describeResponse.Table?.TableStatus).toBe("ACTIVE");
-
-      await destroy(table);
-
-      // Verify table is fully deleted
-      await assertTableNotExists("alchemy-test-create-table");
-    });
-  });
-});
-
-async function assertTableNotExists(tableName: string) {
-  await expect(
-    dynamo.send(
-      new DescribeTableCommand({
-        TableName: tableName,
-      }),
-    ),
-  ).rejects.toThrow(ResourceNotFoundException);
-}

package/test/esbuild.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import path from "node:path";
-import { apply } from "../src/apply";
-import { destroy } from "../src/destroy";
-import { Bundle } from "../src/esbuild";
-
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-
-describe("esbuild", () => {
-  describe("Bundle", () => {
-    const outputDir = ".out";
-    const outputFile = path.join(outputDir, "handler.js");
-
-    test("bundle and cleanup", async () => {
-      const bundle = new Bundle("test-bundle", {
-        entryPoint: path.join(__dirname, "handler.ts"),
-        outdir: outputDir,
-        format: "esm",
-        platform: "node",
-        target: "node18",
-      });
-
-      // Apply the bundle
-      const output = await apply(bundle);
-      expect(output.path).toBe(outputFile);
-      expect(output.hash).toBeTruthy();
-
-      // Verify the file exists and contains our code
-      expect(fs.existsSync(outputFile)).toBe(true);
-      const contents = await fs.promises.readFile(outputFile, "utf-8");
-      expect(contents).toContain("Hello from bundled handler");
-
-      // Destroy the bundle
-      await destroy(bundle);
-
-      // Verify the file is deleted
-      expect(fs.existsSync(outputFile)).toBe(false);
-    });
-  });
-});

package/test/handler.ts

@@ -1,9 +0,0 @@
-export async function handler(event: any) {
-  return {
-    statusCode: 200,
-    body: JSON.stringify({
-      message: "Hello from bundled handler!",
-      event,
-    }),
-  };
-}

package/test/scope.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { apply } from "../src/apply";
-import type { PolicyDocument } from "../src/aws/policy";
-import { Role } from "../src/aws/role";
-import { destroy } from "../src/destroy";
-import { File } from "../src/fs";
-import { rootScope } from "../src/global";
-import { type Context, Resource } from "../src/resource";
-import { Scope, getScope, withScope } from "../src/scope";
-
-describe("Scope", () => {
-  it("should maintain scope context and track resources", async () => {
-    const testScope = new Scope("test");
-
-    await withScope(testScope, async () => {
-      new File("test-file", "test.txt", "Hello World");
-
-      const currentScope = getScope();
-      expect(currentScope).toEqual(testScope);
-    });
-    expect(testScope.nodes.size).toBe(1);
-    expect(testScope).toBe(testScope);
-    expect(testScope).not.toBe(rootScope);
-  });
-
-  it("should handle nested resources with AWS Role", async () => {
-    class ServiceResources extends Resource(
-      "service-resources",
-      async (
-        ctx: Context<{ roleArn: string }>,
-        props: { roleName: string },
-      ) => {
-        const assumeRolePolicy: PolicyDocument = {
-          Version: "2012-10-17",
-          Statement: [
-            {
-              Effect: "Allow",
-              Principal: {
-                Service: "lambda.amazonaws.com",
-              },
-              Action: "sts:AssumeRole",
-            },
-          ],
-        };
-
-        const role = new Role(`role`, {
-          roleName: props.roleName,
-          assumeRolePolicy,
-        });
-
-        return {
-          roleArn: role.arn,
-        };
-      },
-    ) {}
-
-    const service = new ServiceResources("test-service", {
-      roleName: "alchemy-test-scope-role",
-    });
-
-    // Apply the parent resource which should create the role
-    const output = await apply(service);
-
-    // Clean up
-    await destroy(service);
-  });
-});

package/test/stripe/stripe.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import Stripe from "stripe";
-import { apply } from "../../src/apply";
-import { destroy } from "../../src/destroy";
-import { Price } from "../../src/stripe/price";
-import { Product } from "../../src/stripe/product";
-import { WebhookEndpoint } from "../../src/stripe/webhook";
-
-const stripeApiKey = process.env.STRIPE_API_KEY;
-if (!stripeApiKey) {
-  throw new Error("STRIPE_API_KEY environment variable is required");
-}
-
-// Initialize a Stripe client for verification
-const stripe = new Stripe(stripeApiKey);
-
-describe("Stripe Resources", () => {
-  test("create and destroy stripe resources", async () => {
-    // Create a test product
-    const product = new Product("alchemy-test-product", {
-      name: "Alchemy Test Product",
-      description: "A product created by Alchemy tests",
-    });
-
-    // Apply the product first to get its ID
-    const productOutput = await apply(product);
-    expect(productOutput.id).toBeTruthy();
-    expect(productOutput.name).toBe("Alchemy Test Product");
-
-    // Verify with Stripe API
-    const stripeProduct = await stripe.products.retrieve(productOutput.id);
-    expect(stripeProduct.name).toBe("Alchemy Test Product");
-
-    // Create a price for the product
-    const price = new Price("alchemy-test-price", {
-      product: productOutput.id,
-      currency: "usd",
-      unitAmount: 1500, // $15.00
-      recurring: {
-        interval: "month",
-      },
-    });
-
-    // Apply the price
-    const priceOutput = await apply(price);
-    expect(priceOutput.id).toBeTruthy();
-    expect(priceOutput.unitAmount).toBe(1500);
-    expect(priceOutput.recurring?.interval).toBe("month");
-
-    // Verify with Stripe API
-    const stripePrice = await stripe.prices.retrieve(priceOutput.id);
-    expect(stripePrice.unit_amount).toBe(1500);
-
-    // Create a webhook endpoint
-    const webhook = new WebhookEndpoint("alchemy-test-webhook", {
-      url: "https://example.com/alchemy-webhook",
-      enabledEvents: [
-        "checkout.session.completed",
-        "customer.subscription.created",
-      ],
-      description: "Webhook for Alchemy tests",
-    });
-
-    // Apply the webhook
-    const webhookOutput = await apply(webhook);
-    expect(webhookOutput.id).toBeTruthy();
-    expect(webhookOutput.url).toBe("https://example.com/alchemy-webhook");
-    expect(webhookOutput.secret).toBeTruthy();
-
-    // Verify with Stripe API
-    const stripeWebhook = await stripe.webhookEndpoints.retrieve(
-      webhookOutput.id,
-    );
-    expect(stripeWebhook.url).toBe("https://example.com/alchemy-webhook");
-
-    // Clean up resources
-    console.log("Cleaning up Stripe resources...");
-    await destroy(webhook);
-    await destroy(price);
-    await destroy(product);
-
-    // Verify clean up
-    await assertProductDeactivated(productOutput.id);
-    await assertPriceDeactivated(priceOutput.id);
-    await assertWebhookDeleted(webhookOutput.id);
-  });
-});
-
-// Helper functions for verification
-async function assertProductDeactivated(productId: string) {
-  try {
-    const product = await stripe.products.retrieve(productId);
-    // Products are deactivated, not deleted
-    expect(product.active).toBe(false);
-  } catch (error) {
-    // If product is not found, that's also acceptable
-    if (
-      error instanceof Stripe.errors.StripeError &&
-      error.code === "resource_missing"
-    ) {
-      return;
-    }
-    throw error;
-  }
-}
-
-async function assertPriceDeactivated(priceId: string) {
-  try {
-    const price = await stripe.prices.retrieve(priceId);
-    // Prices are deactivated, not deleted
-    expect(price.active).toBe(false);
-  } catch (error) {
-    // If price is not found, that's also acceptable
-    if (
-      error instanceof Stripe.errors.StripeError &&
-      error.code === "resource_missing"
-    ) {
-      return;
-    }
-    throw error;
-  }
-}
-
-async function assertWebhookDeleted(webhookId: string) {
-  try {
-    await stripe.webhookEndpoints.retrieve(webhookId);
-    throw new Error("Webhook still exists");
-  } catch (error) {
-    // Webhook should be deleted, so we expect a resource_missing error
-    if (error instanceof Stripe.errors.StripeError) {
-      expect(error.code).toBe("resource_missing");
-    } else {
-      throw error;
-    }
-  }
-}

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-  "include": ["src/**/*"],
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./lib",
-    "noEmit": false,
-    // Enable latest features
-    "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "verbatimModuleSyntax": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}