Zakaria
bafe799d00
CI / checks (pull_request) Failing after 12m24s
The Cognito panel gains a test sign-in that shows the decoded ID and access token claims, a groups section, and a per-user panel to enable or disable, confirm, sign out everywhere, reset or set a password and change group membership. Delete confirmations (row and bulk) now say what else goes, driven by the schema's deleteImpact, and the inspector follows list refreshes instead of the click-time snapshot.
1957 lines
63 KiB
TypeScript
1957 lines
63 KiB
TypeScript
import { API_BASE_URL, apiClient, apiEndpointKeys } from "./api";
|
|
import type {
|
|
CloudDescriptor,
|
|
CloudProvider,
|
|
CloudServiceDescriptor,
|
|
CloudServiceStatus,
|
|
CloudServiceType,
|
|
CloudStatus,
|
|
RuntimeDiagnostics,
|
|
} from "@/types/cloud";
|
|
import type {
|
|
AppConfigConfigurationProfile,
|
|
AppConfigDeployment,
|
|
AppConfigDeploymentStrategy,
|
|
AppConfigEnvironment,
|
|
AppConfigHostedConfigurationVersion,
|
|
ChildCollection,
|
|
ChildItem,
|
|
CloudResource,
|
|
CollectionPage,
|
|
CosmosContainer,
|
|
CosmosItem,
|
|
CosmosQueryResult,
|
|
CreateDatabaseSnapshotInput,
|
|
CreateKubernetesFargateProfileInput,
|
|
CreateKubernetesNodegroupInput,
|
|
DatabaseSnapshot,
|
|
KubernetesFargateProfile,
|
|
KubernetesNodegroup,
|
|
CreateUserPoolGroupInput,
|
|
UserPoolGroup,
|
|
UserPoolSignInTestInput,
|
|
UserPoolSignInTestResult,
|
|
UserPoolUserAction,
|
|
LogsInsightsQueryInput,
|
|
LogsInsightsQueryResult,
|
|
LogsFilterInput,
|
|
SqsMessage,
|
|
SqsSendMessageInput,
|
|
SqlCredentials,
|
|
SqlDatabase,
|
|
SqlEngine,
|
|
SqlQueryResult,
|
|
SqlTable,
|
|
StorageObjectList,
|
|
S3BucketWebsiteConfiguration,
|
|
} from "@/types/resource";
|
|
import type { ServiceSchema } from "@/types/schema";
|
|
import { getAccountId } from "@/lib/accountStore";
|
|
|
|
type CloudPathParams = Record<string, string>;
|
|
|
|
const DATABASE_MUTATION_TIMEOUT_MS = 5 * 60_000;
|
|
const LIGHTSAIL_CREATION_TIMEOUT_MS = 3 * 60_000;
|
|
const SQL_DATA_TIMEOUT_MS = 45_000;
|
|
/** Floci completes Insights queries instantly by default, but bounded server-side polling can take longer. */
|
|
const LOGS_QUERY_TIMEOUT_MS = 20_000;
|
|
/** Cold starts pull a container image; measured at ~60s on a first invoke. */
|
|
const INVOKE_TIMEOUT_MS = 120_000;
|
|
|
|
export async function listClouds(
|
|
signal?: AbortSignal,
|
|
): Promise<CloudDescriptor[]> {
|
|
const res = await apiClient.call<CloudDescriptor[]>(
|
|
apiEndpointKeys.clouds.list,
|
|
{ signal },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listCloudServices(
|
|
cloud: CloudProvider,
|
|
signal?: AbortSignal,
|
|
): Promise<CloudServiceDescriptor[]> {
|
|
const res = await apiClient.call<CloudServiceDescriptor[]>(
|
|
apiEndpointKeys.clouds.services,
|
|
requestOptions(cloud, "cloud-proxy", { signal }),
|
|
{ cloud },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCloudStatus(
|
|
cloud: CloudProvider,
|
|
signal?: AbortSignal,
|
|
): Promise<CloudStatus> {
|
|
const res = await apiClient.call<CloudStatus>(
|
|
apiEndpointKeys.clouds.status,
|
|
requestOptions(cloud, "cloud-proxy", { signal }),
|
|
{ cloud },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCloudDiagnostics(
|
|
cloud: CloudProvider,
|
|
signal?: AbortSignal,
|
|
): Promise<RuntimeDiagnostics> {
|
|
const res = await apiClient.call<RuntimeDiagnostics>(
|
|
apiEndpointKeys.clouds.diagnostics,
|
|
requestOptions(cloud, "cloud-proxy", { signal }),
|
|
{ cloud },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCloudServiceStatus(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
signal?: AbortSignal,
|
|
): Promise<CloudServiceStatus> {
|
|
const res = await apiClient.call<CloudServiceStatus>(
|
|
apiEndpointKeys.clouds.serviceStatus,
|
|
requestOptions(cloud, service, { signal }),
|
|
{ cloud, service },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getServiceSchema(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
signal?: AbortSignal,
|
|
): Promise<ServiceSchema> {
|
|
const res = await apiClient.call<ServiceSchema>(
|
|
apiEndpointKeys.clouds.schema,
|
|
requestOptions(cloud, service, { signal }),
|
|
{ cloud, service },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export type LoadBalancingDependencies = {
|
|
vpcs: Array<{id: string; cidrBlock: string}>;
|
|
subnets: Array<{id: string; vpcId: string; availabilityZone: string; cidrBlock: string}>;
|
|
securityGroups: Array<{id: string; vpcId: string; name: string; description: string}>;
|
|
};
|
|
|
|
export async function getLoadBalancingDependencies(
|
|
service: "loadbalancing" | "targetgroups" = "loadbalancing",
|
|
signal?: AbortSignal,
|
|
): Promise<LoadBalancingDependencies & {instances?: Array<{id: string; name: string; privateIp: string | null}>}> {
|
|
const res = await apiClient.call<LoadBalancingDependencies>(
|
|
apiEndpointKeys.clouds.dependencies,
|
|
requestOptions("aws", service, {signal}),
|
|
{cloud: "aws", service},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listCloudResources(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
search?: string,
|
|
signal?: AbortSignal,
|
|
state?: string,
|
|
): Promise<CloudResource[]> {
|
|
const res = await apiClient.call<CloudResource[]>(
|
|
apiEndpointKeys.clouds.resources.list,
|
|
requestOptions(cloud, service, { signal, params: { search, state } }),
|
|
{ cloud, service },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CloudResource> {
|
|
const res = await apiClient.call<CloudResource>(
|
|
apiEndpointKeys.clouds.resources.get,
|
|
requestOptions(cloud, service, { signal }),
|
|
{ cloud, service, id },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
values: Record<string, unknown>,
|
|
signal?: AbortSignal,
|
|
): Promise<CloudResource> {
|
|
const timeout =
|
|
(cloud === "azure" || cloud === "aws") && service === "database"
|
|
? DATABASE_MUTATION_TIMEOUT_MS
|
|
: cloud === "aws" && service === "lightsail"
|
|
? LIGHTSAIL_CREATION_TIMEOUT_MS
|
|
: undefined;
|
|
const res = await apiClient.call<CloudResource, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.resources.create,
|
|
requestOptions(cloud, service, { signal, body: values, timeout }),
|
|
{ cloud, service },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function updateCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
values: Record<string, unknown>,
|
|
signal?: AbortSignal,
|
|
): Promise<CloudResource> {
|
|
const timeout =
|
|
(cloud === "azure" || cloud === "aws") && service === "database"
|
|
? DATABASE_MUTATION_TIMEOUT_MS
|
|
: undefined;
|
|
const res = await apiClient.call<CloudResource, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.resources.update,
|
|
requestOptions(cloud, service, { signal, body: values, timeout }),
|
|
{ cloud, service, id },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.delete,
|
|
requestOptions(cloud, service, { signal }),
|
|
{ cloud, service, id },
|
|
);
|
|
}
|
|
|
|
export async function startCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.start,
|
|
requestOptions(cloud, service),
|
|
{ cloud, service, id },
|
|
);
|
|
}
|
|
|
|
export async function stopCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.stop,
|
|
requestOptions(cloud, service),
|
|
{ cloud, service, id },
|
|
);
|
|
}
|
|
|
|
export async function rebootCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.reboot,
|
|
requestOptions(cloud, service),
|
|
{ cloud, service, id },
|
|
);
|
|
}
|
|
|
|
export async function clearEmailInbox(
|
|
cloud: CloudProvider,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.email.inbox.clear,
|
|
requestOptions(cloud, "email", { signal }),
|
|
{ cloud },
|
|
);
|
|
}
|
|
export interface ServerlessInvokeResult {
|
|
statusCode: number;
|
|
payload: string;
|
|
functionError?: string;
|
|
logResult?: string;
|
|
executionDuration?: number;
|
|
}
|
|
|
|
export interface PublishNotificationInput {
|
|
message: string;
|
|
subject?: string;
|
|
messageAttributes?: Record<string, string>;
|
|
}
|
|
|
|
export interface PublishNotificationResult {
|
|
messageId: string | null;
|
|
}
|
|
|
|
export interface WorkflowExecutionSummary {
|
|
executionArn: string;
|
|
name: string;
|
|
status: string;
|
|
startDate: string;
|
|
stopDate?: string;
|
|
}
|
|
|
|
export interface WorkflowExecutionDetail extends WorkflowExecutionSummary {
|
|
stateMachineArn: string;
|
|
input?: string;
|
|
output?: string;
|
|
error?: string;
|
|
cause?: string;
|
|
}
|
|
|
|
export interface WorkflowExecutionHistoryPage {
|
|
events: Array<Record<string, unknown>>;
|
|
nextToken?: string;
|
|
}
|
|
|
|
export interface CodeBuildEnvironmentVariableOverride {
|
|
name: string;
|
|
value: string;
|
|
type?: "PLAINTEXT" | "PARAMETER_STORE" | "SECRETS_MANAGER";
|
|
}
|
|
|
|
export interface CodeBuildBuild {
|
|
id: string;
|
|
arn?: string;
|
|
projectName: string;
|
|
buildNumber?: number;
|
|
buildStatus?: string;
|
|
currentPhase?: string;
|
|
startTime?: string;
|
|
endTime?: string;
|
|
phases: Array<{phaseType: string; phaseStatus?: string; startTime?: string; endTime?: string; contexts: Array<{statusCode?: string; message?: string}>}>;
|
|
logGroupName?: string;
|
|
logStreamName?: string;
|
|
}
|
|
|
|
export interface PipelineExecutionSummary {
|
|
id: string;
|
|
status?: string;
|
|
statusSummary?: string;
|
|
startTime?: string;
|
|
lastUpdateTime?: string;
|
|
}
|
|
|
|
export interface PipelineState {
|
|
stages: Array<{
|
|
name: string;
|
|
status?: string;
|
|
lastStatusChange?: string;
|
|
actions: Array<{name: string; status?: string; summary?: string; lastStatusChange?: string; externalExecutionId?: string; externalExecutionUrl?: string; entityUrl?: string; revisionUrl?: string; codeBuildProject?: string; codeDeployDeploymentId?: string; codeDeployApplication?: string; codeDeployDeploymentGroup?: string}>;
|
|
}>;
|
|
}
|
|
|
|
export interface CodeDeployDeployment { id: string; applicationName: string; deploymentGroupName: string; status: string | null; creator: string | null; deploymentConfigName: string | null; createTime?: string; completeTime?: string; errorInformation: {code?: string; message?: string} | null; currentVersion: string | null; targetVersion: string | null; trafficPercent: number | null }
|
|
export interface StartCodeDeployDeploymentInput { functionName: string; alias: string; currentVersion: string; targetVersion: string; beforeAllowTrafficHook?: string; afterAllowTrafficHook?: string }
|
|
export interface CodeDeployDependencies { lambdaFunctions: Array<{name: string; aliases: string[]; versions: string[]}> }
|
|
|
|
export interface CreateApiGatewayLambdaRouteInput {
|
|
path: string;
|
|
parentResourceId?: string;
|
|
pathPart?: string;
|
|
method: string;
|
|
stage: string;
|
|
functionName: string;
|
|
}
|
|
|
|
export interface ApiGatewayLambdaRoute {
|
|
resourceId: string;
|
|
deploymentId: string;
|
|
invokeUrl: string;
|
|
}
|
|
|
|
export interface TestApiGatewayRouteInput {
|
|
path: string;
|
|
method: string;
|
|
stage: string;
|
|
body: string;
|
|
headers: Record<string, string>;
|
|
query: string;
|
|
}
|
|
|
|
export interface ApiGatewayTestRouteResult {
|
|
statusCode: number;
|
|
headers: Record<string, string>;
|
|
body: string;
|
|
durationMs: number;
|
|
}
|
|
|
|
export interface TestApiGatewayMethodInput {
|
|
resourceId: string;
|
|
httpMethod: string;
|
|
pathWithQueryString: string;
|
|
body: string;
|
|
headers: Record<string, string>;
|
|
multiValueHeaders: Record<string, string[]>;
|
|
stageVariables: Record<string, string>;
|
|
}
|
|
|
|
export interface ApiGatewayMethodTestResult {
|
|
statusCode: number;
|
|
body: string;
|
|
headers: Record<string, string>;
|
|
multiValueHeaders: Record<string, string[]>;
|
|
log: string | null;
|
|
latency: number | null;
|
|
}
|
|
|
|
export interface ApiGatewayRouteOverview {
|
|
resourceId: string;
|
|
path: string;
|
|
method: string;
|
|
functionName: string | null;
|
|
integrationType: string | null;
|
|
}
|
|
|
|
export interface ApiGatewayResourceOverview {
|
|
resourceId: string;
|
|
parentId: string | null;
|
|
path: string;
|
|
pathPart: string | null;
|
|
methods: ApiGatewayRouteOverview[];
|
|
}
|
|
|
|
export interface ApiGatewayRoutesResult {
|
|
resources: ApiGatewayResourceOverview[];
|
|
routes: ApiGatewayRouteOverview[];
|
|
stages: string[];
|
|
}
|
|
|
|
export interface DeleteApiGatewayRouteInput {
|
|
resourceId: string;
|
|
path: string;
|
|
method: string;
|
|
stage: string;
|
|
}
|
|
|
|
export interface EnableApiGatewayCorsInput {
|
|
resourceId: string;
|
|
stage: string;
|
|
origin: string;
|
|
headers: string;
|
|
methods: string[];
|
|
}
|
|
|
|
export interface ApiGatewayCorsResult {
|
|
configuredMethods: string[];
|
|
proxyMethods: string[];
|
|
}
|
|
|
|
export interface CreateS3LambdaTriggerInput {
|
|
functionName: string;
|
|
events: string[];
|
|
prefix?: string;
|
|
suffix?: string;
|
|
}
|
|
|
|
export interface S3LambdaTriggerOverview {
|
|
id: string;
|
|
functionName: string;
|
|
functionArn: string;
|
|
events: string[];
|
|
prefix: string | null;
|
|
suffix: string | null;
|
|
}
|
|
|
|
export interface CreateSnsSubscriptionInput {
|
|
protocol: string;
|
|
endpoint: string;
|
|
}
|
|
|
|
export interface SnsSubscriptionOverview {
|
|
arn: string | null;
|
|
protocol: string;
|
|
endpoint: string;
|
|
status: "Confirmed" | "PendingConfirmation";
|
|
filterPolicy: string | null;
|
|
}
|
|
|
|
export interface CreateEventBridgeLambdaTriggerInput {
|
|
ruleName: string;
|
|
scheduleExpression: string;
|
|
}
|
|
|
|
export interface EventBridgeLambdaTriggerOverview {
|
|
id: string;
|
|
ruleName: string;
|
|
ruleArn: string;
|
|
functionName: string;
|
|
functionArn: string;
|
|
scheduleExpression: string;
|
|
state: string | null;
|
|
}
|
|
|
|
export interface EventBridgeRuleTarget {
|
|
id: string;
|
|
arn: string;
|
|
}
|
|
|
|
export interface CreateEventBridgeRuleInput {
|
|
name: string;
|
|
scheduleExpression?: string;
|
|
eventPattern?: string;
|
|
state?: "ENABLED" | "DISABLED";
|
|
description?: string;
|
|
targets: EventBridgeRuleTarget[];
|
|
}
|
|
|
|
export interface EventBridgeRuleOverview extends CreateEventBridgeRuleInput {
|
|
busName: string;
|
|
busId: string;
|
|
arn: string | null;
|
|
state: "ENABLED" | "DISABLED";
|
|
}
|
|
|
|
export interface PutEventBridgeEventInput {
|
|
source: string;
|
|
detailType: string;
|
|
detail: string;
|
|
resources?: string[];
|
|
}
|
|
|
|
export interface PutEventBridgeEventResult {
|
|
eventId: string | null;
|
|
errorCode: string | null;
|
|
errorMessage: string | null;
|
|
}
|
|
export interface CloudFormationChangeSet { name: string; id: string; status: string | null; executionStatus: string | null; changes: Array<{action: string | null; logicalResourceId: string | null; resourceType: string | null}> }
|
|
|
|
export interface CreateSqsLambdaEventSourceMappingInput {
|
|
queueArn: string;
|
|
batchSize?: number;
|
|
}
|
|
|
|
export interface SqsLambdaEventSourceMappingOverview {
|
|
id: string;
|
|
uuid: string;
|
|
functionName: string;
|
|
functionArn: string | null;
|
|
queueArn: string;
|
|
batchSize: number | null;
|
|
state: string | null;
|
|
stateTransitionReason: string | null;
|
|
}
|
|
|
|
export interface KinesisRecord {sequenceNumber: string; partitionKey: string | null; data: string; approximateArrivalTimestamp: string | null}
|
|
export interface LambdaEventSourceMappingOverview {id: string; uuid: string; functionName: string | null; functionArn: string | null; eventSourceArn: string; batchSize: number | null; startingPosition: string | null; state: string | null; stateTransitionReason: string | null}
|
|
export interface CreateLambdaEventSourceMappingInput {functionName: string; eventSourceArn: string; batchSize?: number; startingPosition?: "TRIM_HORIZON" | "LATEST"}
|
|
|
|
export async function putKinesisRecord(cloud: CloudProvider, streamName: string, input: {partitionKey: string; data: string}): Promise<{sequenceNumber: string; shardId: string}> {
|
|
const res = await apiClient.call<{sequenceNumber: string; shardId: string}, typeof input>(apiEndpointKeys.clouds.resources.putKinesisRecord, requestOptions(cloud, "kinesis", {body: input}), {cloud, id: streamName})
|
|
return res.data
|
|
}
|
|
|
|
export async function listKinesisRecords(cloud: CloudProvider, streamName: string, signal?: AbortSignal): Promise<KinesisRecord[]> {
|
|
const res = await apiClient.call<KinesisRecord[]>(apiEndpointKeys.clouds.resources.listKinesisRecords, requestOptions(cloud, "kinesis", {signal}), {cloud, id: streamName})
|
|
return res.data
|
|
}
|
|
|
|
export async function createLambdaEventSourceMapping(cloud: CloudProvider, input: CreateLambdaEventSourceMappingInput): Promise<LambdaEventSourceMappingOverview> {
|
|
const res = await apiClient.call<LambdaEventSourceMappingOverview, CreateLambdaEventSourceMappingInput>(apiEndpointKeys.clouds.resources.createLambdaEventSourceMapping, requestOptions(cloud, "serverless", {body: input}), {cloud})
|
|
return res.data
|
|
}
|
|
|
|
export async function listLambdaEventSourceMappings(cloud: CloudProvider, filter: {functionName?: string; eventSourceArn?: string}, signal?: AbortSignal): Promise<LambdaEventSourceMappingOverview[]> {
|
|
const res = await apiClient.call<LambdaEventSourceMappingOverview[]>(apiEndpointKeys.clouds.resources.listLambdaEventSourceMappings, requestOptions(cloud, "serverless", {signal, params: filter}), {cloud})
|
|
return res.data
|
|
}
|
|
|
|
export async function updateLambdaEventSourceMapping(cloud: CloudProvider, mappingId: string, input: {batchSize?: number; enabled?: boolean}): Promise<LambdaEventSourceMappingOverview> {
|
|
const res = await apiClient.call<LambdaEventSourceMappingOverview, typeof input>(apiEndpointKeys.clouds.resources.updateLambdaEventSourceMapping, requestOptions(cloud, "serverless", {body: input}), {cloud, mappingId})
|
|
return res.data
|
|
}
|
|
|
|
export async function deleteLambdaEventSourceMapping(cloud: CloudProvider, mappingId: string): Promise<void> {
|
|
await apiClient.call<void>(apiEndpointKeys.clouds.resources.deleteLambdaEventSourceMapping, requestOptions(cloud, "serverless"), {cloud, mappingId})
|
|
}
|
|
|
|
export async function createApiGatewayLambdaRoute(
|
|
cloud: CloudProvider,
|
|
apiId: string,
|
|
input: CreateApiGatewayLambdaRouteInput,
|
|
signal?: AbortSignal,
|
|
): Promise<ApiGatewayLambdaRoute> {
|
|
const res = await apiClient.call<ApiGatewayLambdaRoute, CreateApiGatewayLambdaRouteInput>(
|
|
apiEndpointKeys.clouds.resources.createApiGatewayRoute,
|
|
requestOptions(cloud, "apigateway", { signal, body: input }),
|
|
{ cloud, id: apiId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listApiGatewayRoutes(
|
|
cloud: CloudProvider,
|
|
apiId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<ApiGatewayRoutesResult> {
|
|
const res = await apiClient.call<ApiGatewayRoutesResult>(
|
|
apiEndpointKeys.clouds.resources.listApiGatewayRoutes,
|
|
requestOptions(cloud, "apigateway", { signal }),
|
|
{ cloud, id: apiId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteApiGatewayRoute(
|
|
cloud: CloudProvider,
|
|
apiId: string,
|
|
input: DeleteApiGatewayRouteInput,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteApiGatewayRoute,
|
|
requestOptions(cloud, "apigateway", {signal, params: {stage: input.stage, path: input.path}}),
|
|
{cloud, id: apiId, resourceId: input.resourceId, method: input.method},
|
|
);
|
|
}
|
|
|
|
export async function enableApiGatewayCors(
|
|
cloud: CloudProvider,
|
|
apiId: string,
|
|
input: EnableApiGatewayCorsInput,
|
|
signal?: AbortSignal,
|
|
): Promise<ApiGatewayCorsResult> {
|
|
const res = await apiClient.call<ApiGatewayCorsResult, EnableApiGatewayCorsInput>(
|
|
apiEndpointKeys.clouds.resources.enableApiGatewayCors,
|
|
requestOptions(cloud, "apigateway", {signal, body: input}),
|
|
{cloud, id: apiId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function testApiGatewayRoute(
|
|
cloud: CloudProvider,
|
|
apiId: string,
|
|
input: TestApiGatewayRouteInput,
|
|
signal?: AbortSignal,
|
|
): Promise<ApiGatewayTestRouteResult> {
|
|
const res = await apiClient.call<ApiGatewayTestRouteResult, TestApiGatewayRouteInput>(
|
|
apiEndpointKeys.clouds.resources.testApiGatewayRoute,
|
|
requestOptions(cloud, "apigateway", { signal, body: input, timeout: INVOKE_TIMEOUT_MS }),
|
|
{ cloud, id: apiId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function testApiGatewayMethod(
|
|
cloud: CloudProvider,
|
|
apiId: string,
|
|
input: TestApiGatewayMethodInput,
|
|
signal?: AbortSignal,
|
|
): Promise<ApiGatewayMethodTestResult> {
|
|
const res = await apiClient.call<ApiGatewayMethodTestResult, TestApiGatewayMethodInput>(
|
|
apiEndpointKeys.clouds.resources.testApiGatewayMethod,
|
|
requestOptions(cloud, "apigateway", { signal, body: input, timeout: INVOKE_TIMEOUT_MS }),
|
|
{ cloud, id: apiId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createS3LambdaTrigger(
|
|
cloud: CloudProvider,
|
|
bucketName: string,
|
|
input: CreateS3LambdaTriggerInput,
|
|
signal?: AbortSignal,
|
|
): Promise<S3LambdaTriggerOverview> {
|
|
const res = await apiClient.call<S3LambdaTriggerOverview, CreateS3LambdaTriggerInput>(
|
|
apiEndpointKeys.clouds.resources.createS3LambdaTrigger,
|
|
requestOptions(cloud, "storage", {signal, body: input}),
|
|
{cloud, id: bucketName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listS3LambdaTriggers(
|
|
cloud: CloudProvider,
|
|
bucketName: string,
|
|
signal?: AbortSignal,
|
|
): Promise<S3LambdaTriggerOverview[]> {
|
|
const res = await apiClient.call<S3LambdaTriggerOverview[]>(
|
|
apiEndpointKeys.clouds.resources.listS3LambdaTriggers,
|
|
requestOptions(cloud, "storage", {signal}),
|
|
{cloud, id: bucketName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteS3LambdaTrigger(
|
|
cloud: CloudProvider,
|
|
bucketName: string,
|
|
triggerId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteS3LambdaTrigger,
|
|
requestOptions(cloud, "storage", {signal}),
|
|
{cloud, id: bucketName, triggerId},
|
|
);
|
|
}
|
|
|
|
export async function getS3BucketWebsite(
|
|
cloud: CloudProvider,
|
|
bucketName: string,
|
|
signal?: AbortSignal,
|
|
): Promise<S3BucketWebsiteConfiguration | null> {
|
|
const res = await apiClient.call<S3BucketWebsiteConfiguration | null>(
|
|
apiEndpointKeys.clouds.resources.getS3BucketWebsite,
|
|
requestOptions(cloud, "storage", {signal}),
|
|
{cloud, id: bucketName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function putS3BucketWebsite(
|
|
cloud: CloudProvider,
|
|
bucketName: string,
|
|
configuration: S3BucketWebsiteConfiguration,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void, S3BucketWebsiteConfiguration>(
|
|
apiEndpointKeys.clouds.resources.putS3BucketWebsite,
|
|
requestOptions(cloud, "storage", {signal, body: configuration}),
|
|
{cloud, id: bucketName},
|
|
);
|
|
}
|
|
|
|
export async function deleteS3BucketWebsite(
|
|
cloud: CloudProvider,
|
|
bucketName: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteS3BucketWebsite,
|
|
requestOptions(cloud, "storage", {signal}),
|
|
{cloud, id: bucketName},
|
|
);
|
|
}
|
|
|
|
export async function createSnsSubscription(
|
|
cloud: CloudProvider,
|
|
topicArn: string,
|
|
input: CreateSnsSubscriptionInput,
|
|
signal?: AbortSignal,
|
|
): Promise<SnsSubscriptionOverview> {
|
|
const res = await apiClient.call<SnsSubscriptionOverview, CreateSnsSubscriptionInput>(
|
|
apiEndpointKeys.clouds.resources.createSnsSubscription,
|
|
requestOptions(cloud, "notifications", {signal, body: input}),
|
|
{cloud, id: topicArn},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listSnsSubscriptions(
|
|
cloud: CloudProvider,
|
|
topicArn: string,
|
|
signal?: AbortSignal,
|
|
): Promise<SnsSubscriptionOverview[]> {
|
|
const res = await apiClient.call<SnsSubscriptionOverview[]>(
|
|
apiEndpointKeys.clouds.resources.listSnsSubscriptions,
|
|
requestOptions(cloud, "notifications", {signal}),
|
|
{cloud, id: topicArn},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteSnsSubscription(
|
|
cloud: CloudProvider,
|
|
topicArn: string,
|
|
subscriptionArn: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteSnsSubscription,
|
|
requestOptions(cloud, "notifications", {signal}),
|
|
{cloud, id: topicArn, subscriptionArn},
|
|
);
|
|
}
|
|
|
|
export async function createEventBridgeLambdaTrigger(
|
|
cloud: CloudProvider,
|
|
functionName: string,
|
|
input: CreateEventBridgeLambdaTriggerInput,
|
|
signal?: AbortSignal,
|
|
): Promise<EventBridgeLambdaTriggerOverview> {
|
|
const res = await apiClient.call<EventBridgeLambdaTriggerOverview, CreateEventBridgeLambdaTriggerInput>(
|
|
apiEndpointKeys.clouds.resources.createEventBridgeLambdaTrigger,
|
|
requestOptions(cloud, "serverless", {signal, body: input}),
|
|
{cloud, id: functionName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listEventBridgeLambdaTriggers(
|
|
cloud: CloudProvider,
|
|
functionName: string,
|
|
signal?: AbortSignal,
|
|
): Promise<EventBridgeLambdaTriggerOverview[]> {
|
|
const res = await apiClient.call<EventBridgeLambdaTriggerOverview[]>(
|
|
apiEndpointKeys.clouds.resources.listEventBridgeLambdaTriggers,
|
|
requestOptions(cloud, "serverless", {signal}),
|
|
{cloud, id: functionName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteEventBridgeLambdaTrigger(
|
|
cloud: CloudProvider,
|
|
functionName: string,
|
|
triggerId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteEventBridgeLambdaTrigger,
|
|
requestOptions(cloud, "serverless", {signal}),
|
|
{cloud, id: functionName, triggerId},
|
|
);
|
|
}
|
|
|
|
export async function createEventBridgeRule(
|
|
cloud: CloudProvider,
|
|
eventBusId: string,
|
|
input: CreateEventBridgeRuleInput,
|
|
signal?: AbortSignal,
|
|
): Promise<EventBridgeRuleOverview> {
|
|
const res = await apiClient.call<EventBridgeRuleOverview, CreateEventBridgeRuleInput>(
|
|
apiEndpointKeys.clouds.resources.createEventBridgeRule,
|
|
requestOptions(cloud, "events", {signal, body: input}),
|
|
{cloud, id: eventBusId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listEventBridgeRules(
|
|
cloud: CloudProvider,
|
|
eventBusId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<EventBridgeRuleOverview[]> {
|
|
const res = await apiClient.call<EventBridgeRuleOverview[]>(
|
|
apiEndpointKeys.clouds.resources.listEventBridgeRules,
|
|
requestOptions(cloud, "events", {signal}),
|
|
{cloud, id: eventBusId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteEventBridgeRule(
|
|
cloud: CloudProvider,
|
|
eventBusId: string,
|
|
ruleName: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteEventBridgeRule,
|
|
requestOptions(cloud, "events", {signal}),
|
|
{cloud, id: eventBusId, ruleName},
|
|
);
|
|
}
|
|
|
|
export async function putEventBridgeEvent(
|
|
cloud: CloudProvider,
|
|
eventBusId: string,
|
|
input: PutEventBridgeEventInput,
|
|
signal?: AbortSignal,
|
|
): Promise<PutEventBridgeEventResult> {
|
|
const res = await apiClient.call<PutEventBridgeEventResult, PutEventBridgeEventInput>(
|
|
apiEndpointKeys.clouds.resources.putEventBridgeEvent,
|
|
requestOptions(cloud, "events", {signal, body: input}),
|
|
{cloud, id: eventBusId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listCloudFormationChangeSets(cloud: CloudProvider, stackName: string, signal?: AbortSignal): Promise<CloudFormationChangeSet[]> { const res = await apiClient.call<CloudFormationChangeSet[]>(apiEndpointKeys.clouds.resources.listCloudFormationChangeSets, requestOptions(cloud, 'iac', {signal}), {cloud, id: stackName}); return res.data }
|
|
export async function createCloudFormationChangeSet(cloud: CloudProvider, stackName: string, input: {name: string; templateBody: string; parameters?: Record<string, string>; capabilities?: string[]}): Promise<CloudFormationChangeSet> { const res = await apiClient.call<CloudFormationChangeSet, typeof input>(apiEndpointKeys.clouds.resources.createCloudFormationChangeSet, requestOptions(cloud, 'iac', {body: input}), {cloud, id: stackName}); return res.data }
|
|
export async function executeCloudFormationChangeSet(cloud: CloudProvider, stackName: string, name: string): Promise<void> { await apiClient.call<void>(apiEndpointKeys.clouds.resources.executeCloudFormationChangeSet, requestOptions(cloud, 'iac', {}), {cloud, id: stackName, name}) }
|
|
export async function deleteCloudFormationChangeSet(cloud: CloudProvider, stackName: string, name: string): Promise<void> { await apiClient.call<void>(apiEndpointKeys.clouds.resources.deleteCloudFormationChangeSet, requestOptions(cloud, 'iac', {}), {cloud, id: stackName, name}) }
|
|
export async function updateCloudFormationTerminationProtection(cloud: CloudProvider, stackName: string, enabled: boolean): Promise<void> { await apiClient.call<void, {enabled: boolean}>(apiEndpointKeys.clouds.resources.updateCloudFormationTerminationProtection, requestOptions(cloud, 'iac', {body: {enabled}}), {cloud, id: stackName}) }
|
|
|
|
export async function createSqsLambdaEventSourceMapping(
|
|
cloud: CloudProvider,
|
|
functionName: string,
|
|
input: CreateSqsLambdaEventSourceMappingInput,
|
|
signal?: AbortSignal,
|
|
): Promise<SqsLambdaEventSourceMappingOverview> {
|
|
const res = await apiClient.call<SqsLambdaEventSourceMappingOverview, CreateSqsLambdaEventSourceMappingInput>(
|
|
apiEndpointKeys.clouds.resources.createSqsLambdaEventSourceMapping,
|
|
requestOptions(cloud, "serverless", {signal, body: input}),
|
|
{cloud, id: functionName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listSqsLambdaEventSourceMappings(
|
|
cloud: CloudProvider,
|
|
functionName: string,
|
|
signal?: AbortSignal,
|
|
): Promise<SqsLambdaEventSourceMappingOverview[]> {
|
|
const res = await apiClient.call<SqsLambdaEventSourceMappingOverview[]>(
|
|
apiEndpointKeys.clouds.resources.listSqsLambdaEventSourceMappings,
|
|
requestOptions(cloud, "serverless", {signal}),
|
|
{cloud, id: functionName},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteSqsLambdaEventSourceMapping(
|
|
cloud: CloudProvider,
|
|
functionName: string,
|
|
mappingId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.deleteSqsLambdaEventSourceMapping,
|
|
requestOptions(cloud, "serverless", {signal}),
|
|
{cloud, id: functionName, mappingId},
|
|
);
|
|
}
|
|
|
|
export type KmsEncryptionAlgorithm =
|
|
| "SYMMETRIC_DEFAULT"
|
|
| "RSAES_OAEP_SHA_1"
|
|
| "RSAES_OAEP_SHA_256";
|
|
|
|
export interface KmsEncryptRequest {
|
|
plaintextBase64: string;
|
|
encryptionAlgorithm: KmsEncryptionAlgorithm;
|
|
encryptionContext?: Record<string, string>;
|
|
}
|
|
|
|
export interface KmsEncryptResponse {
|
|
ciphertextBlobBase64: string;
|
|
keyId: string;
|
|
encryptionAlgorithm: KmsEncryptionAlgorithm;
|
|
}
|
|
|
|
export interface KmsDecryptRequest {
|
|
ciphertextBlobBase64: string;
|
|
encryptionAlgorithm: KmsEncryptionAlgorithm;
|
|
encryptionContext?: Record<string, string>;
|
|
}
|
|
|
|
export interface KmsDecryptResponse {
|
|
plaintextBase64: string;
|
|
keyId: string;
|
|
encryptionAlgorithm: KmsEncryptionAlgorithm;
|
|
}
|
|
|
|
export async function invokeCloudResource(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
id: string,
|
|
payload: string,
|
|
signal?: AbortSignal,
|
|
): Promise<ServerlessInvokeResult> {
|
|
const res = await apiClient.call<ServerlessInvokeResult, { payload: string }>(
|
|
apiEndpointKeys.clouds.resources.invoke,
|
|
requestOptions(cloud, service, {
|
|
signal,
|
|
body: { payload },
|
|
// A cold invoke can exceed a minute while the runtime pulls and starts the
|
|
// function container, so the 10s default would abort a request that is
|
|
// working. The user-visible alternative is a timeout error for a function
|
|
// that in fact ran.
|
|
timeout: INVOKE_TIMEOUT_MS,
|
|
}),
|
|
{ cloud, service, id },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function startWorkflowExecution(
|
|
stateMachineArn: string,
|
|
input: {input: string; name?: string},
|
|
): Promise<{executionArn: string; startDate: string}> {
|
|
const res = await apiClient.call<{executionArn: string; startDate: string}, {input: string; name?: string}>(
|
|
apiEndpointKeys.clouds.resources.startWorkflowExecution,
|
|
requestOptions("aws", "workflows", {body: input}),
|
|
{cloud: "aws", id: stateMachineArn},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listWorkflowExecutions(stateMachineArn: string, signal?: AbortSignal): Promise<WorkflowExecutionSummary[]> {
|
|
const res = await apiClient.call<WorkflowExecutionSummary[]>(
|
|
apiEndpointKeys.clouds.resources.listWorkflowExecutions,
|
|
requestOptions("aws", "workflows", {signal}),
|
|
{cloud: "aws", id: stateMachineArn},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function describeWorkflowExecution(stateMachineArn: string, executionArn: string, signal?: AbortSignal): Promise<WorkflowExecutionDetail> {
|
|
const res = await apiClient.call<WorkflowExecutionDetail>(
|
|
apiEndpointKeys.clouds.resources.describeWorkflowExecution,
|
|
requestOptions("aws", "workflows", {signal}),
|
|
{cloud: "aws", id: stateMachineArn, executionArn},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getWorkflowExecutionHistory(stateMachineArn: string, executionArn: string, nextToken?: string, signal?: AbortSignal): Promise<WorkflowExecutionHistoryPage> {
|
|
const res = await apiClient.call<WorkflowExecutionHistoryPage>(
|
|
apiEndpointKeys.clouds.resources.getWorkflowExecutionHistory,
|
|
requestOptions("aws", "workflows", {signal, params: {nextToken}}),
|
|
{cloud: "aws", id: stateMachineArn, executionArn},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function stopWorkflowExecution(stateMachineArn: string, executionArn: string): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.resources.stopWorkflowExecution,
|
|
requestOptions("aws", "workflows"),
|
|
{cloud: "aws", id: stateMachineArn, executionArn},
|
|
);
|
|
}
|
|
|
|
export async function startCodeBuild(projectName: string, input: {environmentVariablesOverride?: CodeBuildEnvironmentVariableOverride[]; buildspecOverride?: string}): Promise<CodeBuildBuild> {
|
|
const res = await apiClient.call<CodeBuildBuild, typeof input>(apiEndpointKeys.clouds.resources.startCodeBuild, requestOptions("aws", "codebuild", {body: input}), {cloud: "aws", id: projectName});
|
|
return res.data;
|
|
}
|
|
|
|
export async function listCodeBuilds(projectName: string, signal?: AbortSignal): Promise<CodeBuildBuild[]> {
|
|
const res = await apiClient.call<CodeBuildBuild[]>(apiEndpointKeys.clouds.resources.listCodeBuilds, requestOptions("aws", "codebuild", {signal}), {cloud: "aws", id: projectName});
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCodeBuild(projectName: string, buildId: string, signal?: AbortSignal): Promise<CodeBuildBuild> {
|
|
const res = await apiClient.call<CodeBuildBuild>(apiEndpointKeys.clouds.resources.getCodeBuild, requestOptions("aws", "codebuild", {signal}), {cloud: "aws", id: projectName, buildId});
|
|
return res.data;
|
|
}
|
|
|
|
export async function startCodePipeline(name: string): Promise<{id: string}> {
|
|
const res = await apiClient.call<{id: string}>(apiEndpointKeys.clouds.resources.startCodePipeline, requestOptions('aws', 'codepipeline'), {cloud: 'aws', id: name});
|
|
return res.data;
|
|
}
|
|
|
|
export async function listCodePipelineExecutions(name: string, signal?: AbortSignal): Promise<PipelineExecutionSummary[]> {
|
|
const res = await apiClient.call<PipelineExecutionSummary[]>(apiEndpointKeys.clouds.resources.listCodePipelineExecutions, requestOptions('aws', 'codepipeline', {signal}), {cloud: 'aws', id: name});
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCodePipelineState(name: string, signal?: AbortSignal): Promise<PipelineState> {
|
|
const res = await apiClient.call<PipelineState>(apiEndpointKeys.clouds.resources.getCodePipelineState, requestOptions('aws', 'codepipeline', {signal}), {cloud: 'aws', id: name});
|
|
return res.data;
|
|
}
|
|
|
|
export async function getCodeDeployDependencies(signal?: AbortSignal): Promise<CodeDeployDependencies> { const res = await apiClient.call<CodeDeployDependencies>(apiEndpointKeys.clouds.dependencies, requestOptions('aws', 'codedeploy', {signal}), {cloud: 'aws', service: 'codedeploy'}); return res.data }
|
|
export async function startCodeDeployDeployment(groupId: string, input: StartCodeDeployDeploymentInput): Promise<CodeDeployDeployment> { const res = await apiClient.call<CodeDeployDeployment, StartCodeDeployDeploymentInput>(apiEndpointKeys.clouds.resources.startCodeDeployDeployment, requestOptions('aws', 'codedeploy', {body: input}), {cloud: 'aws', id: groupId}); return res.data }
|
|
export async function listCodeDeployDeployments(groupId: string, signal?: AbortSignal): Promise<CodeDeployDeployment[]> { const res = await apiClient.call<CodeDeployDeployment[]>(apiEndpointKeys.clouds.resources.listCodeDeployDeployments, requestOptions('aws', 'codedeploy', {signal}), {cloud: 'aws', id: groupId}); return res.data }
|
|
export async function getCodeDeployDeployment(id: string, signal?: AbortSignal): Promise<CodeDeployDeployment> { const res = await apiClient.call<CodeDeployDeployment>(apiEndpointKeys.clouds.resources.getCodeDeployDeployment, requestOptions('aws', 'codedeploy', {signal}), {cloud: 'aws', deploymentId: id}); return res.data }
|
|
export async function stopCodeDeployDeployment(id: string, rollback: boolean): Promise<void> { await apiClient.call<void, {rollback: boolean}>(apiEndpointKeys.clouds.resources.stopCodeDeployDeployment, requestOptions('aws', 'codedeploy', {body: {rollback}}), {cloud: 'aws', deploymentId: id}) }
|
|
|
|
export async function publishNotification(
|
|
cloud: CloudProvider,
|
|
topicArn: string,
|
|
input: PublishNotificationInput,
|
|
signal?: AbortSignal,
|
|
): Promise<PublishNotificationResult> {
|
|
const res = await apiClient.call<PublishNotificationResult, PublishNotificationInput>(
|
|
apiEndpointKeys.clouds.resources.publish,
|
|
requestOptions(cloud, "notifications", { signal, body: input }),
|
|
{ cloud, id: topicArn },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function encryptKmsResource(
|
|
cloud: CloudProvider,
|
|
id: string,
|
|
body: KmsEncryptRequest,
|
|
signal?: AbortSignal,
|
|
): Promise<KmsEncryptResponse> {
|
|
const res = await apiClient.call<KmsEncryptResponse, KmsEncryptRequest>(
|
|
apiEndpointKeys.clouds.resources.encrypt,
|
|
requestOptions(cloud, "kms", { signal, body }),
|
|
{ cloud, id },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function decryptKmsResource(
|
|
cloud: CloudProvider,
|
|
id: string,
|
|
body: KmsDecryptRequest,
|
|
signal?: AbortSignal,
|
|
): Promise<KmsDecryptResponse> {
|
|
const res = await apiClient.call<KmsDecryptResponse, KmsDecryptRequest>(
|
|
apiEndpointKeys.clouds.resources.decrypt,
|
|
requestOptions(cloud, "kms", { signal, body }),
|
|
{ cloud, id },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listStorageObjects(
|
|
cloud: CloudProvider,
|
|
resourceId: string,
|
|
prefix?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<StorageObjectList> {
|
|
const res = await apiClient.call<StorageObjectList>(
|
|
apiEndpointKeys.clouds.storage.objects.list,
|
|
requestOptions(cloud, "storage", { signal, params: { prefix } }),
|
|
storagePathParams(cloud, resourceId),
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function uploadStorageObject(
|
|
cloud: CloudProvider,
|
|
resourceId: string,
|
|
key: string,
|
|
file: File | Blob,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.storage.objects.upload,
|
|
requestOptions(cloud, "storage", {
|
|
signal,
|
|
rawBody: file,
|
|
params: { key },
|
|
headers: { "Content-Type": file.type || "application/octet-stream" },
|
|
}),
|
|
storagePathParams(cloud, resourceId),
|
|
);
|
|
}
|
|
|
|
export type LightsailStaticDeployment = {status: 'deployed'; files: number}
|
|
export type LightsailNodeDeployment = {status: 'deployed'; files: number; port: number; releaseId: string}
|
|
|
|
export async function deployLightsailStaticFiles(instanceId: string, files: File[]): Promise<LightsailStaticDeployment> {
|
|
const form = new FormData()
|
|
for (const file of files) {
|
|
const path = file.webkitRelativePath || file.name
|
|
form.append('files', file, path)
|
|
}
|
|
const res = await apiClient.call<LightsailStaticDeployment>(
|
|
apiEndpointKeys.clouds.resources.deployLightsailStaticFiles,
|
|
requestOptions('aws', 'lightsail', {rawBody: form}),
|
|
{id: instanceId},
|
|
)
|
|
return res.data
|
|
}
|
|
|
|
export async function deployLightsailNodeApplication(instanceId: string, files: File[], startCommand: string, port: number): Promise<LightsailNodeDeployment> {
|
|
const form = new FormData()
|
|
for (const file of files) form.append('files', file, file.webkitRelativePath || file.name)
|
|
if (startCommand.trim()) form.append('startCommand', startCommand.trim())
|
|
form.append('port', String(port))
|
|
const res = await apiClient.call<LightsailNodeDeployment>(
|
|
apiEndpointKeys.clouds.resources.deployLightsailNodeApplication,
|
|
requestOptions('aws', 'lightsail', {rawBody: form, timeout: 370_000}),
|
|
{id: instanceId},
|
|
)
|
|
return res.data
|
|
}
|
|
|
|
export function storageObjectDownloadUrl(
|
|
cloud: CloudProvider,
|
|
resourceId: string,
|
|
key: string,
|
|
): string {
|
|
const path = `/clouds/${encodeURIComponent(
|
|
cloud,
|
|
)}/services/storage/resources/${encodeURIComponent(resourceId)}/object`;
|
|
// This URL is opened directly by the browser (anchor/img), so it bypasses the
|
|
// request interceptor — pass the account as a query param the API also reads.
|
|
return `${API_BASE_URL}${path}?key=${encodeURIComponent(
|
|
key,
|
|
)}&account=${encodeURIComponent(getAccountId())}`;
|
|
}
|
|
|
|
export async function deleteStorageObject(
|
|
cloud: CloudProvider,
|
|
resourceId: string,
|
|
key: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.storage.objects.delete,
|
|
requestOptions(cloud, "storage", { signal, params: { key } }),
|
|
storagePathParams(cloud, resourceId),
|
|
);
|
|
}
|
|
|
|
export async function copyStorageObject(
|
|
cloud: CloudProvider,
|
|
srcResourceId: string,
|
|
srcKey: string,
|
|
destKey: string,
|
|
destResourceId?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.storage.objects.copy,
|
|
requestOptions(cloud, "storage", {
|
|
signal,
|
|
body: { srcKey, destKey, ...(destResourceId ? { destResourceId } : {}) },
|
|
}),
|
|
storagePathParams(cloud, srcResourceId),
|
|
);
|
|
}
|
|
|
|
export async function listCosmosContainers(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CosmosContainer[]> {
|
|
const res = await apiClient.call<CosmosContainer[]>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.containers.list,
|
|
requestOptions(cloud, "nosql", { signal }),
|
|
databasePathParams(cloud, databaseId),
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createCosmosContainer(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
values: Record<string, unknown>,
|
|
signal?: AbortSignal,
|
|
): Promise<CosmosContainer> {
|
|
const res = await apiClient.call<CosmosContainer, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.containers.create,
|
|
requestOptions(cloud, "nosql", { signal, body: values }),
|
|
databasePathParams(cloud, databaseId),
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteCosmosContainer(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
containerId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.containers.delete,
|
|
requestOptions(cloud, "nosql", { signal }),
|
|
{ ...databasePathParams(cloud, databaseId), containerId },
|
|
);
|
|
}
|
|
|
|
|
|
|
|
export async function listCosmosItems(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
containerId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CosmosItem[]> {
|
|
const res = await apiClient.call<CosmosItem[]>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.items.list,
|
|
requestOptions(cloud, "nosql", { signal }),
|
|
{ ...databasePathParams(cloud, databaseId), containerId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function upsertCosmosItem(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
containerId: string,
|
|
document: Record<string, unknown>,
|
|
signal?: AbortSignal,
|
|
): Promise<CosmosItem> {
|
|
const res = await apiClient.call<CosmosItem, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.items.upsert,
|
|
requestOptions(cloud, "nosql", { signal, body: document }),
|
|
{ ...databasePathParams(cloud, databaseId), containerId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteCosmosItem(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
containerId: string,
|
|
itemId: string,
|
|
partitionKey?: string | null,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.items.delete,
|
|
requestOptions(cloud, "nosql", {
|
|
signal,
|
|
params: partitionKey ? { partitionKey } : undefined,
|
|
}),
|
|
{ ...databasePathParams(cloud, databaseId), containerId, itemId },
|
|
);
|
|
}
|
|
|
|
export async function queryCosmosItems(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
containerId: string,
|
|
query: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CosmosQueryResult> {
|
|
const res = await apiClient.call<CosmosQueryResult, { query: string }>(
|
|
apiEndpointKeys.clouds.nosql.cosmos.items.query,
|
|
requestOptions(cloud, "nosql", { signal, body: { query } }),
|
|
{ ...databasePathParams(cloud, databaseId), containerId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listChildCollections(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
cursor?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CollectionPage<ChildCollection>> {
|
|
const res = await apiClient.call<CollectionPage<ChildCollection>>(
|
|
apiEndpointKeys.clouds.childCollections.list,
|
|
requestOptions(cloud, service, { signal, params: cursor ? { cursor } : undefined }),
|
|
{ cloud, service, id: resourceId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listCollectionItems(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
collectionId: string,
|
|
cursor?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CollectionPage<ChildItem>> {
|
|
const res = await apiClient.call<CollectionPage<ChildItem>>(
|
|
apiEndpointKeys.clouds.childCollections.items.list,
|
|
requestOptions(cloud, service, { signal, params: cursor ? { cursor } : undefined }),
|
|
{ cloud, service, id: resourceId, cid: collectionId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listFlatItems(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
cursor?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CollectionPage<ChildItem>> {
|
|
const res = await apiClient.call<CollectionPage<ChildItem>>(
|
|
apiEndpointKeys.clouds.flatItems.list,
|
|
requestOptions(cloud, service, { signal, params: cursor ? { cursor } : undefined }),
|
|
{ cloud, service, id: resourceId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function queryFlatItems(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
query: Record<string, unknown>,
|
|
cursor?: string,
|
|
limit = 100,
|
|
signal?: AbortSignal,
|
|
): Promise<CollectionPage<ChildItem>> {
|
|
const res = await apiClient.call<CollectionPage<ChildItem>, {query: Record<string, unknown>}>(
|
|
apiEndpointKeys.clouds.flatItems.query,
|
|
requestOptions(cloud, service, {signal, params: {cursor, limit}, body: {query}}),
|
|
{cloud, service, id: resourceId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteFlatItem(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
itemId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.flatItems.delete,
|
|
requestOptions(cloud, service, { signal }),
|
|
{ cloud, service, id: resourceId, itemId },
|
|
);
|
|
}
|
|
|
|
export async function getFlatItem(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
itemId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<ChildItem> {
|
|
const res = await apiClient.call<ChildItem>(
|
|
apiEndpointKeys.clouds.flatItems.get,
|
|
requestOptions(cloud, service, { signal }),
|
|
{ cloud, service, id: resourceId, itemId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function updateUserPoolUser(
|
|
cloud: CloudProvider,
|
|
poolId: string,
|
|
username: string,
|
|
input: UserPoolUserAction,
|
|
): Promise<void> {
|
|
await apiClient.call<void, UserPoolUserAction>(
|
|
apiEndpointKeys.clouds.userpools.userAction,
|
|
requestOptions(cloud, "userpools", { body: input }),
|
|
{ cloud, id: poolId, username },
|
|
);
|
|
}
|
|
|
|
export async function setUserPoolUserGroups(
|
|
cloud: CloudProvider,
|
|
poolId: string,
|
|
username: string,
|
|
groups: string[],
|
|
): Promise<void> {
|
|
await apiClient.call<void, { groups: string[] }>(
|
|
apiEndpointKeys.clouds.userpools.userGroups,
|
|
requestOptions(cloud, "userpools", { body: { groups } }),
|
|
{ cloud, id: poolId, username },
|
|
);
|
|
}
|
|
|
|
export async function listUserPoolGroups(
|
|
cloud: CloudProvider,
|
|
poolId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<UserPoolGroup[]> {
|
|
const res = await apiClient.call<UserPoolGroup[]>(
|
|
apiEndpointKeys.clouds.userpools.groups.list,
|
|
requestOptions(cloud, "userpools", { signal }),
|
|
{ cloud, id: poolId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createUserPoolGroup(
|
|
cloud: CloudProvider,
|
|
poolId: string,
|
|
input: CreateUserPoolGroupInput,
|
|
): Promise<UserPoolGroup> {
|
|
const res = await apiClient.call<UserPoolGroup, CreateUserPoolGroupInput>(
|
|
apiEndpointKeys.clouds.userpools.groups.create,
|
|
requestOptions(cloud, "userpools", { body: input }),
|
|
{ cloud, id: poolId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteUserPoolGroup(
|
|
cloud: CloudProvider,
|
|
poolId: string,
|
|
groupName: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.userpools.groups.delete,
|
|
requestOptions(cloud, "userpools"),
|
|
{ cloud, id: poolId, groupName },
|
|
);
|
|
}
|
|
|
|
export async function testUserPoolSignIn(
|
|
cloud: CloudProvider,
|
|
poolId: string,
|
|
input: UserPoolSignInTestInput,
|
|
): Promise<UserPoolSignInTestResult> {
|
|
const res = await apiClient.call<UserPoolSignInTestResult, UserPoolSignInTestInput>(
|
|
apiEndpointKeys.clouds.userpools.signInTest,
|
|
requestOptions(cloud, "userpools", { body: input }),
|
|
{ cloud, id: poolId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function putFlatItem(
|
|
cloud: CloudProvider,
|
|
service: CloudServiceType,
|
|
resourceId: string,
|
|
body: Record<string, unknown>,
|
|
): Promise<ChildItem> {
|
|
const res = await apiClient.call<ChildItem, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.flatItems.create,
|
|
requestOptions(cloud, service, {body}),
|
|
{cloud, service, id: resourceId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listSqlDatabases(
|
|
cloud: CloudProvider,
|
|
serverId: string,
|
|
engine: SqlEngine,
|
|
credentials: SqlCredentials,
|
|
signal?: AbortSignal,
|
|
): Promise<SqlDatabase[]> {
|
|
const res = await apiClient.call<SqlDatabase[], SqlCredentials & { engine: SqlEngine }>(
|
|
apiEndpointKeys.clouds.database.sql.databases,
|
|
requestOptions(cloud, "database", {
|
|
signal,
|
|
body: { ...credentials, engine },
|
|
timeout: SQL_DATA_TIMEOUT_MS,
|
|
}),
|
|
{ cloud, id: serverId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listSqlTables(
|
|
cloud: CloudProvider,
|
|
serverId: string,
|
|
engine: SqlEngine,
|
|
database: string,
|
|
credentials: SqlCredentials,
|
|
signal?: AbortSignal,
|
|
): Promise<SqlTable[]> {
|
|
const res = await apiClient.call<
|
|
SqlTable[],
|
|
SqlCredentials & { database: string; engine: SqlEngine }
|
|
>(
|
|
apiEndpointKeys.clouds.database.sql.tables,
|
|
requestOptions(cloud, "database", {
|
|
signal,
|
|
body: { ...credentials, database, engine },
|
|
timeout: SQL_DATA_TIMEOUT_MS,
|
|
}),
|
|
{ cloud, id: serverId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function querySql(
|
|
cloud: CloudProvider,
|
|
serverId: string,
|
|
engine: SqlEngine,
|
|
database: string,
|
|
credentials: SqlCredentials,
|
|
query: string,
|
|
signal?: AbortSignal,
|
|
): Promise<SqlQueryResult> {
|
|
const res = await apiClient.call<
|
|
SqlQueryResult,
|
|
SqlCredentials & { database: string; engine: SqlEngine; query: string }
|
|
>(
|
|
apiEndpointKeys.clouds.database.sql.query,
|
|
requestOptions(cloud, "database", {
|
|
signal,
|
|
body: { ...credentials, database, engine, query },
|
|
timeout: SQL_DATA_TIMEOUT_MS,
|
|
}),
|
|
{ cloud, id: serverId },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function queryLogs(
|
|
cloud: CloudProvider,
|
|
logGroupName: string,
|
|
input: LogsInsightsQueryInput,
|
|
signal?: AbortSignal,
|
|
): Promise<LogsInsightsQueryResult> {
|
|
const res = await apiClient.call<LogsInsightsQueryResult, LogsInsightsQueryInput>(
|
|
apiEndpointKeys.clouds.logs.query,
|
|
requestOptions(cloud, "logs", { signal, body: input, timeout: LOGS_QUERY_TIMEOUT_MS }),
|
|
{ cloud, id: logGroupName },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function filterLogEvents(
|
|
cloud: CloudProvider,
|
|
logGroupName: string,
|
|
input: LogsFilterInput,
|
|
cursor?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<CollectionPage<ChildItem>> {
|
|
const res = await apiClient.call<CollectionPage<ChildItem>, LogsFilterInput>(
|
|
apiEndpointKeys.clouds.logs.filter,
|
|
requestOptions(cloud, "logs", { signal, body: input, params: cursor ? { cursor } : undefined }),
|
|
{ cloud, id: logGroupName },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function sendSqsMessage(cloud: CloudProvider, queueId: string, input: SqsSendMessageInput): Promise<{messageId: string}> {
|
|
const res = await apiClient.call<{messageId: string}, SqsSendMessageInput>(apiEndpointKeys.clouds.messaging.messages.send, requestOptions(cloud, 'messaging', {body: input}), {cloud, id: queueId})
|
|
return res.data
|
|
}
|
|
|
|
export async function receiveSqsMessages(cloud: CloudProvider, queueId: string, maxNumberOfMessages: number): Promise<SqsMessage[]> {
|
|
const res = await apiClient.call<SqsMessage[], {maxNumberOfMessages: number}>(apiEndpointKeys.clouds.messaging.messages.receive, requestOptions(cloud, 'messaging', {body: {maxNumberOfMessages}}), {cloud, id: queueId})
|
|
return res.data
|
|
}
|
|
|
|
export async function deleteSqsMessage(cloud: CloudProvider, queueId: string, receiptHandle: string): Promise<void> {
|
|
await apiClient.call(apiEndpointKeys.clouds.messaging.messages.delete, requestOptions(cloud, 'messaging', {body: {receiptHandle}}), {cloud, id: queueId})
|
|
}
|
|
|
|
export async function purgeSqsQueue(cloud: CloudProvider, queueId: string): Promise<void> {
|
|
await apiClient.call(apiEndpointKeys.clouds.messaging.messages.purge, requestOptions(cloud, 'messaging'), {cloud, id: queueId})
|
|
}
|
|
|
|
export async function startSqsMoveTask(cloud: CloudProvider, queueId: string, destinationArn?: string): Promise<{taskHandle: string}> {
|
|
const res = await apiClient.call<{taskHandle: string}, {destinationArn?: string}>(apiEndpointKeys.clouds.messaging.moveTasks, requestOptions(cloud, 'messaging', {body: {destinationArn}}), {cloud, id: queueId})
|
|
return res.data
|
|
}
|
|
|
|
export async function listDatabaseSnapshots(
|
|
cloud: CloudProvider,
|
|
instanceIdentifier?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<DatabaseSnapshot[]> {
|
|
const res = await apiClient.call<DatabaseSnapshot[]>(
|
|
apiEndpointKeys.clouds.database.snapshots.list,
|
|
requestOptions(cloud, "database", {
|
|
signal,
|
|
params: instanceIdentifier ? { instanceIdentifier } : undefined,
|
|
}),
|
|
{ cloud },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createDatabaseSnapshot(
|
|
cloud: CloudProvider,
|
|
input: CreateDatabaseSnapshotInput,
|
|
signal?: AbortSignal,
|
|
): Promise<DatabaseSnapshot> {
|
|
const res = await apiClient.call<DatabaseSnapshot, CreateDatabaseSnapshotInput>(
|
|
apiEndpointKeys.clouds.database.snapshots.create,
|
|
requestOptions(cloud, "database", { signal, body: input }),
|
|
{ cloud },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listDatabaseOrderableClasses(
|
|
cloud: CloudProvider,
|
|
engine?: string,
|
|
signal?: AbortSignal,
|
|
): Promise<string[]> {
|
|
const res = await apiClient.call<string[]>(
|
|
apiEndpointKeys.clouds.database.orderableClasses.list,
|
|
requestOptions(cloud, "database", {
|
|
signal,
|
|
params: engine ? { engine } : undefined,
|
|
}),
|
|
{ cloud },
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function listKubernetesNodegroups(
|
|
cloud: CloudProvider,
|
|
clusterId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<KubernetesNodegroup[]> {
|
|
const res = await apiClient.call<KubernetesNodegroup[]>(
|
|
apiEndpointKeys.clouds.k8s.nodegroups.list,
|
|
requestOptions(cloud, "k8s", {signal}),
|
|
{cloud, id: clusterId},
|
|
)
|
|
return res.data
|
|
}
|
|
|
|
export async function createKubernetesNodegroup(
|
|
cloud: CloudProvider,
|
|
clusterId: string,
|
|
input: CreateKubernetesNodegroupInput,
|
|
): Promise<KubernetesNodegroup> {
|
|
const res = await apiClient.call<KubernetesNodegroup, CreateKubernetesNodegroupInput>(
|
|
apiEndpointKeys.clouds.k8s.nodegroups.create,
|
|
requestOptions(cloud, "k8s", {body: input}),
|
|
{cloud, id: clusterId},
|
|
)
|
|
return res.data
|
|
}
|
|
|
|
export async function deleteKubernetesNodegroup(
|
|
cloud: CloudProvider,
|
|
clusterId: string,
|
|
nodegroupId: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.k8s.nodegroups.delete,
|
|
requestOptions(cloud, "k8s"),
|
|
{cloud, id: clusterId, nodegroupId},
|
|
)
|
|
}
|
|
|
|
export async function listKubernetesFargateProfiles(
|
|
cloud: CloudProvider,
|
|
clusterId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<KubernetesFargateProfile[]> {
|
|
const res = await apiClient.call<KubernetesFargateProfile[]>(
|
|
apiEndpointKeys.clouds.k8s.fargateProfiles.list,
|
|
requestOptions(cloud, "k8s", {signal}),
|
|
{cloud, id: clusterId},
|
|
)
|
|
return res.data
|
|
}
|
|
|
|
export async function createKubernetesFargateProfile(
|
|
cloud: CloudProvider,
|
|
clusterId: string,
|
|
input: CreateKubernetesFargateProfileInput,
|
|
): Promise<KubernetesFargateProfile> {
|
|
const res = await apiClient.call<KubernetesFargateProfile, CreateKubernetesFargateProfileInput>(
|
|
apiEndpointKeys.clouds.k8s.fargateProfiles.create,
|
|
requestOptions(cloud, "k8s", {body: input}),
|
|
{cloud, id: clusterId},
|
|
)
|
|
return res.data
|
|
}
|
|
|
|
export async function deleteKubernetesFargateProfile(
|
|
cloud: CloudProvider,
|
|
clusterId: string,
|
|
profileId: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.k8s.fargateProfiles.delete,
|
|
requestOptions(cloud, "k8s"),
|
|
{cloud, id: clusterId, profileId},
|
|
)
|
|
}
|
|
|
|
export async function listAppConfigEnvironments(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<AppConfigEnvironment[]> {
|
|
const res = await apiClient.call<AppConfigEnvironment[]>(
|
|
apiEndpointKeys.clouds.configuration.environments.list,
|
|
requestOptions(cloud, "configuration", {signal}),
|
|
{cloud, id: applicationId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createAppConfigEnvironment(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
values: Record<string, unknown>,
|
|
): Promise<AppConfigEnvironment> {
|
|
const res = await apiClient.call<AppConfigEnvironment, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.configuration.environments.create,
|
|
requestOptions(cloud, "configuration", {body: values}),
|
|
{cloud, id: applicationId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteAppConfigEnvironment(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
environmentId: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.configuration.environments.delete,
|
|
requestOptions(cloud, "configuration"),
|
|
{cloud, id: applicationId, environmentId},
|
|
);
|
|
}
|
|
|
|
export async function listAppConfigConfigurationProfiles(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<AppConfigConfigurationProfile[]> {
|
|
const res = await apiClient.call<AppConfigConfigurationProfile[]>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.list,
|
|
requestOptions(cloud, "configuration", {signal}),
|
|
{cloud, id: applicationId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createAppConfigConfigurationProfile(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
values: Record<string, unknown>,
|
|
): Promise<AppConfigConfigurationProfile> {
|
|
const res = await apiClient.call<AppConfigConfigurationProfile, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.create,
|
|
requestOptions(cloud, "configuration", {body: values}),
|
|
{cloud, id: applicationId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteAppConfigConfigurationProfile(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
profileId: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.delete,
|
|
requestOptions(cloud, "configuration"),
|
|
{cloud, id: applicationId, profileId},
|
|
);
|
|
}
|
|
|
|
export async function listAppConfigHostedConfigurationVersions(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
profileId: string,
|
|
signal?: AbortSignal,
|
|
): Promise<AppConfigHostedConfigurationVersion[]> {
|
|
const res = await apiClient.call<AppConfigHostedConfigurationVersion[]>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.list,
|
|
requestOptions(cloud, "configuration", {signal}),
|
|
{cloud, id: applicationId, profileId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getAppConfigHostedConfigurationVersion(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
profileId: string,
|
|
versionNumber: number,
|
|
signal?: AbortSignal,
|
|
): Promise<AppConfigHostedConfigurationVersion> {
|
|
const res = await apiClient.call<AppConfigHostedConfigurationVersion>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.get,
|
|
requestOptions(cloud, "configuration", {signal}),
|
|
{cloud, id: applicationId, profileId, versionNumber: String(versionNumber)},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createAppConfigHostedConfigurationVersion(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
profileId: string,
|
|
values: Record<string, unknown>,
|
|
): Promise<AppConfigHostedConfigurationVersion> {
|
|
const res = await apiClient.call<AppConfigHostedConfigurationVersion, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.create,
|
|
requestOptions(cloud, "configuration", {body: values}),
|
|
{cloud, id: applicationId, profileId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteAppConfigHostedConfigurationVersion(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
profileId: string,
|
|
versionNumber: number,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.delete,
|
|
requestOptions(cloud, "configuration"),
|
|
{cloud, id: applicationId, profileId, versionNumber: String(versionNumber)},
|
|
);
|
|
}
|
|
|
|
export async function listAppConfigDeploymentStrategies(
|
|
cloud: CloudProvider,
|
|
signal?: AbortSignal,
|
|
): Promise<AppConfigDeploymentStrategy[]> {
|
|
const res = await apiClient.call<AppConfigDeploymentStrategy[]>(
|
|
apiEndpointKeys.clouds.configuration.deploymentStrategies.list,
|
|
requestOptions(cloud, "configuration", {signal}),
|
|
{cloud},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function createAppConfigDeploymentStrategy(
|
|
cloud: CloudProvider,
|
|
values: Record<string, unknown>,
|
|
): Promise<AppConfigDeploymentStrategy> {
|
|
const res = await apiClient.call<AppConfigDeploymentStrategy, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.configuration.deploymentStrategies.create,
|
|
requestOptions(cloud, "configuration", {body: values}),
|
|
{cloud},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function deleteAppConfigDeploymentStrategy(
|
|
cloud: CloudProvider,
|
|
strategyId: string,
|
|
): Promise<void> {
|
|
await apiClient.call<void>(
|
|
apiEndpointKeys.clouds.configuration.deploymentStrategies.delete,
|
|
requestOptions(cloud, "configuration"),
|
|
{cloud, strategyId},
|
|
);
|
|
}
|
|
|
|
export async function startAppConfigDeployment(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
environmentId: string,
|
|
values: Record<string, unknown>,
|
|
): Promise<AppConfigDeployment> {
|
|
const res = await apiClient.call<AppConfigDeployment, Record<string, unknown>>(
|
|
apiEndpointKeys.clouds.configuration.environments.deployments.start,
|
|
requestOptions(cloud, "configuration", {body: values}),
|
|
{cloud, id: applicationId, environmentId},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
export async function getAppConfigDeployment(
|
|
cloud: CloudProvider,
|
|
applicationId: string,
|
|
environmentId: string,
|
|
deploymentNumber: number,
|
|
signal?: AbortSignal,
|
|
): Promise<AppConfigDeployment> {
|
|
const res = await apiClient.call<AppConfigDeployment>(
|
|
apiEndpointKeys.clouds.configuration.environments.deployments.get,
|
|
requestOptions(cloud, "configuration", {signal}),
|
|
{cloud, id: applicationId, environmentId, deploymentNumber: String(deploymentNumber)},
|
|
);
|
|
return res.data;
|
|
}
|
|
|
|
function requestOptions<TBody = unknown>(
|
|
_cloud: CloudProvider,
|
|
_service: string,
|
|
options: {
|
|
signal?: AbortSignal;
|
|
params?: Record<string, string | number | boolean | undefined>;
|
|
body?: TBody;
|
|
rawBody?: BodyInit;
|
|
headers?: HeadersInit;
|
|
/** Overrides the client default; needed for calls that can legitimately run long. */
|
|
timeout?: number;
|
|
} = {},
|
|
) {
|
|
return {
|
|
...options,
|
|
};
|
|
}
|
|
|
|
function storagePathParams(
|
|
cloud: CloudProvider,
|
|
resourceId: string,
|
|
): CloudPathParams {
|
|
return { cloud, id: resourceId };
|
|
}
|
|
|
|
function databasePathParams(
|
|
cloud: CloudProvider,
|
|
databaseId: string,
|
|
): CloudPathParams {
|
|
return { cloud, id: databaseId };
|
|
}
|