@8ms/helpers 2.3.5 → 2.3.6

package/.github/workflows/deploy_npmjs.yml

@@ -23,9 +23,6 @@ jobs:
             -   name: Build
                 run: yarn build
 
-            -   name: Generate exports field
-                run: node .github/generate-exports.js
-
             -   name: Publish to npm
                 run: npm publish --access public
                 env:

package/dist/_class/index.d.mts

@@ -0,0 +1,2 @@
+import { n as BaseClass, t as BaseNamespace } from "../index-CFaAdPAh.mjs";
+export { BaseClass, BaseNamespace };

package/dist/_class/index.mjs

@@ -0,0 +1,62 @@
+import { defaultTo } from "../util/index.mjs";
+import { isServer } from "../environment/index.mjs";
+import isArray from "lodash/isArray";
+import set from "lodash/set";
+
+//#region src/_class/BaseClass.ts
+var BaseClass = class {
+	/**
+	* Shortcut to set a value to an array and return the instance.
+	*/
+	_setArray = (fields, input) => {
+		if (isArray(input)) set(this, fields, input);
+		else set(this, fields, [input]);
+		return this;
+	};
+	/**
+	* Shortcut to set a value and return the instance.
+	*/
+	_setValue = (fields, input) => {
+		set(this, fields, input);
+		return this;
+	};
+	/**
+	* Shortcut to add a value to an existing array.
+	*/
+	_push = (fields, input) => {
+		let temp = this._get(fields, []);
+		if (isArray(input)) temp = temp.concat(input);
+		else temp = temp.push(input);
+		set(this, fields, temp);
+		return this;
+	};
+	/**
+	* Shortcut to get a value, but default if the fields don't exist.
+	*/
+	_get = (fields, defaultValue = null) => {
+		return defaultTo(this, fields, defaultValue);
+	};
+};
+
+//#endregion
+//#region src/_class/BaseNamespace.ts
+var BaseNamespace = class {
+	client = null;
+	key;
+	config = null;
+	constructor(key, config) {
+		if (!isServer) throw new Error("Server-side only class accessed from client");
+		this.key = key;
+		this.config = config;
+	}
+	ensureInit = async () => {};
+	reset = () => {
+		this.client = null;
+	};
+	getClient = async () => {
+		return this.client();
+	};
+};
+
+//#endregion
+export { BaseClass, BaseNamespace };

package/dist/adverity/index.d.mts

@@ -0,0 +1,2 @@
+import { a as jobSchema, i as datastreamSchema, n as JobSchemaType, o as stackSchema, r as StackSchemaType, t as DatastreamSchemaType } from "../index-DEm1Wodf.mjs";
+export { DatastreamSchemaType, JobSchemaType, StackSchemaType, datastreamSchema, jobSchema, stackSchema };

package/dist/adverity/index.mjs

@@ -0,0 +1,64 @@
+import { z } from "zod/v4";
+
+//#region src/adverity/adverity.ts
+const stackSchema = z.object({
+	id: z.string(),
+	uuid: z.string(),
+	name: z.string(),
+	slug: z.string(),
+	url: z.string(),
+	change_url: z.string(),
+	extracts_url: z.string(),
+	issues_url: z.string(),
+	overview_url: z.string(),
+	permissions: z.object({
+		isCreator: z.boolean(),
+		isDatastreamManager: z.boolean(),
+		isViewer: z.boolean()
+	})
+});
+const datastreamSchema = z.object({
+	id: z.number(),
+	stack: stackSchema,
+	stack_id: z.number(),
+	name: z.string(),
+	slug: z.string(),
+	app_label: z.string(),
+	absolute_url: z.string(),
+	change_url: z.string(),
+	extracts_url: z.string(),
+	fetch_url: z.string(),
+	overview_url: z.string(),
+	schema_mapping_url: z.string(),
+	enabled: z.bigint(),
+	next_run: z.union([z.string(), z.literal("Not Scheduled")]),
+	url: z.string(),
+	datastream_type_id: z.number(),
+	logo_url: z.string(),
+	extracts_stream_url: z.string(),
+	supports_extended_intervals: z.number(),
+	updated: z.string(),
+	created: z.string(),
+	creator: z.string(),
+	can_be_fetched: z.number()
+});
+const jobSchema = z.object({
+	id: z.number(),
+	url: z.string(),
+	job_start: z.string().nullable(),
+	job_end: z.string().nullable(),
+	progress: z.number(),
+	state: z.number(),
+	state_label: z.string(),
+	state_color: z.string(),
+	datastream: datastreamSchema,
+	issues: z.any().array(),
+	type: z.union([
+		z.string("Fetch"),
+		z.string("Enrich"),
+		z.string("Transfer")
+	])
+});
+
+//#endregion
+export { datastreamSchema, jobSchema, stackSchema };

package/{adverity/server/getJobs.d.ts → dist/adverity/server/index.d.mts}

@@ -1,15 +1,18 @@
-import { InputDate } from "../../date";
-import { JobSchemaType } from "../index";
+import { n as JobSchemaType } from "../../index-DEm1Wodf.mjs";
+import { X as InputDate } from "../../index-CMfxuwL1.mjs";
+
+//#region src/adverity/server/getJobs.d.ts
 type AdverityJobsResponse = {
-    count: number;
-    next: string | null;
-    previous: string | null;
-    results: JobSchemaType[];
+  count: number;
+  next: string | null;
+  previous: string | null;
+  results: JobSchemaType[];
 };
 /**
  * Fetch all the jobs that ran yesterday by default.
  * A job can either by in Fetch, Enrich or Transfer states, but all have different job ids. This makes it difficult to track and we would be reliant on the start/end time which could varu.
  * As a result, we only store the Transfer jobs as this is when it gets moved into Bigquery. If it's not in Bigquery we cant use it anyway.
  */
-export declare const getJobs: (apiKey: string, start?: InputDate, end?: InputDate, url?: string) => Promise<AdverityJobsResponse[]>;
-export {};
+declare const getJobs: (apiKey: string, start?: InputDate, end?: InputDate, url?: string) => Promise<AdverityJobsResponse[]>;
+//#endregion
+export { getJobs };

package/dist/adverity/server/index.mjs

@@ -0,0 +1,25 @@
+import "../../api-DGKJDAfb.mjs";
+import { get } from "../../axios/index.mjs";
+import { getLuxonDate, getToday, getYesterday, getYmdString } from "../../date/index.mjs";
+
+//#region src/adverity/server/getJobs.ts
+/**
+* Fetch all the jobs that ran yesterday by default.
+* A job can either by in Fetch, Enrich or Transfer states, but all have different job ids. This makes it difficult to track and we would be reliant on the start/end time which could varu.
+* As a result, we only store the Transfer jobs as this is when it gets moved into Bigquery. If it's not in Bigquery we cant use it anyway.
+*/
+const getJobs = async (apiKey, start, end, url) => {
+	const startYmd = getYmdString(start ? getLuxonDate(start) : getYesterday());
+	const endYmd = getYmdString(end ? getLuxonDate(end) : getToday());
+	const finalUrl = "undefined" !== typeof url ? url : `https://8ms.datatap.adverity.com/api/jobs/?start=${startYmd}&end=${endYmd}&page_size=300`;
+	let response = [];
+	const apiResponse = await get(finalUrl, { headers: { Authorization: `Bearer ${apiKey}` } });
+	if (apiResponse.isSuccess()) {
+		const apiResponseBody = apiResponse.getBody();
+		if (apiResponseBody.next) response = [...apiResponse.getBody(), await getJobs(apiKey, start, end, apiResponseBody.next)];
+	}
+	return response;
+};
+
+//#endregion
+export { getJobs };

package/dist/api/index.d.mts

@@ -0,0 +1,2 @@
+import { a as isSuccess, c as ApiState, d as unexpectedError, f as ApiResponseClass, i as isPending, l as apiState, n as isError, o as isValidationError, r as isIdle, s as ApiResponse, t as isCancelled, u as defaultResponse } from "../index-B20FTOvk.mjs";
+export { ApiResponse, ApiResponseClass, ApiState, apiState, defaultResponse, isCancelled, isError, isIdle, isPending, isSuccess, isValidationError, unexpectedError };

package/dist/api/index.mjs

@@ -0,0 +1,3 @@
+import { a as isSuccess, c as defaultResponse, i as isPending, l as unexpectedError, n as isError, o as isValidationError, r as isIdle, s as apiState, t as isCancelled, u as ApiResponseClass } from "../api-DGKJDAfb.mjs";
+
+export { ApiResponseClass, apiState, defaultResponse, isCancelled, isError, isIdle, isPending, isSuccess, isValidationError, unexpectedError };

package/dist/api-DGKJDAfb.mjs

@@ -0,0 +1,139 @@
+import { defaultTo } from "./util/index.mjs";
+
+//#region src/api/ApiResponseClass.ts
+/**
+* Class version of the API to enable quicker instances.
+*/
+var ApiResponseClass = class ApiResponseClass {
+	state = apiState.IDLE;
+	body = null;
+	error = null;
+	constructor({ body, error, state } = {}) {
+		this.body = body || null;
+		this.error = error || null;
+		this.state = state || apiState.IDLE;
+		return this;
+	}
+	fromJson = (input) => {
+		this.body = input.body;
+		this.error = input.error;
+		this.state = input.state;
+		return this;
+	};
+	getBody = () => {
+		return this.body;
+	};
+	getBodyDefaultTo = (keys, defaultValue) => {
+		return defaultTo(this.body, keys, defaultValue);
+	};
+	getError = () => {
+		return this.error;
+	};
+	getJson = () => {
+		return {
+			body: this.body,
+			error: this.error,
+			state: this.state
+		};
+	};
+	getApiState = () => {
+		return this.state;
+	};
+	isError = () => {
+		return this.state === apiState.ERROR;
+	};
+	isIdle = () => {
+		return this.state === apiState.IDLE;
+	};
+	isPending = () => {
+		return this.state === apiState.PENDING;
+	};
+	isSuccess = () => {
+		return this.state === apiState.SUCCESS;
+	};
+	setToIdle = () => {
+		this.state = apiState.IDLE;
+		return this;
+	};
+	setToPending = () => {
+		this.state = apiState.PENDING;
+		return this;
+	};
+	setToError = (error, body) => {
+		this.body = body || null;
+		this.error = error;
+		this.state = apiState.ERROR;
+		return this;
+	};
+	setToSuccess = (body) => {
+		this.body = body;
+		this.state = apiState.SUCCESS;
+		return this;
+	};
+	setBody = (body) => {
+		this.body = body;
+		return this;
+	};
+	setError = (error) => {
+		this.error = error;
+		return this;
+	};
+	setApiState = (state) => {
+		this.state = state;
+		return this;
+	};
+	validateZod = (schema) => {
+		try {
+			return new ApiResponseClass({
+				body: schema.parse(this.body),
+				state: this.state
+			});
+		} catch (error) {
+			return new ApiResponseClass({
+				error,
+				state: apiState.ERROR
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/api/api.ts
+const apiState = {
+	CANCELLED: "CANCELLED",
+	ERROR: "ERROR",
+	IDLE: "IDLE",
+	PENDING: "PENDING",
+	SUCCESS: "SUCCESS",
+	VALIDATION_ERROR: "VALIDATION_ERROR"
+};
+const defaultResponse = {
+	body: null,
+	error: null,
+	state: apiState.IDLE
+};
+const unexpectedError = "An unexpected error occurred, please try again.";
+
+//#endregion
+//#region src/api/functions.ts
+const isCancelled = (apiResponse) => {
+	return apiState.CANCELLED === apiResponse.state;
+};
+const isError = (apiResponse) => {
+	return apiState.ERROR === apiResponse.state;
+};
+const isIdle = (apiResponse) => {
+	return apiState.IDLE === apiResponse.state;
+};
+const isPending = (apiResponse) => {
+	return apiState.PENDING === apiResponse.state;
+};
+const isSuccess = (apiResponse) => {
+	return apiState.SUCCESS === apiResponse.state;
+};
+const isValidationError = (apiResponse) => {
+	return apiState.VALIDATION_ERROR === apiResponse.state;
+};
+
+//#endregion
+export { isSuccess as a, defaultResponse as c, isPending as i, unexpectedError as l, isError as n, isValidationError as o, isIdle as r, apiState as s, isCancelled as t, ApiResponseClass as u };

package/dist/array/index.d.mts

@@ -0,0 +1,11 @@
+//#region src/array/array.d.ts
+/**
+ * Shorthand to check if an array or string contains a needle.
+ */
+declare const contains: <T>(haystack: T[], needle: T) => boolean;
+/**
+ * Convert an array into an array or return if already an array.
+ */
+declare const getArray: <T>(input: T) => T[];
+//#endregion
+export { contains, getArray };

package/dist/array/index.mjs

@@ -0,0 +1,14 @@
+import isArray from "lodash/isArray";
+
+//#region src/array/array.ts
+/**
+* Shorthand to check if an array or string contains a needle.
+*/
+const contains = (haystack, needle) => -1 !== haystack.indexOf(needle);
+/**
+* Convert an array into an array or return if already an array.
+*/
+const getArray = (input) => isArray(input) ? input : [input];
+
+//#endregion
+export { contains, getArray };

package/dist/atInternet/index.d.mts

@@ -0,0 +1,20 @@
+import { z } from "zod/v4";
+
+//#region src/atInternet/atInternet.d.ts
+/**
+ * The request in the structure required by AT Internet.
+ */
+declare const requestSchema: z.ZodObject<{
+  columns: z.ZodArray<z.ZodString>;
+  evo: z.ZodObject<{}, z.core.$strip>;
+  filter: z.ZodObject<{}, z.core.$strip>;
+  "max-results": z.ZodNumber;
+  options: z.ZodObject<{
+    ignore_null_properties: z.ZodBoolean;
+  }, z.core.$strip>;
+  "page-num": z.ZodNumber;
+  period: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>;
+type RequestSchemaType = z.infer<typeof requestSchema>;
+//#endregion
+export { RequestSchemaType, requestSchema };

package/dist/atInternet/index.mjs

@@ -0,0 +1,18 @@
+import { z } from "zod/v4";
+
+//#region src/atInternet/atInternet.ts
+/**
+* The request in the structure required by AT Internet.
+*/
+const requestSchema = z.object({
+	columns: z.array(z.string()),
+	evo: z.object({}),
+	filter: z.object({}),
+	"max-results": z.number(),
+	options: z.object({ "ignore_null_properties": z.boolean() }),
+	"page-num": z.number(),
+	period: z.object({})
+});
+
+//#endregion
+export { requestSchema };

package/dist/aws/ec2/server/index.d.mts

@@ -0,0 +1,18 @@
+import { t as BaseNamespace } from "../../../index-CFaAdPAh.mjs";
+import { t as AwsConfig } from "../../../index-B4K9Z1U-.mjs";
+import * as _aws_sdk_client_ec20 from "@aws-sdk/client-ec2";
+import { EC2Client } from "@aws-sdk/client-ec2";
+
+//#region src/aws/ec2/server/AwsEc2Namespace.d.ts
+declare class AwsEc2Namespace extends BaseNamespace {
+  client: EC2Client;
+  config: AwsConfig;
+  ensureInit: () => Promise<void>;
+  startInstances: (instanceIds: string[], additionalInfo?: string, dryRun?: boolean) => Promise<_aws_sdk_client_ec20.StartInstancesCommandOutput>;
+  stopInstances: (instanceIds: string[], hibernate?: boolean, force?: boolean, dryRun?: boolean) => Promise<_aws_sdk_client_ec20.StopInstancesCommandOutput>;
+}
+//#endregion
+//#region src/aws/ec2/server/awsEc2.d.ts
+declare const awsEc2Client: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsEc2Namespace>;
+//#endregion
+export { AwsEc2Namespace, awsEc2Client };

package/dist/aws/ec2/server/index.mjs

@@ -0,0 +1,48 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/ec2/server/AwsEc2Namespace.ts
+var AwsEc2Namespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { EC2Client } = await import("@aws-sdk/client-ec2");
+			this.client = new EC2Client(this.config);
+		} catch (e) {
+			throw new Error("AWS EC2 Client not installed");
+		}
+	};
+	startInstances = async (instanceIds, additionalInfo, dryRun) => {
+		await this.ensureInit();
+		const { StartInstancesCommand } = await import("@aws-sdk/client-ec2");
+		const command = new StartInstancesCommand({
+			InstanceIds: instanceIds,
+			AdditionalInfo: additionalInfo,
+			DryRun: dryRun
+		});
+		return await this.client.send(command);
+	};
+	stopInstances = async (instanceIds, hibernate, force, dryRun) => {
+		await this.ensureInit();
+		const { StopInstancesCommand } = await import("@aws-sdk/client-ec2");
+		const command = new StopInstancesCommand({
+			InstanceIds: instanceIds,
+			Hibernate: hibernate,
+			DryRun: dryRun,
+			Force: force
+		});
+		return await this.client.send(command);
+	};
+};
+
+//#endregion
+//#region src/aws/ec2/server/awsEc2.ts
+const awsEc2Namespaces = /* @__PURE__ */ new Map();
+const awsEc2Client = async (key = "default", config, vaultId, itemId) => {
+	if (awsEc2Namespaces.has(key)) return awsEc2Namespaces.get(key);
+	const namespace = new AwsEc2Namespace(key, await getConfig(key, config, vaultId, itemId));
+	awsEc2Namespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { AwsEc2Namespace, awsEc2Client };

package/dist/aws/ecs/server/index.d.mts

@@ -0,0 +1,59 @@
+import { t as BaseNamespace } from "../../../index-CFaAdPAh.mjs";
+import { t as AwsConfig } from "../../../index-B4K9Z1U-.mjs";
+import { DesiredStatus, ECSClient, LaunchType, NetworkConfiguration, SortOrder, TaskDefinitionStatus, TaskOverride } from "@aws-sdk/client-ecs";
+
+//#region src/aws/ecs/server/AwsEcsNamespace.d.ts
+type GetTaskDefinitionsProps = {
+  familyPrefix?: string;
+  maxResults?: number;
+  sort?: SortOrder;
+  status?: TaskDefinitionStatus;
+};
+type GetTasksProps = {
+  cluster?: string;
+  containerInstance?: string;
+  desiredStatus?: DesiredStatus;
+  family?: string;
+  maxResults?: number;
+  serviceName?: string;
+  startedBy?: string;
+};
+type RunTaskProps = {
+  cluster?: string;
+  count?: number;
+  launchType?: LaunchType;
+  networkConfiguration?: NetworkConfiguration;
+  overrides?: TaskOverride;
+  taskDefinition?: string;
+};
+declare class AwsEcsNamespace extends BaseNamespace {
+  client: ECSClient;
+  config: AwsConfig;
+  ensureInit: () => Promise<void>;
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/ListClustersCommand/
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/ListClustersCommandInput/
+   */
+  getClusters: (maxResults?: number) => Promise<string[]>;
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/ListTaskDefinitionsCommand/
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/ListTaskDefinitionsCommandInput/
+   */
+  getTaskDefinitions: (props: GetTaskDefinitionsProps) => Promise<string[]>;
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/ListTasksCommand/
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/ListTasksCommandInput/
+   */
+  getTasks: (props: GetTasksProps) => Promise<string[]>;
+  /**
+   * Initialise and run a task
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/RunTaskCommand/
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/RunTaskCommandInput/
+   */
+  runTask: (props: RunTaskProps) => Promise<any>;
+}
+//#endregion
+//#region src/aws/ecs/server/awsEcs.d.ts
+declare const awsEcsClient: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsEcsNamespace>;
+//#endregion
+export { AwsEcsNamespace, awsEcsClient };

package/dist/aws/ecs/server/index.mjs

@@ -0,0 +1,113 @@
+import { BaseNamespace } from "../../../_class/index.mjs";
+import { n as isResponse200, t as getConfig } from "../../../server-Bwy4JI8Z.mjs";
+
+//#region src/aws/ecs/server/AwsEcsNamespace.ts
+var AwsEcsNamespace = class extends BaseNamespace {
+	ensureInit = async () => {
+		if (!this.client) try {
+			const { ECSClient } = await import("@aws-sdk/client-ecs");
+			this.client = new ECSClient(this.config);
+		} catch (e) {
+			throw new Error("AWS ECS Client not installed");
+		}
+	};
+	/**
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/ListClustersCommand/
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/ListClustersCommandInput/
+	*/
+	getClusters = async (maxResults) => {
+		await this.ensureInit();
+		const { ListClustersCommand } = await import("@aws-sdk/client-ecs");
+		let response = [];
+		let apiResponse = null;
+		while (null === apiResponse || apiResponse?.nextToken) {
+			const listClustersCommand = new ListClustersCommand({
+				maxResults,
+				nextToken: apiResponse?.nextToken
+			});
+			apiResponse = await this.client.send(listClustersCommand);
+			if (isResponse200(apiResponse)) response = [...response, ...apiResponse.clusterArns];
+		}
+		return response;
+	};
+	/**
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/ListTaskDefinitionsCommand/
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/ListTaskDefinitionsCommandInput/
+	*/
+	getTaskDefinitions = async (props) => {
+		await this.ensureInit();
+		const { ListTaskDefinitionsCommand } = await import("@aws-sdk/client-ecs");
+		let response = [];
+		let apiResponse = null;
+		while (null === apiResponse || apiResponse?.nextToken) {
+			const listTaskDefinitionsCommand = new ListTaskDefinitionsCommand({
+				maxResults: props?.maxResults,
+				familyPrefix: props?.familyPrefix,
+				sort: props?.sort,
+				status: props?.status,
+				nextToken: apiResponse?.nextToken
+			});
+			apiResponse = await this.client.send(listTaskDefinitionsCommand);
+			if (isResponse200(apiResponse)) response = [...response, ...apiResponse.taskDefinitionArns];
+		}
+		return response;
+	};
+	/**
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/ListTasksCommand/
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/ListTasksCommandInput/
+	*/
+	getTasks = async (props) => {
+		await this.ensureInit();
+		const { ListTasksCommand } = await import("@aws-sdk/client-ecs");
+		let response = [];
+		let apiResponse = null;
+		while (null === apiResponse || apiResponse?.nextToken) {
+			const listTasksCommand = new ListTasksCommand({
+				cluster: props?.cluster,
+				containerInstance: props?.containerInstance,
+				desiredStatus: props?.desiredStatus,
+				family: props?.family,
+				maxResults: props?.maxResults,
+				nextToken: apiResponse?.nextToken,
+				serviceName: props?.serviceName,
+				startedBy: props?.startedBy
+			});
+			apiResponse = await this.client.send(listTasksCommand);
+			if (isResponse200(apiResponse)) response = [...response, ...apiResponse.taskArns];
+		}
+		return response;
+	};
+	/**
+	* Initialise and run a task
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ecs/command/RunTaskCommand/
+	* https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ecs/Interface/RunTaskCommandInput/
+	*/
+	runTask = async (props) => {
+		await this.ensureInit();
+		const { RunTaskCommand } = await import("@aws-sdk/client-ecs");
+		let response = false;
+		const runtTaskCommand = new RunTaskCommand({
+			cluster: props?.cluster,
+			launchType: props?.launchType,
+			networkConfiguration: props?.networkConfiguration,
+			overrides: props?.overrides,
+			taskDefinition: props?.taskDefinition
+		});
+		const apiResponse = await this.client.send(runtTaskCommand);
+		if (isResponse200(apiResponse)) response = apiResponse;
+		return response;
+	};
+};
+
+//#endregion
+//#region src/aws/ecs/server/awsEcs.ts
+const awsEcsNamespaces = /* @__PURE__ */ new Map();
+const awsEcsClient = async (key = "default", config, vaultId, itemId) => {
+	if (awsEcsNamespaces.has(key)) return awsEcsNamespaces.get(key);
+	const namespace = new AwsEcsNamespace(key, await getConfig(key, config, vaultId, itemId));
+	awsEcsNamespaces.set(key, namespace);
+	return namespace;
+};
+
+//#endregion
+export { AwsEcsNamespace, awsEcsClient };