@awsless/ecs 0.0.1

package/dist/index.cjs

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ECSClient: () => import_client_ecs4.ECSClient,
+  ecsClient: () => ecsClient,
+  mockEcs: () => mockEcs,
+  runTask: () => runTask
+});
+module.exports = __toCommonJS(index_exports);
+var import_client_ecs4 = require("@aws-sdk/client-ecs");
+
+// src/client.ts
+var import_client_ecs = require("@aws-sdk/client-ecs");
+var import_utils = require("@awsless/utils");
+var ecsClient = (0, import_utils.globalClient)(() => {
+  return new import_client_ecs.ECSClient({});
+});
+
+// src/commands.ts
+var import_client_ecs2 = require("@aws-sdk/client-ecs");
+var import_json = require("@awsless/json");
+var runTask = async ({
+  client = ecsClient(),
+  cluster,
+  taskDefinition,
+  subnets,
+  securityGroups,
+  container,
+  payload,
+  assignPublicIp = true
+}) => {
+  const result = await client.send(
+    new import_client_ecs2.RunTaskCommand({
+      cluster,
+      taskDefinition,
+      launchType: "FARGATE",
+      networkConfiguration: {
+        awsvpcConfiguration: {
+          subnets,
+          securityGroups,
+          assignPublicIp: assignPublicIp ? "ENABLED" : "DISABLED"
+        }
+      },
+      overrides: {
+        containerOverrides: [
+          {
+            name: container,
+            environment: payload !== void 0 ? [
+              {
+                name: "PAYLOAD",
+                value: (0, import_json.stringify)(payload)
+              }
+            ] : []
+          }
+        ]
+      },
+      count: 1
+    })
+  );
+  if (result.failures && result.failures.length > 0) {
+    const { reason, detail } = result.failures[0];
+    throw new Error(`ECS RunTask failed: ${reason}${detail ? ` - ${detail}` : ""}`);
+  }
+  return { taskArn: result.tasks?.[0]?.taskArn };
+};
+
+// src/mock.ts
+var import_client_ecs3 = require("@aws-sdk/client-ecs");
+var import_json2 = require("@awsless/json");
+var import_utils2 = require("@awsless/utils");
+var import_aws_sdk_vitest_mock = require("aws-sdk-vitest-mock");
+var globalList = {};
+var mockEcs = (tasks) => {
+  const alreadyMocked = Object.keys(globalList).length > 0;
+  const list = (0, import_utils2.mockObjectValues)(tasks);
+  Object.assign(globalList, list);
+  if (alreadyMocked) {
+    return list;
+  }
+  const client = (0, import_aws_sdk_vitest_mock.mockClient)(import_client_ecs3.ECSClient);
+  client.on(import_client_ecs3.RunTaskCommand).callsFake(async (input) => {
+    const name = input.taskDefinition ?? "";
+    const callback = globalList[name];
+    if (!callback) {
+      throw new TypeError(`ECS mock function not defined for: ${name}`);
+    }
+    const envVars = input.overrides?.containerOverrides?.[0]?.environment ?? [];
+    const payloadEntry = envVars.find((e) => e.name === "PAYLOAD");
+    const payload = payloadEntry?.value ? (0, import_json2.parse)(payloadEntry.value) : void 0;
+    await (0, import_utils2.nextTick)(callback, payload);
+    return {
+      tasks: [
+        {
+          taskArn: `arn:aws:ecs:us-east-1:000000000000:task/mock/${name}`
+        }
+      ],
+      failures: []
+    };
+  });
+  beforeEach && beforeEach(() => {
+    Object.values(globalList).forEach((fn) => {
+      fn.mockClear();
+    });
+  });
+  return list;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ECSClient,
+  ecsClient,
+  mockEcs,
+  runTask
+});

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import { ECSClient } from '@aws-sdk/client-ecs';
+export { ECSClient } from '@aws-sdk/client-ecs';
+
+declare const ecsClient: {
+    (): ECSClient;
+    set(client: ECSClient): void;
+};
+
+type RunTaskOptions = {
+    client?: ECSClient;
+    cluster: string;
+    taskDefinition: string;
+    subnets: string[];
+    securityGroups: string[];
+    container: string;
+    payload?: unknown;
+    assignPublicIp?: boolean;
+};
+declare const runTask: ({ client, cluster, taskDefinition, subnets, securityGroups, container, payload, assignPublicIp, }: RunTaskOptions) => Promise<{
+    taskArn: string | undefined;
+}>;
+
+type Tasks = {
+    [key: string]: (payload: any) => unknown;
+};
+declare const mockEcs: <T extends Tasks>(tasks: T) => { [P in keyof T]: any; };
+
+export { type RunTaskOptions, ecsClient, mockEcs, runTask };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { ECSClient } from '@aws-sdk/client-ecs';
+export { ECSClient } from '@aws-sdk/client-ecs';
+
+declare const ecsClient: {
+    (): ECSClient;
+    set(client: ECSClient): void;
+};
+
+type RunTaskOptions = {
+    client?: ECSClient;
+    cluster: string;
+    taskDefinition: string;
+    subnets: string[];
+    securityGroups: string[];
+    container: string;
+    payload?: unknown;
+    assignPublicIp?: boolean;
+};
+declare const runTask: ({ client, cluster, taskDefinition, subnets, securityGroups, container, payload, assignPublicIp, }: RunTaskOptions) => Promise<{
+    taskArn: string | undefined;
+}>;
+
+type Tasks = {
+    [key: string]: (payload: any) => unknown;
+};
+declare const mockEcs: <T extends Tasks>(tasks: T) => { [P in keyof T]: any; };
+
+export { type RunTaskOptions, ecsClient, mockEcs, runTask };

package/dist/index.js

@@ -0,0 +1,104 @@
+// src/index.ts
+import { ECSClient as ECSClient4 } from "@aws-sdk/client-ecs";
+
+// src/client.ts
+import { ECSClient } from "@aws-sdk/client-ecs";
+import { globalClient } from "@awsless/utils";
+var ecsClient = globalClient(() => {
+  return new ECSClient({});
+});
+
+// src/commands.ts
+import { RunTaskCommand } from "@aws-sdk/client-ecs";
+import { stringify } from "@awsless/json";
+var runTask = async ({
+  client = ecsClient(),
+  cluster,
+  taskDefinition,
+  subnets,
+  securityGroups,
+  container,
+  payload,
+  assignPublicIp = true
+}) => {
+  const result = await client.send(
+    new RunTaskCommand({
+      cluster,
+      taskDefinition,
+      launchType: "FARGATE",
+      networkConfiguration: {
+        awsvpcConfiguration: {
+          subnets,
+          securityGroups,
+          assignPublicIp: assignPublicIp ? "ENABLED" : "DISABLED"
+        }
+      },
+      overrides: {
+        containerOverrides: [
+          {
+            name: container,
+            environment: payload !== void 0 ? [
+              {
+                name: "PAYLOAD",
+                value: stringify(payload)
+              }
+            ] : []
+          }
+        ]
+      },
+      count: 1
+    })
+  );
+  if (result.failures && result.failures.length > 0) {
+    const { reason, detail } = result.failures[0];
+    throw new Error(`ECS RunTask failed: ${reason}${detail ? ` - ${detail}` : ""}`);
+  }
+  return { taskArn: result.tasks?.[0]?.taskArn };
+};
+
+// src/mock.ts
+import { ECSClient as ECSClient3, RunTaskCommand as RunTaskCommand2 } from "@aws-sdk/client-ecs";
+import { parse } from "@awsless/json";
+import { mockObjectValues, nextTick } from "@awsless/utils";
+import { mockClient } from "aws-sdk-vitest-mock";
+var globalList = {};
+var mockEcs = (tasks) => {
+  const alreadyMocked = Object.keys(globalList).length > 0;
+  const list = mockObjectValues(tasks);
+  Object.assign(globalList, list);
+  if (alreadyMocked) {
+    return list;
+  }
+  const client = mockClient(ECSClient3);
+  client.on(RunTaskCommand2).callsFake(async (input) => {
+    const name = input.taskDefinition ?? "";
+    const callback = globalList[name];
+    if (!callback) {
+      throw new TypeError(`ECS mock function not defined for: ${name}`);
+    }
+    const envVars = input.overrides?.containerOverrides?.[0]?.environment ?? [];
+    const payloadEntry = envVars.find((e) => e.name === "PAYLOAD");
+    const payload = payloadEntry?.value ? parse(payloadEntry.value) : void 0;
+    await nextTick(callback, payload);
+    return {
+      tasks: [
+        {
+          taskArn: `arn:aws:ecs:us-east-1:000000000000:task/mock/${name}`
+        }
+      ],
+      failures: []
+    };
+  });
+  beforeEach && beforeEach(() => {
+    Object.values(globalList).forEach((fn) => {
+      fn.mockClear();
+    });
+  });
+  return list;
+};
+export {
+  ECSClient4 as ECSClient,
+  ecsClient,
+  mockEcs,
+  runTask
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@awsless/ecs",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/awsless/awsless.git"
+  },
+  "bugs": {
+    "url": "https://github.com/awsless/awsless/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@aws-sdk/client-ecs": "3.1024.0",
+    "aws-sdk-vitest-mock": "1.0.55",
+    "@awsless/json": "^0.0.11",
+    "@awsless/utils": "^0.0.2"
+  },
+  "peerDependencies": {
+    "vitest": ">=4"
+  },
+  "scripts": {
+    "test": "pnpm vitest run",
+    "build": "pnpm tsup src/index.ts --format cjs,esm --dts --clean",
+    "prepublish": "if pnpm test; then pnpm build; else exit; fi"
+  }
+}