Current section
Files
Jump to
Current section
Files
src/aws_codeartifact.erl
%% WARNING: DO NOT EDIT, AUTO-GENERATED CODE!
%% See https://github.com/aws-beam/aws-codegen for more details.
%% @doc CodeArtifact is a fully managed artifact repository compatible with
%% language-native package managers and build tools such as npm, Apache
%% Maven, pip, and dotnet.
%%
%% You can use CodeArtifact to share packages with development teams and pull
%% packages. Packages can be pulled from both public and CodeArtifact
%% repositories. You can also create an upstream relationship between a
%% CodeArtifact repository and another repository, which effectively merges
%% their contents from the point of view of a package manager client.
%%
%% CodeArtifact Components
%%
%% Use the information in this guide to help you work with the following
%% CodeArtifact components:
%%
%% <ul> <li> Repository: A CodeArtifact repository contains a set of package
%% versions, each of which maps to a set of assets, or files. Repositories
%% are polyglot, so a single repository can contain packages of any supported
%% type. Each repository exposes endpoints for fetching and publishing
%% packages using tools like the `npm' CLI, the Maven CLI ( `mvn' ), Python
%% CLIs ( `pip' and `twine'), and NuGet CLIs (`nuget' and `dotnet').
%%
%% </li> <li> Domain: Repositories are aggregated into a higher-level entity
%% known as a domain. All package assets and metadata are stored in the
%% domain, but are consumed through repositories. A given package asset, such
%% as a Maven JAR file, is stored once per domain, no matter how many
%% repositories it's present in. All of the assets and metadata in a domain
%% are encrypted with the same customer master key (CMK) stored in Key
%% Management Service (KMS).
%%
%% Each repository is a member of a single domain and can't be moved to a
%% different domain.
%%
%% The domain allows organizational policy to be applied across multiple
%% repositories, such as which accounts can access repositories in the
%% domain, and which public repositories can be used as sources of packages.
%%
%% Although an organization can have multiple domains, we recommend a single
%% production domain that contains all published artifacts so that teams can
%% find and share packages across their organization.
%%
%% </li> <li> Package: A package is a bundle of software and the metadata
%% required to resolve dependencies and install the software. CodeArtifact
%% supports npm, PyPI, Maven, and NuGet package formats.
%%
%% In CodeArtifact, a package consists of:
%%
%% <ul> <li> A name (for example, `webpack' is the name of a popular npm
%% package)
%%
%% </li> <li> An optional namespace (for example, `@types' in `@types/node')
%%
%% </li> <li> A set of versions (for example, `1.0.0', `1.0.1', `1.0.2',
%% etc.)
%%
%% </li> <li> Package-level metadata (for example, npm tags)
%%
%% </li> </ul> </li> <li> Package version: A version of a package, such as
%% `@types/node 12.6.9'. The version number format and semantics vary for
%% different package formats. For example, npm package versions must conform
%% to the Semantic Versioning specification. In CodeArtifact, a package
%% version consists of the version identifier, metadata at the package
%% version level, and a set of assets.
%%
%% </li> <li> Upstream repository: One repository is upstream of another when
%% the package versions in it can be accessed from the repository endpoint of
%% the downstream repository, effectively merging the contents of the two
%% repositories from the point of view of a client. CodeArtifact allows
%% creating an upstream relationship between two repositories.
%%
%% </li> <li> Asset: An individual file stored in CodeArtifact associated
%% with a package version, such as an npm `.tgz' file or Maven POM and JAR
%% files.
%%
%% </li> </ul> CodeArtifact supports these operations:
%%
%% <ul> <li> `AssociateExternalConnection': Adds an existing external
%% connection to a repository.
%%
%% </li> <li> `CopyPackageVersions': Copies package versions from one
%% repository to another repository in the same domain.
%%
%% </li> <li> `CreateDomain': Creates a domain
%%
%% </li> <li> `CreateRepository': Creates a CodeArtifact repository in a
%% domain.
%%
%% </li> <li> `DeleteDomain': Deletes a domain. You cannot delete a domain
%% that contains repositories.
%%
%% </li> <li> `DeleteDomainPermissionsPolicy': Deletes the resource policy
%% that is set on a domain.
%%
%% </li> <li> `DeletePackageVersions': Deletes versions of a package. After a
%% package has been deleted, it can be republished, but its assets and
%% metadata cannot be restored because they have been permanently removed
%% from storage.
%%
%% </li> <li> `DeleteRepository': Deletes a repository.
%%
%% </li> <li> `DeleteRepositoryPermissionsPolicy': Deletes the resource
%% policy that is set on a repository.
%%
%% </li> <li> `DescribeDomain': Returns a `DomainDescription' object that
%% contains information about the requested domain.
%%
%% </li> <li> `DescribePackage': Returns a PackageDescription object that
%% contains details about a package.
%%
%% </li> <li> `DescribePackageVersion': Returns a PackageVersionDescription
%% object that contains details about a package version.
%%
%% </li> <li> `DescribeRepository': Returns a `RepositoryDescription' object
%% that contains detailed information about the requested repository.
%%
%% </li> <li> `DisposePackageVersions': Disposes versions of a package. A
%% package version with the status `Disposed' cannot be restored because they
%% have been permanently removed from storage.
%%
%% </li> <li> `DisassociateExternalConnection': Removes an existing external
%% connection from a repository.
%%
%% </li> <li> `GetAuthorizationToken': Generates a temporary authorization
%% token for accessing repositories in the domain. The token expires the
%% authorization period has passed. The default authorization period is 12
%% hours and can be customized to any length with a maximum of 12 hours.
%%
%% </li> <li> `GetDomainPermissionsPolicy': Returns the policy of a resource
%% that is attached to the specified domain.
%%
%% </li> <li> `GetPackageVersionAsset': Returns the contents of an asset that
%% is in a package version.
%%
%% </li> <li> `GetPackageVersionReadme': Gets the readme file or descriptive
%% text for a package version.
%%
%% </li> <li> `GetRepositoryEndpoint': Returns the endpoint of a repository
%% for a specific package format. A repository has one endpoint for each
%% package format:
%%
%% <ul> <li> `maven'
%%
%% </li> <li> `npm'
%%
%% </li> <li> `nuget'
%%
%% </li> <li> `pypi'
%%
%% </li> </ul> </li> <li> `GetRepositoryPermissionsPolicy': Returns the
%% resource policy that is set on a repository.
%%
%% </li> <li> `ListDomains': Returns a list of `DomainSummary' objects. Each
%% returned `DomainSummary' object contains information about a domain.
%%
%% </li> <li> `ListPackages': Lists the packages in a repository.
%%
%% </li> <li> `ListPackageVersionAssets': Lists the assets for a given
%% package version.
%%
%% </li> <li> `ListPackageVersionDependencies': Returns a list of the direct
%% dependencies for a package version.
%%
%% </li> <li> `ListPackageVersions': Returns a list of package versions for a
%% specified package in a repository.
%%
%% </li> <li> `ListRepositories': Returns a list of repositories owned by the
%% Amazon Web Services account that called this method.
%%
%% </li> <li> `ListRepositoriesInDomain': Returns a list of the repositories
%% in a domain.
%%
%% </li> <li> `PutDomainPermissionsPolicy': Attaches a resource policy to a
%% domain.
%%
%% </li> <li> `PutPackageOriginConfiguration': Sets the package origin
%% configuration for a package, which determine how new versions of the
%% package can be added to a specific repository.
%%
%% </li> <li> `PutRepositoryPermissionsPolicy': Sets the resource policy on a
%% repository that specifies permissions to access it.
%%
%% </li> <li> `UpdatePackageVersionsStatus': Updates the status of one or
%% more versions of a package.
%%
%% </li> <li> `UpdateRepository': Updates the properties of a repository.
%%
%% </li> </ul>
-module(aws_codeartifact).
-export([associate_external_connection/2,
associate_external_connection/3,
copy_package_versions/2,
copy_package_versions/3,
create_domain/2,
create_domain/3,
create_repository/2,
create_repository/3,
delete_domain/2,
delete_domain/3,
delete_domain_permissions_policy/2,
delete_domain_permissions_policy/3,
delete_package_versions/2,
delete_package_versions/3,
delete_repository/2,
delete_repository/3,
delete_repository_permissions_policy/2,
delete_repository_permissions_policy/3,
describe_domain/2,
describe_domain/4,
describe_domain/5,
describe_package/5,
describe_package/7,
describe_package/8,
describe_package_version/6,
describe_package_version/8,
describe_package_version/9,
describe_repository/3,
describe_repository/5,
describe_repository/6,
disassociate_external_connection/2,
disassociate_external_connection/3,
dispose_package_versions/2,
dispose_package_versions/3,
get_authorization_token/2,
get_authorization_token/3,
get_domain_permissions_policy/2,
get_domain_permissions_policy/4,
get_domain_permissions_policy/5,
get_package_version_asset/7,
get_package_version_asset/9,
get_package_version_asset/10,
get_package_version_readme/6,
get_package_version_readme/8,
get_package_version_readme/9,
get_repository_endpoint/4,
get_repository_endpoint/6,
get_repository_endpoint/7,
get_repository_permissions_policy/3,
get_repository_permissions_policy/5,
get_repository_permissions_policy/6,
list_domains/2,
list_domains/3,
list_package_version_assets/2,
list_package_version_assets/3,
list_package_version_dependencies/2,
list_package_version_dependencies/3,
list_package_versions/2,
list_package_versions/3,
list_packages/2,
list_packages/3,
list_repositories/2,
list_repositories/3,
list_repositories_in_domain/2,
list_repositories_in_domain/3,
list_tags_for_resource/2,
list_tags_for_resource/3,
put_domain_permissions_policy/2,
put_domain_permissions_policy/3,
put_package_origin_configuration/2,
put_package_origin_configuration/3,
put_repository_permissions_policy/2,
put_repository_permissions_policy/3,
tag_resource/2,
tag_resource/3,
untag_resource/2,
untag_resource/3,
update_package_versions_status/2,
update_package_versions_status/3,
update_repository/2,
update_repository/3]).
-include_lib("hackney/include/hackney_lib.hrl").
%%====================================================================
%% API
%%====================================================================
%% @doc Adds an existing external connection to a repository.
%%
%% One external connection is allowed per repository.
%%
%% A repository can have one or more upstream repositories, or an external
%% connection.
associate_external_connection(Client, Input) ->
associate_external_connection(Client, Input, []).
associate_external_connection(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/repository/external-connection"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"external-connection">>, <<"externalConnection">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Copies package versions from one repository to another repository in
%% the same domain.
%%
%% You must specify `versions' or `versionRevisions'. You cannot specify
%% both.
copy_package_versions(Client, Input) ->
copy_package_versions(Client, Input, []).
copy_package_versions(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/versions/copy"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"destination-repository">>, <<"destinationRepository">>},
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"namespace">>, <<"namespace">>},
{<<"package">>, <<"package">>},
{<<"source-repository">>, <<"sourceRepository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Creates a domain.
%%
%% CodeArtifact domains make it easier to manage multiple repositories across
%% an organization. You can use a domain to apply permissions across many
%% repositories owned by different Amazon Web Services accounts. An asset is
%% stored only once in a domain, even if it's in multiple repositories.
%%
%% Although you can have multiple domains, we recommend a single production
%% domain that contains all published artifacts so that your development
%% teams can find and share packages. You can use a second pre-production
%% domain to test changes to the production domain configuration.
create_domain(Client, Input) ->
create_domain(Client, Input, []).
create_domain(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/domain"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Creates a repository.
create_repository(Client, Input) ->
create_repository(Client, Input, []).
create_repository(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/repository"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Deletes a domain.
%%
%% You cannot delete a domain that contains repositories. If you want to
%% delete a domain with repositories, first delete its repositories.
delete_domain(Client, Input) ->
delete_domain(Client, Input, []).
delete_domain(Client, Input0, Options0) ->
Method = delete,
Path = ["/v1/domain"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Deletes the resource policy set on a domain.
delete_domain_permissions_policy(Client, Input) ->
delete_domain_permissions_policy(Client, Input, []).
delete_domain_permissions_policy(Client, Input0, Options0) ->
Method = delete,
Path = ["/v1/domain/permissions/policy"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"policy-revision">>, <<"policyRevision">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Deletes one or more versions of a package.
%%
%% A deleted package version cannot be restored in your repository. If you
%% want to remove a package version from your repository and be able to
%% restore it later, set its status to `Archived'. Archived packages cannot
%% be downloaded from a repository and don't show up with list package APIs
%% (for example, ListackageVersions), but you can restore them using
%% UpdatePackageVersionsStatus.
delete_package_versions(Client, Input) ->
delete_package_versions(Client, Input, []).
delete_package_versions(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/versions/delete"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"namespace">>, <<"namespace">>},
{<<"package">>, <<"package">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Deletes a repository.
delete_repository(Client, Input) ->
delete_repository(Client, Input, []).
delete_repository(Client, Input0, Options0) ->
Method = delete,
Path = ["/v1/repository"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Deletes the resource policy that is set on a repository.
%%
%% After a resource policy is deleted, the permissions allowed and denied by
%% the deleted policy are removed. The effect of deleting a resource policy
%% might not be immediate.
%%
%% Use `DeleteRepositoryPermissionsPolicy' with caution. After a policy is
%% deleted, Amazon Web Services users, roles, and accounts lose permissions
%% to perform the repository actions granted by the deleted policy.
delete_repository_permissions_policy(Client, Input) ->
delete_repository_permissions_policy(Client, Input, []).
delete_repository_permissions_policy(Client, Input0, Options0) ->
Method = delete,
Path = ["/v1/repository/permissions/policies"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"policy-revision">>, <<"policyRevision">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns a DomainDescription object that contains information about
%% the requested domain.
describe_domain(Client, Domain)
when is_map(Client) ->
describe_domain(Client, Domain, #{}, #{}).
describe_domain(Client, Domain, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
describe_domain(Client, Domain, QueryMap, HeadersMap, []).
describe_domain(Client, Domain, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/domain"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns a PackageDescription object that contains information about
%% the requested package.
describe_package(Client, Domain, Format, Package, Repository)
when is_map(Client) ->
describe_package(Client, Domain, Format, Package, Repository, #{}, #{}).
describe_package(Client, Domain, Format, Package, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
describe_package(Client, Domain, Format, Package, Repository, QueryMap, HeadersMap, []).
describe_package(Client, Domain, Format, Package, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/package"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"format">>, Format},
{<<"namespace">>, maps:get(<<"namespace">>, QueryMap, undefined)},
{<<"package">>, Package},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns a PackageVersionDescription object that contains information
%% about the requested package version.
describe_package_version(Client, Domain, Format, Package, PackageVersion, Repository)
when is_map(Client) ->
describe_package_version(Client, Domain, Format, Package, PackageVersion, Repository, #{}, #{}).
describe_package_version(Client, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
describe_package_version(Client, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap, []).
describe_package_version(Client, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/package/version"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"format">>, Format},
{<<"namespace">>, maps:get(<<"namespace">>, QueryMap, undefined)},
{<<"package">>, Package},
{<<"version">>, PackageVersion},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns a `RepositoryDescription' object that contains detailed
%% information about the requested repository.
describe_repository(Client, Domain, Repository)
when is_map(Client) ->
describe_repository(Client, Domain, Repository, #{}, #{}).
describe_repository(Client, Domain, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
describe_repository(Client, Domain, Repository, QueryMap, HeadersMap, []).
describe_repository(Client, Domain, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/repository"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Removes an existing external connection from a repository.
disassociate_external_connection(Client, Input) ->
disassociate_external_connection(Client, Input, []).
disassociate_external_connection(Client, Input0, Options0) ->
Method = delete,
Path = ["/v1/repository/external-connection"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"external-connection">>, <<"externalConnection">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Deletes the assets in package versions and sets the package versions'
%% status to `Disposed'.
%%
%% A disposed package version cannot be restored in your repository because
%% its assets are deleted.
%%
%% To view all disposed package versions in a repository, use
%% ListPackageVersions and set the status parameter to `Disposed'.
%%
%% To view information about a disposed package version, use
%% DescribePackageVersion.
dispose_package_versions(Client, Input) ->
dispose_package_versions(Client, Input, []).
dispose_package_versions(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/versions/dispose"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"namespace">>, <<"namespace">>},
{<<"package">>, <<"package">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Generates a temporary authorization token for accessing repositories
%% in the domain.
%%
%% This API requires the `codeartifact:GetAuthorizationToken' and
%% `sts:GetServiceBearerToken' permissions. For more information about
%% authorization tokens, see CodeArtifact authentication and tokens.
%%
%% CodeArtifact authorization tokens are valid for a period of 12 hours when
%% created with the `login' command. You can call `login' periodically to
%% refresh the token. When you create an authorization token with the
%% `GetAuthorizationToken' API, you can set a custom authorization period, up
%% to a maximum of 12 hours, with the `durationSeconds' parameter.
%%
%% The authorization period begins after `login' or `GetAuthorizationToken'
%% is called. If `login' or `GetAuthorizationToken' is called while assuming
%% a role, the token lifetime is independent of the maximum session duration
%% of the role. For example, if you call `sts assume-role' and specify a
%% session duration of 15 minutes, then generate a CodeArtifact authorization
%% token, the token will be valid for the full authorization period even
%% though this is longer than the 15-minute session duration.
%%
%% See Using IAM Roles for more information on controlling session duration.
get_authorization_token(Client, Input) ->
get_authorization_token(Client, Input, []).
get_authorization_token(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/authorization-token"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"duration">>, <<"durationSeconds">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns the resource policy attached to the specified domain.
%%
%% The policy is a resource-based policy, not an identity-based policy. For
%% more information, see Identity-based policies and resource-based policies
%% in the IAM User Guide.
get_domain_permissions_policy(Client, Domain)
when is_map(Client) ->
get_domain_permissions_policy(Client, Domain, #{}, #{}).
get_domain_permissions_policy(Client, Domain, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
get_domain_permissions_policy(Client, Domain, QueryMap, HeadersMap, []).
get_domain_permissions_policy(Client, Domain, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/domain/permissions/policy"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns an asset (or file) that is in a package.
%%
%% For example, for a Maven package version, use `GetPackageVersionAsset' to
%% download a `JAR' file, a `POM' file, or any other assets in the package
%% version.
get_package_version_asset(Client, Asset, Domain, Format, Package, PackageVersion, Repository)
when is_map(Client) ->
get_package_version_asset(Client, Asset, Domain, Format, Package, PackageVersion, Repository, #{}, #{}).
get_package_version_asset(Client, Asset, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
get_package_version_asset(Client, Asset, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap, []).
get_package_version_asset(Client, Asset, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/package/version/asset"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"asset">>, Asset},
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"format">>, Format},
{<<"namespace">>, maps:get(<<"namespace">>, QueryMap, undefined)},
{<<"package">>, Package},
{<<"version">>, PackageVersion},
{<<"revision">>, maps:get(<<"revision">>, QueryMap, undefined)},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
case request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode) of
{ok, Body0, {_, ResponseHeaders, _} = Response} ->
ResponseHeadersParams =
[
{<<"X-AssetName">>, <<"assetName">>},
{<<"X-PackageVersion">>, <<"packageVersion">>},
{<<"X-PackageVersionRevision">>, <<"packageVersionRevision">>}
],
FoldFun = fun({Name_, Key_}, Acc_) ->
case lists:keyfind(Name_, 1, ResponseHeaders) of
false -> Acc_;
{_, Value_} -> Acc_#{Key_ => Value_}
end
end,
Body = lists:foldl(FoldFun, Body0, ResponseHeadersParams),
{ok, Body, Response};
Result ->
Result
end.
%% @doc Gets the readme file or descriptive text for a package version.
%%
%% For packages that do not contain a readme file, CodeArtifact extracts a
%% description from a metadata file. For example, from the `<description>'
%% element in the `pom.xml' file of a Maven package.
%%
%% The returned text might contain formatting. For example, it might contain
%% formatting for Markdown or reStructuredText.
get_package_version_readme(Client, Domain, Format, Package, PackageVersion, Repository)
when is_map(Client) ->
get_package_version_readme(Client, Domain, Format, Package, PackageVersion, Repository, #{}, #{}).
get_package_version_readme(Client, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
get_package_version_readme(Client, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap, []).
get_package_version_readme(Client, Domain, Format, Package, PackageVersion, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/package/version/readme"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"format">>, Format},
{<<"namespace">>, maps:get(<<"namespace">>, QueryMap, undefined)},
{<<"package">>, Package},
{<<"version">>, PackageVersion},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns the endpoint of a repository for a specific package format.
%%
%% A repository has one endpoint for each package format:
%%
%% <ul> <li> `maven'
%%
%% </li> <li> `npm'
%%
%% </li> <li> `nuget'
%%
%% </li> <li> `pypi'
%%
%% </li> </ul>
get_repository_endpoint(Client, Domain, Format, Repository)
when is_map(Client) ->
get_repository_endpoint(Client, Domain, Format, Repository, #{}, #{}).
get_repository_endpoint(Client, Domain, Format, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
get_repository_endpoint(Client, Domain, Format, Repository, QueryMap, HeadersMap, []).
get_repository_endpoint(Client, Domain, Format, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/repository/endpoint"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"format">>, Format},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns the resource policy that is set on a repository.
get_repository_permissions_policy(Client, Domain, Repository)
when is_map(Client) ->
get_repository_permissions_policy(Client, Domain, Repository, #{}, #{}).
get_repository_permissions_policy(Client, Domain, Repository, QueryMap, HeadersMap)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap) ->
get_repository_permissions_policy(Client, Domain, Repository, QueryMap, HeadersMap, []).
get_repository_permissions_policy(Client, Domain, Repository, QueryMap, HeadersMap, Options0)
when is_map(Client), is_map(QueryMap), is_map(HeadersMap), is_list(Options0) ->
Path = ["/v1/repository/permissions/policy"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Query0_ =
[
{<<"domain">>, Domain},
{<<"domain-owner">>, maps:get(<<"domain-owner">>, QueryMap, undefined)},
{<<"repository">>, Repository}
],
Query_ = [H || {_, V} = H <- Query0_, V =/= undefined],
request(Client, get, Path, Query_, Headers, undefined, Options, SuccessStatusCode).
%% @doc Returns a list of DomainSummary objects for all domains owned by the
%% Amazon Web Services account that makes this call.
%%
%% Each returned `DomainSummary' object contains information about a domain.
list_domains(Client, Input) ->
list_domains(Client, Input, []).
list_domains(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/domains"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
Query_ = [],
Input = Input2,
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns a list of AssetSummary objects for assets in a package
%% version.
list_package_version_assets(Client, Input) ->
list_package_version_assets(Client, Input, []).
list_package_version_assets(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/version/assets"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"max-results">>, <<"maxResults">>},
{<<"namespace">>, <<"namespace">>},
{<<"next-token">>, <<"nextToken">>},
{<<"package">>, <<"package">>},
{<<"version">>, <<"packageVersion">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns the direct dependencies for a package version.
%%
%% The dependencies are returned as PackageDependency objects. CodeArtifact
%% extracts the dependencies for a package version from the metadata file for
%% the package format (for example, the `package.json' file for npm packages
%% and the `pom.xml' file for Maven). Any package version dependencies that
%% are not listed in the configuration file are not returned.
list_package_version_dependencies(Client, Input) ->
list_package_version_dependencies(Client, Input, []).
list_package_version_dependencies(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/version/dependencies"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"namespace">>, <<"namespace">>},
{<<"next-token">>, <<"nextToken">>},
{<<"package">>, <<"package">>},
{<<"version">>, <<"packageVersion">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns a list of PackageVersionSummary objects for package versions
%% in a repository that match the request parameters.
list_package_versions(Client, Input) ->
list_package_versions(Client, Input, []).
list_package_versions(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/versions"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"max-results">>, <<"maxResults">>},
{<<"namespace">>, <<"namespace">>},
{<<"next-token">>, <<"nextToken">>},
{<<"originType">>, <<"originType">>},
{<<"package">>, <<"package">>},
{<<"repository">>, <<"repository">>},
{<<"sortBy">>, <<"sortBy">>},
{<<"status">>, <<"status">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns a list of PackageSummary objects for packages in a repository
%% that match the request parameters.
list_packages(Client, Input) ->
list_packages(Client, Input, []).
list_packages(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/packages"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"max-results">>, <<"maxResults">>},
{<<"namespace">>, <<"namespace">>},
{<<"next-token">>, <<"nextToken">>},
{<<"package-prefix">>, <<"packagePrefix">>},
{<<"publish">>, <<"publish">>},
{<<"repository">>, <<"repository">>},
{<<"upstream">>, <<"upstream">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns a list of RepositorySummary objects.
%%
%% Each `RepositorySummary' contains information about a repository in the
%% specified Amazon Web Services account and that matches the input
%% parameters.
list_repositories(Client, Input) ->
list_repositories(Client, Input, []).
list_repositories(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/repositories"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"max-results">>, <<"maxResults">>},
{<<"next-token">>, <<"nextToken">>},
{<<"repository-prefix">>, <<"repositoryPrefix">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Returns a list of RepositorySummary objects.
%%
%% Each `RepositorySummary' contains information about a repository in the
%% specified domain and that matches the input parameters.
list_repositories_in_domain(Client, Input) ->
list_repositories_in_domain(Client, Input, []).
list_repositories_in_domain(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/domain/repositories"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"administrator-account">>, <<"administratorAccount">>},
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"max-results">>, <<"maxResults">>},
{<<"next-token">>, <<"nextToken">>},
{<<"repository-prefix">>, <<"repositoryPrefix">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Gets information about Amazon Web Services tags for a specified
%% Amazon Resource Name (ARN) in CodeArtifact.
list_tags_for_resource(Client, Input) ->
list_tags_for_resource(Client, Input, []).
list_tags_for_resource(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/tags"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"resourceArn">>, <<"resourceArn">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Sets a resource policy on a domain that specifies permissions to
%% access it.
%%
%% When you call `PutDomainPermissionsPolicy', the resource policy on the
%% domain is ignored when evaluting permissions. This ensures that the owner
%% of a domain cannot lock themselves out of the domain, which would prevent
%% them from being able to update the resource policy.
put_domain_permissions_policy(Client, Input) ->
put_domain_permissions_policy(Client, Input, []).
put_domain_permissions_policy(Client, Input0, Options0) ->
Method = put,
Path = ["/v1/domain/permissions/policy"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
Query_ = [],
Input = Input2,
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Sets the package origin configuration for a package.
%%
%% The package origin configuration determines how new versions of a package
%% can be added to a repository. You can allow or block direct publishing of
%% new package versions, or ingestion and retaining of new package versions
%% from an external connection or upstream source. For more information about
%% package origin controls and configuration, see Editing package origin
%% controls in the CodeArtifact User Guide.
%%
%% `PutPackageOriginConfiguration' can be called on a package that doesn't
%% yet exist in the repository. When called on a package that does not exist,
%% a package is created in the repository with no versions and the requested
%% restrictions are set on the package. This can be used to preemptively
%% block ingesting or retaining any versions from external connections or
%% upstream repositories, or to block publishing any versions of the package
%% into the repository before connecting any package managers or publishers
%% to the repository.
put_package_origin_configuration(Client, Input) ->
put_package_origin_configuration(Client, Input, []).
put_package_origin_configuration(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"namespace">>, <<"namespace">>},
{<<"package">>, <<"package">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Sets the resource policy on a repository that specifies permissions
%% to access it.
%%
%% When you call `PutRepositoryPermissionsPolicy', the resource policy on the
%% repository is ignored when evaluting permissions. This ensures that the
%% owner of a repository cannot lock themselves out of the repository, which
%% would prevent them from being able to update the resource policy.
put_repository_permissions_policy(Client, Input) ->
put_repository_permissions_policy(Client, Input, []).
put_repository_permissions_policy(Client, Input0, Options0) ->
Method = put,
Path = ["/v1/repository/permissions/policy"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Adds or updates tags for a resource in CodeArtifact.
tag_resource(Client, Input) ->
tag_resource(Client, Input, []).
tag_resource(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/tag"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"resourceArn">>, <<"resourceArn">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Removes tags from a resource in CodeArtifact.
untag_resource(Client, Input) ->
untag_resource(Client, Input, []).
untag_resource(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/untag"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"resourceArn">>, <<"resourceArn">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Updates the status of one or more versions of a package.
%%
%% Using `UpdatePackageVersionsStatus', you can update the status of package
%% versions to `Archived', `Published', or `Unlisted'. To set the status of a
%% package version to `Disposed', use DisposePackageVersions.
update_package_versions_status(Client, Input) ->
update_package_versions_status(Client, Input, []).
update_package_versions_status(Client, Input0, Options0) ->
Method = post,
Path = ["/v1/package/versions/update_status"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"format">>, <<"format">>},
{<<"namespace">>, <<"namespace">>},
{<<"package">>, <<"package">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%% @doc Update the properties of a repository.
update_repository(Client, Input) ->
update_repository(Client, Input, []).
update_repository(Client, Input0, Options0) ->
Method = put,
Path = ["/v1/repository"],
SuccessStatusCode = undefined,
Options = [{send_body_as_binary, false},
{receive_body_as_binary, false}
| Options0],
Headers = [],
Input1 = Input0,
CustomHeaders = [],
Input2 = Input1,
QueryMapping = [
{<<"domain">>, <<"domain">>},
{<<"domain-owner">>, <<"domainOwner">>},
{<<"repository">>, <<"repository">>}
],
{Query_, Input} = aws_request:build_headers(QueryMapping, Input2),
request(Client, Method, Path, Query_, CustomHeaders ++ Headers, Input, Options, SuccessStatusCode).
%%====================================================================
%% Internal functions
%%====================================================================
-spec request(aws_client:aws_client(), atom(), iolist(), list(),
list(), map() | undefined, list(), pos_integer() | undefined) ->
{ok, {integer(), list()}} |
{ok, Result, {integer(), list(), hackney:client()}} |
{error, Error, {integer(), list(), hackney:client()}} |
{error, term()} when
Result :: map(),
Error :: map().
request(Client, Method, Path, Query, Headers0, Input, Options, SuccessStatusCode) ->
RequestFun = fun() -> do_request(Client, Method, Path, Query, Headers0, Input, Options, SuccessStatusCode) end,
aws_request:request(RequestFun, Options).
do_request(Client, Method, Path, Query, Headers0, Input, Options, SuccessStatusCode) ->
Client1 = Client#{service => <<"codeartifact">>},
Host = build_host(<<"codeartifact">>, Client1),
URL0 = build_url(Host, Path, Client1),
URL = aws_request:add_query(URL0, Query),
AdditionalHeaders = [ {<<"Host">>, Host}
, {<<"Content-Type">>, <<"application/x-amz-json-1.1">>}
],
Headers1 = aws_request:add_headers(AdditionalHeaders, Headers0),
Payload =
case proplists:get_value(send_body_as_binary, Options) of
true ->
maps:get(<<"Body">>, Input, <<"">>);
false ->
encode_payload(Input)
end,
MethodBin = aws_request:method_to_binary(Method),
SignedHeaders = aws_request:sign_request(Client1, MethodBin, URL, Headers1, Payload),
Response = hackney:request(Method, URL, SignedHeaders, Payload, Options),
DecodeBody = not proplists:get_value(receive_body_as_binary, Options),
handle_response(Response, SuccessStatusCode, DecodeBody).
handle_response({ok, StatusCode, ResponseHeaders}, SuccessStatusCode, _DecodeBody)
when StatusCode =:= 200;
StatusCode =:= 202;
StatusCode =:= 204;
StatusCode =:= 206;
StatusCode =:= SuccessStatusCode ->
{ok, {StatusCode, ResponseHeaders}};
handle_response({ok, StatusCode, ResponseHeaders}, _, _DecodeBody) ->
{error, {StatusCode, ResponseHeaders}};
handle_response({ok, StatusCode, ResponseHeaders, Client}, SuccessStatusCode, DecodeBody)
when StatusCode =:= 200;
StatusCode =:= 202;
StatusCode =:= 204;
StatusCode =:= 206;
StatusCode =:= SuccessStatusCode ->
case hackney:body(Client) of
{ok, <<>>} when StatusCode =:= 200;
StatusCode =:= SuccessStatusCode ->
{ok, #{}, {StatusCode, ResponseHeaders, Client}};
{ok, Body} ->
Result = case DecodeBody of
true ->
try
jsx:decode(Body)
catch
Error:Reason:Stack ->
erlang:raise(error, {body_decode_failed, Error, Reason, StatusCode, Body}, Stack)
end;
false -> #{<<"Body">> => Body}
end,
{ok, Result, {StatusCode, ResponseHeaders, Client}}
end;
handle_response({ok, StatusCode, ResponseHeaders, Client}, _, _DecodeBody) ->
{ok, Body} = hackney:body(Client),
Error = jsx:decode(Body),
{error, Error, {StatusCode, ResponseHeaders, Client}};
handle_response({error, Reason}, _, _DecodeBody) ->
{error, Reason}.
build_host(_EndpointPrefix, #{region := <<"local">>, endpoint := Endpoint}) ->
Endpoint;
build_host(_EndpointPrefix, #{region := <<"local">>}) ->
<<"localhost">>;
build_host(EndpointPrefix, #{region := Region, endpoint := Endpoint}) ->
aws_util:binary_join([EndpointPrefix, Region, Endpoint], <<".">>).
build_url(Host, Path0, Client) ->
Proto = maps:get(proto, Client),
Path = erlang:iolist_to_binary(Path0),
Port = maps:get(port, Client),
aws_util:binary_join([Proto, <<"://">>, Host, <<":">>, Port, Path], <<"">>).
-spec encode_payload(undefined | map()) -> binary().
encode_payload(undefined) ->
<<>>;
encode_payload(Input) ->
jsx:encode(Input).