alchemy 0.0.8 → 0.1.1

package/test/aws/role.test.ts

@@ -0,0 +1,153 @@
+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/components/aws";
+import { Role, type RoleProps } from "../../src/components/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

@@ -0,0 +1,73 @@
+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/components/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

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import path from "node:path";
+import { apply } from "../src/apply";
+import { Bundle } from "../src/components/esbuild";
+import { destroy } from "../src/destroy";
+
+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

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

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": ["src/**/*"],
+  "compilerOptions": {
+    "composite": true
+  }
+}

package/Column.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Column')

package/Create.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Create')

package/Delete.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Delete')

package/Drop.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Drop')

package/Insert.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Insert')

package/Makefile

@@ -1,8 +0,0 @@
-REPORTER = spec
-
-test:
-	./node_modules/.bin/mocha --reporter $(REPORTER) --require should
-test-w:
-	./node_modules/.bin/mocha --reporter $(REPORTER) --require should --watch
-
-.PHONY: test test-w

package/Select.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Select')

package/Table.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Table')

package/Transaction.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Transaction')

package/Types.js

@@ -1 +0,0 @@
-module.exports = require('./sql/types')

package/Update.js

@@ -1 +0,0 @@
-module.exports = require('./sql/Update')

package/alchemy.js

@@ -1,57 +0,0 @@
-var F = require('functionally')
-var getType = require('./sql/types/getType')
-
-module.exports = function(connString){
-
-	var engine = require('./engine')(connString)
-
-	require('./defaultEngine')(engine)
-
-	var SETTERS = {
-		'sql.logfile': function(value){
-			require('./config/app').logger.sql = value
-		},
-		'main.logfile': function(value){
-			require('./config/app').logger.main = value
-			ensureLogger()
-		}
-	}
-
-	var logger
-	var info
-	var error
-
-	function ensureLogger(){
-		if (!logger){
-			logger = require('./loggerFactory')('main')
-			info = logger.info
-			error = logger.error
-		}
-	}
-
-	return F.bindFunctionsOf({
-
-		set: function(key, value){
-			if (key in SETTERS){
-				SETTERS[key](value)
-			}
-			if (logger){
-				info('Set "' + key + '" to value ' + value + '.')
-			}
-
-			return this
-		},
-
-		getType: getType,
-
-		execute: function(query, callback){
-			return engine.query.apply(engine, arguments)
-		},
-
-		executeTransaction: function(query, callback){
-			return engine.transaction.apply(engine, arguments)
-		},
-
-		engine: engine
-	})
-}

package/alchemy.sublime-project

@@ -1,9 +0,0 @@
-{
-	"folders":
-	[
-		{
-			"follow_symlinks": true,
-			"path": "."
-		}
-	]
-}